August 29, 2021
Recent advances in summarization provide models that can generate summaries of higher quality. Such models now exist for a number of summarization tasks, including query-based summarization, dialogue summarization, and multi-document summarization. While such models and tasks are rapidly growing in the research field, it has also become challenging for non-experts to keep track of them. To make summarization methods more accessible to a wider audience, we develop SummerTime by rethinking the summarization task from the perspective of an NLP non-expert. SummerTime is a complete toolkit for text summarization, including various models, datasets and evaluation metrics, for a full spectrum of summarization-related tasks. SummerTime integrates with libraries designed for NLP researchers, and enables users with easy-to-use APIs. With SummerTime, users can locate pipeline solutions and search for the best model with their own data, and visualize the differences, all with a few lines of code. We also provide explanations for models and evaluation metrics to help users understand the model behaviors and select models that best suit their needs. Our library, along with a notebook demo, is available at https://github.com/Yale-LILY/SummerTime.
The goal of text summarization is to generate short and fluent summaries from longer textual sources, while preserving the most salient information in them. Benefiting from recent advances of deep neural networks, in particular sequence to sequence models, with or without attention [1]–[3], current state-of-the-art summarization models produce high quality summaries that can be useful in practice cases [4], [5]. Moreover, neural summarization has broadened its scope with the introduction of more summarization tasks, such as query-based summarization [6], [7], long-document summarization [8], multi-document summarization [9], [10], dialogue summarization [7], [11]. Such summarization tasks can also be from different domains [8], [12], [13].
However, as the field rapidly grows, it is often hard for NLP non-experts to follow all relevant new models, datasets, and evaluation metrics. Moreover, those models and datasets are often from different sources, making it a non-trivial effort for the users to directly compare the performance of such models side-by-side. This makes it hard for them to decide which models to use. The development of libraries such as Transformers [14] alleviate such problems to some extent, but they only cover a narrow range of summarization models and tasks and assume certain proficiency in NLP from the users, thus the target audience is still largely the research community.
To address those challenges for non-expert users and make state-of-the-art summarizers more accessible as a tool, we introduce SummerTime, a text summarization toolkit intended for users with no NLP background. We build this library from this perspective, and provide an integration of different summarization models, datasets and evaluation metrics, all in one place. We allow the users to view a side-by-side comparison of all classic and state-of-the-art summarization models we support, on their own data and combined into pipelines that fit their own task. SummerTime also provides the functionality for automatic model selection, by constructing pipelines for specific tasks first and iteratively evaluation to find the best working solutions. Assuming no background in NLP, we list “pros and cons” for each model, and provide simple explanations for all the evaluation metrics we support. Moreover, we go beyond pure numbers and provide visualization of the performance and output of different models, to facilitate users in making decisions about which models or pipelines to finally adopt.
The purpose of SummerTime is not to replace any previous work, on the contrary, we integrate existing libraries and place them in the same framework. We provide wrappers around such libraries intended for expert users, maintaining the user-friendly and easy-to-use APIs.
Text summarization has been a long-standing task for natural language processing. Early systems for summarization had been focusing on extractive summarization [15], [16], by finding the most salient sentences from source documents. With the advancement of neural networks [1], [2], the task of abstractive summarization has been receiving more attention [17]–[22] while neural-based methods have also been developed for extractive summarization [23]–[28]. Moreover, the field of text summarization has also been broadening into several subcategories, such as multi-document summarization [9], [10], [29], [30], query-based summarization [31]–[37] and dialogue summarization [7], [11], [38]–[41]. The proposed tasks, along with the datasets can also be classified by domain, such as news [10], [12], [42], meetings [7], [43], [44], scientifc literature [8], [45], and medical records [13], [46], [47].
Transformers [14] includes a large number of transformer-based models in its Modelhub1, including BART [5] and Pegasus [4], two strong neural summarizers we also use in SummerTime. It also hosts datasets for various NLP tasks in its Datasets2 library [48]. Despite the wide coverage in transformer-based models, Transformers do not natively support models or pipelines that can handle aforementioned subcategories of summarization tasks. Moreover, it assumes certain NLP proficiency in its users, thus is harder for non-expert users to use. We integrate with Transformers and Datasets to import the state-of-the-art models, as well as summarization datasets into SummerTime, under the same easy-to-use framework.
Another library that we integrate with is SummEval [49], which is a collection of evaluation metrics for text summarization. SummerTime adopts a subset of such metrics in SummEval that are more popular and easier to understand. SummerTime also works well with SummVis [50], which provides an interactive way of analysing summarization results on the token-level. We also allow SummerTime to store output in a format that can be directly used by SummVis and its UI.
Other systems also exist for text summarization. MEAD3 is a platform for multi-lingual summarization. Sumy4 can produce extractive summaries from HTML pages or plain texts, using several traditional summarization methods including [15] and [16]. OpenNMT5 is mostly for machine translation, but it also hosts several summarization models such as [51].
The main purpose of SummerTime is to help non-expert users navigate through various summarization models, datasets and evaluation metrics, and provide simple yet comprehensive information for them to select the models that best suit their needs. 1 shows how SummerTime is split into different modules to help users achieve such goal.
We will describe in detail each component of SummerTime in the following sections. With 3.1, we introduce the models we support in all subcategories of summarization; in 3.2 we list all the existing datasets we support and how users can create their own evaluation set. Finally in 3.3, we explain the evaluation metrics included with SummerTime and how they can help users find the most suitable model for their task.
Here we introduce the summarization tasks SummerTime covers and the models we include to support these tasks. We first introduce the single-document summarization models (i.e., “base models”) in SummerTime, and then we show how those models can be used in a pipeline with other methods to complete more complex tasks such as query-based summarization and multi-document summarization.
The following base summarization models are used in SummerTime. They all take a single document and generate a short summary.
TextRank [15] is a graph-based ranking model that can be used to perform extractive
summarization;
LexRank [16] is also a graph-based extractive summarization model, which is originally developed for multi-document
summarization, but can also be applied to a single document. It uses centrality in a graph representation of sentences to measure their relative importance;
BART [5] is an autoencoder model trained with denoising objectives during training. This seq2seq model is
constructed with a bidirectional transformer encoder and a left-to-right transformer decoder, which can be fine-tuned to perform abstractive summarization;
Pegasus [4] proposes a new self-supervised pretraining objective for abstractive summarization, by reconstructing the
target sentence with the remaining sentences in the document, it also shows strong results in low-resource settings;
Longformer [52] addresses the problem of memory need for self-attention models by using a combination of sliding
window attention and global attention to approximate standard self-attention. It is able to support input length of 16K tokens, a large improvement over previous transformer-based models.
For multi-document summarization, we adopt two popular single-document summarizers to complete the task, as this is shown to be effective in previous work [10].
Combine-then-summarize is a pipeline method to handle multiple source documents, where the documents are concatenated and then a single document summarizer is used to produce the summary. Note that the length of the combined documents may
exceed the input length limit for typical transformer-based models;
Summarize-then-combine first summarizes each source document independently, then merges the resulting summaries. Compared to the combine-then-summarize method, it is not affected by overlong inputs. However, since each document is
summarized separately, the final summary may contain redundant information [30].
For summarization tasks based on queries, we adopt a pipeline method and first use retrieval methods to identify salient sentences or utterances in the original document or dialogue, then generate summaries with a single-document summarization
model.
TF-IDF retrieval is used in a pipeline to first retrieve the sentences that are most similar to the query based on the TF-IDF metric;
BM25 retrieval is used in the same pipeline, but BM25 is used as the similarity metric for retrieving the top-\(k\) relevant sentences.
Dialogue summarization is used to extract salient information from a dialogue. SummerTime includes two methods for dialogue summarization.
Flatten-then-summarize first flattens the dialogue data while preserving the speaker information, then a summarizer is used to generate the summary. [7] found that this presents a strong baseline for dialogue summarization.
HMNet [41] explores the semantic structure of dialogues and develops a hierarchical architecture to
first encode each utterance then aggregate with another encoder in modeling the long dialogue script. It also exploits role vectors to perform better speaker modeling.
Since we assume no NLP background of our target users, we provide a short description for every model to illustrate the strengths and weaknesses for each model. Such manually written descriptions are displayed when calling a static
get_description() method on the model class. A sample description is shown in 2.
| Dataset | Domain | Size | Src. length | Tgt. length | Query | Multi-doc | Dial. | Lang. | |
|---|---|---|---|---|---|---|---|---|---|
| CNN/DM(3.0.0) | News | 300k | 781 | 56 | En | ||||
| Multi-News | News | 56k | 2.1k | 263.8 | En | ||||
| SAMSum | Open-domain | 16k | 94 | 20 | En | ||||
| XSum | News | 226k | 431 | 23.3 | En | ||||
| ScisummNet | Scientific articles | 1k | 4.7k | 150 | En | ||||
| QMSum | Meetings | 1k | 9.0k | 69.6 | En | ||||
| ArXiv | Scientific papers | 215k | 4.9k | 220 | En | ||||
| PubMedQA | Biomedial | 273.5k | 239 | 43 | En | ||||
| SummScreen | TV shows | 26.9k | 6.6k | 337.4 | En | ||||
| MLSum | News | 1.5M | 635 | 31.8 | |||||
| Ru, Tr |
With SummerTime, users can easily create or convert their own summarization datasets and evaluate all the supporting models within the framework. However, in the case that no such datasets are available, SummerTime also provides access to a list of existing summarization datasets. This way, users can select models that perform the best on one or more datasets that are similar to their task.
CNN/DM [12] contains news articles from CNN and Daily Mail. Version 1.0.0 of it was originally developed for
reading comprehension and abstractive question answering, then the extractive and abstractive summarization annotations were added in version 2.0.0 and 3.0.0, respectively;
Multi-News [10] is a large-scale multi-document summarization dataset which contains news articles from the
site newser.com with corresponding human-written summaries. Over 1,500 sites, i.e. news sources, appear as source documents, which is higher than the other common news datasets.
SAMSum [11] is a dataset with chat dialogues corpus, and human-annotated abstractive summarizations. In the
SAMSum corpus, each dialogue is written by one person. After collecting all the dialogues, experts write a single summary for each dialogue.
XSum [42] is a news summarization dataset for generating a one-sentence summary aiming to answer the question “What is the article
about?”. It consists of real-world articles and corresponding one-sentence summarization from British Broadcasting Corporation (BBC).
ScisummNet [45] is a human-annotated dataset made for citation-aware scientific paper summarization (Scisumm).
It contains over 1,000 papers in the ACL anthology network as well as their citation networks and their manually labeled summaries.
QMSum [7] is designed for query-based multi-domain meeting summarization. It collects the meetings from AMI and
ICSI dataset, as well as the committee meetings of the Welsh Parliament and Parliament of Canada. Experts manually wrote summaries for each meeting.
ArXiv [8] is a dataset extracted from research papers for abstractive summarization of single,
longer-form documents. For each research paper from arxiv.org, its abstract is used as ground-truth summaries.
PubMedQA [53] is a question answering dataset on the biomedical domain. Every QA instance contains a short
answer and a long answer, latter of which can also be used for query-based summarization.
SummScreen [38] consists of community contributed transcripts of television show episodes from The TVMegaSite,
Inc. (TMS) and ForeverDream (FD). The summary of each transcript is the recap from TMS, or a recap of the FD shows from Wikipedia and TVMaze.
MLSum [54] is a large-scale multilingual summarization dataset. It contains over 1.5M news articles in five
languages, namely French, German, Spanish, Russian, and Turkish.
A summary of all datasets included in SummerTime is shown as 1, it is worth noticing that the fields in this table (i.e., domain, query-based, multi-doc, etc) are also incorporated in each of the dataset classes
(e.g., SAMSumDataset) as class variables, so that such labels can later be used to identify applicable models. Similar with the models classes, we include a short description for each of the datasets. Note that the datasets, either
existing ones or user created are mainly for evaluation purposes. We leave the important task of fine-tuning the models on these datasets for future work, for which we describe in more detail in 5.
To evaluate the performance of each supported model on certain dataset, SummerTime integrates with SummEval [49] and
provides the following evaluation metrics for the users to understand model performance:
ROUGE [55] is a recall-oriented method based on overlapping n-grams, word sequences, and word pairs between the generated output
and the gold summary;
BLEU [56] measures n-gram precision and employs a penalty for brevity, BLEU is often used as an evaluation metric for
machine translation;
ROUGE-WE [57] aims to go beyond surface lexical similarity and uses pretrained word embeddings to measure the
similarity between different words and presents a better correlation with human judgements;
METEOR [58] is based on word-to-word matches between generated and reference summaries, it consider two words as “aligned”
based on a Porter stemmer [59] or synonyms in WordNet [60];
BERTScore [61] computes token-level similarity between sentences with the contextualized embeddings of each tokens.
Since we assume no NLP background from our target users, we make sure that SummerTime provides a short explanation for each evaluation metric as well as a clarification whether high or low scores are better for a given evaluation metric, to help the non-expert users understand the meaning of the metrics and use them to make decisions.
In this section, we describe in detail about the workflow of SummerTime and how it can help our non-expert users find the best models for their use cases, which is one of the main functionalities that makes SummerTime stands out from similar libraries. A concrete code example of this is shown in 5.
The user would first load a dataset with the APIs we provide. During the process, the users also need to specify some Boolean attributes (e.g., is_query_based, is_dialogue_based) to facilitate next steps.
Alternatively, the user can also choose to use one of the datasets that are included in SummerTime, where such attributes are already specified in 1.
After identifying the potential pipeline modules (e.g., query-based module, dialogue-based module) that are applicable to the task, SummerTime automatically constructs solutions to a specific dataset by combining the pipelines and summarization models specified in 3.1. It further places all such constructed solutions in a pool for further evaluation and selection purposes. An example of this process in shown in 3.
As shown in 3, there can be a large pool of solutions to be evaluated. To save time and resources in searching for best models, SummerTime adopts the idea of successive halving [62], [63]. More specifically, SummerTime first uses a small number of examples from the dataset to evaluate all the candidates and eliminate models that are surpassed by at least one other model on every evaluation metric, then it does so iteratively and gradually increases the evaluation set size to reduce the variance. As shown in 4, the final output is a set of competing models \(M\) that are better6 than one another on at least one metric.


