CCF-BDCI-2021客服通话文本摘要提取

作者

摘要：

合集：AI案例-自然语言处理-零售业
赛题：CCF大数据与计算智能大赛-BDCI-2021-客服通话文本摘要提取
AI问题：文本生成-摘要提取问题
数据集：联通客服中心通话文本数据集，包括25,001条训练数据和7,526条测试数据。
数据集发布方：中国联合网络通信集团有限公司
数据集价值：挖掘海量客服通话数据，采用合适的算法精准提取文本摘要。
解决方案：文本摘要提取PEGASUS模型、PaddleNLP开发框架。

一、赛题描述

客服中心每天都需要接通大量的客户来电，客户来电需要进行语音转文本，同时对文本进行概括，提取客户核心诉求，但是人工总结会增加客服工作量，降低工作效率，因此期望使用AI算法进行自动的文本摘要生成。

赛题任务是对客户通话数据进行摘要提取，因属于特定领域的通话数据，所以同宽泛性文本摘要提取存在一定的异同，主要的难点如下：

  • 语音通话通过第三方服务转写为文本内容，存在一定的转写错误；
  • 文本长度不固定，长短不一，可能存在文本长度过长的现象；
  • 因为是具体领域的客服通话文本，专业词汇可能较多。

二、数据集描述

数据来源于客服中心通话文本数据库，首先是对通话进行录音，然后使用第三方服务进行语音转文本，文本常规情况下主要用于数据分析，用于支撑客服中心的各种客服人员指标评定和关键字分析。

数据说明

文件划分为训练集和评测集

训练集

文件名：train.csv  
文件格式：UTF-8  
文件内字段分隔符：|  
文件内字段：  
Id：索引，评测用  
content：通话文本  
abstract：摘要

数据样例：编号为0和1的数据记录包括索引、通话文本和摘要三个字段。

