昇思25天学习打卡营第17天|LLM-基于MindSpore的GPT2文本摘要

于 2024-07-21 23:11:29 发布
阅读量268 收藏 3
点赞数 12
分类专栏： 深度学习/机器学习 华为云 #培训赛事总结 文章标签： 自然语言处理 华为云 python gpt 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wwt72/article/details/140506536
版权

打卡

目录

打卡

环境准备

准备阶段

数据加载与预处理

BertTokenizer

部分输出

模型构建

gpt2模型结构输出

训练流程

部分输出

部分输出2（减少训练数据）

推理流程

环境准备

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

准备阶段

nlpcc2017摘要数据，内容为新闻正文及其摘要，总计50000个样本。

来源：nlpcc2017摘要数据

数据加载与预处理

  • 原始数据格式：
article: [CLS] article_context [SEP]
summary: [CLS] summary_context [SEP]
  • 预处理后的数据格式：
[CLS] article_context [SEP] summary_context [SEP]

BertTokenizer

因GPT2无中文的tokenizer，使用BertTokenizer替代。代码如下：

from mindspore.dataset import TextFileDataset
import json
import numpy as np
from mindnlp.transformers import BertTokenizer


# 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


# load dataset
dataset = TextFileDataset(str(path), shuffle=False)
print(dataset.get_dataset_size())   ### 50000

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

# We use BertTokenizer for tokenizing chinese context.
tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')
len(tokenizer)

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

部分输出

模型构建

如下，通过两个类实现：

  1. 构建GPT2ForSummarization模型，注意shift right的操作。
  2. 动态学习率
from mindspore import ops
from mindnlp.transformers import GPT2LMHeadModel 
from mindspore.nn.learning_rate_schedule import LearningRateSchedule

from mindspore import nn
from mindnlp.transformers import GPT2Config, GPT2LMHeadModel
from mindnlp._legacy.engine import Trainer
from mindnlp._legacy.engine.callbacks import CheckpointCallback



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


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


## 训练参数设置
num_epochs = 1
warmup_steps = 2000
learning_rate = 1.5e-4

num_training_steps = num_epochs * train_dataset.get_dataset_size()


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

gpt2模型结构输出

1. 1级主类：GPT2ForSummarization

2. 2级类：GPT2Model 层，是transformer 结构，是模型的核心部分。

3. 2级类：lm_head 结构的 Dense 全连接层 , dim[in, out]=[768,  21128]。

4. GPT2Model 结构下的3级类组件分三层：

        >> wte 嵌入层：dim[in, out]=[21128, 768] ，即使用了 21128 个词汇，每个词汇映射到一个768 维的向量。

        >> wpe 嵌入层：dim[in, out]=[1024, 768] 

        >> drop 层。

        >> layers h 隐网络结构层：Transformer模型的主体，包含 12 个 GPT2Block。  

        >> ln_f LayerNorm 最后的层归一化。        

5. GPT2Block 的结构：

        》》ln_1 LayerNorm层，层归一化，用于在注意力机制之前对输入进行归一化。

        》》attn GPT2Attention层，自注意力机制，用于计算输入序列中不同位置的注意力权重。共包括3层：Conv1D、Conv1D、CustomDropout、CustomDropout。

        》》ln_2 LayerNorm层，用于自注意力之后的归一化。

        》》mlp  GPT2MLP层，多层感知机，用于对自注意力层的输出进行进一步的非线性变换。这里使用的操作包括：Conv1D、Conv1D、GELU、CustomDropout。
 

$ print(model)

