公司建立网站的优势,如何做表白网站的教程,如何开通网络,功能型类的网站打卡 目录 打卡 任务说明 流程 数据准备与加载 加载预训练词向量#xff08;分词#xff09; 数据集预处理 模型构建 Embedding RNN(循环神经网络) LSTM 全连接层 损失函数与优化器 训练逻辑 评估指标和逻辑 模型训练与保存 模型加载与测试 自定义输入测试 …打卡 目录 打卡 任务说明 流程 数据准备与加载 加载预训练词向量分词 数据集预处理 模型构建 Embedding RNN(循环神经网络) LSTM 全连接层 损失函数与优化器 训练逻辑 评估指标和逻辑 模型训练与保存 模型加载与测试 自定义输入测试 代码 任务说明 使用MindSpore实现一个基于RNN网络的情感分类模型 流程 数据准备与加载 1、从 https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/aclImdb_v1.tar.gz 下载数据集。注意可用tqdm库对下载百分比进行可视化、用IO的方式可安全地下载临时文件而后保存至指定的路径并返回。如下是下载的数据集展示。 2、将IMDB数据集加载至内存并构造为迭代对象后使用 mindspore.dataset 提供的Generatordataset 接口加载数据集迭代对象并进行下一步的数据处理例子如下其中 IMDBData 类是 IMDB 数据集加载器imdb_train 是构建的一个 Generatordataset 对象。 import mindspore.dataset as dsdef load_imdb(imdb_path):imdb_train ds.GeneratorDataset(IMDBData(imdb_path, train), column_names[text, label], shuffleTrue, num_samples10000)imdb_test ds.GeneratorDataset(IMDBData(imdb_path, test), column_names[text, label], shuffleFalse)return imdb_train, imdb_testimdb_train, imdb_test load_imdb(imdb_path) 加载预训练词向量分词 Glove Global Vectors for Word Representation  词向量作为Embedding是一种无监督学习算法。从 https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/glove.6B.zip 下载数据集。如下图所示。 预训练词向量是对输入单词的数值化表示通过nn.Embedding层采用查表的方式输入单词对应词表中的index获得对应的表达向量。  由于数据集中可能存在词表没有覆盖的单词因此需要加入unk标记符同时由于输入长度的不一致在打包为一个batch时需要将短的文本进行填充因此需要加入pad标记符。 完成后的词表长度为原词表长度2。mindspore.dataset.text.Vocab 用于创建用于训练NLP模型的VocabVocab是数据集中可能出现的所有Token的集合保存了各Token与其ID之间的映射关系其中的函数 from_list(word_list, special_tokensNone, special_firstTrue) 从给定Token列表创建Vocab special_tokens 表示追加到Vocab中的Token列表tokens_to_ids(tokens) 查找指定Token对应的ID。 示例代码如下根据输出对应的词表大小 400002 向量长度为100。 import zipfile import numpy as npdef load_glove(glove_path):glove_100d_path os.path.join(cache_dir, glove.6B.100d.txt)if not os.path.exists(glove_100d_path):glove_zip zipfile.ZipFile(glove_path)glove_zip.extractall(cache_dir)embeddings []tokens []with open(glove_100d_path, encodingutf-8) as gf:for glove in gf:word, embedding glove.split(maxsplit1)tokens.append(word)embeddings.append(np.fromstring(embedding, dtypenp.float32, sep ))# 添加 unk, pad 两个特殊占位符对应的embeddingembeddings.append(np.random.rand(100))embeddings.append(np.zeros((100,), np.float32))vocab ds.text.Vocab.from_list(tokens, special_tokens[unk, pad], special_firstFalse)embeddings np.array(embeddings).astype(np.float32)return vocab, embeddingsglove_path download(glove.6B.zip, https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/glove.6B.zip) vocab, embeddings load_glove(glove_path) # print(len(vocab.vocab())) # 400002 print(np.shape(embeddings)) ## (400002, 100) 比原始文件多两行idx vocab.tokens_to_ids(the) embedding embeddings[idx] print(fidx{idx}, embedding{embedding}) 代码运行结果例子。 数据集预处理 通过Vocab将所有的 Token 处理为index id。将文本序列统一长度不足的使用pad补齐超出的进行截断。 首先针对token 到 index id 的查表操作使用 mindspore.dataset.text.Lookup(vocab, unknown_tokenNone, data_typemstype.int32) 接口将前文构造的词表加载并指定 unknown_token 。其次为文本序列统一长度操作使用 dataset.transforms.PadEnd(pad_shape, pad_valueNone) 接口此接口定义最大长度和补齐值(pad_value)这里取最大长度为500填充值对应词表中 pad 的 index id。由于后续模型训练的需要同时要将label数据转为float32格式。接着手动将IMDB数据集分割为训练和验证两部分比例取0.7, 0.3。 最后通过 batch(batch_size, drop_remainderFalse, num_parallel_workersNone, **kwargs) 接口指定数据集的 batch 大小并设置是否丢弃无法被batch size整除的剩余数据。 代码例子 import mindspore as ms# 根据词表将分词标记(token)映射到其索引值(id)。 lookup_op ds.text.Lookup(vocab, # 词表对象用于存储分词和索引的映射。unknown_tokenunk # 备用词汇用于要查找的单词不在词汇表时进行替换。 如果单词不在词汇表中则查找结果将替换为 unknown_token 的值。 如果单词不在词汇表中且未指定 unknown_token 将抛出运行时错误。默认值 None 不指定该参数。)# 对输入Tensor进行填充要求 pad_shape 与输入Tensor的维度保持一致。 pad_op ds.transforms.PadEnd([500], ## 指定填充的shape。设置为较小的维数时该维度的元素将被截断。pad_valuevocab.tokens_to_ids(pad) ## 用于填充的值。默认 None 表示不指定填充值。 当指定为默认值输入Tensor为数值型时默认填充 0 输入Tensor为字符型时填充空字符串。) type_cast_op ds.transforms.TypeCast(ms.float32)imdb_train imdb_train.map(operations[lookup_op, pad_op], input_columns[text]) imdb_train imdb_train.map(operations[type_cast_op], input_columns[label])imdb_test imdb_test.map(operations[lookup_op, pad_op], input_columns[text]) imdb_test imdb_test.map(operations[type_cast_op], input_columns[label])imdb_train, imdb_valid imdb_train.split([0.7, 0.3]) imdb_train imdb_train.batch(64, drop_remainderTrue) imdb_valid imdb_valid.batch(64, drop_remainderTrue) 模型构建 结构nn.Embedding - nn.RNN - nn.Dense其中nn.Embedding层加载Glove词向量RNN 层做特征提取nn.Dense 层将特征转化为与分类数量相同的size用于后续进行模型优化训练。这里使用能够一定程度规避RNN梯度消失问题的变种LSTM(Long short-term memory)做特征提取层。 Embedding mindspore.nn.Embedding(vocab_size, embedding_size, use_one_hotFalse, embedding_tablenormal, dtypemstype.float32, padding_idxNone) 用于存储词向量并使用索引进行检索根据输入Tensor中的id从 embedding_table 中查询对应的 embedding 向量。当输入为id组成的序列时输出为对应embedding向量构成的矩阵。当 use_one_hot 等于True时x的类型必须是mindpore.int32。 vocab_size (int) - 词典的大小。如上文对应的词表大小 400002 。 embedding_size (int) - 每个嵌入向量的大小。如上文向量长度为100。 use_one_hot (bool) - 指定是否使用one-hot形式。默认值 False 。 embedding_table (Union[Tensor, str, Initializer, numbers.Number]) - embedding_table的初始化方法。当指定为字符串字符串取值请参见类 mindspore.common.initializer 。默认值 normal 。 dtype (mindspore.dtype) - x的数据类型。默认值 mstype.float32 。 padding_idx (int, None) - 将 padding_idx 对应索引所输出的嵌入向量用零填充。默认值 None 。该功能已停用。 RNN(循环神经网络) LSTM 循环神经网络Recurrent Neural Network, RNN是一类以序列sequence数据为输入在序列的演进方向进行递归recursion且所有节点循环单元按链式连接的神经网络。 RNN的结构拆解 RNN单个Cell的结构简单因此也造成了梯度消失(Gradient Vanishing)问题具体表现为RNN网络在序列较长时在序列尾部已经基本丢失了序列首部的信息。为了克服这一问题LSTM(Long short-term memory)被提出通过门控机制(Gating Mechanism)来控制信息流在每个循环步中的留存和丢弃。选择LSTM变种而不是经典的RNN做特征提取来规避梯度消失问题可以获得更好的模型效果。 mindspore.nn.LSTM(*args, **kwargs)  长短期记忆LSTM网络根据输入序列和给定的初始状态计算输出序列和最终状态。在LSTM模型中有两条管道连接两个连续的Cell一条是Cell状态管道另一条是隐藏状态管道。将两个连续的时间节点表示为 t−1 和 t。指定在 t 时刻输入   t-1 时刻的隐藏状态   和Cell状态 。 t 时刻的Cell状态  和隐藏状态  使用门控机制计算得到。 输入门   计算出候选值。遗忘门  决定是否让   学到的信息通过或部分通过。 输出门   决定哪些信息输出。 候选Cell状态  是用当前输入计算的。 最后使用遗忘门、输入门、输出门计算得到当前时刻的Cell状态 和隐藏状态 。 如下公式 是sigmoid激活函数 ∗ 是乘积。 ,  是公式中输出和输入之间的可学习权重。例如 、 是用于从输入  转换为  的权重和偏置。 MindSpore中的LSTM隐藏了整个循环神经网络在序列时间步(Time step)上的循环(同pyTorch)送入输入序列、初始状态即可获得每个时间步的隐藏状态(hidden state)拼接而成的矩阵以及最后一个时间步对应的隐状态。我们使用最后的一个时间步的隐藏状态作为输入句子的编码特征送入下一层。LSTM 公式为 全连接层 全连接层即 nn.Dense (in_channels, out_channels, weight_initNone, bias_initNone, has_biasTrue, activationNone, dtypemstype.float32)将特征维度变换为二分类所需的维度1经过Dense层后的输出即为模型预测结果。 其中公式为 outputs activation(X * kernel bias) activation 是激活函数kernel 是权重矩阵bias 是偏置向量。 模型构建的示例代码如下 import math import mindspore as ms import mindspore.nn as nn import mindspore.ops as ops from mindspore.common.initializer import Uniform, HeUniformclass RNN(nn.Cell):def __init__(self, embeddings, hidden_dim, output_dim, n_layers,bidirectional, pad_idx):super().__init__()vocab_size, embedding_dim embeddings.shapeself.embedding nn.Embedding(vocab_size, embedding_dim, embedding_tablems.Tensor(embeddings), padding_idxpad_idx)self.rnn nn.LSTM(embedding_dim,hidden_dim,num_layersn_layers,bidirectionalbidirectional,batch_firstTrue)weight_init HeUniform(math.sqrt(5))bias_init Uniform(1 / math.sqrt(hidden_dim * 2))self.fc nn.Dense(hidden_dim * 2, output_dim, weight_initweight_init, bias_initbias_init)def construct(self, inputs):embedded self.embedding(inputs)_, (hidden, _) self.rnn(embedded)hidden ops.concat((hidden[-2, :, :], hidden[-1, :, :]), axis1)output self.fc(hidden)return output 损失函数与优化器 针对本节情感分类问题的特性即预测Positive或Negative的二分类问题选择nn.BCEWithLogitsLoss(reductionmean, weightNone, pos_weightNone) (二分类交叉熵损失函数)。 训练逻辑 一般训练逻辑分为一下步骤 读取一个Batch的数据送入网络进行正向计算和反向传播更新权重返回loss。 grad_fn   mindspore.value_and_grad(forward_fn, None, optimizer.parameters) 生成求导函数用于计算给定函数的正向计算结果和梯度。 评估指标和逻辑 模型评估使用模型的预测结果和测试集的正确标签进行对比求出预测的准确率。 由于IMDB的情感分类为二分类问题对预测值直接进行四舍五入即可获得分类标签(0或1)然后判断是否与正确标签相等即可。下面为二分类准确率计算函数实现 def binary_accuracy(preds, y):计算每个batch的准确率# 对预测值进行四舍五入rounded_preds np.around(ops.sigmoid(preds).asnumpy())correct (rounded_preds y).astype(np.float32)acc correct.sum() / len(correct)return acc 模型评估逻辑设计步骤 读取一个Batch的数据送入网络进行正向计算获得预测结果计算准确率。 def evaluate(model, test_dataset, criterion, epoch0):total test_dataset.get_dataset_size()epoch_loss 0epoch_acc 0step_total 0## 在进行evaluate前通过model.set_train(False)将模型置为评估状态此时Dropout不生效。model.set_train(False)with tqdm(totaltotal) as t:# 使用tqdm进行loss和过程的可视化。t.set_description(Epoch %i % epoch)for i in test_dataset.create_tuple_iterator():## 进行evaluate时使用的模型是不包含损失函数和优化器的网络主体predictions model(i[0])loss criterion(predictions, i[1])epoch_loss loss.asnumpy()acc binary_accuracy(predictions, i[1])epoch_acc accstep_total 1t.set_postfix(lossepoch_loss/step_total, accepoch_acc/step_total)t.update(1)return epoch_loss / total 模型训练与保存 模型训练设置5轮。同时维护一个用于保存最优模型的变量best_valid_loss根据每一轮评估的loss值取loss值最小的轮次将模型进行保存。为节省用例运行时长此处num_epochs设置为3 。 num_epochs 3 best_valid_loss float(inf) ckpt_file_name os.path.join(cache_dir, sentiment-analysis.ckpt)for epoch in range(num_epochs):train_one_epoch(model, imdb_train, epoch)valid_loss evaluate(model, imdb_valid, loss_fn, epoch)if valid_loss best_valid_loss:best_valid_loss valid_lossms.save_checkpoint(model, ckpt_file_name) 模型加载与测试 加载已保存的最优模型(即checkpoint)供后续测试使用。 直接使用MindSpore提供的Checkpoint加载和网络权重加载接口1.将保存的模型Checkpoint加载到内存中2.将Checkpoint加载至模型。 param_dict ms.load_checkpoint(ckpt_file_name) ms.load_param_into_net(model, param_dict)## 对测试集打batch然后使用evaluate方法进行评估得到模型在测试集上的效果。 imdb_test imdb_test.batch(64) evaluate(model, imdb_test, loss_fn) 如下测试集效果一般有空了可以调一调训练参数。比如LSTM层数、学习率等。 自定义输入测试 输入一句评价获得评价的情感分类. score_map {1: Positive,0: Negative }def predict_sentiment(model, vocab, sentence):model.set_train(False)tokenized sentence.lower().split()indexed vocab.tokens_to_ids(tokenized)tensor ms.Tensor(indexed, ms.int32)tensor tensor.expand_dims(0)prediction model(tensor)return score_map[int(np.round(ops.sigmoid(prediction).asnumpy()))]predict_sentiment(model, vocab, This film is terrible) predict_sentiment(model, vocab, This film is great) predict_sentiment(model, vocab, This movie is not good, but i like it) 代码 import os import shutil import requests import tempfile from tqdm import tqdm from typing import IO from pathlib import Path import re import six import string import tarfile import mindspore.dataset as ds import zipfile import numpy as np import mindspore as ms# 指定保存路径为 home_path/.mindspore_examples cache_dir Path.home() / .mindspore_examplesdef http_get(url: str, temp_file: IO):使用requests库下载数据并使用tqdm库进行流程可视化req requests.get(url, streamTrue)content_length req.headers.get(Content-Length)total int(content_length) if content_length is not None else Noneprogress tqdm(unitB, totaltotal)for chunk in req.iter_content(chunk_size1024):if chunk:progress.update(len(chunk))temp_file.write(chunk)progress.close()def download(file_name: str, url: str):下载数据并存为指定名称if not os.path.exists(cache_dir):os.makedirs(cache_dir)cache_path os.path.join(cache_dir, file_name)cache_exist os.path.exists(cache_path)if not cache_exist:with tempfile.NamedTemporaryFile() as temp_file:http_get(url, temp_file)temp_file.flush()temp_file.seek(0)with open(cache_path, wb) as cache_file:shutil.copyfileobj(temp_file, cache_file)return cache_pathclass IMDBData():IMDB数据集加载器加载IMDB数据集并处理为一个Python迭代对象。# label_map是一个类属性它是一个字典将影评的情感标签映射为数值pos代表正面评价映射为1neg代表负面评价映射为0。label_map {pos: 1,neg: 0}def __init__(self, path, modetrain):# 构造函数接受两个参数path数据集的路径和mode模式默认为train可能还有test等。# 初始化实例变量mode和path以及两个空列表docs和labels用于存储文档内容和对应的标签。然后调用_load方法加载正面和负面评价的数据。self.mode modeself.path pathself.docs, self.labels [], []self._load(pos)self._load(neg)def _load(self, label):pattern re.compile(raclImdb/{}/{}/.*\.txt$.format(self.mode, label))# 将数据加载至内存with tarfile.open(self.path) as tarf:tf tarf.next()while tf is not None:if bool(pattern.match(tf.name)):# 对文本进行分词、去除标点和特殊字符、小写处理self.docs.append(str(tarf.extractfile(tf).read().rstrip(six.b(\n\r)).translate(None, six.b(string.punctuation)).lower()).split())self.labels.append([self.label_map[label]])tf tarf.next()def __getitem__(self, idx):return self.docs[idx], self.labels[idx]def __len__(self):return len(self.docs)def load_imdb(imdb_path):imdb_train ds.GeneratorDataset(IMDBData(imdb_path, train), column_names[text, label], shuffleTrue, num_samples10000)imdb_test ds.GeneratorDataset(IMDBData(imdb_path, test), column_names[text, label], shuffleFalse)return imdb_train, imdb_testdef load_glove(glove_path):glove_100d_path os.path.join(cache_dir, glove.6B.100d.txt)if not os.path.exists(glove_100d_path):glove_zip zipfile.ZipFile(glove_path)glove_zip.extractall(cache_dir)embeddings []tokens []with open(glove_100d_path, encodingutf-8) as gf:for glove in gf:word, embedding glove.split(maxsplit1)tokens.append(word)embeddings.append(np.fromstring(embedding, dtypenp.float32, sep ))# 添加 unk, pad 两个特殊占位符对应的embeddingembeddings.append(np.random.rand(100))embeddings.append(np.zeros((100,), np.float32))vocab ds.text.Vocab.from_list(tokens, special_tokens[unk, pad], special_firstFalse)embeddings np.array(embeddings).astype(np.float32)return vocab, embeddingsimdb_path download(aclImdb_v1.tar.gz, https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/aclImdb_v1.tar.gz) glove_path download(glove.6B.zip, https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/glove.6B.zip)imdb_train IMDBData(imdb_path, train) print(ftrain dataset len: {len(imdb_train)}) ### pos neg 25000 train/test imdb_train, imdb_test load_imdb(imdb_path) ## imdb_train 是构建的一个 mindspore.dataset.Generatordataset 对象。vocab, embeddings load_glove(glove_path) print(len(vocab.vocab())) ## 400002, mindspore.dataset.text.utils.Vocab object at 0xfffe9a9e38b0 print(np.shape(embeddings)) ## (400002, 100) ## 例子 idx vocab.tokens_to_ids(the) embedding embeddings[idx] print(fidx{idx}, embedding{embedding}, len embedding{len(embedding)}) idx vocab.tokens_to_ids(it) embedding embeddings[idx] print(fidx{idx}, embedding{embedding}, len embedding{len(embedding)})# 数据预处理 lookup_op ds.text.Lookup(vocab, unknown_tokenunk) pad_op ds.transforms.PadEnd([500], pad_valuevocab.tokens_to_ids(pad)) type_cast_op ds.transforms.TypeCast(ms.float32)imdb_train imdb_train.map(operations[lookup_op, pad_op], input_columns[text]) imdb_train imdb_train.map(operations[type_cast_op], input_columns[label]) imdb_test imdb_test.map(operations[lookup_op, pad_op], input_columns[text]) imdb_test imdb_test.map(operations[type_cast_op], input_columns[label])imdb_train, imdb_valid imdb_train.split([0.7, 0.3]) print(flen imdb_train , len(imdb_train)) imdb_train imdb_train.batch(64, drop_remainderTrue) imdb_valid imdb_valid.batch(64, drop_remainderTrue) print(flen imdb_train , len(imdb_train) * 64)###############################################################################3 ## model construct import math import mindspore as ms import mindspore.nn as nn import mindspore.ops as ops from mindspore.common.initializer import Uniform, HeUniformclass RNN(nn.Cell):def __init__(self, embeddings, hidden_dim, output_dim, n_layers,bidirectional, pad_idx):super().__init__()vocab_size, embedding_dim embeddings.shapeself.embedding nn.Embedding(vocab_size, embedding_dim, embedding_tablems.Tensor(embeddings), padding_idxpad_idx)self.rnn nn.LSTM(embedding_dim, ## 100 hidden_dim, ## num_layersn_layers,bidirectionalbidirectional,batch_firstTrue)weight_init HeUniform(math.sqrt(5))bias_init Uniform(1 / math.sqrt(hidden_dim * 2))self.fc nn.Dense(hidden_dim * 2, output_dim, weight_initweight_init, bias_initbias_init)def construct(self, inputs):embedded self.embedding(inputs)_, (hidden, _) self.rnn(embedded)hidden ops.concat((hidden[-2, :, :], hidden[-1, :, :]), axis1)output self.fc(hidden)return outputdef forward_fn(data, label):logits model(data)loss loss_fn(logits, label)return lossdef train_step(data, label):loss, grads grad_fn(data, label)optimizer(grads)return lossdef train_one_epoch(model, train_dataset, epoch0):model.set_train()total train_dataset.get_dataset_size()loss_total 0step_total 0with tqdm(totaltotal) as t:t.set_description(Epoch %i % epoch)for i in train_dataset.create_tuple_iterator():loss train_step(*i)loss_total loss.asnumpy()step_total 1t.set_postfix(lossloss_total/step_total)t.update(1)def binary_accuracy(preds, y):二分类准确率计算函数计算每个batch的准确率# 对预测值进行四舍五入rounded_preds np.around(ops.sigmoid(preds).asnumpy())correct (rounded_preds y).astype(np.float32)acc correct.sum() / len(correct)return accdef evaluate(model, test_dataset, criterion, epoch0):total test_dataset.get_dataset_size()epoch_loss 0epoch_acc 0step_total 0## 在进行evaluate前需要通过model.set_train(False)将模型置为评估状态此时Dropout不生效。model.set_train(False)with tqdm(totaltotal) as t:# 使用tqdm进行loss和过程的可视化。t.set_description(Epoch %i % epoch)for i in test_dataset.create_tuple_iterator():## 进行evaluate时使用的模型是不包含损失函数和优化器的网络主体predictions model(i[0])loss criterion(predictions, i[1])epoch_loss loss.asnumpy()acc binary_accuracy(predictions, i[1])epoch_acc accstep_total 1t.set_postfix(lossepoch_loss/step_total, accepoch_acc/step_total)t.update(1)return epoch_loss / totalhidden_size 256 ## 输入size output_size 1 ## 输出size num_layers 2 ## 层级 bidirectional True lr 0.001 ## 学习率 pad_idx vocab.tokens_to_ids(pad) ## tokens_to_ids(tokens) 查找指定Token对应的ID。model RNN(embeddings, hidden_size, output_size, num_layers, bidirectional, pad_idx) loss_fn nn.BCEWithLogitsLoss(reductionmean) optimizer nn.Adam(model.trainable_params(), learning_ratelr) print(model , model) print(loss_fn , loss_fn) print(optimizer , optimizer)## 生成求导函数用于计算给定函数的正向计算结果和梯度。 grad_fn ms.value_and_grad(forward_fn, None, optimizer.parameters)### 模型训练设置5轮。同时维护一个用于保存最优模型的变量best_valid_loss根据每一轮评估的loss值取loss值最小的轮次将模型进行保存。 num_epochs 5 best_valid_loss float(inf) ckpt_file_name os.path.join(cache_dir, sentiment-analysis.ckpt)for epoch in range(num_epochs):train_one_epoch(model, imdb_train, epoch)valid_loss evaluate(model, imdb_valid, loss_fn, epoch)if valid_loss best_valid_loss:best_valid_loss valid_lossms.save_checkpoint(model, ckpt_file_name)## 加载已保存的最优模型(即checkpoint)供后续测试使用。 param_dict ms.load_checkpoint(ckpt_file_name) ms.load_param_into_net(model, param_dict)## 对测试集打batch然后使用evaluate方法进行评估得到模型在测试集上的效果。 imdb_test imdb_test.batch(64) evaluate(model, imdb_test, loss_fn)################################自定义输入测试 ## 输入一句评价获得评价的情感分类. score_map {1: Positive,0: Negative }def predict_sentiment(model, vocab, sentence):model.set_train(False)tokenized sentence.lower().split()indexed vocab.tokens_to_ids(tokenized)tensor ms.Tensor(indexed, ms.int32)tensor tensor.expand_dims(0)prediction model(tensor)print(fprediction{prediction})return score_map[int(np.round(ops.sigmoid(prediction).asnumpy()))]predict_sentiment(model, vocab, This film is terrible) predict_sentiment(model, vocab, This film is great) predict_sentiment(model, vocab, This movie is not good, but i like it)