昇思25天学习打卡营第10天|NLP-RNN实现情感分类

打卡

目录

打卡

任务说明

流程

数据准备与加载

加载预训练词向量(分词)

数据集预处理

模型构建

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"], shuffle=True, num_samples=10000)imdb_test = ds.GeneratorDataset(IMDBData(imdb_path, "test"), column_names=["text", "label"], shuffle=False)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模型的Vocab,Vocab是数据集中可能出现的所有Token的集合,保存了各Token与其ID之间的映射关系,其中的函数 from_list(word_listspecial_tokens=Nonespecial_first=True) 从给定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, encoding='utf-8') as gf:for glove in gf:word, embedding = glove.split(maxsplit=1)tokens.append(word)embeddings.append(np.fromstring(embedding, dtype=np.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_first=False)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(f"idx={idx}, embedding={embedding}")

代码运行结果例子。

数据集预处理

  • 通过Vocab将所有的 Token 处理为index id。
  • 将文本序列统一长度,不足的使用<pad>补齐,超出的进行截断。

  1. 首先针对token 到 index id 的查表操作,使用 mindspore.dataset.text.Lookup(vocab, unknown_token=None, data_type=mstype.int32) 接口,将前文构造的词表加载,并指定 unknown_token 
  2. 其次为文本序列统一长度操作,使用 dataset.transforms.PadEnd(pad_shape, pad_value=None) 接口,此接口定义最大长度和补齐值(pad_value),这里取最大长度为500,填充值对应词表中 <pad> 的 index id。
  3. 由于后续模型训练的需要,同时要将label数据转为float32格式。
  4. 接着,手动将IMDB数据集分割为训练和验证两部分,比例取0.7, 0.3。
  5. 最后,通过 batch(batch_size, drop_remainder=False, num_parallel_workers=None, **kwargs) 接口指定数据集的 batch 大小,,并设置是否丢弃无法被batch size整除的剩余数据。

代码例子

import mindspore as ms# 根据词表,将分词标记(token)映射到其索引值(id)。
lookup_op = ds.text.Lookup(vocab,  # 词表对象,用于存储分词和索引的映射。unknown_token='<unk>'  # 备用词汇,用于要查找的单词不在词汇表时进行替换。 如果单词不在词汇表中,则查找结果将替换为 unknown_token 的值。 如果单词不在词汇表中,且未指定 unknown_token ,将抛出运行时错误。默认值: None ,不指定该参数。)# 对输入Tensor进行填充,要求 pad_shape 与输入Tensor的维度保持一致。
pad_op = ds.transforms.PadEnd([500],  ## 指定填充的shape。设置为较小的维数时该维度的元素将被截断。pad_value=vocab.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_remainder=True)
imdb_valid = imdb_valid.batch(64, drop_remainder=True)

模型构建

  • 结构: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_hot=False, embedding_table='normal', dtype=mstype.float32, padding_idx=None)

用于存储词向量并使用索引进行检索,根据输入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 时刻输入 $x_t$ , t-1 时刻的隐藏状态 $h_{t-1}$  和Cell状态 $c_{t-1}$

t 时刻的Cell状态 $c_{t}$ 和隐藏状态 $h_{t}$ 使用门控机制计算得到。

输入门  $i_t$ 计算出候选值。遗忘门  $f_t$决定是否让  $h_{t-1}$ 学到的信息通过或部分通过。

输出门  $o_t$ 决定哪些信息输出。

候选Cell状态 $ \tilde{c_{t}} $ 是用当前输入计算的。

最后,使用遗忘门、输入门、输出门计算得到当前时刻的Cell状态 $c_t$和隐藏状态 $h_t$

如下公式,𝜎 是sigmoid激活函数, ∗ 是乘积。 𝑊, 𝑏 是公式中输出和输入之间的可学习权重。例如, $W_{ix}$$b_{ix}$ 是用于从输入 𝑥 转换为 𝑖 的权重和偏置。

$i_t = \sigma (W_{ix}x_{t} + b_{ix} + W_{ih}h_{(t-1)} + b_{ih})$

$f_t = \sigma (W_{fx}x_{t} + b_{fx} + W_{fh}h_{(t-1)} + b_{fh})$

$ \tilde{c_{t}} = tanh(W_{cx}x_t + b_{cx} + W_{ch}h_{(t-1)} + b_{ch})$

$o_t = \sigma (W_{ox} x_{t} + b_{ox} + W_{oh} h_{(t-1)} + b_{oh}) $

$ c_{t} = f_t * c_{(t-1)} + i_t * \tilde{c_t}$

h_t = o_t * tanh(c_t)

MindSpore中的LSTM隐藏了整个循环神经网络在序列时间步(Time step)上的循环(同pyTorch),送入输入序列、初始状态,即可获得每个时间步的隐藏状态(hidden state)拼接而成的矩阵,以及最后一个时间步对应的隐状态。我们使用最后的一个时间步的隐藏状态作为输入句子的编码特征,送入下一层。LSTM 公式为:$h_{0:n}, (h_n, c_n) = LSTM(x_{0:n}, (h_0, c_0))$

全连接层

全连接层,即 nn.Dense (in_channels, out_channels, weight_init=None, bias_init=None, has_bias=True, activation=None, dtype=mstype.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_table=ms.Tensor(embeddings), padding_idx=pad_idx)self.rnn = nn.LSTM(embedding_dim,hidden_dim,num_layers=n_layers,bidirectional=bidirectional,batch_first=True)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_init=weight_init, bias_init=bias_init)def construct(self, inputs):embedded = self.embedding(inputs)_, (hidden, _) = self.rnn(embedded)hidden = ops.concat((hidden[-2, :, :], hidden[-1, :, :]), axis=1)output = self.fc(hidden)return output

