目录

环境配置

数据集下载和获取

数据集拆分

处理数据集

模型构建

​​​​​​​模型训练

​​​​​​​模型推理

---

环境配置

---

        “%%capture captured_output”这一行指令通常旨在捕获后续整个代码块所产生的输出结果。首先，将已预装的 mindspore 库予以卸载。随后，借助指定的国内镜像源（如 https://pypi.mirrors.ustc.edu.cn/simple ）来安装特定版本（即 2.2.14 版）的 mindspore 库。接着，通过另一个国内镜像源（如 https://pypi.tuna.tsinghua.edu.cn/simple ）完成指定版本（0.15.0 版）的 tokenizers 库的安装。最后，对 mindnlp 库进行安装操作。

        代码如下：

%%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  
!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  

数据集下载和获取

---

        对一个数据集进行下载操作，而后将其加载构建为 TextFileDataset 类型的对象，最后获取该数据集的规模大小信息。

        代码如下：

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()  

        分析：首先，从 mindnlp.utils 模块导入了 http_get 函数。接着，定义了一个字符串，此字符串乃是数据集的下载链接 URL 。随后，运用 http_get 函数从指定的该 URL 下载数据集，并将其保存至当前目录（即'./'），返回的路径被存储在 path 变量里。之后，从 mindspore.dataset 模块引入 TextFileDataset 类。再接着，利用下载完成的数据集的路径创建了一个 TextFileDataset 对象，并将其命名为 dataset ，同时设置不打乱数据的顺序（shuffle=False）。最终，调用 get_dataset_size 方法以获取数据集的大小。

        运行结果：

数据集拆分

---

        将名为 dataset 的数据集按照比例 0.9 和 0.1 拆分为训练数据集 train_dataset 和测试数据集 test_dataset ，并且拆分过程不进行随机操作（randomize=False）。

        代码如下：

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

​​​​​​​处理数据集

---

        第一步：构建了一个用于对数据集予以预处理的函数 process_dataset ，同时借助 BertTokenizer 开展中文文本的处理工作。

        代码如下：

import json  
import numpy as np  
# preprocess dataset  
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  
from mindnlp.transformers import BertTokenizer  
# We use BertTokenizer for tokenizing chinese context.  
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')  
len(tokenizer)

        分析：首先，在 process_dataset 函数中：

        定义了一个内部函数read_map，用于将输入的文本转换为numpy 数组形式的 article 和 summarization 。

        定义了 merge_and_pad 函数，对 article 和 summary 进行分词处理，并进行填充以达到最大序列长度。

        对输入的数据集进行一系列的操作，包括读取映射、合并和填充、分批次处理以及可选的随机打乱。

        接着，通过 BertTokenizer.from_pretrained('bert-base-chinese') 加载了一个预训练的用于中文的 BertTokenizer 。

        最后，len(tokenizer) 尝试获取 tokenizer 对象的长度，但对于 BertTokenizer 来说，len 操作的含义通常不太明确，可能不会得到有意义的结果，或者可能会引发错误，具体取决于 BertTokenizer 类的实现。

        运行结果：

        第二步：对训练数据集 train_dataset 进行处理，并创建一个迭代器。

        代码如下：

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

        分析：process_dataset 此函数应当是针对数据集展开某种预处理操作的，比如运用给定的 tokenizer 进行分词之类的，同时设定了批处理规模为 4 。而后获取由 create_tuple_iterator 方法所创建的迭代器的下一个元素。

        运行结果：

[Tensor(shape=[4, 1024], dtype=Int64, value=  
 [[ 101, 1724, 3862 ...    0,    0,    0],  
  [ 101,  704, 3173 ...    0,    0,    0],  
  [ 101, 1079, 2159 ... 1745, 8021,  102],  
  [ 101, 1355, 2357 ...    0,    0,    0]]),  
 Tensor(shape=[4, 1024], dtype=Int64, value=  
 [[ 101, 1724, 3862 ...    0,    0,    0],  
  [ 101,  704, 3173 ...    0,    0,    0],  
  [ 101, 1079, 2159 ... 1745, 8021,  102],  
  [ 101, 1355, 2357 ...    0,    0,    0]])]  

​​​​​​​模型构建

---

        第一步：自定义模型的计算逻辑，用于计算特定的损失值。

        代码如下：

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  

        分析：定义了一个名为 GPT2ForSummarization 的类，它继承自 GPT2LMHeadModel 。

        在 construct 方法中，首先调用父类的 construct 方法获取输出。然后，对输出的 logits 进行处理，得到 shift_logits（去除了最后一个位置的 logits），对 labels 也进行相应处理得到 shift_labels（去除了第一个位置的 labels）。

        接着，使用 mindspore 中的 ops.cross_entropy 函数计算交叉熵损失。将 shift_logits 和 shift_labels 展平后作为参数传入，同时指定了 ignore_index 为 tokenizer.pad_token_id，这通常表示在计算损失时忽略填充的标记。

        第二步：实现一种先上升后下降的学习率调整策略，前期通过热身逐渐上升学习率，后期随着训练步数的增加逐渐降低学习率。

        代码如下：

