240706_昇思学习打卡-Day18-基于MindSpore的GPT2文本摘要

今天做一个根据一段文章提取摘要的提取器，基于nlpcc2017摘要数据，内容为新闻正文及其摘要，就是训练集及标签。

首先我们来预装以下MindSpore环境

%%capture captured_output
# 实验环境已经预装了mindspore==2.2.14，如需更换mindspore版本，可更改下面mindspore的版本号
!pip uninstall mindspore -y
!pip install -i https://pypi.mirrors.ustc.edu.cn/simple mindspore==2.2.14

安装tokenizers和mindnlp

!pip install tokenizers==0.15.0 -i https://pypi.tuna.tsinghua.edu.cn/simple
# 该案例在 mindnlp 0.3.1 版本完成适配，如果发现案例跑不通，可以指定mindnlp版本，执行`!pip install mindnlp==0.3.1`
!pip install mindnlp

数据集加载与处理

1.数据集加载

from mindnlp.utils import http_get# download dataset
url = 'https://download.mindspore.cn/toolkits/mindnlp/dataset/text_generation/nlpcc2017/train_with_summ.txt'
path = http_get(url, './')

from mindspore.dataset import TextFileDataset# load dataset
dataset = TextFileDataset(str(path), shuffle=False)
dataset.get_dataset_size()

# split into training and testing dataset
train_dataset, test_dataset = dataset.split([0.9, 0.1], randomize=False)

2.数据预处理

import json
import numpy as np# 数据预处理函数
def process_dataset(dataset, tokenizer, batch_size=6, max_seq_len=1024, shuffle=False):"""对数据集进行预处理，包括读取、映射、批处理和打乱顺序。参数:- dataset: 输入的数据集- tokenizer: 用于文本编码的分词器- batch_size: 批次大小，默认为6- max_seq_len: 最大序列长度，默认为1024- shuffle: 是否在批处理前打乱数据，默认为False返回:- 处理后的数据集"""# 定义一个转换函数，将json字符串转换成numpy数组def read_map(text):data = json.loads(text.tobytes())  # 将二进制字符串转换成json对象return np.array(data['article']), np.array(data['summarization'])  # 返回文章和摘要的numpy数组# 定义一个合并并填充函数，用于处理文章和摘要def merge_and_pad(article, summary):# 使用tokenizer进行文本编码，设置最大长度，仅截断文章部分tokenized = tokenizer(text=article, text_pair=summary,padding='max_length', truncation='only_first', max_length=max_seq_len)return tokenized['input_ids'], tokenized['input_ids']  # 返回输入ID# 应用read_map函数到数据集上，将文本列转换为文章和摘要的numpy数组dataset = dataset.map(read_map, 'text', ['article', 'summary'])# 应用merge_and_pad函数到数据集上，将文章和摘要列转换为模型输入所需的格式dataset = dataset.map(merge_and_pad, ['article', 'summary'], ['input_ids', 'labels'])# 对数据集进行批处理dataset = dataset.batch(batch_size)# 如果shuffle为True，则对批处理后的数据集进行随机打乱if shuffle:dataset = dataset.shuffle(batch_size)# 返回处理后的数据集return dataset

我们要将原始文本转化为BERT模型可以理解的形式将原始文本转化为BERT模型可以理解的形式，即将文本切分成子词（subwords），并转换为相应的token ID，同时添加特殊标记如[CLS]和[SEP]，以满足BERT模型的输入要求。

因为GPT-2模型没有专门针对中文设计的Tokenizer，但BERT有专门针对中文的预训练模型，如bert-base-chinese，其Tokenizer能够很好地处理中文文本但BERT有专门针对中文的预训练模型，如bert-base-chinese，其Tokenizer能够很好地处理中文文本，所以我们选择了BertTokenizer作为替代方案。

