昇思25天学习打卡营第14天|GPT2文本摘要

一、简介：

GPT-2（Generative Pre-trained Transformer 2）是由OpenAI开发的一种基于Transformer架构（decoder-only）的大型自然语言处理模型。它通过在大规模文本数据上进行预训练，能够理解和生成自然语言文本。GPT-2的特点在于其庞大的模型规模和强大的生成能力，能够生成连贯且上下文相关的文本，适用于多种自然语言处理任务，如文本生成、翻译、问答系统等。

二、环境准备：

在开始训练模型之前，需要先安装mindspore和mindnlp两个工具库，mindspore的下载可以参考我的昇思25天学习打卡营第1天|快速入门-CSDN博客 ，mindnlp可以直接使用pip方式下载：

pip install tokenizers==0.15.0 -i https://pypi.tuna.tsinghua.edu.cn/simple

pip install mindnlp

下载完成之后就可以，开始下面的训练了：

三、数据集准备：

1、数据集加载：

本次实验使用的是nlpcc2017摘要数据，内容为新闻正文及其摘要，总计50000个样本

from mindnlp.utils import http_get
import time

# 下载数据
url = 'https://download.mindspore.cn/toolkits/mindnlp/dataset/text_generation/nlpcc2017/train_with_summ.txt'
path = http_get(url, './')

from mindspore.dataset import TextFileDataset

# 加载数据
dataset = TextFileDataset(str(path), shuffle=False)
dataset.get_dataset_size()

# 划分训练集和测试集
train_dataset, test_dataset = dataset.split([0.9, 0.1], randomize=False)

2、数据预处理：

import json
import numpy as np
from mindnlp.transformers import BertTokenizer

# 构建处理的类
def process_dataset(dataset, tokenizer, batch_size=6, max_seq_len=1024, shuffle=False):
    def read_map(text):
        data = json.loads(text.tobytes())
        return np.array(data['article']), np.array(data['summarization'])

    def merge_and_pad(article, summary):
        # tokenization
        # pad to max_seq_length, only truncate the article
        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']
    
    dataset = dataset.map(read_map, 'text', ['article', 'summary'])
    # change column names to input_ids and labels for the following training
    dataset = dataset.map(merge_and_pad, ['article', 'summary'], ['input_ids', 'labels'])

    dataset = dataset.batch(batch_size)
    if shuffle:
        dataset = dataset.shuffle(batch_size)

    return dataset


# 使用BertTokenizer分词器
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
len(tokenizer)

train_dataset = process_dataset(train_dataset, tokenizer, batch_size=4)
print(next(train_dataset.create_tuple_iterator()))

 四、模型搭建：

1、构建GPT2ForSummarization模型：

from mindspore import ops
from mindnlp.transformers import GPT2LMHeadModel

class GPT2ForSummarization(GPT2LMHeadModel):
    def construct(
        self,
        input_ids = None,
        attention_mask = None,
        labels = None,
    ):
        outputs = super().construct(input_ids=input_ids, attention_mask=attention_mask)
        shift_logits = outputs.logits[..., :-1, :]
        shift_labels = labels[..., 1:]
        # 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)
        return loss

在这段代码中，`shift_logits`和`shift_labels`的操作体现了“shift right”的概念。"Shift right"（右移）是一种在自然语言处理中常用的操作，通过将模型的输出（logits）和标签（labels）向右移动一个位置，使得每个时间步的预测与下一个时间步的实际标签对齐，从而在训练过程中有效地计算损失函数，帮助模型学习到正确的上下文关系，生成连贯的文本。具体来说：

1. `shift_logits = outputs.logits[..., :-1, :]`：这一行代码将`logits`向右移动了一个位置。原本`logits`的形状是`[batch_size, sequence_length, vocab_size]`，通过`[..., :-1, :]`的操作，去掉了最后一个时间步的`logits`，相当于将`logits`向右移动了一个位置。

2. `shift_labels = labels[..., 1:]`：这一行代码将`labels`向右移动了一个位置。原本`labels`的形状是`[batch_size, sequence_length]`，通过`[..., 1:]`的操作，去掉了第一个时间步的`labels`，相当于将`labels`向右移动了一个位置。

通过这两步操作，`shift_logits`和`shift_labels`在时间步上对齐了，即`shift_logits`的每个时间步对应的是`shift_labels`的下一个时间步。这种对齐方式是为了计算损失函数，使得模型预测的下一个词与实际的下一个词进行比较，从而训练模型生成连贯的文本。

2、动态学习率：

通过定义一个动态学习率调度器 `LinearWithWarmUp`，通过在训练初期线性增加学习率（预热阶段），然后在训练后期线性降低学习率（衰减阶段），以帮助模型在训练过程中更快地收敛并稳定性能。这种策略结合了学习率的预热和衰减，使得模型在不同训练阶段都能获得合适的学习率，从而提高训练效果。

from mindspore import ops
from mindspore.nn.learning_rate_schedule import LearningRateSchedule

class LinearWithWarmUp(LearningRateSchedule):
    """
    设置动态学习率
    """
    def __init__(self, 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):
        if global_step < self.num_warmup_steps:
            return global_step / float(max(1, self.num_warmup_steps)) * self.learning_rate
        return ops.maximum(
            0.0, (self.num_training_steps - global_step) / (max(1, self.num_training_steps - self.num_warmup_steps))
        ) * self.learning_rate

五、模型训练：

下面的训练耗时巨大，最好使用A100完成

num_epochs = 1
warmup_steps = 2000
learning_rate = 1.5e-4

num_training_steps = num_epochs * train_dataset.get_dataset_size()


from mindspore import nn
from mindnlp.transformers import GPT2Config, GPT2LMHeadModel

config = GPT2Config(vocab_size=len(tokenizer))
model = GPT2ForSummarization(config)

lr_scheduler = LinearWithWarmUp(learning_rate=learning_rate, num_warmup_steps=warmup_steps, num_training_steps=num_training_steps)
optimizer = nn.AdamWeightDecay(model.trainable_params(), learning_rate=lr_scheduler)

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

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(network=model, train_dataset=train_dataset,
                  epochs=1, optimizer=optimizer, callbacks=ckpoint_cb)
trainer.set_amp(level='O1')  # 开启混合精度

trainer.run(tgt_columns="labels")

 六、模型推理：

首先将测试数据集，转换成中文数据：

def process_test_dataset(dataset, tokenizer, batch_size=1, max_seq_len=1024, max_summary_len=100):
    def read_map(text):
        data = json.loads(text.tobytes())
        return np.array(data['article']), np.array(data['summarization'])

    def pad(article):
        tokenized = tokenizer(text=article, truncation=True, max_length=max_seq_len-max_summary_len)
        return tokenized['input_ids']

    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)
model.config.eos_token_id = model.config.sep_token_id
i = 0
for (input_ids, raw_summary) in test_dataset.create_tuple_iterator():
    output_ids = model.generate(input_ids, max_new_tokens=50, num_beams=5, no_repeat_ngram_size=2)
    output_text = tokenizer.decode(output_ids[0].tolist())
    print(output_text)
    i += 1
    if i == 1:
        break

 由于，我的模型还没训练完成，所以结果就不展示了（doge）