Figure 6: Examples of the visualization SummerTime provides for the users to better compare the performance between different models..
In addition to showing the numerical results as tables, SummerTime also allows the users to visualize the differences between different models with different charts and SummVis [50]. 6 shows some examples of such visualization methods SummerTime provides. A scatter plot can help the users understand the distribution of the model’s performance over each example, while the radar chart is an intuitive way of comparing different models over various metrics. SummerTime can also output the generated summaries to file formats that are directly compatible with SummVis [50], so that the users can easily use it to visualize the per-instance output differences on the token level.
An important piece of future work for SummerTime is to include more summarization models (e.g., multilingual, query-aware, etc) to enlarge the number of choices for the users, and more datasets to increase the chance of users finding similar tasks or domain for evaluation when they do not have a dataset of their own. We also plan to add more visualization methods for the users to better understand the differences between the outputs of various models and the behavior of each individual model itself. Moreover, we would like to enable fine-tuning for a subset of smaller models we support, to enable better performance on some domains or tasks for which no pretrained models are available. With all such potential improvements in the near future, we plan to supply SummerTime not only as a way for non-expert users to access state-of-art summarization models, but also as a go-to choice to quickly establishing baseline results for researchers as well.
We introduce SummerTime, a text summarization toolkit designed for non-expert users. SummerTime includes various summarization datasets, models and evaluation metrics and covers a wide range of summarization tasks. It can also automatically identify the best models or pipelines for a specific dataset and task, and visualize the differences between the model outputs and performances. SummerTime is open source under the Apache-2.0 license and is available online.
The authors would like to thank Rui Zhang, Alexander Fabbri, Chenguang Zhu, Budhaditya Deb, Asli Celikyilmaz and Rahul Jha for their advice for this work. This work is supported in part by a grant from Microsoft Research.