from mindnlp.transformers import BertTokenizer# 我们使用BertTokenizer来对中文文本进行分词。
# 从预训练的'bert-base-chinese'模型加载tokenizer实例。
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')# 输出tokenizer的词汇表大小。
len(tokenizer)

train_dataset = process_dataset(train_dataset, tokenizer, batch_size=4)

next(train_dataset.create_tuple_iterator())

模型构建

1. 构建GPT2ForSummarization模型，注意shift right的操作。

from mindspore import ops
from mindnlp.transformers import GPT2LMHeadModel# 定义GPT2ForSummarization类，继承自GPT2LMHeadModel，用于文本摘要任务。
class GPT2ForSummarization(GPT2LMHeadModel):def construct(self,input_ids = None,  # 输入的token ID序列attention_mask = None,  # 注意力掩码，用于指示哪些位置应该被忽略labels = None,  # 标签序列，用于计算损失):"""构造函数，用于前向传播计算。参数:- input_ids: 输入的token ID序列- attention_mask: 注意力掩码- labels: 标签序列返回:- loss: 计算得到的损失值"""# 调用父类的构造函数，执行前向传播计算。outputs = super().construct(input_ids=input_ids, attention_mask=attention_mask)# 将输出的logits向左移动一位，去除最后一个token的预测结果。shift_logits = outputs.logits[..., :-1, :]# 将标签向右移动一位，去除第一个token的标签。shift_labels = labels[..., 1:]# 将shift_logits和shift_labels展平，以便于计算交叉熵损失。# Flatten the tokensloss = ops.cross_entropy(shift_logits.view(-1, shift_logits.shape[-1]), shift_labels.view(-1), ignore_index=tokenizer.pad_token_id)  # 忽略pad_token_id对应的损失# 返回计算得到的损失值。return loss

2.动态学习率

from mindspore import ops
from mindspore.nn.learning_rate_schedule import LearningRateSchedule# 定义带有预热阶段的学习率调度器
class LinearWithWarmUp(LearningRateSchedule):"""实现线性预热后衰减的学习率策略。属性:- learning_rate: 基础学习率- num_warmup_steps: 预热步数- num_training_steps: 总训练步数"""def __init__(self, learning_rate, num_warmup_steps, num_training_steps):"""初始化LinearWithWarmUp类。参数:- learning_rate: 浮点数，基础学习率。- num_warmup_steps: 整数，预热阶段的步数。- num_training_steps: 整数，总训练步数。"""super().__init__()self.learning_rate = learning_rateself.num_warmup_steps = num_warmup_stepsself.num_training_steps = num_training_stepsdef construct(self, global_step):"""根据当前全局步数计算学习率。参数:- global_step: 当前全局训练步数。返回:- 学习率：根据预热和衰减策略计算出的学习率。"""if global_step < self.num_warmup_steps:# 在预热阶段，学习率线性增加return global_step / float(max(1, self.num_warmup_steps)) * self.learning_rateelse:# 在预热阶段之后，学习率线性衰减至0return ops.maximum(0.0, (self.num_training_steps - global_step) / (max(1, self.num_training_steps - self.num_warmup_steps))) * self.learning_rate

模型训练

num_epochs = 1
warmup_steps = 2000
learning_rate = 1.5e-4num_training_steps = num_epochs * train_dataset.get_dataset_size()

# 导入MindSpore的神经网络模块和GPT-2相关配置及模型
from mindspore import nn
from mindnlp.transformers import GPT2Config, GPT2LMHeadModel# 初始化GPT-2配置，基于tokenizer的词汇表大小
config = GPT2Config(vocab_size=len(tokenizer))# 创建GPT-2用于摘要生成的模型实例
model = GPT2ForSummarization(config)# 初始化学习率调度器，包括学习率和warmup步数
lr_scheduler = LinearWithWarmUp(learning_rate=learning_rate, num_warmup_steps=warmup_steps, num_training_steps=num_training_steps)# 创建Adam优化器，带有权重衰减，参数为模型的可训练参数和学习率调度器
optimizer = nn.AdamWeightDecay(model.trainable_params(), learning_rate=lr_scheduler)

# 记录模型参数数量
print('number of model parameters: {}'.format(model.num_parameters()))

# 导入Trainer类和CheckpointCallback类，用于训练模型和设置保存检查点的回调函数
from mindnlp._legacy.engine import Trainer
from mindnlp._legacy.engine.callbacks import CheckpointCallback# 设置检查点回调函数，指定保存路径、检查点名称、保存频率和最多保留的检查点数量
ckpoint_cb = CheckpointCallback(save_path='checkpoint', ckpt_name='gpt2_summarization',epochs=1, keep_checkpoint_max=2)# 初始化Trainer对象，传入模型、训练数据集、训练轮数、优化器和回调函数
trainer = Trainer(network=model, train_dataset=train_dataset,epochs=1, optimizer=optimizer, callbacks=ckpoint_cb)# 开启自动混合精度训练，以提高训练速度和精度
trainer.set_amp(level='O1')  # 开启混合精度

这里官方说训练时间较长，确实比较长，在jupyter中确实不太好跑。两个点儿跑了四分之一

# 训练
trainer.run(tgt_columns="labels")

模型推理

模型处理，将向量数据处理为中文数据

def process_test_dataset(dataset, tokenizer, batch_size=1, max_seq_len=1024, max_summary_len=100):"""处理测试数据集，为摘要生成任务准备数据。参数:dataset: tf.data.Dataset对象，包含测试数据的文章和摘要。tokenizer: Hugging Face的tokenizer对象，用于将文章文本转换为token序列。batch_size: int，数据加载时的批量大小，默认为1。max_seq_len: int，最大序列长度，包括文章和摘要，默认为1024。max_summary_len: int，摘要的最大长度，默认为100。返回:处理后的数据集，每批包含多个样本的文章和摘要序列。"""def read_map(text):"""从TensorFlow数据集中提取文章和摘要文本。参数:text: tf.Tensor，包含JSON格式文本的数据。返回:np.array，包含文章和摘要的数组。"""data = json.loads(text.tobytes())return np.array(data['article']), np.array(data['summarization'])def pad(article):"""对文章文本进行padding和truncation，以适应最大序列长度。参数:article: str，待处理的文章文本。返回:list，经过padding和truncation后的token序列。"""tokenized = tokenizer(text=article, truncation=True, max_length=max_seq_len-max_summary_len)return tokenized['input_ids']# 对数据集进行预处理，包括提取文章和摘要，以及对文章进行paddingdataset = dataset.map(read_map, 'text', ['article', 'summary'])dataset = dataset.map(pad, 'article', ['input_ids'])# 将处理后的数据集组织成批量dataset = dataset.batch(batch_size)return dataset

test_dataset = process_test_dataset(test_dataset, tokenizer, batch_size=1)

print(next(test_dataset.create_tuple_iterator(output_numpy=True)))

# 加载预训练模型
model = GPT2LMHeadModel.from_pretrained('./checkpoint/gpt2_summarization_epoch_0.ckpt', config=config)

# 设置模型为推理模式
model.set_train(False)# 将eos_token_id设置为sep_token_id，确保生成的摘要以分隔符结尾
model.config.eos_token_id = model.config.sep_token_id# 初始化计数器
i = 0# 遍历测试数据集
for (input_ids, raw_summary) in test_dataset.create_tuple_iterator():# 使用模型生成摘要，限制新生成的token数量，使用多束搜索算法output_ids = model.generate(input_ids, max_new_tokens=50, num_beams=5, no_repeat_ngram_size=2)# 将生成的token ids解码为文本output_text = tokenizer.decode(output_ids[0].tolist())# 打印生成的摘要文本print(output_text)# 计数器加一i += 1# 当计数器达到1时，退出循环，只输出一个示例if i == 1:break

打卡图片：