损失函数与优化器

针对本节情感分类问题的特性,即预测Positive或Negative的二分类问题,选择nn.BCEWithLogitsLoss(reduction='mean', weight=None, pos_weight=None) (二分类交叉熵损失函数)。

训练逻辑

一般训练逻辑分为一下步骤:

  1. 读取一个Batch的数据;
  2. 送入网络,进行正向计算和反向传播,更新权重;
  3. 返回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

模型评估逻辑设计步骤:

  1. 读取一个Batch的数据;
  2. 送入网络,进行正向计算,获得预测结果;
  3. 计算准确率。
def evaluate(model, test_dataset, criterion, epoch=0):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(total=total) 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(loss=epoch_loss/step_total, acc=epoch_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_examples'def http_get(url: str, temp_file: IO):"""使用requests库下载数据,并使用tqdm库进行流程可视化"""req = requests.get(url, stream=True)content_length = req.headers.get('Content-Length')total = int(content_length) if content_length is not None else Noneprogress = tqdm(unit='B', total=total)for chunk in req.iter_content(chunk_size=1024):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"代表正面评价,映射为1;"neg"代表负面评价,映射为0)。label_map = {"pos": 1,"neg": 0}def __init__(self, path, mode="train"):# 构造函数接受两个参数: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(r"aclImdb/{}/{}/.*\.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"], shuffle=True, num_samples=10000)imdb_test = ds.GeneratorDataset(IMDBData(imdb_path, "test"), column_names=["text", "label"], shuffle=False)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, encoding='utf-8') as gf:for glove in gf:word, embedding = glove.split(maxsplit=1)tokens.append(word)embeddings.append(np.fromstring(embedding, dtype=np.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_first=False)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(f"train 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(f"idx={idx}, embedding={embedding}, len embedding={len(embedding)}")
idx = vocab.tokens_to_ids('it')
embedding = embeddings[idx]
print(f"idx={idx}, embedding={embedding}, len embedding={len(embedding)}")# 数据预处理
lookup_op = ds.text.Lookup(vocab, unknown_token='<unk>')
pad_op = ds.transforms.PadEnd([500], pad_value=vocab.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(f"len imdb_train = ", len(imdb_train))
imdb_train = imdb_train.batch(64, drop_remainder=True)
imdb_valid = imdb_valid.batch(64, drop_remainder=True)
print(f"len 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_table=ms.Tensor(embeddings), padding_idx=pad_idx)self.rnn = nn.LSTM(embedding_dim, ## 100 hidden_dim,  ## num_layers=n_layers,bidirectional=bidirectional,batch_first=True)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_init=weight_init, bias_init=bias_init)def construct(self, inputs):embedded = self.embedding(inputs)_, (hidden, _) = self.rnn(embedded)hidden = ops.concat((hidden[-2, :, :], hidden[-1, :, :]), axis=1)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, epoch=0):model.set_train()total = train_dataset.get_dataset_size()loss_total = 0step_total = 0with tqdm(total=total) 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(loss=loss_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, epoch=0):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(total=total) 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(loss=epoch_loss/step_total, acc=epoch_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(reduction='mean')
optimizer = nn.Adam(model.trainable_params(), learning_rate=lr)
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(f"prediction={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")

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/871990.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

高频面试题基本总结回顾4(含笔试高频算法整理)

目录 一、基本面试流程回顾 二、基本高频算法题展示 三、基本面试题总结回顾 &#xff08;一&#xff09;Java高频面试题整理 &#xff08;二&#xff09;JVM相关面试问题整理 &#xff08;三&#xff09;MySQL相关面试问题整理 &#xff08;四&#xff09;Redis相关面试…

Python从0到100(三十九):数据提取之正则(文末免费送书)

前言&#xff1a; 零基础学Python&#xff1a;Python从0到100最新最全教程。 想做这件事情很久了&#xff0c;这次我更新了自己所写过的所有博客&#xff0c;汇集成了Python从0到100&#xff0c;共一百节课&#xff0c;帮助大家一个月时间里从零基础到学习Python基础语法、Pyth…

Qt|QTreewidget类下函数qt助手详解说明示例(二)

上篇&#xff1a;Qt|QTreewidget类下函数qt助手详解说明示例&#xff08;一&#xff09; 该系列持续更新&#xff0c;喜欢请一键三连&#xff0c;一起学习进步&#xff0c;升职加薪&#xff0c;感谢各位大佬。 QT5.14.2 参考官方QT助手 Kimi辅助说明 文章目录 insertTopLevelI…

服务器数据恢复—2块硬盘离线且热备盘未完全激活的raid5数据恢复案例

服务器存储数据恢复环境&#xff1a; 北京某企业一台EMC FCAX-4存储上搭建一组由12块成员盘的raid5磁盘阵列&#xff0c;其中包括2块热备盘。 服务器存储故障&#xff1a; raid5阵列中两块硬盘离线&#xff0c;热备盘只有一块成功激活&#xff0c;raid瘫痪&#xff0c;上层LUN…

记录些Spring+题集(1)

接口防刷机制 接口被刷指的是同一接口被频繁调用&#xff0c;可能是由于以下原因导致&#xff1a; 恶意攻击&#xff1a;攻击者利用自动化脚本或工具对接口进行大量请求&#xff0c;以消耗系统资源、拖慢系统响应速度或达到其他恶意目的。误操作或程序错误&#xff1a;某些情…

防火墙小试——部分(书接上回)NAT

toop接上回 1.实验拓扑及要求 前情回顾 DMZ区内的服务器&#xff0c;办公区仅能在办公时间内&#xff08;9&#xff1a;00 - 18&#xff1a;00&#xff09;可以访问&#xff0c;生产区的设备全天可以访问. 生产区不允许访问互联网&#xff0c;办公区和游客区允许访问互联网 …

全球DeepFake攻防挑战赛DataWhale AI 夏令营——图像赛道

全球DeepFake攻防挑战赛&DataWhale AI 夏令营——图像赛道 赛题背景 随着人工智能技术的迅猛发展&#xff0c;深度伪造技术&#xff08;Deepfake&#xff09;正成为数字世界中的一把双刃剑。这项技术不仅为创意内容的生成提供了新的可能性&#xff0c;同时也对数字安全构…

两个视频怎么剪辑成一个视频?3个方法分享

两个视频怎么剪辑成一个视频&#xff1f;将两个视频剪辑成一个视频&#xff0c;是现代数字内容创作中的高频需求&#xff0c;它不仅简化了素材管理&#xff0c;还能通过创意剪辑提升作品连贯性与表现力。通过精心编排&#xff0c;两个视频片段可以无缝融合&#xff0c;讲述更完…

PLC电工实操题库—匠心整理—高分资源—即刻下载!

1.编制用PLC控制的车辆出入库管理控制程序 答&#xff1a; 传感器布置&#xff1a; 显示电路&#xff1a; 说明&#xff1a; 1.光传感器的接收光被遮断时定义为“有信号”;2.传感器1#有信号时启动增计数逻辑:3.传感器2#有信号时启动减计数逻辑:4.传感器1#完成脉冲同时2#有信…

【深度学习】PyTorch框架(2):激活函数

1.引言 在文中&#xff0c;我们将深入探讨流行的激活函数&#xff0c;并分析它们在神经网络优化特性中的作用。激活函数在深度学习模型中扮演着至关重要的角色&#xff0c;因为它们为网络引入了非线性特性。尽管文献中描述了众多的激活函数&#xff0c;但它们并非一视同仁&…

220v降压5v用几k电阻?

# 220V降压至5V的电阻选择与AH8652和AH8696芯片的应用 在电子电路设计中&#xff0c;将高电压转换为低电压是常见的需求。例如&#xff0c;将220V交流电&#xff08;AC&#xff09;降压至5V直流电&#xff08;DC&#xff09;用于低功耗设备。这通常通过使用降压转换器&#xf…

C判断一个点在三角形上

背景 鼠标操作时&#xff0c;经常要判断是否命中显示控件&#xff0c;特开发此算法快速判断。 原理 三角形三等分点定理是指在任意三角形ABC中&#xff0c;可以找到三个点D、E和F&#xff0c;使得线段AD、BE和CF均等分三角形ABC。 这意味着三个等分点分别位于三个边界上&…

Golang中init()函数初始化顺序

Q24.init()函数初始化顺序 init() 函数是用于程序执行前做包的初始化的函数&#xff0c;比如初始化包里的变量等一个包可以出线多个 init() 函数,一个源文件也可以包含多个 init() 函数同一个包中多个 init() 函数的执行顺序没有明确定义&#xff0c;但是不同包的init函数是根…

线程的复习

目录 大纲Java中的线程概念创建线程的方法线程的生命周期线程的同步和通信线程的优先级和调度线程的中断 案例 大纲 Java中的线程概念 在Java中&#xff0c;线程是操作系统能够进行运算调度的最小单位&#xff0c;它被包含在进程之中&#xff0c;是进程中实际运作的部分。一个…

网络配置命令

文章目录 一、查看网络接口信息 ifconfig1.1 网络接口名称1.2 使用 ifconfig 查看网络接口信息1.2.1 输出示例1.2.2 输出解释 1.3 查看特定网络接口信息1.3.1 输出示例 1.4 查看所有网络接口信息1.5 特殊网络接口 二、修改网络配置文件2.1 配置文件示例2.2 使配置生效2.3 关闭 …

图——图的遍历(DFS与BFS)

前面的文章中我们学习了图的基本概念和存储结构&#xff0c;大家可以通过下面的链接学习&#xff1a; 图的定义和基本术语 图的类型定义和存储结构 这篇文章就来学习一下图的重要章节——图的遍历。 目录 一&#xff0c;图的遍历定义&#xff1a; 二&#xff0c;深度优先…

应用实践之基于MindNLP+MusicGen生成自己的个性化音乐

前言 MusicGen是基于单个语言模型&#xff08;LM&#xff09;的音乐生成模型&#xff0c;使用文本描述或音频提示生成高质量的音乐样本。它基于Transformer结构&#xff0c;包括文本编码器模型和音频压缩模型&#xff0c;以及一个解码器来预测离散的隐形状态音频token。与传统…

uni-data-select 插件配置接收字段,更改默认的text,value

当后台返回的数据源格式不是如下value,text字段时&#xff0c;需要自定义字段配置 range: [{ value: 0, text: "篮球" },{ value: 1, text: "足球" },{ value: 2, text: "游泳" },], 思路有两个&#xff0c; 思路一&#xff1a;前端遍历更改为…

PE文件(十一)移动导出表和重定位表

移动表的原因 一个PE文件中有很多节&#xff0c;每个节都存储不同的数据。而PE文件中的各种表也都分散存储在这些节当中。此时各种表的信息与程序的代码和数据相互混合在一起&#xff0c;如果我们直接对整个程序进行加密&#xff0c;那系统在初始化程序时就会出问题。比如&…

DHCP原理及配置

目录 一、DHCP原理 DHCP介绍 DHCP工作原理 DHCP分配方式 工作原理 DHCP重新登录 DHCP优点 二、DHCP配置 一、DHCP原理 1 DHCP介绍 大家都知道&#xff0c;现在出门很多地方基本上都有WIFI&#xff0c;那么有没有想过这样一个问题&#xff0c;平时在家里都是“固定”的…