from mindspore import ops  
from mindspore.nn.learning_rate_schedule import LearningRateSchedule  
class LinearWithWarmUp(LearningRateSchedule):  
    """ 
    Warmup-decay learning rate. 
    """  
    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  

        分析：定义了一个名为 LinearWithWarmUp 的类，它继承自

        mindspore.nn.learning_rate_schedule.LearningRateSchedule 。

        __init__ 方法用于初始化类的属性，包括学习率 learning_rate 、热身步数 num_warmup_steps 和总训练步数 num_training_steps 。

        construct 方法根据传入的当前全局步数 global_step 计算学习率。

        如果 global_step 小于热身步数 num_warmup_steps ，则学习率的计算方式为 global_step 除以最大为 1 的 num_warmup_steps ，再乘以学习率 learning_rate ，实现热身阶段学习率的逐渐上升。

        如果 global_step 大于等于热身步数，学习率的计算方式为 (self.num_training_steps - global_step) / (max(1, self.num_training_steps - self.num_warmup_steps)) 乘以学习率 learning_rate ，并且使用 ops.maximum 函数确保学习率不为负，实现训练后期学习率的逐渐下降。

​​​​​​​模型训练

---

        第一步：为模型的训练进行准备工作，包括配置模型、设置学习率调度器和优化器，并获取模型的参数数量信息。

        代码如下：

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())) 

        分析：定义了一些训练相关的参数，如训练轮数 num_epochs 为 1，热身步数 warmup_steps 为 2000，学习率 learning_rate 为 1.5e-4 。然后根据训练轮数和训练数据集的大小计算出总的训练步数 num_training_steps 。

        配置了 GPT2 模型的参数 config ，其中指定了词汇表大小。

        创建了 GPT2ForSummarization 模型 model 。

        创建了一个名为 lr_scheduler 的学习率调度器 LinearWithWarmUp ，使用之前定义的学习率、热身步数和总训练步数进行初始化。

        使用 nn.AdamWeightDecay 优化器，并将模型的可训练参数和学习率调度器传递给它进行优化。

        最后打印出模型的参数数量。

        运行结果：

        number of model parameters: 102068736

        第二步：设定检查点的保存路径、名称、保存频次以及最大保存数量。将模型、训练数据集、训练轮数、优化器和回调函数传入。开启混合精度的训练模式。启动训练进程并指定目标列。

        代码如下：

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")  

        分析：首先，从 mindnlp._legacy.engine 模块导入 Trainer 类和 CheckpointCallback 回调函数。

        然后，创建了一个 CheckpointCallback 实例 ckpoint_cb ，设置了保存检查点的路径为 'checkpoint' ，检查点的名称为 'gpt2_summarization' ，每 1 个 epoch 保存一次检查点，最多保存 2 个检查点。

        接下来，创建了 Trainer 实例 trainer ，将模型 model 、训练数据集 train_dataset 、训练轮数设置为 1 、优化器 optimizer 以及之前创建的回调函数 ckpoint_cb 传递给它。

        之后，通过 trainer.set_amp(level='O1') 开启了混合精度训练模式。

        最后，使用 trainer.run(tgt_columns="labels") 来启动训练过程，并指定目标列是 "labels" ，即训练过程中关注的目标列是 "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)))  

        分析：定义了一个名为 process_test_dataset 的函数，用于处理测试数据集。

        函数内部：read_map 函数用于将输入的文本数据解析为文章和摘要的数组。pad 函数使用 tokenizer 对文章进行处理，并截断使其长度不超过指定的最大序列长度减去最大摘要长度，然后返回处理后的输入 ID 序列。

        在函数主体中，首先使用 map 方法应用 read_map 函数将数据解析为文章和摘要，然后应用 pad 函数处理文章，再将数据集按指定的批大小进行分批。

        在主程序中，调用 process_test_dataset 函数处理测试数据集 test_dataset ，并设置批大小为 1 。最后，使用 next 函数获取处理后的数据集的下一个元素，并打印出来。

        第二步：加载预训练模型并设置模型为评估模式，遍历测试数据集的迭代器。

        代码如下：

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  

        分析：首先，从指定的检查点文件（'./checkpoint/gpt2_summarization_epoch_0.ckpt'）加载预训练的 GPT2LMHeadModel 模型，并使用给定的配置 config 。然后设置模型为评估模式（set_train(False)），并将模型配置中的结束标记 ID 设置为分隔标记 ID 。

        接下来，通过遍历测试数据集的迭代器，对于每个输入 ID 和原始摘要对，使用模型进行生成。生成时设置最大新生成的标记数为 50，束搜索的束数量为 5，不重复的 n 元语法大小为 2。然后对生成的输出 ID 进行解码得到输出文本，并打印输出。

        最后，设置一个计数器 i ，当 i 达到 1 时停止循环。

        运行结果：