• 技术干货｜昇思MindSpore NLP模型迁移之Roberta ——情感分析任务

    熟悉 BERT 模型的小伙伴对于 Roberta 模型肯定不陌生了。Roberta 模型在 BERT 模型的基础上进行了一定的改进，主要改进点有以下几个部分：

    1. 训练语料：BERT只使用 16 GB 的Book Corpus数据集和英语维基百科进行训练，Roberta增加了 CC-NEWS 、OPEN WEB TEXT、STORIES 等语料，一共有 160 GB 的纯文本。

    2. Batch Size：Roberta模型在训练中使用了更大的Batch Size -> [256 ~ 8000]。

    3. 训练时间：Roberta模型使用 1024 块 V100 的 GPU 训练了整整 1 天的时间，模型参数量和训练时间更加多和更加长。

    同时Roberta在具体的训练方法上也有所改进：

    1. 动态 MASK 机制

    2. 去除了 NSP 任务

    3. Tokenizer部分更换成 BPE 算法，分词这一点和 GPT-2 十分相似

    Roberta 源码（huggingface）：

    https://huggingface.co/roberta-base

    Roberta论文：

    https://arxiv.org/abs/1907.11692

    这里我们采用了华为开发的 MindSpore 框架，并且选择了 Pytorch 版本 Roberta 模型进行模型迁移。欢迎大家一起参与到 MindSpore 开源社区的开发中来！

    前言

    本文环境：

    系统：Ubuntu 18

    GPU：RTX 3090

    MindSpore版本：1.3

    数据集：SST-2（情感分析任务）

    SST-2 数据集定义：

    这是一个二分类的数据集，训练集和验证集的句子所对应的标签是0或1

    模型权重转换

    我们需要将 Pytorch 版本的 Roberta 权重转换成 MindSpore 适用的权重，这里提供一个转换的思路。主要可以参考官网的API映射文档进行改写。

    官网链接：转换映射

    （https://www.mindspore.cn/docs/migration_guide/zh-CN/r1.5/api_mapping/pytorch_api_mapping.html）

    1.  
    2. def torch_to_ms(model, torch_model):
    3.     """
    4.     Updates mobilenetv2 model mindspore param's data from torch param's data.
    5.     Args:
    6.         model: mindspore model
    7.         torch_model: torch model
    8.     """
    9.     print("start load")
    10.     # load torch parameter and mindspore parameter
    11.     torch_param_dict = torch_model
    12.     ms_param_dict = model.parameters_dict()
    13.     count = 0
    14.     for ms_key in ms_param_dict.keys():
    15.         ms_key_tmp = ms_key.split('.')
    16.         if ms_key_tmp[0] == 'roberta_embedding_lookup':
    17.             count += 1
    18.             update_torch_to_ms(torch_param_dict, ms_param_dict, 'embeddings.word_embeddings.weight', ms_key)
    19.         elif ms_key_tmp[0] == 'roberta_embedding_postprocessor':
    20.             if ms_key_tmp[1] == "token_type_embedding":
    21.                 count += 1
    22.                 update_torch_to_ms(torch_param_dict, ms_param_dict, 'embeddings.token_type_embeddings.weight', ms_key)
    23.             elif ms_key_tmp[1] == "full_position_embedding":
    24.                 count += 1
    25.                 update_torch_to_ms(torch_param_dict, ms_param_dict, 'embeddings.position_embeddings.weight',
    26.                                    ms_key)
    27.             elif ms_key_tmp[1] =="layernorm":
    28.                 if ms_key_tmp[2]=="gamma":
    29.                     count += 1
    30.                     update_torch_to_ms(torch_param_dict, ms_param_dict, 'embeddings.LayerNorm.weight',
    31.                                        ms_key)
    32.                 else:
    33.                     count += 1
    34.                     update_torch_to_ms(torch_param_dict, ms_param_dict, 'embeddings.LayerNorm.bias',
    35.                                        ms_key)
    36.         elif ms_key_tmp[0] == "roberta_encoder":
    37.             if ms_key_tmp[3]=='attention':
    38.                     par = ms_key_tmp[4].split('_')[0]
    39.                     count += 1
    40.                     update_torch_to_ms(torch_param_dict, ms_param_dict, 'encoder.layer.'+ms_key_tmp[2]+'.'+ms_key_tmp[3]+'.'
    41.                                        +'self.'+par+'.'+ms_key_tmp[5],
    42.                                        ms_key)
    43.             elif ms_key_tmp[3]=='attention_output':
    44.                 if ms_key_tmp[4]=='dense':
    45.                     count += 1
    46.                     update_torch_to_ms(torch_param_dict, ms_param_dict,
    47.                                    'encoder.layer.' + ms_key_tmp[2] + '.attention.output.'+ms_key_tmp[4]+'.'+ms_key_tmp[5],
    48.                                    ms_key)
    49.  
    50.                 elif ms_key_tmp[4]=='layernorm':
    51.                     if ms_key_tmp[5]=='gamma':
    52.                         count += 1
    53.                         update_torch_to_ms(torch_param_dict, ms_param_dict,
    54.                                            'encoder.layer.' + ms_key_tmp[2] + '.attention.output.LayerNorm.weight',
    55.                                            ms_key)
    56.                     else:
    57.                         count += 1
    58.                         update_torch_to_ms(torch_param_dict, ms_param_dict,
    59.                                            'encoder.layer.' + ms_key_tmp[2] + '.attention.output.LayerNorm.bias',
    60.                                            ms_key)
    61.             elif ms_key_tmp[3]=='intermediate':
    62.                 count += 1
    63.                 update_torch_to_ms(torch_param_dict, ms_param_dict,
    64.                                    'encoder.layer.' + ms_key_tmp[2] + '.intermediate.dense.'+ms_key_tmp[4],
    65.                                    ms_key)
    66.             elif ms_key_tmp[3]=='output':
    67.                 if ms_key_tmp[4]=='dense':
    68.                     count += 1
    69.                     update_torch_to_ms(torch_param_dict, ms_param_dict,
    70.                                    'encoder.layer.' + ms_key_tmp[2] + '.output.dense.'+ms_key_tmp[5],
    71.                                    ms_key)
    72.                 else:
    73.                     if ms_key_tmp[5]=='gamma':
    74.                         count += 1
    75.                         update_torch_to_ms(torch_param_dict, ms_param_dict,
    76.                                        'encoder.layer.' + ms_key_tmp[2] + '.output.LayerNorm.weight',
    77.                                        ms_key)
    78.  
    79.                     else:
    80.                         count += 1
    81.                         update_torch_to_ms(torch_param_dict, ms_param_dict,
    82.                                        'encoder.layer.' + ms_key_tmp[2] + '.output.LayerNorm.bias',
    83.                                        ms_key)
    84.  
    85.         if ms_key_tmp[0]=='dense':
    86.             if ms_key_tmp[1]=='weight':
    87.                 count += 1
    88.                 update_torch_to_ms(torch_param_dict, ms_param_dict,
    89.                                    'pooler.dense.weight',
    90.                                    ms_key)
    91.             else:
    92.                 count += 1
    93.                 update_torch_to_ms(torch_param_dict, ms_param_dict,
    94.                                    'pooler.dense.bias',
    95.                                    ms_key)
    96.  
    97.     save_checkpoint(model, "./model/roberta-base.ckpt")
    98.     print(count)
    99.     print("finish load")

    这里值得注意的是转换的参数一定要对应的上，不然在后续权重加载中会出现权重加载失败，或是训练过程中loss值降不下去的情况！转换完后可以试着打印对应参数的 key 值防止错漏。

    这样我们就获得了转换出来的roberta.ckpt文件用于加载权重。这里的权重文件一定要和tensorflow的权重文件进行区分！

    数据处理

    对于数据的输入这一块，MindSpore和Pytorch也是存在差异的。这里我们直接使用自己准备的dataset部分，这里面封装了多种NLP任务的数据集处理方式，可以将数据集转换成mindrecord形式，然后用于模型的训练和验证。下面跟着笔者继续去了解一下吧！

    1. """
    2.     SST-2 dataset
    3. """
    4. from typing import Union, Dict, List
    5. import mindspore.dataset as ds
    6. from ..base_dataset import CLSBaseDataset
    7.  
    8.  
    9. class SST2Dataset(CLSBaseDataset):
    10.     """
    11.     SST2 dataset.
    13.     Args:
    14.         paths (Union[str, Dict[str, str]], Optional): Dataset file path or Dataset directory path, default None.
    15.         tokenizer (Union[str]): Tokenizer function, default 'spacy'.
    16.         lang (str): Tokenizer language, default 'en'.
    17.         max_size (int, Optional): Vocab max size, default None.
    18.         min_freq (int, Optional): Min word frequency, default None.
    19.         padding (str): Padding token, default `<pad>`.
    20.         unknown (str): Unknown token, default `<unk>`.
    21.         buckets (List[int], Optional): Padding row to the length of buckets, default None.
    23.     Examples:
    24.         >>> sst2 = SST2Dataset(tokenizer='spacy', lang='en')
    25.         # sst2 = SST2Dataset(tokenizer='spacy', lang='en', buckets=[16,32,64])
    26.         >>> ds = sst2()
    27.     """
    28.  
    29.     def __init__(self, paths: Union[str, Dict[str, str]] = None,
    30.                  tokenizer: Union[str] = 'spacy', lang: str = 'en', max_size: int = None, min_freq: int = None,
    31.                  padding: str = '<pad>', unknown: str = '<unk>',
    32.                  buckets: List[int] = None):
    33.         super(SST2Dataset, self).__init__(sep='\t', name='SST-2')
    34.         self._paths = paths
    35.         self._tokenize = tokenizer
    36.         self._lang = lang
    37.         self._vocab_max_size = max_size
    38.         self._vocab_min_freq = min_freq
    39.         self._padding = padding
    40.         self._unknown = unknown
    41.         self._buckets = buckets
    42.  
    43.     def __call__(self) -> Dict[str, ds.MindDataset]:
    44.         self.load(self._paths)
    45.         self.process(tokenizer=self._tokenize, lang=self._lang, max_size=self._vocab_max_size,
    46.                      min_freq=self._vocab_min_freq, padding=self._padding,
    47.                      unknown=self._unknown, buckets=self._buckets)
    48.         return self.mind_datasets
    1. from mindtext.dataset.classification import SST2Dataset
    2.  
    3. #对SST-2情感分析的数据集进行处理 如果本来缓存就有只需要直接读缓存
    4. dataset = SST2Dataset(paths='./mindtext/dataset/SST-2',
    5.                       tokenizer="roberta-base",
    6.                       max_length=128,
    7.                       truncation_strategy=True,
    8.                       columns_list=['input_ids', 'attention_mask','label'],
    9.                       test_columns_list=['input_ids', 'attention_mask'],
    10.                       batch_size=64 )
    11.  
    12.  
    13. ds = dataset() #生成对应的train、dev的mindrecord文件
    14. ds = dataset.from_cache( columns_list=['input_ids', 'attention_mask','label'],
    15.                       test_columns_list=['input_ids', 'attention_mask'],
    16.                       batch_size=64
    17.                       )
    18. dev_dataset = ds['dev'] #取出转成mindrecord的验证集用于验证

    生成出来的mindrecord文件，一个是 .mindrecord文件 一个是 .mindrecord.db文件，值得注意的是我们不能随意去修改它们的名字，两个文件是存在着一定的映射关系，如果强行去修改它们名字会出现读取不了mindrecord文件的错误！

    还有进行数据处理的参数一定要和模型输入的参数一致，例如我们Roberta模型输入的参数是['input_ids', 'attention_mask','label']。

    模型的主体架构

    项目架构图：

    架构方面我们主要是参考的fastnlp的划分方式。将模型划分为Encoder、Embedding、Tokenizer三个部分，后续会进一步的优化模型的架构。

    1.Embedding

    1. """Roberta Embedding."""
    2. import logging
    3. from typing import Tuple
    4. import mindspore.nn as nn
    5. from mindspore import Tensor
    6. from mindspore.train.serialization import load_checkpoint, load_param_into_net
    7. from mindtext.modules.encoder.roberta import RobertaModel, RobertaConfig
    8.  
    9.  
    10. logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    11. logger = logging.getLogger(__name__)
    12.  
    13. class RobertaEmbedding(nn.Cell):
    14.     """
    15.     This is a class that loads pre-trained weight files into the model.
    16.     """
    17.     def __init__(self, roberta_config: RobertaConfig, is_training: bool = False):
    18.         super(RobertaEmbedding, self).__init__()
    19.         self.roberta = RobertaModel(roberta_config, is_training)
    20.  
    21.     def init_robertamodel(self,roberta):
    22.         """
    23.         Manual initialization BertModel
    24.         """
    25.         self.roberta=roberta
    26.  
    27.     def from_pretrain(self, ckpt_file):
    28.         """
    29.         Load the model parameters from checkpoint
    30.         """
    31.         param_dict = load_checkpoint(ckpt_file)
    32.         load_param_into_net(self.roberta, param_dict)
    33.  
    34.     def construct(self, input_ids: Tensor, input_mask: Tensor)-> Tuple[Tensor, Tensor]:
    35.         """
    36.         Returns the result of the model after loading the pre-training weights
    38.         Args:
    39.             input_ids:A vector containing the transformation of characters into corresponding ids.
    40.             input_mask:the mask for input_ids.
    42.         Returns:
    43.             sequence_output:the sequence output .
    44.             pooled_output:the pooled output of first token:cls..
    45.         """
    46.         sequence_output, pooled_output, _ = self.roberta(input_ids, input_mask)
    47.         return sequence_output, pooled_output

    这部分主要用来加载预训练好的权重，在前文我们就得到了mindrecord形式的权重文件。

    2.Encoder

    1. class RobertaModel(nn.Cell):
    2.     """
    3.         Used from mindtext.modules.encoder.roberta with Roberta
    5.         Args:
    6.         config (Class): Configuration for RobertaModel.
    7.         is_training (bool): True for training mode. False for eval mode.
    8.         use_one_hot_embeddings (bool): Specifies whether to use one hot encoding form.
    9.                             Default: False.
    10.     """
    11.  
    12.     def __init__(self,
    13.                  config: RobertaConfig,
    14.                  is_training: bool,
    15.                  use_one_hot_embeddings: bool = False):
    16.         super().__init__()
    17.         config = copy.deepcopy(config)
    18.         if not is_training:
    19.             config.hidden_dropout_prob = 0.0
    20.             config.attention_probs_dropout_prob = 0.0
    21.  
    22.         self.seq_length = config.seq_length
    23.         self.hidden_size = config.hidden_size
    24.         self.num_hidden_layers = config.num_hidden_layers
    25.         self.embedding_size = config.hidden_size
    26.         self.token_type_ids = None
    27.         self.compute_type = numbtpye2mstype(config.compute_type)
    28.         self.last_idx = self.num_hidden_layers - 1
    29.         output_embedding_shape = [-1, self.seq_length, self.embedding_size]
    30.         self.roberta_embedding_lookup = nn.Embedding(
    31.             vocab_size=config.vocab_size,
    32.             embedding_size=self.embedding_size,
    33.             use_one_hot=use_one_hot_embeddings,
    34.             embedding_table=TruncatedNormal(config.initializer_range))
    35.  
    36.         self.roberta_embedding_postprocessor = EmbeddingPostprocessor(
    37.             embedding_size=self.embedding_size,
    38.             embedding_shape=output_embedding_shape,
    39.             use_token_type=False,
    40.             token_type_vocab_size=config.type_vocab_size,
    41.             use_one_hot_embeddings=use_one_hot_embeddings,
    42.             max_position_embeddings=config.max_position_embeddings,
    43.             dropout_prob=config.hidden_dropout_prob)
    44.  
    45.         self.roberta_encoder = RobertaTransformer(
    46.             hidden_size=self.hidden_size,
    47.             seq_length=self.seq_length,
    48.             num_attention_heads=config.num_attention_heads,
    49.             num_hidden_layers=self.num_hidden_layers,
    50.             intermediate_size=config.intermediate_size,
    51.             attention_probs_dropout_prob=config.attention_probs_dropout_prob,
    52.             initializer_range=config.initializer_range,
    53.             hidden_dropout_prob=config.hidden_dropout_prob,
    54.             hidden_act=config.hidden_act,
    55.             compute_type=self.compute_type,
    56.             return_all_encoders=True)
    57.  
    58.         self.cast = P.Cast()
    59.         self.dtype = numbtpye2mstype(config.dtype)
    60.         self.cast_compute_type = SecurityCast()
    61.         self.slice = P.StridedSlice()
    62.  
    63.         self.squeeze_1 = P.Squeeze(axis=1)
    64.         self.dense = nn.Dense(self.hidden_size, self.hidden_size,
    65.                               activation="tanh",
    66.                               weight_init=TruncatedNormal(config.initializer_range))\
    67.                                     .to_float(mstype.float32)
    68.         self._create_attention_mask_from_input_mask = CreateAttentionMaskFromInputMask(config)
    69.  
    70.     def construct(self, input_ids: Tensor, input_mask: Tensor) -> Tuple[Tensor, Tensor, Tensor]:
    71.         """Bidirectional Encoder Representations from Transformers.
    72.         Args:
    73.             input_ids:A vector containing the transformation of characters into corresponding ids.
    74.             input_mask:the mask for input_ids.
    76.         Returns:
    77.             sequence_output:the sequence output .
    78.             pooled_output:the pooled output of first token:cls.
    79.             embedding_table:fixed embedding table.
    81.         """
    82.         # embedding
    83.         embedding_tables = self.roberta_embedding_lookup.embedding_table
    84.         word_embeddings = self.roberta_embedding_lookup(input_ids)
    85.         embedding_output = self.roberta_embedding_postprocessor(input_ids,
    86.                                                                 word_embeddings)
    87.         # attention mask [batch_size, seq_length, seq_length]
    88.         attention_mask = self._create_attention_mask_from_input_mask(input_mask)
    89.  
    90.         # roberta encoder
    91.         encoder_output = self.roberta_encoder(self.cast_compute_type(embedding_output),
    92.                                              attention_mask)
    93.  
    94.         sequence_output = self.cast(encoder_output[self.last_idx], self.dtype)
    95.  
    96.         # pooler
    97.         batch_size = P.Shape()(input_ids)[0]
    98.         sequence_slice = self.slice(sequence_output,
    99.                                     (0, 0, 0),
    100.                                     (batch_size, 1, self.hidden_size),
    101.                                     (1, 1, 1))
    102.         first_token = self.squeeze_1(sequence_slice)
    103.         pooled_output = self.dense(first_token)
    104.         pooled_output = self.cast(pooled_output, self.dtype)
    105.         return sequence_output, pooled_output, embedding_tables

    这是我们的模型主体，这里我们将模型整体放入到了encoder文件下的roberta.py。我们可以看到encoder部分主要包括 encoder_output 和 sequence_output 两个部分。这里的部分实现我们是参照了 MindSpore ModelZoo 项目的 BERT 模型去实现的（小伙伴们在迁移模型时候可以登录MindSpore官网前去参考哦~），所以只需要简单的将几个重要的模块进行拼接就OK了,这几个模块包括：

    EncoderOutput：每个sub-layer加上残差连接和归一化的模块。

    RobertaAttention：单个多头自注意力层。

    RobertaEncoderCell：单个的RobertaEncoder层。

    RobertaTransformer：将多个RobertaEncoderCell拼接在一起，形成完整的roberta模块。

    这样可以大大减少我们模型架构的时间，也能更好的学习到MindSpore框架的使用。

    3.Tokenizer

    分词方面我们封装在dataset中。可以通过指定huggingface库中存在的预训练模型的名字来直接加载词表等文件！使用起来非常方便，详情可以回溯到数据处理部分的代码。如果想实现别的下游任务，但在dataset中没有的话，也可以使用我们实现的tokenlizer来用自己的方式去构建mindrecord形式的数据。

    1. def get_tokenizer(tokenize_method: str, lang: str = 'en'):
    2.     """
    3.     Get a tokenizer.
    5.     Args:
    6.         tokenize_method (str): Select a tokenizer method.
    7.         lang (str): Tokenizer language, default English.
    9.     Returns:
    10.         function: A tokenizer function.
    11.     """
    12.     tokenizer_dict = {
    13.         'spacy': None,
    14.         'raw': _split,
    15.         'cn-char': _cn_split,
    16.     }
    17.     if tokenize_method == 'spacy':
    18.         import spacy
    19.         spacy.prefer_gpu()
    20.         if lang != 'en':
    21.             raise RuntimeError("Spacy only supports english")
    22.         if parse_version(spacy.__version__) >= parse_version('3.0'):
    23.             en = spacy.load('en_core_web_sm')
    24.         else:
    25.             en = spacy.load(lang)
    26.  
    27.         def _spacy_tokenizer(text):
    28.             return [w.text for w in en.tokenizer(text)]
    29.  
    30.         tokenizer = _spacy_tokenizer
    31.     elif tokenize_method in tokenizer_dict:
    32.         tokenizer = tokenizer_dict[tokenize_method]
    33.     else:
    34.         raise RuntimeError(f"Only support {tokenizer_dict.keys()} tokenizer.")
    35.     return tokenizer

    模型参数加载

    在模型主体的roberta.py文件中 RobertaConfig 模块可以加载yaml文件中的对应参数到 RobertaModel中去。以下是yaml文件的参数配置：

    1. seq_length: 128
    2. vocab_size: 50265
    3. hidden_size: 768
    4. bos_token_id: 0
    5. eos_token_id: 2
    6. num_hidden_layers: 12
    7. num_attention_heads: 12
    8. intermediate_size: 3072
    9. hidden_act: "gelu"
    10. hidden_dropout_prob: 0.1
    11. attention_probs_dropout_prob: 0.1
    12. max_position_embeddings: 514
    13. pad_token_id: 1
    14. type_vocab_size: 1
    15. initializer_range: 0.02
    16. use_relative_positions: False
    17. dtype: mstype.float32
    18. compute_type: mstype.float32

    模型训练

    接下来就是大家最期待的模型训练部分啦！我们首先要做的是将适用于 MindSpore 框架的权重参数加载到Roberta模型中去，同时初始化。可以看到，yaml 形式的超参数配置写入到RobertaModel 中并进行实例化，随后权重参数通过MindSpore内置的load_checkpoint和load_param_intonet函数加载进RobertaModel。这里我们不是直接进行加载，而是中间嵌套了一层RobertaEmbedding。而且需要注意的是训练时我们的 is_training 值设置为True，num_labels视具体下游任务要求设置。

    1. roberta_config_file = "./mindtext/config/test.yaml"
    2.    roberta_config = RobertaConfig.from_yaml_file(roberta_config_file)
    3.    rbm = RobertaModel(roberta_config, True)
    4.    param_dict = load_checkpoint('./mindtext/pretrain/roberta-base-ms.ckpt')
    5.    p = load_param_into_net(rbm, param_dict)
    6.    em = RobertaEmbedding(roberta_config, True)
    7.    em.initRobertaModel(rbm)
    8.    roberta = RobertaforSequenceClassification(roberta_config, is_training=True, num_labels=2)
    9.    roberta.init_embedding(em)

    模型权重加载完毕后，设置好学习率lr、训练轮数epoch、损失函数、优化器等等，就可以开始训练啦！这里我们根据论文提供的learning_rate来设置：3e-5。其次还使用了warm_up预热学习率，待模型趋于稳定后，再选择预先设置的学习率进行训练,使得模型收敛速度变得更快，模型效果更佳。epoch设为3轮。

    1. epoch_num = 3
    2.     save_path = "./mindtext/pretrain/output/roberta-base_sst.ckpt"
    3.     lr_schedule = RobertaLearningRate(learning_rate=3e-5,
    4.                                    end_learning_rate=1e-5,
    5.                                    warmup_steps=int(train_dataset.get_dataset_size() * epoch_num * 0.1),
    6.                                    decay_steps=train_dataset.get_dataset_size() * epoch_num,
    7.                                    power=1.0)
    8.     params = roberta.trainable_params()
    9.     optimizer = AdamWeightDecay(params, lr_schedule, eps=1e-8)

    一切准备好后，就进入训练阶段，最后将经过微调的模型参数保存至指定路径的ckpt文件中。

    1. def train(train_data, roberta, optimizer, save_path, epoch_num):
    2.     update_cell = DynamicLossScaleUpdateCell(loss_scale_value=2 ** 32, scale_factor=2, scale_window=1000)
    3.     netwithgrads = RobertaFinetuneCell(roberta, optimizer=optimizer, scale_update_cell=update_cell)
    4.     callbacks = [TimeMonitor(train_data.get_dataset_size()), LossCallBack(train_data.get_dataset_size())]
    5.     model = Model(netwithgrads)
    6.     model.train(epoch_num, train_data, callbacks=callbacks, dataset_sink_mode=False)
    7.     save_checkpoint(model.train_network, save_path)

    模型评估

    评估和训练的流程大致一样，读取转换成mindrecord形式的验证集，准备用作评估模型性能。

    1. dataset = SST2Dataset(paths='./mindtext/dataset/SST-2',
    2.                       tokenizer="roberta-base",
    3.                       max_length=128,
    4.                       truncation_strategy=True,
    5.                       columns_list=['input_ids', 'attention_mask','label'],
    6.                       test_columns_list=['input_ids', 'attention_mask'],
    7.                       batch_size=64 )
    8. ds = dataset.from_cache( columns_list=['input_ids', 'attention_mask','label'],
    9.                       test_columns_list=['input_ids', 'attention_mask'],
    10.                       batch_size=64
    11.                       )
    12. dev_dataset = ds['dev']

    接着加载超参数配置和模型权重文件，通过from_pretrain函数装载到Roberta模型中去。注意这里的下游任务也需指定 is_training 和 num_labels 两个参数值，根据具体任务设置。

    1. roberta_config_file = "./mindtext/conf/test.yaml"
    2.     roberta_config = RobertaConfig.from_yaml_file(roberta_config_file)
    3.  
    4.     roberta = RobertaforSequenceClassification(roberta_config, is_training=False, num_labels=2, dropout_prob=0.0)
    5.     model_path = "./mindtext/pretrain/output/roberta_trainsst2.ckpt"
    6.     roberta.from_pretrain(model_path)

    最后就可以开始评估啦！该任务是一个文本二分类任务，模型预测标签和真实标签进行对比，模型精度为[0-1]之间的小数。

    1. def eval(eval_data, model):
    2.     metirc = Accuracy('classification')
    3.     metirc.clear()
    4.     squeeze = mindspore.ops.Squeeze(1)
    5.     for batch in tqdm(eval_data.create_dict_iterator(num_epochs=1), total=eval_data.get_dataset_size()):
    6.         input_ids = batch['input_ids']
    7.         input_mask = batch['attention_mask']
    8.         label_ids = batch['label']
    9.         inputs = {"input_ids": input_ids,
    10.                   "input_mask": input_mask
    11.                   }
    12.         output = model(**inputs)
    13.         sm = mindspore.nn.Softmax(axis=-1)
    14.         output = sm(output)
    15.         metirc.update(output, squeeze(label_ids))
    16.     print(metirc.eval())

  • 相关阅读:
    Go HTTP 调用（下）
    试一试FineReport，教你玩转花样商业报表！
    Matlab数值计算（多项式插值）
    基于Windows 的 VS Code C/C++ 编译环境搭建
    vue3实现表格的分页以及确认消息弹窗
    Nginx反向代理与负载均衡与504错误
    动态规划算法实现------空间中的移动(路径)问题
    记一次：Python的学习笔记五（Django集成swagger）
    电脑重装系统后桌面图标如何调小尺寸
    将 WSL 安装到C盘以外的位置
  • 原文地址：https://blog.csdn.net/Kenji_Shinji/article/details/125479204