0|
​
【坐席】您好，实习话务员为您，【客户】服务，喂，你好，是这样的，我那个我的电话因为上次突然把给我停机了，我不知道啥意思，然后我就好长时间没有使用，我这次拿着10，怎么我欠费160多了？噢，我想问一下，我这机器现在是在停机状态吧，【坐席】嗯，对是的？【客户】对停机状态，你们怎么还收我费用啊，【坐席】嗯，您稍等这边看的话，先生，咱们这12月份的话是没有收您的费用的，这边是这个产生的费用是您11月份的女士先生，【客户】那我11月份我现在-160，那我想问一下，那我这个怎么能-160？我始终没超一个星期，他就你们就给我停机了，因为那我忙着在外地出差，我就没有，我就没有那个办这个找你们，【坐席】嗯，先生这边看的话，先生，您是一个就是11月份的话，有一个是，嗯，基本套餐费是88块钱，还有您上个月未结清的话费是76块钱，【客户】但是我刚才你们给我反馈那个是我欠160多，。。。|
​
用户来电反映手机号卡收费问题，用户称现在怎么欠费167.65，我方经查询用户有10月欠费76和11月欠费88，用户称********此号卡是在9月1号开通的，没用几天就别关停服务了(局方停机），我都没有怎么使用，怎么还扣取我的费用，我某某人常解释，用户对超出的费用不认可，请核实处理，谢谢             
                                                           
1|
【客户】嗯，【坐席】，很高兴为您服务，【客户】喂，你好，你好，我想问一下，我没有去过这个吉林松原市，为什么我的以前吧，数据查询码里头会有松，原是这个这个码，【坐席】请问您是？您是不是通过附近这个附近，他搜索人气的当地的基站，【客户】我根本就没有去过，他这跟卡都变呐？【坐席】没有试过周边是您来电的这个号码是吗，【客户】对，而且不是一回了，上回头两天也是【坐席】那您这个问题，我这边给您登记上报一下，然后让后台帮您核实一下，如果联系您的话，联系您来电的这个号码就行是吧，嗯，好的，那您稍后保持电话通畅，我这边给您登记了，还有其他可以帮您的吗，【客户】对？没了好【坐席】好的，感谢您的来电|
​
用户来电反映查询漫游地，显示有吉林，用户称没有去过附近，要求核实回复，请处理谢谢

测试集

和训练集比较，测试集中没有abstract/摘要字段。

文件名：test_dataset.csv  
文件格式：UTF-8  
文件内字段分隔符：|  
文件内字段：  
id：索引，评测用  
content：通话文本

数据集版权许可协议

BY-NC-SA 4.0
https://creativecommons.org/licenses/by-nc-sa/4.0/deed.zh-hans

三、解决方案样例

PEGASUS模型

解决方案采用PEGASUS模型。PEGASUS (Pre-training with Extracted Gap-sentences for Abstractive SUmmarization) 是 Google Research 在 2020 年提出的一种专门为文本摘要任务设计的预训练语言模型。其核心创新在于通过自监督学习目标直接模拟摘要生成过程，显著提升了抽象式摘要（abstractive summarization）的性能。本案例采用模型：Randeng-Pegasus-238M-Summary-Chinese。IDEA-CCNL/Randeng-Pegasus-238M-Summary-Chinese 是 IDEA研究院（粤港澳大湾区数字经济研究院） 和 CCNL（中国中文信息学会） 联合发布的 中文 PEGASUS 预训练模型，专门用于 中文文本摘要生成。

1. 核心思想

传统预训练模型（如BERT、GPT）的目标（如掩码语言建模）与摘要任务差异较大。PEGASUS提出关键句重构/Gap Sentences Generation (GSG) 预训练目标：

  • 关键步骤：从文档中选取重要句子（称为Gap Sentences）并掩码，模型基于剩余文本生成这些句子。
  • 模拟摘要：被掩码的句子类似摘要中的关键信息，迫使模型学习如何压缩和重构核心内容。

2. 模型架构

  • 基础结构：基于Transformer的编码器-解码器架构（类似BART）。
  • 预训练数据：利用海量无监督文本（如C4、HugeNews数据集）。
  • 两种预训练目标：
    • GSG（主目标）：学习摘要能力。
    • MLM（辅助目标，如BERT）：增强语言理解。

3. 关键创新点

  • 句子选择策略：
    • 重要性评分：通过ROUGE或TF-IDF计算句子与文档的相似度，选择高相关性句子作为Gap Sentences。
    • 随机选择：作为基线对比。
  • 高效微调：预训练后，在少量有监督摘要数据（如CNN/Daily Mail、XSum）上微调即可达到SOTA。

4. 性能优势

  • 低资源适应：在极少量标注数据下（仅1000条样本）仍能生成高质量摘要。
  • 多领域泛化：在新闻、科学论文、对话等不同领域表现优异。
  • SOTA结果：发布时在12项摘要任务中刷新纪录（如ROUGE、BERTScore指标）。

5. 应用场景

  • 长文本摘要：如新闻文章、研究报告。
  • 多文档摘要：整合多个相关文档的核心信息。
  • 实时摘要生成：适合需要快速提取关键信息的场景（如金融、医疗）。

安装开发包

外部库名称版本号
python3.7.12
pandas1.3.5
numpy1.21.6
paddlepaddle-gpu2.4.2.post116
paddlenlp2.5.2
paddlehub2.3.0
rouge1.0.1
  • 请参考文章《安装Paddle系列深度学习框架》，安装PaddleNLP框架。
  • 安装rouge Python 开发包，专门用于计算 ROUGE（Recall-Oriented Understudy for Gisting Evaluation） 指标，主要用于评估自动文本摘要（或机器翻译）的质量，通过与参考摘要（人工摘要）对比来评估生成摘要的效果。
  • 安装textrank4zh开发包。textrank4zh 是一个基于 TextRank 算法 的中文文本摘要和关键词提取工具，专门针对中文文本优化。它支持句子级摘要（TextRank4Sentence） 和关键词提取（TextRank4Keyword），适合中文自然语言处理任务。
  • 降低networkx版本号到2.5。textrank4zh 调用了旧版 NetworkX 的 from_numpy_matrix 方法，但新版 NetworkX（≥2.6）已将该方法更名为 from_numpy_array。
conda install -c conda-forge rouge
pip install textrank4zh
​
​
conda list NetworkX
# packages in environment at C:\AppData\Conda-Data\envs\paddle3-p312:
#
# Name                    Version                   Build  Channel
networkx                  3.4.2           py312haa95532_0    anaconda
​
(paddle3-p312) C:\Users\admin>pip install networkx==2.5

主要源码文件

各代码文件的运行顺序如下：

  • 运行 DataPreprocessing.ipynb，生成预处理数据（放在 processed 文件夹中）
  • 运行 Train.ipynb，训练模型
  • 运行 GenerateResult.py，根据训练的模型生成摘要

四、数据预处理流程

源码：DataPreprocessing.ipynb

这个Python脚本是一个对话摘要生成系统，主要包含数据预处理、分析和摘要生成三个主要部分。生成预处理数据将在processed文件夹中。

导入开发包包括：PegasusForConditionalGeneration、PegasusChineseTokenizer、Rouge、TextRank4Sentence等文本摘要相关的类。

import warnings
warnings.filterwarnings("ignore")
​
import re
import json
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from paddlenlp.transformers import PegasusForConditionalGeneration, PegasusChineseTokenizer
from rouge import Rouge
from textrank4zh import TextRank4Sentence

1. 数据加载与初步分析

  • 数据加载：从CSV文件(train_dataset.csv)加载训练数据，包含对话内容(content)和摘要(abstract)两列。
  • 长度分析：
    • 计算内容和摘要的最大、平均长度
    • 使用直方图可视化长度分布，标记90%分位数和平均值
    • 分析对话轮数和每轮对话的平均长度
#读取训练文件数据
txt_path='data/train_dataset.csv'
#读取训练数据文件
data=pd.read_csv(txt_path,encoding='utf-8',sep='|')
#打印查看数据样例
data.head(5)

2. 数据预处理流程

预处理包含多个步骤，逐步清洗和规范化对话数据：

  1. 去除问候语：
    • 对于以【客户】开头的对话，根据长度判断是否去除前几句
    • 短于25字符的第一句会被去除，短于20字符的第二句也会被去除
  2. 替换处理：
    • 加载停用词表 stopwords_dict.json 和替换词典 replace_dict.json
    • 应用替换规则去除无意义内容(如”* * * * * * * * “等)
  3. 去除短句子：
    • 过滤掉长度小于6个字符的短句
    • 规范化标点符号(将句号、问号统一为逗号)
  4. 更换前缀：
    • 将【坐席】替换为”坐:”，【客户】替换为”客:”

数据样例：stopwords_dict.json

    "你你": "你",
    "您您": "您",
    "女士": "",
    "很高兴为您服务，": "",
    "高兴为您服务，": "",
    "高兴为您服务？": "",
    "其他可以帮您": "",
    ...

数据样例：replace_dict.json

    "我我": "我",
    "你你": "你",
    "您您": "您",
    "先生": "",
    "女士": "",

3. 摘要生成方法

脚本实现了三种摘要生成方法并进行比较：

3.1、PEGASUS模型方法

  • 使用预训练的PEGASUS模型(中文版)生成摘要
  • 对于长文本(>512字符)，采用分段处理策略：
    • 直接截取前256+后256字符
    • 或先处理中间部分，再结合两端
model = PegasusForConditionalGeneration.from_pretrained('./model/checkpoints1')
model.eval()
tokenizer = PegasusChineseTokenizer.from_pretrained('./model/checkpoints1')

函数 infer()

  • 输入原始文本，输出生成的摘要
  • 处理流程：
    1. 使用分词器对文本进行tokenize和截断
    2. 调用模型生成摘要（使用beam search策略）
    3. 将生成的token序列解码回文本
num_beams = 4
max_source_length = 512
min_target_length = 0
max_target_length = 160
​
def infer(text, model, tokenizer):
    tokenized = tokenizer(text,
                          truncation=True,
                          max_length=max_source_length,
                          return_tensors='pd')
    preds, _ = model.generate(input_ids=tokenized['input_ids'],
                              max_length=160,
                              min_length=min_target_length,
                              decode_strategy='beam_search',
                              num_beams=num_beams)
    return(tokenizer.decode(preds[0], skip_special_tokens=True, clean_up_tokenization_spaces=False))
# 计算训练评估参数Rouge-1，Rouge-2，Rouge-L
# rouge = rg.Rouge()
# 初始化 ROUGE 评估器
rouge = Rouge()
def compute_metrics(rg,preds, targets):
    score = rg.get_scores(' '.join(preds), ' '.join(targets))
    rouge1 = score[0]['rouge-1']['f']
    rouge2 = score[0]['rouge-2']['f']
    rougel = score[0]['rouge-l']['f']
    # print(round(rouge1*100, 2),round(rouge2*100, 2),round(rougel*100, 2))
    score = round((rouge1 * 0.2 + rouge2 * 0.4 + rougel * 0.4) * 100, 2)
    return score

样例：

text = data['content'][0]
infer(text[:256]+ text[-256:],model,tokenizer)

生成的摘要：’我的电话上次突然把给我停机我不知道意思我就好长时间没有使用我这次拿着10怎我欠费160多，我想问我这机器现在是在停机状态吧’。

3.2、TextRank方法

  • 基于TextRank4Sentence从对话中提取关键句子
  • 使用停用词表过滤无关内容
  • 按权重排序选取最重要的句子组成摘要

TextRank 是一种基于图的 无监督 文本摘要算法，灵感来源于 Google 的 PageRank 算法。它通过分析句子之间的相似性关系，构建图模型并计算句子重要性，最终提取关键句子作为摘要。TextRank 将文本中的句子（或词语）视为图中的 节点，句子之间的相似性作为 边，通过迭代计算节点的权重（重要性），最终选出权重最高的句子作为摘要。

具体步骤

(1) 文本预处理

  • 分句：将文本拆分为句子列表（如按句号、问号分割）。
  • 分词与清洗：对每个句子分词，去除停用词（如“的”、“是”）、标点符号，并可能进行词干化（如“running” → “run”）。

(2) 构建图模型

  • 节点：每个句子代表图中的一个节点。
  • 边：计算句子之间的相似度（通常用 余弦相似度 或 重叠词比例），若相似度超过阈值，则添加边（有权重或无权重）。

(3) 迭代计算权重

  • 初始化所有节点的权重为 1。
  • 通过TextRank公式迭代更新权重，直到收敛（或达到最大迭代次数）：

(4) 提取关键句子

  • 按权重排序所有句子，选择 Top-K 个句子作为摘要。
  • 可选：限制摘要长度（如代码中的 sentence_min_len=5 和 len(processed_text) > 512）。

3.3、前后截取方法

简单截取前256+后256字符作为摘要。

4. 评估与比较

使用ROUGE指标评估三种方法：

  • ROUGE-1、ROUGE-2、ROUGE-L的F1值
  • 综合得分 = ROUGE-10.2 + ROUGE-20.4 + ROUGE-L*0.4

基于 def process_cut(text,new_replace_dict) 函数迭代生成方法：

  1. 如果小于512，直接塞进去
  2. 如果大于512小于1024，首先预测中间一段：text[256:256+512]，计算中间一段长度，mid_len=len(infer(change(text[256:256+512]))), 然后去两边的长度为(512-mid_len)/2的文本，分别调用 infer() 函数进行PEGASUS模型预测，然后拼接。
  3. 如果小于2048，取文本的前51后512，分别预测，然后拼接。
def process_cut(text,new_replace_dict):
    if len(text) <= 512:
        # print('小于512')
        return text
    elif len(text) <= 600:
        # print('小于600')
        return text[:256] + text[-256:]
    elif len(text) <= 2048:
        # print('小于2048')
        mid_text = text[256:-256]
        mid_text = mid_text[:256] + mid_text[-256:]
        mid_text = infer(mid_text, model, tokenizer)  # PEGASUS模型预测
        mid_text = change_word(mid_text,new_replace_dict)
        mid_len = len(mid_text)
        text1 = text[:(256-mid_len//2)] + mid_text + text[-(256-mid_len//2):]
        return text1
    else:
        # print('大于2048')
        return cut_upper512(text,new_replace_dict)

已知文本text，停用数据集new_replace_dict，使用三种方法进行指标评估。其中 processed_text 采用TextRank4Sentence 方法。

new_content = process_cut(text,new_replace_dict)
score1 = compute_metrics(rouge,new_content,abstract__)
score2 = compute_metrics(rouge,processed_text,abstract__)
score3 = compute_metrics(rouge,text[:256] + text[-256:],abstract__)
print("迭代抽取",score1,"TextRank",score2,"前后抽取",score3)

输出样例如下。通过箱线图比较三种方法的得分分布，最终选择表现最好的”迭代抽取”方法处理所有数据。

迭代抽取 24.22 TextRank 23.52 前后抽取 25.37
迭代抽取 14.88 TextRank 15.1 前后抽取 14.89
...

5. 输出结果

将处理后的对话内容保存到新的CSV文件(test_data.csv)，包含ID和处理后的content。

关键技术点

  1. 长文本处理策略：针对客服对话通常较长的问题，设计了分段处理和摘要迭代优化的方法。
  2. 领域特定清洗：针对客服对话特点，设计了专门的清洗规则(如问候语处理、短句过滤等)。
  3. 混合评估指标：结合多种ROUGE指标评估摘要质量，更全面反映生成效果。

这个系统特别适合处理客服对话场景，通过结合深度学习模型和规则方法，在保持语义完整性的同时有效缩短了文本长度。

五、训练流程

源码：Train.ipynb 。具体代码流程如下：

1. 环境配置与数据加载

  • 导入库：包括数据处理（pandas、numpy）、深度学习（paddle）、NLP 工具（paddlenlp）、评估工具（rouge）等。
  • 数据加载：
    • 从 CSV 文件 train_data_all.csv 加载数据。
    • 计算文本长度统计信息（data['content'].str.len().describe()）。
    • 随机打乱数据并按 9:1 划分训练集（train_data）和验证集（dev_data）。
    • 保存划分后的数据到 train_data.csv 和 dev_data.csv。
import os
import time
import numpy as np
import pandas as pd
import sklearn
​
from tqdm import tqdm
from rouge import Rouge
from functools import partial
import matplotlib.pyplot as plt
​
import paddle
from paddle.io import BatchSampler, DataLoader
​
from paddlenlp.datasets import load_dataset
from paddlenlp.transformers import PegasusForConditionalGeneration, PegasusChineseTokenizer
from paddlenlp.transformers import LinearDecayWithWarmup
from paddlenlp.data import DataCollatorForSeq2Seq
from paddlenlp.utils.log import logger
​
data_path = './processed/train_data_all.csv'
data=pd.read_csv(data_path,encoding='utf-8',sep='|')
data['content'].str.len().describe()

2. 超参数设置

MAX_CONTENT_LENGTH = 512
MAX_ABSTRACT_LENGTH = 160
MIN_CONTENT_LENGTH = 0
MIN_ABSTRACT_LENGTH = 0
BATCH_SIZE = 8 # 8
WARMUP_RATIO = 0.02
LR_RATE = 5e-5
EPOCHS_NUM = 2 # 50
LOG_STEP = 2000 # 2000
SSTIA_RATIO = 0.5 # 0.5
USE_SSTIA = True
NUM_BEAM = 4
ROUGE_METRIC_NAME = ['rouge-1', 'rouge-2', 'rouge-l']
CHECKPOINT_DIR = 'checkpoints'

3. 数据预处理

3.1、数据集构建

  • 定义 read_from_csv 函数读取 CSV 数据。
  • 使用 load_dataset 创建 PaddleNLP 数据集对象（train_dataset, dev_dataset）。
def read_from_csv(data_path):
    with open(data_path, 'r', encoding='utf-8') as f:
        next(f)
        for line in f:
            content, abstract = line.strip('\t').split("|")[1].strip(),line.strip('\t').split("|")[2].strip()
            yield {'content': content, 'abstract': abstract}
​
train_dataset  = load_dataset(read_from_csv, data_path=train_data_path, lazy=False, split="train")
dev_dataset  = load_dataset(read_from_csv, data_path=dev_data_path, lazy=False, split="dev")

3.2、文本和摘要的分词与编码

  • 加载预训练分词器：PegasusChineseTokenizer。
  • 使用 tokenize_input 函数对文本进行分词和编码（转换为 input_ids, attention_mask, labels）。
  • 应用 data_collator（DataCollatorForSeq2Seq）生成批次数据。

这个函数是 PEGASUS 模型训练流程中的关键预处理步骤，负责将原始文本（content）和摘要（abstract）转换为模型可处理的 tokenized 格式。例子：

假设输入：

example = {
    "content": "坐: 您好，请问有什么可以帮您？客: 我的网络无法连接。",
    "abstract": "客户反映网络无法连接"
}

Tokenize 后：

{
    "input_ids": [101, 234, 543, ..., 102],       # "坐: 您好..." 的 token IDs
    "attention_mask": [1, 1, 1, ..., 1],
    "labels": [102, 456, 789, ..., 103]           # "客户反映网络无法连接" 的 token IDs
}

tokenize_input()函数定义：

def tokenize_input(example,
                   content_name,
                   abstract_name,
                   tokenizer,
                   max_content_length,
                   max_abstract_length):
    """
    将输入的example中的content和abstract转换为id，并构造labels
    :arg example: 一个样本，包含content和abstract
    :arg content_name: content的key
    :arg abstract_name: abstract的key
    :arg tokenizer: 分词器
    :arg max_content_length: content的最大长度
    :arg max_abstract_length: abstract的最大长度
    :return: 返token后的input
    """
    inputs,targets = example[content_name],example[abstract_name]
    tokened_inputs = tokenizer(inputs,
                             max_length=max_content_length,
                             padding=False,
                             truncation=True,
                             return_attention_mask=True)
    tokened_labels = tokenizer(targets,
                       max_length=max_abstract_length,
                       padding=False,
                       truncation=True)
    # 把token后的【label】换为【input_ids】
    tokened_inputs["labels"] = tokened_labels["input_ids"]
    return tokened_inputs

该函数tokenize_input()的调用：

packed_tokened_fn = partial(tokenize_input,
                            content_name='content',
                            abstract_name='abstract',
                            tokenizer=tokenizer,
                            max_content_length=MAX_CONTENT_LENGTH,
                            max_abstract_length=MAX_ABSTRACT_LENGTH)

4. 数据加载器

train_data_loader  = paddle.io.DataLoader(dataset=train_dataset,batch_size=BATCH_SIZE,return_list=True,collate_fn=data_collator)
dev_batch_sampler  = BatchSampler(dataset=dev_dataset,batch_size=BATCH_SIZE,shuffle=False)
dev_data_loader = DataLoader(dataset=dev_dataset,batch_sampler=dev_batch_sampler,collate_fn=data_collator,return_list=True)

5. PEGASUS 模型训练类

  • 初始化：
    • 加载预训练模型 PegasusForConditionalGeneration。
    • 配置优化器（AdamW）和学习率调度器（LinearDecayWithWarmup）。
  • 训练与评估：
    • train_and_eval()：训练循环，按批次计算损失并反向传播，定期验证。
    • eval()：在验证集生成摘要，使用 ROUGE 指标评估质量，保存最佳模型。
  • ROUGE 计算：
    • 使用 rouge.get_scores() 计算 ROUGE-1/2/L 分数。
# 加载Toleknizer
tokenizer = PegasusChineseTokenizer.from_pretrained('IDEA-CCNL/Randeng-Pegasus-238M-Summary-Chinese')
​
# 加载预训练模型
model = PegasusForConditionalGeneration.from_pretrained('IDEA-CCNL/Randeng-Pegasus-238M-Summary-Chinese')
​
# 设置数据收集器
data_collator = DataCollatorForSeq2Seq(tokenizer=tokenizer, model=model)
​
    def train_and_eval(self):
        if self.mode != 'train_and_eval':
            self.mode = 'train_and_eval'
        logger.info("***** Running training *****")
        logger.info(f"  Num examples = {len(self.train_data_loader.dataset)}")
        logger.info(f"  Num Epochs = {EPOCHS_NUM}")
        logger.info(f"  Instantaneous batch size per GPU = {BATCH_SIZE}")
        logger.info(f"  Total num training steps = {self.num_steps}")
        for epoch in range(EPOCHS_NUM):
            for step, batch in enumerate(self.train_data_loader):
                self.global_step += 1
                lm_logits, _, loss = self.model(**batch)
                loss.backward()
                self.optimizer.step()
                self.lr_scheduler.step()
                self.optimizer.clear_grad()
                if self.global_step % LOG_STEP == 0:
                    logger.info(f"【step {self.global_step}, "
                                f"epoch: {epoch}, "
                                f"batch: {step}, "
                                f"loss: {round(float(loss),5)}, "
                                f"lr: {self.optimizer.get_lr()}, "
                                f"speed: {round(LOG_STEP / (time.time() - self.train_time),4)}step/s】")
                    self.train_time = time.time()
                # 为了节约时间，间隔一定时间进行验证
                if self.global_step % self.eval_steps == 5 or \
                        self.global_step == self.num_steps or \
                        self.global_step in [1000,6000,10000]:
                    self.eval()
        logger.info("***** Finish training *****")

6. 训练执行

PEGASUS_ = PEGASUS(model=model,
                   tokenizer=tokenizer,
                   train_data_loader=train_data_loader,
                   dev_data_loader=dev_data_loader)
​
PEGASUS_.train_and_eval()

运行过程

运行 Train.ipynb 的部分输出如下：

[2025-07-10 14:55:27,345] [    INFO] - ***** Running training *****
[2025-07-10 14:55:27,346] [    INFO] -   Num examples = 22501
[2025-07-10 14:55:27,348] [    INFO] -   Num Epochs = 2
[2025-07-10 14:55:27,348] [    INFO] -   Instantaneous batch size per GPU = 8
[2025-07-10 14:55:27,349] [    INFO] -   Total num training steps = 5626
Evaluation:: 100%|██████████| 313/313 [5:59:00<00:00, 68.82s/it]   
[2025-07-10 21:10:32,449] [    INFO] - eval done total : 22505.11562681198 s
[2025-07-10 21:10:32,452] [    INFO] - Eval use time: 22505.119639873505 s
rouge-1: 0.08144851605513426, rouge-2: 0.08144851605513426, rouge-l: 0.08144851605513426
[2025-07-10 21:10:39,611] [    INFO] - tokenizer config file saved in checkpoints\tokenizer_config.json
[2025-07-10 21:10:39,616] [    INFO] - Special tokens file saved in checkpoints\special_tokens_map.json

六、生成摘要

源码：GenerateResult.py

这个Python脚本是一个基于PEGASUS模型的文本摘要生成系统，主要用于对测试数据生成摘要结果。

1、文件处理

  1. 输入文件：
    • 预期格式：processed/test_data.csv
    • 每行结构：id|content
  2. 输出文件：
    • 生成文件：result.csv
    • 每行结构：id|ret（ret为生成的摘要）

2、关键技术点

  1. Beam Search解码：
    • 使用beam search策略提高生成质量
    • beam数量设为4，平衡生成质量和计算效率
  2. 长度控制：
    • 输入文本超过512token会被截断
    • 生成摘要限制在0-160token之间

运行 GenerateResult.py 的部分输出如下：

W0711 14:53:26.987985 21464 gpu_resources.cc:61] Please NOTE: device: 0, GPU Compute Capability: 7.5, Driver API Version: 12.6, Runtime API Version: 10.2
W0711 14:53:27.001204 21464 gpu_resources.cc:91] device: 0, cuDNN Version: 7.6.
Building prefix dict from the default dictionary ...
Loading model from cache C:\Users\huuuyjia\AppData\Local\Temp\jieba.cache
Loading model cost 0.882 seconds.
Prefix dict has been built successfully.
Infer::   7%|████▌                                                                | 497/7526 [15:33<3:39:58,  1.88s/it]

源码开源协议

GPL-v3

七、获取案例套装

需要登录后才允许下载文件包。登录 需要登录后才允许下载文件包。登录

发表评论