GPT2ForSummarization<
  (transformer): GPT2Model<
    (wte): Embedding<vocab_size=21128, embedding_size=768, use_one_hot=False, weight=Parameter (Tensor(shape=[21128, 768], dtype=Float32, value=[...], name=transformer.wte.weight), requires_grad=True), dtype=Float32, padding_idx=None>
    (wpe): Embedding<vocab_size=1024, embedding_size=768, use_one_hot=False, weight=Parameter (Tensor(shape=[1024, 768], dtype=Float32, value=[...], name=transformer.wpe.weight), requires_grad=True), dtype=Float32, padding_idx=None>
    (drop): CustomDropout<>
    (h): CellList<
      (0): GPT2Block<
        (ln_1): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.0.ln_1.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.0.ln_1.bias), requires_grad=True)>
        (attn): GPT2Attention<
          (c_attn): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (attn_dropout): CustomDropout<>
          (resid_dropout): CustomDropout<>
          >
        (ln_2): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.0.ln_2.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.0.ln_2.bias), requires_grad=True)>
        (mlp): GPT2MLP<
          (c_fc): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (act): GELU<>
          (dropout): CustomDropout<>
          >
        >
      (1): GPT2Block<
        (ln_1): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.1.ln_1.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.1.ln_1.bias), requires_grad=True)>
        (attn): GPT2Attention<
          (c_attn): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (attn_dropout): CustomDropout<>
          (resid_dropout): CustomDropout<>
          >
        (ln_2): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.1.ln_2.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.1.ln_2.bias), requires_grad=True)>
        (mlp): GPT2MLP<
          (c_fc): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (act): GELU<>
          (dropout): CustomDropout<>
          >
        >
      (2): GPT2Block<
        (ln_1): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.2.ln_1.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.2.ln_1.bias), requires_grad=True)>
        (attn): GPT2Attention<
          (c_attn): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (attn_dropout): CustomDropout<>
          (resid_dropout): CustomDropout<>
          >
        (ln_2): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.2.ln_2.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.2.ln_2.bias), requires_grad=True)>
        (mlp): GPT2MLP<
          (c_fc): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (act): GELU<>
          (dropout): CustomDropout<>
          >
        >
      (3): GPT2Block<
        (ln_1): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.3.ln_1.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.3.ln_1.bias), requires_grad=True)>
        (attn): GPT2Attention<
          (c_attn): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (attn_dropout): CustomDropout<>
          (resid_dropout): CustomDropout<>
          >
        (ln_2): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.3.ln_2.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.3.ln_2.bias), requires_grad=True)>
        (mlp): GPT2MLP<
          (c_fc): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (act): GELU<>
          (dropout): CustomDropout<>
          >
        >
      (4): GPT2Block<
        (ln_1): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.4.ln_1.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.4.ln_1.bias), requires_grad=True)>
        (attn): GPT2Attention<
          (c_attn): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (attn_dropout): CustomDropout<>
          (resid_dropout): CustomDropout<>
          >
        (ln_2): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.4.ln_2.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.4.ln_2.bias), requires_grad=True)>
        (mlp): GPT2MLP<
          (c_fc): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (act): GELU<>
          (dropout): CustomDropout<>
          >
        >
      (5): GPT2Block<
        (ln_1): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.5.ln_1.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.5.ln_1.bias), requires_grad=True)>
        (attn): GPT2Attention<
          (c_attn): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (attn_dropout): CustomDropout<>
          (resid_dropout): CustomDropout<>
          >
        (ln_2): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.5.ln_2.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.5.ln_2.bias), requires_grad=True)>
        (mlp): GPT2MLP<
          (c_fc): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (act): GELU<>
          (dropout): CustomDropout<>
          >
        >
      (6): GPT2Block<
        (ln_1): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.6.ln_1.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.6.ln_1.bias), requires_grad=True)>
        (attn): GPT2Attention<
          (c_attn): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (attn_dropout): CustomDropout<>
          (resid_dropout): CustomDropout<>
          >
        (ln_2): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.6.ln_2.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.6.ln_2.bias), requires_grad=True)>
        (mlp): GPT2MLP<
          (c_fc): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (act): GELU<>
          (dropout): CustomDropout<>
          >
        >
      (7): GPT2Block<
        (ln_1): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.7.ln_1.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.7.ln_1.bias), requires_grad=True)>
        (attn): GPT2Attention<
          (c_attn): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (attn_dropout): CustomDropout<>
          (resid_dropout): CustomDropout<>
          >
        (ln_2): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.7.ln_2.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.7.ln_2.bias), requires_grad=True)>
        (mlp): GPT2MLP<
          (c_fc): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (act): GELU<>
          (dropout): CustomDropout<>
          >
        >
      (8): GPT2Block<
        (ln_1): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.8.ln_1.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.8.ln_1.bias), requires_grad=True)>
        (attn): GPT2Attention<
          (c_attn): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (attn_dropout): CustomDropout<>
          (resid_dropout): CustomDropout<>
          >
        (ln_2): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.8.ln_2.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.8.ln_2.bias), requires_grad=True)>
        (mlp): GPT2MLP<
          (c_fc): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (act): GELU<>
          (dropout): CustomDropout<>
          >
        >
      (9): GPT2Block<
        (ln_1): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.9.ln_1.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.9.ln_1.bias), requires_grad=True)>
        (attn): GPT2Attention<
          (c_attn): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (attn_dropout): CustomDropout<>
          (resid_dropout): CustomDropout<>
          >
        (ln_2): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.9.ln_2.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.9.ln_2.bias), requires_grad=True)>
        (mlp): GPT2MLP<
          (c_fc): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (act): GELU<>
          (dropout): CustomDropout<>
          >
        >
      (10): GPT2Block<
        (ln_1): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.10.ln_1.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.10.ln_1.bias), requires_grad=True)>
        (attn): GPT2Attention<
          (c_attn): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (attn_dropout): CustomDropout<>
          (resid_dropout): CustomDropout<>
          >
        (ln_2): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.10.ln_2.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.10.ln_2.bias), requires_grad=True)>
        (mlp): GPT2MLP<
          (c_fc): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (act): GELU<>
          (dropout): CustomDropout<>
          >
        >
      (11): GPT2Block<
        (ln_1): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.11.ln_1.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.11.ln_1.bias), requires_grad=True)>
        (attn): GPT2Attention<
          (c_attn): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (attn_dropout): CustomDropout<>
          (resid_dropout): CustomDropout<>
          >
        (ln_2): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.11.ln_2.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.h.11.ln_2.bias), requires_grad=True)>
        (mlp): GPT2MLP<
          (c_fc): Conv1D<
            (matmul): Matmul<>
            >
          (c_proj): Conv1D<
            (matmul): Matmul<>
            >
          (act): GELU<>
          (dropout): CustomDropout<>
          >
        >
      >
    (ln_f): LayerNorm<normalized_shape=[768], begin_norm_axis=-1, begin_params_axis=-1, weight=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.ln_f.weight), requires_grad=True), bias=Parameter (Tensor(shape=[768], dtype=Float32, value=[...], name=transformer.ln_f.bias), requires_grad=True)>
    >
  (lm_head): Dense<input_channels=768, output_channels=21128>
  >

