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 tokens
        loss = 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_rate
        self.num_warmup_steps = num_warmup_steps
        self.num_training_steps = num_training_steps

    def 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_rate
        else:
            # 在预热阶段之后，学习率线性衰减至0
            return 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-4

num_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']

    # 对数据集进行预处理，包括提取文章和摘要，以及对文章进行padding
    dataset = 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

打卡图片：