This chapter covers extractive and abstractive text summarisation, two fundamental approaches to automatically condensing documents. For the AI-900 exam, understanding the differences, use cases, and Azure AI services that support each method is critical, as questions on summarisation appear in approximately 5-7% of exams under objective 4.3. You will learn the internal mechanisms, key configuration parameters, and how to choose between extractive and abstractive summarisation in real-world applications.
Jump to a section
Imagine a courtroom where a trial is taking place. A court reporter (extractive summariser) sits and transcribes every word verbatim. Later, when asked for a summary, the reporter highlights the most important sentences from the transcript—exact quotes from the judge, the key witness testimony, the verdict—and presents them in order. The summary contains only words that were actually spoken. In contrast, an editor (abstractive summariser) listens to the entire trial, understands the facts, and then writes a new, concise article describing what happened, using her own words. She might say, 'The defendant was found guilty of theft after the prosecution proved beyond a reasonable doubt that he took the car.' The editor may rephrase, combine facts, or infer conclusions that were not explicitly stated in any single sentence. The court reporter's output is always faithful to the original text but may lack flow; the editor's output is more natural but risks introducing inaccuracies. In NLP, extractive summarisation selects existing sentences, while abstractive summarisation generates new sentences that capture the essence.
What is Text Summarisation and Why Does It Exist?
Text summarisation is the process of creating a concise, coherent version of a longer document while preserving its key information. The need arises from information overload: organisations process thousands of documents daily—news articles, legal contracts, medical records, customer feedback—and manual summarisation is time-consuming and inconsistent. Automated summarisation enables faster decision-making, improves productivity, and powers applications like news digests, meeting notes, and report generation.
In the context of AI-900, summarisation falls under Natural Language Processing (NLP) workloads on Azure. Microsoft Azure provides pre-built AI services that can perform both extractive and abstractive summarisation without requiring custom models. The primary service is Azure AI Language, which includes a Text Summarisation feature (part of the Language Service). This feature supports both extractive and abstractive summarisation via REST APIs and SDKs.
Extractive Summarisation: How It Works Internally
Extractive summarisation selects the most important sentences from the source text and concatenates them to form a summary. The process involves several steps:
1. Sentence Segmentation: The document is split into individual sentences using punctuation and language-specific rules. 2. Feature Extraction: Each sentence is represented as a vector of features. Common features include: - Term Frequency-Inverse Document Frequency (TF-IDF): Measures how important a word is to a sentence relative to the whole document. - Sentence Position: Sentences at the beginning or end of a document often carry more weight. - Length of Sentence: Very short or very long sentences may be penalised. - Presence of Named Entities: Sentences containing key entities (people, organisations, dates) are often more important. - Similarity to Title/Headline: Sentences that overlap with the title are considered salient. 3. Scoring: A machine learning model (often a regression model or neural network) assigns a relevance score to each sentence based on the extracted features. The model is trained on human-annotated data where sentences are ranked by importance. 4. Selection: The top N sentences (where N is a user-specified number or determined by a compression ratio) are selected. Duplicate or highly similar sentences are removed using techniques like Maximum Marginal Relevance (MMR) to ensure diversity. 5. Ordering: Selected sentences are arranged in the order they appear in the original document (or sometimes reordered for coherence).
The final summary is a subset of the original text. No new words are generated.
Abstractive Summarisation: How It Works Internally
Abstractive summarisation generates new sentences that capture the core meaning of the source text, potentially using words not present in the original. It is more complex and typically uses deep learning models, specifically sequence-to-sequence (seq2seq) architectures with attention mechanisms and transformer models (like BART, T5, or PEGASUS). The process:
Encoding: The source text is tokenised and passed through an encoder (e.g., a bidirectional transformer) that produces a contextualised representation of each token.
Attention: The decoder (another transformer) uses attention to focus on relevant parts of the source text while generating each output word. This allows the model to paraphrase and combine information from different parts of the document.
Decoding: The decoder generates tokens one by one, using a vocabulary that includes all possible words (not limited to source words). The generation may use beam search to explore multiple candidate sequences and select the one with the highest probability.
Post-processing: The generated text may be cleaned up (e.g., removing incomplete sentences, ensuring proper punctuation).
Abstractive models are trained on large datasets of source-summary pairs (e.g., CNN/DailyMail dataset). They learn to compress, paraphrase, and generate coherent text. However, they can produce factual inaccuracies (hallucinations) if the model generates information not present in the source.
Key Components and Configuration in Azure AI Language
Azure AI Language's Text Summarisation API provides two endpoints:
- Extractive Summarisation: /analyze with kind: ExtractiveSummarization
- Abstractive Summarisation: /analyze with kind: AbstractiveSummarization
Configuration parameters:
- `sentenceCount` (extractive only): Integer specifying the maximum number of sentences to include in the summary. Default is 3. Valid range: 1-20.
- `sortBy` (extractive only): Determines ordering of selected sentences. Options: Offset (original order) or Rank (by relevance score descending). Default is Offset.
- `summaryLength` (abstractive only): Controls the length of the summary. Options: short, medium, long. Default is medium. The exact word counts vary by language and model.
Both endpoints require the document text (up to 125,000 characters per request) and language code (e.g., en for English). The API returns a JSON response containing the summary text and, for extractive, a list of sentences with their rank scores and positions.
Interaction with Related Technologies
Summarisation is often combined with other NLP features: - Key Phrase Extraction: Identifies important terms that can guide the summariser. - Sentiment Analysis: Helps tailor summaries for positive/negative content. - Entity Recognition: Ensures summaries include relevant entities. - Language Detection: Automatically selects the appropriate model.
Azure Cognitive Search can use summarisation to generate search result snippets. Power Automate flows can trigger summarisation on new documents. In Azure Synapse Analytics, summarisation can be applied to large text corpora for data exploration.
Performance and Scaling
Extractive summarisation is faster and cheaper than abstractive because it does not require a generative model. Abstractive summarisation demands more compute (GPU recommended for large-scale use) and has higher latency. Azure AI Language handles both via provisioned throughput units (PTUs) or pay-as-you-go pricing. For production, consider using batch processing (up to 100 documents per request) to reduce cost.
Limitations:
Extractive summaries may lack coherence if selected sentences do not flow naturally.
Abstractive summaries may hallucinate facts or omit critical details.
Both methods work best with well-structured, single-topic documents. Highly technical or domain-specific text may require custom fine-tuning.
Prepare the source document
Ensure the input text is clean, properly formatted, and within the size limit (125,000 characters for Azure AI Language). Remove extraneous whitespace, HTML tags, or special characters that could confuse the tokeniser. For best results, the document should be a coherent piece of writing on a single topic. If the document is too long, consider splitting it into logical sections and summarising each separately, then combining summaries.
Choose extractive or abstractive summarisation
Decide based on your use case. If you need a verbatim, factually exact summary and can tolerate some lack of flow, use extractive. If you need a fluent, concise summary that may rephrase content (and you can accept minor risk of inaccuracy), use abstractive. For the AI-900 exam, remember that extractive summarisation selects existing sentences, while abstractive generates new sentences.
Configure the summarisation request
Set the API parameters. For extractive: specify `sentenceCount` (default 3, max 20) and optionally `sortBy` (`Offset` or `Rank`). For abstractive: specify `summaryLength` (`short`, `medium`, `long`). Include the language code (e.g., `en`). The request body is a JSON object containing the `analysisInput` with `documents` array. Each document has an `id`, `language`, and `text`.
Send the request to Azure AI Language
Use the REST API endpoint: `POST https://<your-resource-name>.cognitiveservices.azure.com/language/analyze-text/jobs?api-version=2023-04-01`. The request body includes `kind` set to `ExtractiveSummarization` or `AbstractiveSummarization`. Authentication is via a subscription key in the `Ocp-Apim-Subscription-Key` header. The API returns a job ID; poll the job status endpoint until the job completes.
Process the summarisation response
Once the job is complete, retrieve the results. For extractive, the response includes `sentences` array with `text`, `rankScore` (0-1), and `offset`. For abstractive, the response includes `summaries` array with `text`. Handle errors (e.g., invalid language, oversized text) by checking the `errors` field. Integrate the summary into your application—display it, store it, or use it as input to another process.
Enterprise Scenario 1: Legal Document Review
A law firm processes thousands of contracts daily. Lawyers need to quickly identify key clauses (e.g., termination, liability limits). Using extractive summarisation, the firm configures Azure AI Language to produce a 5-sentence summary of each contract. The summary includes the most important sentences based on TF-IDF and entity presence. This reduces review time from 30 minutes to 2 minutes per contract. However, if the extractive model selects sentences that are out of context, lawyers may miss nuances. To mitigate, the firm also uses key phrase extraction to highlight important terms. In production, they process batches of 100 documents per API call, achieving throughput of 10,000 documents per hour with a 99.9% success rate. Misconfiguration (e.g., setting sentenceCount too high) leads to overly long summaries that defeat the purpose.
Enterprise Scenario 2: News Aggregation
A media monitoring service aggregates articles from thousands of sources. They need to generate concise, readable summaries for their subscribers. They use abstractive summarisation because it produces fluent text that can be used directly in newsletters. The service sets summaryLength to short to fit headlines and medium for full summaries. They monitor for hallucinations by cross-referencing summaries with original articles using entity matching. When the abstractive model occasionally invents a quote, the service flags the summary for human review. Scale is challenging: each request takes 2-3 seconds, so they use a pool of 50 API resources to handle peak loads of 100 requests per second. Cost is a concern; they optimise by caching summaries for duplicate articles.
Scenario 3: Customer Feedback Analysis
A retail company collects thousands of product reviews. They use extractive summarisation to identify common complaints and praises. By summarising reviews per product, they quickly see top issues. The sortBy: Rank parameter ensures the most impactful sentences appear first. However, because extractive summaries can be disjointed, they also run sentiment analysis to label each summary as positive, negative, or neutral. A common mistake is not setting a language code, causing the API to default to English and produce poor summaries for non-English reviews.
What AI-900 Tests
AI-900 objective 4.3 (NLP workloads) includes comparing extractive and abstractive summarisation. The exam expects you to:
Identify which approach selects existing sentences vs. generates new ones.
Recognise that extractive summarisation is used when verbatim accuracy is critical.
Know that abstractive summarisation can produce more fluent summaries but may introduce inaccuracies.
Understand that Azure AI Language provides both options via the Text Summarisation API.
Recall that extractive summarisation uses sentence ranking and selection, while abstractive uses deep learning to generate text.
Common Wrong Answers and Why
'Extractive summarisation generates new sentences.' – This is false. Candidates confuse 'extractive' with 'abstractive.' The key is that extractive pulls existing text; abstractive creates new text.
'Abstractive summarisation is always more accurate.' – False. Abstractive can hallucinate; extractive is more faithful to the source.
'Both methods require custom training.' – False. Azure AI Language provides pre-built models for both; no custom training needed.
'Extractive summarisation uses neural networks to generate text.' – False. Extractive typically uses feature-based scoring or simpler models; abstractive uses neural seq2seq.
Specific Numbers and Terms
- sentenceCount: default 3, max 20 (extractive).
- summaryLength: short, medium, long (abstractive).
- Maximum document size: 125,000 characters.
- API version: 2023-04-01 (current at time of writing).
- kind: ExtractiveSummarization or AbstractiveSummarization.
Edge Cases
- The exam may test that extractive summarisation cannot summarise a single sentence (since it needs multiple sentences to select from).
- If a document has fewer sentences than sentenceCount, the API returns all sentences.
- Abstractive summarisation may return an empty summary if the model cannot generate a coherent output (rare).
How to Eliminate Wrong Answers If an answer says 'selects sentences verbatim,' it points to extractive. If it says 'generates new sentences,' it points to abstractive. Look for keywords: 'extracts' vs. 'generates,' 'existing' vs. 'new.' For Azure-specific questions, remember that both are available in the same service.
Extractive summarisation selects existing sentences; abstractive summarisation generates new sentences.
Azure AI Language provides both extractive and abstractive summarisation via the Text Summarisation API.
Extractive summarisation uses sentence ranking based on features like TF-IDF, position, and entity presence.
Abstractive summarisation uses transformer-based seq2seq models with attention.
Key parameters: `sentenceCount` (extractive, default 3, max 20) and `summaryLength` (abstractive: short/medium/long).
Maximum input document size is 125,000 characters.
Extractive is faster and cheaper; abstractive is slower but produces more fluent summaries.
Abstractive summarisation may hallucinate; extractive is more faithful to the source.
Both methods are available as pre-built models in Azure AI Language—no custom training needed.
Use extractive for accuracy-critical applications; use abstractive when readability is paramount.
These come up on the exam all the time. Here's how to tell them apart.
Extractive Summarisation
Selects existing sentences from the source text.
Output is always verbatim—no new words.
Faster and cheaper to run.
May produce disjointed or choppy summaries.
Used when factual accuracy is critical (e.g., legal, medical).
Abstractive Summarisation
Generates new sentences that paraphrase the source.
Output is fluent and natural-sounding.
Slower and more computationally expensive.
Risk of hallucinating facts not in the source.
Used when readability and conciseness are priorities (e.g., news digests).
Mistake
Extractive summarisation uses deep learning to generate new sentences.
Correct
Extractive summarisation selects existing sentences from the source text; it does not generate new text. Deep learning may be used for ranking, but the output is always a subset of the original.
Mistake
Abstractive summarisation is always better because it produces more fluent summaries.
Correct
While abstractive summaries are often more fluent, they risk hallucinating facts not present in the source. Extractive summaries are more faithful to the original and are preferred when accuracy is paramount.
Mistake
You need to train a custom model for summarisation in Azure.
Correct
Azure AI Language provides pre-built extractive and abstractive summarisation models. Custom training is possible but not required for most use cases.
Mistake
Extractive summarisation can be used for any document length.
Correct
The input document must be at least a few sentences long; otherwise, there is nothing to extract. The API has a maximum of 125,000 characters, but very short documents may yield poor summaries.
Mistake
Abstractive summarisation always produces a summary of exactly the requested length.
Correct
The `summaryLength` parameter is a rough guide; the model may produce a slightly shorter or longer summary. The exact length is not guaranteed.
Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.
Extractive summarisation selects the most important sentences from the source text and presents them verbatim. Abstractive summarisation uses deep learning to generate new sentences that capture the meaning, potentially using different words. On Azure, both are available through the Azure AI Language Text Summarisation API. Extractive is configured with `kind: ExtractiveSummarization` and parameters like `sentenceCount`. Abstractive uses `kind: AbstractiveSummarization` and `summaryLength`. Choose extractive when verbatim accuracy is critical; choose abstractive for fluent, concise summaries.
No, extractive summarisation requires multiple sentences to select from. If the input document has fewer sentences than the requested `sentenceCount`, the API will return all available sentences. For a single sentence, the summary would be that sentence itself, which is not useful. In such cases, abstractive summarisation might still produce a condensed version, but it may not add value. For the exam, remember that extractive summarisation works best with multi-sentence documents.
Consider your requirements for accuracy vs. fluency. If you need a factually exact summary and can tolerate some lack of flow, use extractive. If you need a natural-sounding summary and can accept minor inaccuracies, use abstractive. Also consider cost and speed: extractive is faster and cheaper. For the AI-900 exam, know that extractive is used when every word matters (e.g., legal contracts) and abstractive is used for general-purpose summarisation (e.g., news articles).
Common pitfalls include: (1) Not setting the correct language code, causing poor performance. (2) Setting `sentenceCount` too high, resulting in a summary that is too long. (3) Relying on abstractive summarisation for critical facts without verifying for hallucinations. (4) Exceeding the 125,000-character limit. (5) Forgetting to handle errors in the API response. For the exam, you should be aware that the API returns errors for invalid input and that you need to poll for job completion.
Yes, the Azure AI Language Text Summarisation API supports both extractive and abstractive summarisation. You specify which one you want using the `kind` parameter in the request body: `ExtractiveSummarization` or `AbstractiveSummarization`. Both are part of the same `/analyze-text/jobs` endpoint. This is a common exam point: candidates may think they are separate services, but they are features within the same service.
The default `sentenceCount` is 3. You can set it between 1 and 20. If the document has fewer than the requested number, the API returns all sentences. The exam may ask for this default value, so remember that it is 3.
Yes, abstractive summarisation can generate words and phrases not present in the source text. This is by design—it paraphrases and condenses. However, it can also hallucinate facts that are not true or not present, which is a known limitation. For the exam, understand that abstractive summaries may introduce inaccuracies, while extractive summaries are always faithful to the source.
You've just covered Extractive vs Abstractive Text Summarisation — now see how well it sticks with free AI-900 practice questions. Full explanations included, no account needed.
Done with this chapter?