训练流程

from mindspore import nn
from mindnlp.transformers import GPT2Config, GPT2LMHeadModel
from mindnlp._legacy.engine import Trainer
from mindnlp._legacy.engine.callbacks import CheckpointCallback
 

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

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

部分输出

注：建议使用较高规格的算力，训练时间较长

部分输出2（减少训练数据）

此次活动的 notebook 只可以连续运行8小时，此次目的也不是性能优化，故此，我将训练数据减少到了1/10，此时的部分输出如下。

推理流程

## 向量数据转为中文数据
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

减少训练数据后的模型推理结果展示。

UtopXExistential
关注
  • 12
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于InternLM-LLM-7B + langchain 的 烹饪小助手（Python）
01-11
【基于InternLM-LLM-7B + langchain的烹饪小助手（Python）】是一个巧妙地结合了自然语言处理技术和烹饪知识的项目。这个小助手是利用Python编程语言开发的，旨在帮助用户在烹饪过程中获取指导、建议和食谱。...
昇思25天学习打卡营第13天|LLM-基于MindSpore实现的GPT对话情绪识别
wwt72的博客
07-17 801
1、数据集准备：IMDB数据集，从 https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/aclImdb_v1.tar.gz 下载数据集并按照7:3切分为训练和验证集。5、开始训练：创建训练器 （mindnlp._legacy.engine.Trainer）并训练，该训练器可以接收模型、训练数据集、评估数据集、评估指标、训练轮数、优化器、回调函数列表以及是否启用JIT编译的选项。评估器使用了之前定义的预训练模型和评估指标。
昇思25天学习打卡营第17天|LLM原理和实践-基于MindSpore的GPT2文本摘要
Kirito_UGO的博客
07-05 398
使得开始训练的几个epoches或者一些steps内学习率较小,在预热的小学习率下，模型可以慢慢趋于稳定,等模型相对稳定后再选择预先设置的学习率进行训练,使得模型收敛速度变得更快，模型效果更佳。
昇思25天学习打卡营第11天|基于MindSpore的GPT2文本摘要
randomize0的专栏
07-04 315
今天是LLM原理和实践的第二课今天学习的目标如何给予MindSpore实现GPT2文本摘要，要点有以下内容：1.学习文本摘要任务的主要实现目标2.实践数据处理的方法3.实践模型构建、训练与推理的方法文本摘要生成是自然语言处理领域的一个重要问题，其核心任务是根据输入的文本内容自动生成包含重要信息的简短摘要。文本摘要生成技术可以帮助人们快速获取并理解大量信息，具有广泛的应用前景。信息压缩：将原始文本内容进行精炼、概括，去除冗余信息，以便读者快速获取主要信息。语义保持。
昇思25天学习打卡营第14天|LLM-文本解码原理--以MindNLP为例
wwt72的博客
07-17 739
限制输出序列的最大长度为50个token。top-p=0.95，top-p采样表示在每一步生成token时，只从概率分布中累计概率达到95%的token中进行采样，有助于保持生成文本的流畅性和质量，同时允许一些低概率的token被选中，从而增加多样性。表示禁用了top-k采样，因为在top-k采样中，通常是从概率最高的k个token中随机选择一个token作为下一个输出，而这里设置为0表示不限制token的选择，实际上这将等同于使用 softmax 概率分布直接进行采样。这有助于提高生成文本的多样性。
昇思25天学习打卡营第12天|基于MindSpore通过GPT实现情感分类
randomize0的专栏
07-05 333
今天是LLM原理和实践的第三课，今天学习的目标学习通过GPT实现情感分类的代码。本次所使用的数据集来自互联网电影资料库（Internet Movie Database，简称IMDb）的电影评论数据，目标是识别电影评论的情感类型：积极的或则消极的，用于训练的数据集标注了评论对应的情感类型。本次所使用的模型为，是GPT-1中的一个文本分分类模型。
昇思25天学习打卡营第13天|基于MindSpore通过GPT实现情感分类
leesan0802的专栏
07-07 275
打开第13天。本次学习的内容为LLM原理和实践中基于MindSpore通过GPT实现情感分类的内容。记录学习的过程。根据实验系统中的内容一步一步学习基于MindSpore通过GPT实现情感分类的整个过程。
昇思25天学习打卡营第13天 | LLM原理和实践：文本解码原理--以MindNLP为例
loveisastory的博客
07-06 928
本文以MindNLP为例，介绍了大语言模型的解码原理。包括贪心搜索、束搜索、样本搜索、温度、TopK采样方法、Top-P采样方法、混合采样方法等对解码结果的影响。
昇思25天学习打卡营第19天|xkd007|LLM原理和实践（2）基于MindSpore的GPT2文本摘要
2301_78470967的博客
07-12 15
数据集加载本次实验使用的是nlpcc2017摘要数据，内容为新闻正文及其摘要，总计5000个样本。数据预处理。
昇思25天学习打卡营第8天|应用实践之基于 MindSpore 实现 BERT 对话情绪识别
m0_52501541的博客
07-02 891
昨天体验实践的模型是自然语言处理领域的模型，今天也是一样的。昨天的MusicGen是LLM模型，使用的是基于transformer的编码-解码器架构，而今天的BERT是基于transformer的双向编码器架构。由于主要目的是体验实践使用MindSpore运行BERT模型，所以只对BERT模型进行简单介绍，详细的可以自行搜索资料了解学习，然后就是使用MindSpore所提供的API去运行一下BERT模型。
昇思学习打卡-6-LLM原理与实践/基于MindSpore的GPT2文本摘要
weixin_42630613的博客
07-04 192
昇思学习打卡-基于MindSpore的GPT2文本摘要
基于GPT2模型的文本摘要实战.zip
03-23
**基于GPT2模型的文本摘要实战** 在当今的AI技术领域，生成式人工智能（Generative AI）已经崭露头角，尤其是以OpenAI的GPT（Generative Pre-trained Transformer）系列模型为代表，它们在自然语言处理（NLP）任务...
tensorrt-llm-0.8.0-cp310-cp310-win-amd64.whl
03-08
TensorRT是由NVIDIA推出的一个高性能的深度学习推理（Inference）优化器和运行时引擎，它可以为深度学习应用提供低延迟、高吞吐率的部署推理。TensorRT是一个C++库，提供C++ API和Python API，主要用于NVIDIA GPU...
文本纠错-基于ChatGLM3-6B+Pycorrector实现的文本纠错-附项目源码+流程教程-优质项目实战.zip
07-07
文本纠错_基于ChatGLM3-6B+Pycorrector实现的文本纠错_附项目源码+流程教程_优质项目实战
谷歌发布技术报告：PaLM-2 推理超越 GPT-4，训练文本是第一代近 5 倍.pdf
08-13
谷歌发布技术报告：PaLM-2 推理超越 GPT-4，训练文本是第一代近 5 倍 PaLM-2 是谷歌 recent 发布的技术报告，展现了他们研究的大模型最新成果。作为 Bard 聊天机器人的基础模型，与以往的技术相比，PaLM-2 在处理...
昇思25天学习打卡营第11天|基于 MindSpore 实现 BERT 对话情绪识别
最新发布
一名全栈开发工程师
07-20 130
BERT的创新之处在于其预训练方法，特别是Masked Language Model和Next Sentence Prediction，这使得它在问答、文本分类等任务上表现出色。在训练中，15%的单词会被随机掩码，以增强模型对上下文的理解。BERT模型经过预训练后，可以用于微调，以适应各种下游任务，如情绪识别，这在智能对话中尤为重要，有助于提升用户体验和服务质量。BERT模型的双向编码特性和创新的预训练方法，不仅提高了语言模型的理解和生成能力，还为情绪识别等应用提供了强大的基础。
新一代大语言模型 GPT-5 对工作与生活的影响及应对策略
fzy20110826的博客
07-14 1475
本文探究了 GPT-5 发布信息及从 GPT-4 到 GPT-5 的变化，解析了其影响，提出了应对策略，旨在提供思考和建议。
【人工智能】自然语言处理(NLP)的突破，关注NLP在机器翻译、情感分析、聊天机器人等方面的最新研究成果和应用案例。
weixin_51306394的博客
07-16 1817
自然语言处理（NLP）作为人工智能的一个重要分支，近年来取得了显著的突破，特别在机器翻译、情感分析、聊天机器人等领域取得了显著的研究成果和广泛的应用。以下是对这些领域最新研究成果和应用案例的概述，并附带相应的代码实例。
NLP篇10 NLP总结
bluewelkin的专栏
07-17 242
针对不同任务，我们使用不同的模型和策略。例如，对于文本分类，可使用卷积神经网络（CNN）、循环神经网络（RNN）及其变体如 LSTM、GRU 等，或者基于 Transformer 架构的模型。未来，NLP 有望在更多领域取得突破，如更加准确和智能的对话系统、更强大的语言生成能力、与其他领域如计算机视觉的深度融合等。然而，NLP 仍面临诸多挑战，如处理语义歧义、理解上下文的复杂性、跨语言和多模态的处理等。同时，不断增长和多样化的数据集对于 NLP 研究和发展至关重要，为模型训练和评估提供了坚实的基础。
LLM-RAG是什么
07-02
LLM-RAG是“Large Language Model with Retrieval Augmentation”（大型语言模型与检索增强）的缩写。这是一种结合了大型预训练语言模型（如通义千问）和基于检索的方法的技术。在传统的语言模型中，模型完全依赖于其自身的知识库来生成响应。而LLM-RAG则增强了这种能力，它会在生成文本之前从外部知识源（比如文本数据库或网络上的信息）检索相关信息，然后结合模型自身的理解进行生成，从而提供更准确、丰富的答案。 这种方法利用了外部信息的丰富性和模型生成的灵活性，使得AI系统能够处理更复杂的查询，并在需要时提供详细的支持。然而，由于涉及外部数据的检索，隐私和版权问题是需要注意的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值