devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

实践：基于双向LSTM模型完成文本分类任务_双向lstm解决什么任务

作者：羊村懒王 | 2024-04-14 11:12:47

赞

踩

双向lstm解决什么任务

                

目录

1 数据处理

        1.1 数据加载

        1.2 构造Dataset类

        1.3 封装DataLoader

2 模型构建

3 模型训练

4 模型评价

5 模型预测

5 拓展实验 

        5.1 使用Pytorch内置的单向LSTM进行文本分类实验

​编辑         5.2 使用Paddle内置的单向LSTM进行文本分类实验

        总结

        电影评论可以蕴含丰富的情感：比如喜欢、讨厌、等等．情感分析（Sentiment Analysis）是为一个文本分类问题，即使用判定给定的一段文本信息表达的情感属于积极情绪，还是消极情绪．

        本实践使用 IMDB 电影评论数据集，使用双向 LSTM 对电影评论进行情感分析．

1 数据处理

        IMDB电影评论数据集是一份关于电影评论的经典二分类数据集．IMDB 按照评分的高低筛选出了积极评论和消极评论，如果评分 $\ge 7$，则认为是积极评论；如果评分 $\le4$，则认为是消极评论．数据集包含训练集和测试集数据，数量各为 25000 条，每条数据都是一段用户关于某个电影的真实评价，以及观众对这个电影的情感倾向，其目录结构如下所示：

        LSTM 模型不能直接处理文本数据，需要先将文本中单词转为向量表示，称为词向量（Word Embedding）．为了提高转换效率，通常会事先把文本的每个单词转换为数字 ID，再使用第节中介绍的方法进行向量转换．因此，需要准备一个词典（Vocabulary），将文本中的每个单词转换为它在词典中的序号 ID．同时还要设置一个特殊的词 [UNK]，表示未知词．在处理文本时，如果碰到不在词表的词，一律按 [UNK] 处理．

        首先展示一下我都项目目录

        在lstm.py中引入头文件（lstm.py为本次实验的主要文件，extend_1.py和extend2.py为实验书中的扩展部分),并且由于本人经受上一次LSTM一跑半个小时的荼毒，这次我将代码改为了gpu运行

  1. import os
  2. import torch
  3. import torch.nn as nn
  4. from torch.utils.data import Dataset
  5. from utils.data import load_vocab
  6. from functools import partial
  7. import time
  8. import random
  9. import numpy as np
  10. from nndl import Accuracy, RunnerV3
  11.  
  12. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

        1.1 数据加载

        原始训练集和测试集数据分别25000条，本节将原始的测试集平均分为两份，分别作为验证集和测试集，存放于./dataset目录下。使用如下代码便可以将数据加载至内存：

  1. def load_imdb_data(path):
  2.     assert os.path.exists(path)
  3.     trainset, devset, testset = [], [], []
  4.     with open(os.path.join(path, "train.txt"), "r", encoding='utf-8') as fr:
  5.         for line in fr:
  6.             sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)
  7.             trainset.append((sentence, sentence_label))
  8.  
  9.     with open(os.path.join(path, "dev.txt"), "r", encoding='utf-8') as fr:
  10.         for line in fr:
  11.             sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)
  12.             devset.append((sentence, sentence_label))
  13.  
  14.     with open(os.path.join(path, "test.txt"), "r", encoding='utf-8') as fr:
  15.         for line in fr:
  16.             sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)
  17.             testset.append((sentence, sentence_label))
  18.  
  19.     return trainset, devset, testset
  20.  
  21.  
  22. # 加载IMDB数据集
  23. train_data, dev_data, test_data = load_imdb_data("./dataset/")
  24. # # 打印一下加载后的数据样式
  25. print(train_data[4])

        输出结果如下：

        从输出结果看，加载后的每条样本包含两部分内容：文本串和标签。

        1.2 构造Dataset类

        首先，我们构造IMDBDataset类用于数据管理，它继承自torch.utils.data.DataSet类。

        由于这里的输入是文本序列，需要先将其中的每个词转换为该词在词表中的序号 ID，然后根据词表ID查询这些词对应的词向量，在获得词向量后会将其输入至模型进行后续计算。可以使用IMDBDataset类中的words_to_id方法实现这个功能。 具体而言，利用词表word2id_dict将序列中的每个词映射为对应的数字编号，便于进一步转为为词向量。当序列中的词没有包含在词表时，默认会将该词用[UNK]代替。words_to_id方法利用一个如图6.14所示的哈希表来进行转换。

        代码实现如下：

  1. class IMDBDataset(Dataset):
  2.     def __init__(self, examples, word2id_dict):
  3.         super(IMDBDataset, self).__init__()
  4.         # 词典，用于将单词转为字典索引的数字
  5.         self.word2id_dict = word2id_dict
  6.         # 加载后的数据集
  7.         self.examples = self.words_to_id(examples)
  8.  
  9.     def words_to_id(self, examples):
  10.         tmp_examples = []
  11.         for idx, example in enumerate(examples):
  12.             seq, label = example
  13.             # 将单词映射为字典索引的ID， 对于词典中没有的单词用[UNK]对应的ID进行替代
  14.             seq = [self.word2id_dict.get(word, self.word2id_dict['[UNK]']) for word in seq.split(" ")]
  15.             label = int(label)
  16.             tmp_examples.append([seq, label])
  17.         return tmp_examples
  18.  
  19.     def __getitem__(self, idx):
  20.         seq, label = self.examples[idx]
  21.         return seq, label
  22.  
  23.     def __len__(self):
  24.         return len(self.examples)
  25.  
  26.  
  27. # 加载词表
  28. word2id_dict = load_vocab("./dataset/vocab.txt")
  29.  
  30. # 实例化Dataset
  31. train_set = IMDBDataset(train_data, word2id_dict)
  32. dev_set = IMDBDataset(dev_data, word2id_dict)
  33. test_set = IMDBDataset(test_data, word2id_dict)
  34.  
  35. print('训练集样本数：', len(train_set))
  36. print('样本示例：', train_set[4])

          load_vocab函数，位于utils文件夹下的data.py中

  1. import os
  2.  
  3.  
  4. def load_vocab(path):
  5.     assert os.path.exists(path)
  6.     words = []
  7.     with open(path, "r", encoding="utf-8") as f:
  8.         words = f.readlines()
  9.         words = [word.strip() for word in words if word.strip()]
  10.     word2id = dict(zip(words, range(len(words))))
  11.     return word2id

        输出结果如下:

 

        1.3 封装DataLoader

        在构建 Dataset 类之后，我们构造对应的 DataLoader，用于批次数据的迭代．和前几章的 DataLoader 不同，这里的 DataLoader 需要引入下面两个功能：

  1.  长度限制：需要将序列的长度控制在一定的范围内，避免部分数据过长影响整体训练效果
  2. 长度补齐：神经网络模型通常需要同一批处理的数据的序列长度是相同的，然而在分批时通常会将不同长度序列放在同一批，因此需要对序列进行补齐处理．

        对于长度限制，我们使用max_seq_len参数对于过长的文本进行截断．

        对于长度补齐，我们先统计该批数据中序列的最大长度，并将短的序列填充一些没有特殊意义的占位符 [PAD]，将长度补齐到该批次的最大长度，这样便能使得同一批次的数据变得规整．比如给定两个句子：

  • 句子1: This movie was craptacular.
  • 句子2: I got stuck in traffic on the way to the theater.

        将上面的两个句子补齐，变为：

  • 句子1: This movie was craptacular [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD]
  • 句子2: I got stuck in traffic on the way to the theater

        具体来讲，本节定义了一个collate_fn函数来做数据的截断和填充. 该函数可以作为回调函数传入 DataLoader，DataLoader 在返回一批数据之前，调用该函数去处理数据，并返回处理后的序列数据和对应标签。

        另外，使用[PAD]占位符对短序列填充后，再进行文本分类任务时，默认无须使用[PAD]位置，因此需要使用变量seq_lens来表示序列中非[PAD]位置的真实长度。seq_lens可以在collate_fn函数处理批次数据时进行获取并返回。需要注意的是，由于RunnerV3类默认按照输入数据和标签两类信息获取数据，因此需要将序列数据和序列长度组成元组作为输入数据进行返回，以方便RunnerV3解析数据。

  1. def collate_fn(batch_data, pad_val=0, max_seq_len=256):
  2.     seqs, seq_lens, labels = [], [], []
  3.     max_len = 0
  4.     for example in batch_data:
  5.         seq, label = example
  6.         # 对数据序列进行截断
  7.         seq = seq[:max_seq_len]
  8.         # 对数据截断并保存于seqs中
  9.         seqs.append(seq)
  10.         seq_lens.append(len(seq))
  11.         labels.append(label)
  12.         # 保存序列最大长度
  13.         max_len = max(max_len, len(seq))
  14.     # 对数据序列进行填充至最大长度
  15.     for i in range(len(seqs)):
  16.         seqs[i] = seqs[i] + [pad_val] * (max_len - len(seqs[i]))
  17.  
  18.     # return (torch.tensor(seqs), torch.tensor(seq_lens)), torch.tensor(labels)
  19.     return (torch.tensor(seqs).to(device), torch.tensor(seq_lens)), torch.tensor(labels).to(device)

        这里需要将返回的处理后的seqs和labels在后面要作为参数训练，本次训练在gpu上进行，所以要将二者返回时加上.to(device) 

        下面我们自定义一批数据来测试一下collate_fn函数的功能，这里假定一下max_seq_len为5，然后定义序列长度分别为6和3的两条数据，传入collate_fn函数中。

  1. max_seq_len = 5
  2. batch_data = [[[1, 2, 3, 4, 5, 6], 1], [[2, 4, 6], 0]]
  3. (seqs, seq_lens), labels = collate_fn(batch_data, pad_val=word2id_dict["[PAD]"], max_seq_len=max_seq_len)
  4. print("seqs: ", seqs)
  5. print("seq_lens: ", seq_lens)
  6. print("labels: ", labels)

输出结果如下:

        可以看到，原始序列中长度为6的序列被截断为5，同时原始序列中长度为3的序列被填充到5，同时返回了非`[PAD]`的序列长度。

        接下来，我们将collate_fn作为回调函数传入DataLoader中， 其在返回一批数据时，可以通过collate_fn函数处理该批次的数据。 这里需要注意的是，这里通过partial函数对collate_fn函数中的关键词参数进行设置，并返回一个新的函数对象作为collate_fn。

        在使用DataLoader按批次迭代数据时，最后一批的数据样本数量可能不够设定的batch_size，可以通过参数drop_last来判断是否丢弃最后一个batch的数据。

  1. max_seq_len = 256
  2. batch_size = 128
  3. collate_fn = partial(collate_fn, pad_val=word2id_dict["[PAD]"], max_seq_len=max_seq_len)
  4. train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size,
  5.                                            shuffle=True, drop_last=False, collate_fn=collate_fn)
  6. dev_loader = torch.utils.data.DataLoader(dev_set, batch_size=batch_size,
  7.                                          shuffle=False, drop_last=False, collate_fn=collate_fn)
  8. test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size,
  9.                                           shuffle=False, drop_last=False, collate_fn=collate_fn)

2 模型构建

本实践的整个模型结构如图

        由如下几部分组成：  

        （1）嵌入层：将输入的数字序列进行向量化，即将每个数字映射为向量。这里直接使用Pytorch API：torch.nn.Embedding来完成。

> class torch.nn.Embedding(num_embeddings, embedding_dim, padding_idx=None, sparse=False, weight_attr=None, name=None)

        该API有两个重要的参数：num_embeddings表示需要用到的Embedding的数量。embedding_dim表示嵌入向量的维度。

        torch.nn.Embedding会根据[num\_embeddings, embedding\_dim]自动构造一个二维嵌入矩阵。参数padding_idx是指用来补齐序列的占位符[PAD]对应的词表ID，那么在训练过程中遇到此ID时，其参数及对应的梯度将会以0进行填充。在实现中为了简单起见，我们通常会将[PAD]放在词表中的第一位，即对应的ID为0。

        （2）双向LSTM层：接收向量序列，分别用前向和反向更新循环单元。这里我们直接使用Pytorch API：torch.nn.LSTM来完成。只需要在定义LSTM时设置参数bidirectional为True，便可以直接使用双向LSTM。

> 思考: 在实现双向LSTM时，因为需要进行序列补齐，在计算反向LSTM时，占位符[PAD]是否会对LSTM参数梯度的更新有影响。如果有的话，如何消除影响？

        由于占位符不包含有用的信息，它们在模型的前向传播和反向传播过程中都参与了计算，这可能导致梯度的不准确估计和更新。特别是在长序列中，如果大部分是占位符，那么梯度更新可能会受到极大的干扰。

        为了消除占位符对LSTM参数梯度更新的影响，可以使用填充掩码（padding mask）来标记占位符的位置，并在计算梯度时将其屏蔽掉。填充掩码是一个与输入序列相同形状的二进制张量，其中占位符位置对应的元素值为0，而其他位置对应的元素值为1。

        在计算损失函数时，可以通过将填充掩码与损失函数进行点乘操作，将占位符位置的梯度置零，从而忽略这些位置的梯度更新。这样，只有真实有效的位置参与了梯度的计算和参数的更新。

        注：在调用torch.nn.LSTM实现双向LSTM时，可以传入该批次数据的真实长度，torch.nn.LSTM会根据真实序列长度处理数据，对占位符[PAD]进行掩蔽，[PAD]位置将返回零向量。

        （3）聚合层：将双向LSTM层所有位置上的隐状态进行平均，作为整个句子的表示。

        （4）输出层：输出层，输出分类的几率。这里可以直接调用torch.nn.Linear来完成。

 汇聚层算子

        汇聚层算子将双向LSTM层所有位置上的隐状态进行平均，作为整个句子的表示。这里我们实现了AveragePooling算子进行隐状态的汇聚，首先利用序列长度向量生成掩码（Mask）矩阵，用于对文本序列中[PAD]位置的向量进行掩蔽，然后将该序列的向量进行相加后取均值。代码实现如下：

        将上面各个模块汇总到一起，代码实现如下：

  1. class AveragePooling(nn.Module):
  2.     def __init__(self):
  3.         super(AveragePooling, self).__init__()
  4.  
  5.     def forward(self, sequence_output, sequence_length):
  6.         # 假设 sequence_length 是一个 PyTorch 张量
  7.         sequence_length = sequence_length.unsqueeze(-1).to(torch.float32)
  8.         # 根据sequence_length生成mask矩阵，用于对Padding位置的信息进行mask
  9.         max_len = sequence_output.shape[1]
  10.  
  11.         mask = torch.arange(max_len, device='cuda') < sequence_length.to('cuda')
  12.         mask = mask.to(torch.float32).unsqueeze(-1)
  13.         # 对序列中paddling部分进行mask
  14.  
  15.         sequence_output = torch.multiply(sequence_output, mask.to('cuda'))
  16.         # 对序列中的向量取均值
  17.         batch_mean_hidden = torch.divide(torch.sum(sequence_output, dim=1), sequence_length.to('cuda'))
  18.         return batch_mean_hidden

模型汇总

将上面的算子汇总，组合为最终的分类模型。代码实现如下：

  1. class Model_BiLSTM_FC(nn.Module):
  2.     def __init__(self, num_embeddings, input_size, hidden_size, num_classes=2):
  3.         super(Model_BiLSTM_FC, self).__init__()
  4.         # 词典大小
  5.         self.num_embeddings = num_embeddings
  6.         # 单词向量的维度
  7.         self.input_size = input_size
  8.         # LSTM隐藏单元数量
  9.         self.hidden_size = hidden_size
  10.         # 情感分类类别数量
  11.         self.num_classes = num_classes
  12.         # 实例化嵌入层
  13.         self.embedding_layer = nn.Embedding(num_embeddings, input_size, padding_idx=0)
  14.         # 实例化LSTM层
  15.         self.lstm_layer = nn.LSTM(input_size, hidden_size, batch_first=True, bidirectional=True)
  16.         # 实例化聚合层
  17.         self.average_layer = AveragePooling()
  18.         # 实例化输出层
  19.         self.output_layer = nn.Linear(hidden_size * 2, num_classes)
  20.  
  21.     def forward(self, inputs):
  22.         # 对模型输入拆分为序列数据和mask
  23.         input_ids, sequence_length = inputs
  24.         # 获取词向量
  25.         inputs_emb = self.embedding_layer(input_ids)
  26.  
  27.         packed_input = nn.utils.rnn.pack_padded_sequence(inputs_emb, sequence_length.cpu(), batch_first=True,
  28.                                                          enforce_sorted=False)
  29.         # 使用lstm处理数据
  30.         packed_output, _ = self.lstm_layer(packed_input)
  31.         # 解包输出
  32.         sequence_output, _ = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)
  33.         # 使用聚合层聚合sequence_output
  34.         batch_mean_hidden = self.average_layer(sequence_output, sequence_length)
  35.         # 输出文本分类logits
  36.         logits = self.output_layer(batch_mean_hidden)
  37.         return logits

        不同于实验书中的代码，我发现pytorch的nn.LSTM不支持变长序列的参数不同于paddleLSTM，需要手动打包成边长序列下面为paddle.nn.LSTM的输入参数，所以转化为pytorch，我们则需要借助torch.nn.utils.rnn.pad_packed_sequence,压缩数据达到一样的目的（当然也有其他方法，这种方式我觉得比较简单)

LSTM-API文档-PaddlePaddle深度学习平台

3 模型训练

        本节将基于RunnerV3进行训练，首先指定模型训练的超参，然后设定模型、优化器、损失函数和评估指标，其中损失函数使用 torch.nn.CrossEntropyLoss ，该损失函数内部会对预测结果使用 softmax 进行计算，数字预测模型输出层的输出 logits 不需要使用 softmax 进行归一化，定义完Runner的相关组件后，便可以进行模型训练。代码实现如下

nndl.py 在本节需要实现如下功能

  1. import torch
  2. import matplotlib.pyplot as plt
  3.  
  4.  
  5. class RunnerV3(object):
  6.     def __init__(self, model, optimizer, loss_fn, metric, **kwargs):
  7.         self.model = model
  8.         self.optimizer = optimizer
  9.         self.loss_fn = loss_fn
  10.         self.metric = metric  # 只用于计算评价指标
  11.  
  12.         # 记录训练过程中的评价指标变化情况
  13.         self.dev_scores = []
  14.  
  15.         # 记录训练过程中的损失函数变化情况
  16.         self.train_epoch_losses = []  # 一个epoch记录一次loss
  17.         self.train_step_losses = []  # 一个step记录一次loss
  18.         self.dev_losses = []
  19.  
  20.         # 记录全局最优指标
  21.         self.best_score = 0
  22.  
  23.     def train(self, train_loader, dev_loader=None, **kwargs):
  24.         # 将模型切换为训练模式
  25.         self.model.train()
  26.  
  27.         # 传入训练轮数，如果没有传入值则默认为0
  28.         num_epochs = kwargs.get("num_epochs", 0)
  29.         # 传入log打印频率，如果没有传入值则默认为100
  30.         log_steps = kwargs.get("log_steps", 100)
  31.         # 评价频率
  32.         eval_steps = kwargs.get("eval_steps", 0)
  33.  
  34.         # 传入模型保存路径，如果没有传入值则默认为"best_model.pdparams"
  35.         save_path = kwargs.get("save_path", "best_model.pdparams")
  36.  
  37.         custom_print_log = kwargs.get("custom_print_log", None)
  38.  
  39.         # 训练总的步数
  40.         num_training_steps = num_epochs * len(train_loader)
  41.  
  42.         if eval_steps:
  43.             if self.metric is None:
  44.                 raise RuntimeError('Error: Metric can not be None!')
  45.             if dev_loader is None:
  46.                 raise RuntimeError('Error: dev_loader can not be None!')
  47.  
  48.         # 运行的step数目
  49.         global_step = 0
  50.         total_acces = []
  51.         total_losses = []
  52.         Iters = []
  53.  
  54.         # 进行num_epochs轮训练
  55.         for epoch in range(num_epochs):
  56.             # 用于统计训练集的损失
  57.             total_loss = 0
  58.  
  59.             for step, data in enumerate(train_loader):
  60.                 X, y = data
  61.                 # 获取模型预测
  62.                 # 计算logits
  63.                 logits = self.model(X)
  64.  
  65.                 # 将y转换为和logits相同的形状
  66.                 acc_y = y.view(-1, 1)
  67.  
  68.                 # 计算准确率
  69.                 probs = torch.softmax(logits, dim=1)
  70.                 pred = torch.argmax(probs, dim=1)
  71.                 correct = (pred == acc_y).sum().item()
  72.                 total = acc_y.size(0)
  73.                 acc = correct / total
  74.                 total_acces.append(acc)
  75.                 # print(acc.numpy()[0])
  76.  
  77.                 loss = self.loss_fn(logits, y)  # 默认求mean
  78.                 total_loss += loss
  79.                 total_losses.append(loss.item())
  80.                 Iters.append(global_step)
  81.  
  82.                 # 训练过程中，每个step的loss进行保存
  83.                 self.train_step_losses.append((global_step, loss.item()))
  84.  
  85.                 if log_steps and global_step % log_steps == 0:
  86.                     print(
  87.                         f"[Train] epoch: {epoch}/{num_epochs}, step: {global_step}/{num_training_steps}, loss: {loss.item():.5f}")
  88.                 # 梯度反向传播，计算每个参数的梯度值
  89.                 loss.backward()
  90.  
  91.                 if custom_print_log:
  92.                     custom_print_log(self)
  93.  
  94.                 # 小批量梯度下降进行参数更新
  95.                 self.optimizer.step()
  96.                 # 梯度归零
  97.                 self.optimizer.zero_grad()
  98.  
  99.                 # 判断是否需要评价
  100.                 if eval_steps > 0 and global_step != 0 and \
  101.                         (global_step % eval_steps == 0 or global_step == (num_training_steps - 1)):
  102.  
  103.                     dev_score, dev_loss = self.evaluate(dev_loader, global_step=global_step)
  104.                     print(f"[Evaluate]  dev score: {dev_score:.5f}, dev loss: {dev_loss:.5f}")
  105.  
  106.                     # 将模型切换为训练模式
  107.                     self.model.train()
  108.  
  109.                     # 如果当前指标为最优指标，保存该模型
  110.                     if dev_score > self.best_score:
  111.                         self.save_model(save_path)
  112.                         print(
  113.                             f"[Evaluate] best accuracy performence has been updated: {self.best_score:.5f} --> {dev_score:.5f}")
  114.                         self.best_score = dev_score
  115.  
  116.                 global_step += 1
  117.  
  118.             # 当前epoch 训练loss累计值
  119.             trn_loss = (total_loss / len(train_loader)).item()
  120.             # epoch粒度的训练loss保存
  121.             self.train_epoch_losses.append(trn_loss)
  122.  
  123.         draw_process("trainning acc", "green", Iters, total_acces, "trainning acc")
  124.         print("total_acc:")
  125.         print(total_acces)
  126.         print("total_loss:")
  127.  
  128.         print(total_losses)
  129.  
  130.         print("[Train] Training done!")
  131.  
  132.     # 模型评估阶段，使用'paddle.no_grad()'控制不计算和存储梯度
  133.     @torch.no_grad()
  134.     def evaluate(self, dev_loader, **kwargs):
  135.         assert self.metric is not None
  136.  
  137.         # 将模型设置为评估模式
  138.         self.model.eval()
  139.  
  140.         global_step = kwargs.get("global_step", -1)
  141.  
  142.         # 用于统计训练集的损失
  143.         total_loss = 0
  144.  
  145.         # 重置评价
  146.         self.metric.reset()
  147.  
  148.         # 遍历验证集每个批次
  149.         for batch_id, data in enumerate(dev_loader):
  150.             X, y = data
  151.  
  152.             # 计算模型输出
  153.             logits = self.model(X)
  154.  
  155.             # 计算损失函数
  156.             loss = self.loss_fn(logits, y).item()
  157.             # 累积损失
  158.             total_loss += loss
  159.  
  160.             # 累积评价
  161.             self.metric.update(logits, y)
  162.  
  163.         dev_loss = (total_loss / len(dev_loader))
  164.         self.dev_losses.append((global_step, dev_loss))
  165.  
  166.         dev_score = self.metric.accumulate()
  167.         self.dev_scores.append(dev_score)
  168.  
  169.         return dev_score, dev_loss
  170.  
  171.     # 模型评估阶段，使用'paddle.no_grad()'控制不计算和存储梯度
  172.     @torch.no_grad()
  173.     def predict(self, x, **kwargs):
  174.         # 将模型设置为评估模式
  175.         self.model.eval()
  176.         # 运行模型前向计算，得到预测值
  177.         logits = self.model(x)
  178.         return logits
  179.  
  180.     def save_model(self, save_path):
  181.         torch.save(self.model.state_dict(), save_path)
  182.  
  183.     def load_model(self, model_path):
  184.         model_state_dict = torch.load(model_path)
  185.         self.model.load_state_dict(model_state_dict)
  186.  
  187.  
  188. class Accuracy():
  189.     def __init__(self, is_logist=True):
  190.         # 用于统计正确的样本个数
  191.         self.num_correct = 0
  192.         # 用于统计样本的总数
  193.         self.num_count = 0
  194.  
  195.         self.is_logist = is_logist
  196.  
  197.     def update(self, outputs, labels):
  198.  
  199.         # 判断是二分类任务还是多分类任务，shape[1]=1时为二分类任务，shape[1]>1时为多分类任务
  200.         if outputs.shape[1] == 1:  # 二分类
  201.             outputs = torch.squeeze(outputs, dim=-1)
  202.             if self.is_logist:
  203.                 # logist判断是否大于0
  204.                 preds = torch.tensor((outputs >= 0), dtype=torch.float32)
  205.             else:
  206.                 # 如果不是logist，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0
  207.                 preds = torch.tensor((outputs >= 0.5), dtype=torch.float32)
  208.         else:
  209.             # 多分类时，使用'torch.argmax'计算最大元素索引作为类别
  210.             preds = torch.argmax(outputs, dim=1)
  211.  
  212.         # 获取本批数据中预测正确的样本个数
  213.         labels = torch.squeeze(labels, dim=-1)
  214.         batch_correct = torch.sum(torch.tensor(preds == labels, dtype=torch.float32)).cpu().numpy()
  215.         batch_count = len(labels)
  216.  
  217.         # 更新num_correct 和 num_count
  218.         self.num_correct += batch_correct
  219.         self.num_count += batch_count
  220.  
  221.     def accumulate(self):
  222.         # 使用累计的数据，计算总的指标
  223.         if self.num_count == 0:
  224.             return 0
  225.         return self.num_correct / self.num_count
  226.  
  227.     def reset(self):
  228.         # 重置正确的数目和总数
  229.         self.num_correct = 0
  230.         self.num_count = 0
  231.  
  232.     def name(self):
  233.         return "Accuracy"
  234.  
  235. def draw_process(title,color,iters,data,label):
  236.     plt.title(title, fontsize=24)
  237.     plt.xlabel("iter", fontsize=20)
  238.     plt.ylabel(label, fontsize=20)
  239.     plt.plot(iters, data,color=color,label=label)
  240.     plt.legend()
  241.     plt.grid()
  242.     print(plt.show())

lstm.py 开始训练

  1. np.random.seed(0)
  2. random.seed(0)
  3. torch.seed()
  4.  
  5. # 指定训练轮次
  6. num_epochs = 3
  7. # 指定学习率
  8. learning_rate = 0.001
  9. # 指定embedding的数量为词表长度
  10. num_embeddings = len(word2id_dict)
  11. # embedding向量的维度
  12. input_size = 256
  13. # LSTM网络隐状态向量的维度
  14. hidden_size = 256
  15.  
  16. # 实例化模型
  17. model = Model_BiLSTM_FC(num_embeddings, input_size, hidden_size).to(device)
  18. # 指定优化器
  19. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.999))
  20. # 指定损失函数
  21. loss_fn = nn.CrossEntropyLoss()
  22. # 指定评估指标
  23. metric = Accuracy()
  24. # 实例化Runner
  25. runner = RunnerV3(model, optimizer, loss_fn, metric)
  26. # 模型训练
  27. start_time = time.time()
  28. runner.train(train_loader, dev_loader, num_epochs=num_epochs, eval_steps=10, log_steps=10, save_path="./checkpoints/best.pdparams")
  29. end_time = time.time()
  30. print("time: ", (end_time-start_time))

         输出结果如下:

        绘制训练过程中在训练集和验证集上的损失图像和在验证集上的准确率图像：

  1. from nndl import plot_training_loss_acc
  2.  
  3. # 图像名字
  4. fig_name = "./images/6.16.pdf"
  5. # sample_step: 训练损失的采样step，即每隔多少个点选择1个点绘制
  6. # loss_legend_loc: loss 图像的图例放置位置
  7. # acc_legend_loc： acc 图像的图例放置位置
  8. plot_training_loss_acc(runner, fig_name, fig_size=(16,6), sample_step=10, loss_legend_loc="lower left", acc_legend_loc="lower right")

        需要在nndl.py 中实现 plot_training_loss_acc，代码如下:

  1. def plot_training_loss_acc(runner, fig_name, fig_size=(16, 6), sample_step=10, loss_legend_loc="lower left",
  2.                            acc_legend_loc="lower left"):
  3.     plt.figure(figsize=fig_size)
  4.  
  5.     plt.subplot(1, 2, 1)
  6.     train_items = runner.train_step_losses[::sample_step]
  7.     train_steps = [x[0] for x in train_items]
  8.     train_losses = [x[1] for x in train_items]
  9.  
  10.     plt.plot(train_steps, train_losses, color='#8E004D', label="Train loss")
  11.  
  12.     while runner.dev_losses[-1][0] == -1:
  13.         runner.dev_losses.pop()
  14.         runner.dev_scores.pop()
  15.     dev_steps = [x[0] for x in runner.dev_losses]
  16.     dev_losses = [x[1] for x in runner.dev_losses]
  17.     plt.plot(dev_steps, dev_losses, color='#E20079', linestyle='--', label="Dev loss")
  18.     # 绘制坐标轴和图例
  19.     plt.ylabel("loss", fontsize='x-large')
  20.     plt.xlabel("step", fontsize='x-large')
  21.     plt.legend(loc=loss_legend_loc, fontsize='x-large')
  22.  
  23.     plt.subplot(1, 2, 2)
  24.     # 绘制评价准确率变化曲线
  25.     plt.plot(dev_steps, runner.dev_scores, color='#E20079', linestyle="--", label="Dev accuracy")
  26.  
  27.     # 绘制坐标轴和图例
  28.     plt.ylabel("score", fontsize='x-large')
  29.     plt.xlabel("step", fontsize='x-large')
  30.     plt.legend(loc=acc_legend_loc, fontsize='x-large')
  31.  
  32.     plt.savefig(fig_name)
  33.     plt.show()

        输出如下：

        展示了文本分类模型在训练过程中的损失曲线和在验证集上的准确率曲线，其中在损失图像中，实线表示训练集上的损失变化，虚线表示验证集上的损失变化. 可以看到，随着训练过程的进行，训练集的损失不断下降， 验证集上的损失在大概200步后开始上升，这是因为在训练过程中发生了过拟合，可以选择保存在训练过程中在验证集上效果最好的模型来解决这个问题. 从准确率曲线上可以看到，首先在验证集上的准确率大幅度上升，然后大概200步后准确率不再上升，并且由于过拟合的因素，在验证集上的准确率稍微降低。 

4 模型评价

        加载训练过程中效果最好的模型，然后使用测试集进行测试。

  1. model_path = "./checkpoints/best.pdparams"
  2. runner.load_model(model_path)
  3. accuracy, _ =  runner.evaluate(test_loader)
  4. print(f"Evaluate on test set, Accuracy: {accuracy:.5f}")

        输出如下：

5 模型预测

        给定任意的一句话，使用训练好的模型进行预测，判断这句话中所蕴含的情感极性。

  1. id2label={0:"消极情绪", 1:"积极情绪"}
  2. text = "this movie is so great. I watched it three times already"
  3. # 处理单条文本
  4. sentence = text.split(" ")
  5. words = [word2id_dict[word] if word in word2id_dict else word2id_dict['[UNK]'] for word in sentence]
  6. words = words[:max_seq_len]
  7. sequence_length = torch.tensor([len(words)], dtype=torch.int64)
  8. words = torch.tensor(words, dtype=torch.int64).unsqueeze(0)
  9. # 使用模型进行预测
  10. logits = runner.predict((words.to(device), sequence_length.to(device)))
  11. max_label_id = torch.argmax(logits, dim=-1).cpu().numpy()[0]
  12. pred_label = id2label[max_label_id]
  13. print("Label: ", pred_label)

        输出结果:

5 拓展实验 

        5.1 使用Pytorch内置的单向LSTM进行文本分类实验

        首先，修改模型定义，将 nn.LSTM 中的 bidirectional 设置为 False 以使用单向LSTM模型(也可以删去此参数，默认为False)，同时设置线性层的shape为[hidden_size， num_classes]。

  1. class AveragePooling(nn.Module):
  2.     def __init__(self):
  3.         super(AveragePooling, self).__init__()
  4.  
  5.     def forward(self, sequence_output, sequence_length):
  6.         # 假设 sequence_length 是一个 PyTorch 张量
  7.         sequence_length = sequence_length.unsqueeze(-1).to(torch.float32)
  8.         # 根据sequence_length生成mask矩阵，用于对Padding位置的信息进行mask
  9.         max_len = sequence_output.shape[1]
  10.  
  11.         mask = torch.arange(max_len) < sequence_length
  12.         mask = mask.to(torch.float32).unsqueeze(-1)
  13.         # 对序列中paddling部分进行mask
  14.  
  15.         sequence_output = torch.multiply(sequence_output, mask.to('cuda'))
  16.         # 对序列中的向量取均值
  17.         batch_mean_hidden = torch.divide(torch.sum(sequence_output, dim=1), sequence_length.to('cuda'))
  18.         return batch_mean_hidden
  19.  
  20.  
  21. class Model_BiLSTM_FC(nn.Module):
  22.     def __init__(self, num_embeddings, input_size, hidden_size, num_classes=2):
  23.         super(Model_BiLSTM_FC, self).__init__()
  24.         # 词典大小
  25.         self.num_embeddings = num_embeddings
  26.         # 单词向量的维度
  27.         self.input_size = input_size
  28.         # LSTM隐藏单元数量
  29.         self.hidden_size = hidden_size
  30.         # 情感分类类别数量
  31.         self.num_classes = num_classes
  32.         # 实例化嵌入层
  33.         self.embedding_layer = nn.Embedding(num_embeddings, input_size, padding_idx=0)
  34.         # 实例化LSTM层
  35.         self.lstm_layer = nn.LSTM(input_size, hidden_size, batch_first=True)
  36.         # 实例化聚合层
  37.         self.average_layer = AveragePooling()
  38.         # 实例化输出层
  39.         self.output_layer = nn.Linear(hidden_size, num_classes)
  40.  
  41.     def forward(self, inputs):
  42.         # 对模型输入拆分为序列数据和mask
  43.         input_ids, sequence_length = inputs
  44.         # 获取词向量
  45.         inputs_emb = self.embedding_layer(input_ids)
  46.  
  47.         packed_input = nn.utils.rnn.pack_padded_sequence(inputs_emb, sequence_length.cpu(), batch_first=True,
  48.                                                          enforce_sorted=False)
  49.         # 使用lstm处理数据
  50.         packed_output, _ = self.lstm_layer(packed_input)
  51.         # 解包输出
  52.         sequence_output, _ = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)
  53.         # 使用聚合层聚合sequence_output
  54.         batch_mean_hidden = self.average_layer(sequence_output, sequence_length)
  55.         # 输出文本分类logits
  56.         logits = self.output_layer(batch_mean_hidden)
  57.         return logits

        接下来，基于Paddle的单向模型开始进行训练，代码实现如下：

  1. np.random.seed(0)
  2. random.seed(0)
  3. torch.seed()
  4.  
  5. # 指定训练轮次
  6. num_epochs = 3
  7. # 指定学习率
  8. learning_rate = 0.001
  9. # 指定embedding的数量为词表长度
  10. num_embeddings = len(word2id_dict)
  11. # embedding向量的维度
  12. input_size = 256
  13. # LSTM网络隐状态向量的维度
  14. hidden_size = 256
  15.  
  16. # 实例化模型
  17. model = Model_BiLSTM_FC(num_embeddings, input_size, hidden_size).to(device)
  18. # 指定优化器
  19. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.999))
  20. # 指定损失函数
  21. loss_fn = nn.CrossEntropyLoss()
  22. # 指定评估指标
  23. metric = Accuracy()
  24. # 实例化Runner
  25. runner = RunnerV3(model, optimizer, loss_fn, metric)
  26. # 模型训练
  27. start_time = time.time()
  28. runner.train(train_loader, dev_loader, num_epochs=num_epochs, eval_steps=10, log_steps=10, save_path="./checkpoints/best_forward.pdparams")
  29. end_time = time.time()
  30. print("time: ", (end_time-start_time))

        其他代码均与LSTM双向代码一致（我也忘了，写了很久了，最后回放全部代码,能跑通的)

         5.2 使用Paddle内置的单向LSTM进行文本分类实验

        由于之前实现的LSTM默认只返回最后时刻的隐状态，然而本实验中需要用到所有时刻的隐状态向量，因此需要对自己实现的LSTM进行修改，使其返回序列向量，代码实现如下：

  1. class LSTM(nn.Module):
  2.     def __init__(self, input_size, hidden_size, Wi_attr=None, Wf_attr=None, Wo_attr=None, Wc_attr=None,
  3.                  Ui_attr=None, Uf_attr=None, Uo_attr=None, Uc_attr=None, bi_attr=None, bf_attr=None,
  4.                  bo_attr=None, bc_attr=None):
  5.         super(LSTM, self).__init__()
  6.         self.input_size = input_size
  7.         self.hidden_size = hidden_size
  8.  
  9.         # 初始化模型参数
  10.         if Wi_attr is None:
  11.             Wi = torch.zeros(size=[input_size, hidden_size], dtype=torch.float32)
  12.         else:
  13.             Wi = torch.tensor(Wi_attr, dtype=torch.float32)
  14.         self.W_i = torch.nn.Parameter(Wi.to('cuda'))
  15.  
  16.         if Wf_attr is None:
  17.             Wf = torch.zeros(size=[input_size, hidden_size], dtype=torch.float32)
  18.         else:
  19.             Wf = torch.tensor(Wf_attr, dtype=torch.float32)
  20.         self.W_f = torch.nn.Parameter(Wf.to('cuda'))
  21.  
  22.         if Wo_attr is None:
  23.             Wo = torch.zeros(size=[input_size, hidden_size], dtype=torch.float32)
  24.         else:
  25.             Wo = torch.tensor(Wo_attr, dtype=torch.float32)
  26.         self.W_o = torch.nn.Parameter(Wo.to('cuda'))
  27.  
  28.         if Wc_attr is None:
  29.             Wc = torch.zeros(size=[input_size, hidden_size], dtype=torch.float32)
  30.         else:
  31.             Wc = torch.tensor(Wc_attr, dtype=torch.float32)
  32.         self.W_c = torch.nn.Parameter(Wc.to('cuda'))
  33.  
  34.         if Ui_attr is None:
  35.             Ui = torch.zeros(size=[hidden_size, hidden_size], dtype=torch.float32)
  36.         else:
  37.             Ui = torch.tensor(Ui_attr, dtype=torch.float32)
  38.         self.U_i = torch.nn.Parameter(Ui.to('cuda'))
  39.  
  40.         if Uf_attr is None:
  41.             Uf = torch.zeros(size=[hidden_size, hidden_size], dtype=torch.float32)
  42.         else:
  43.             Uf = torch.tensor(Uf_attr, dtype=torch.float32)
  44.         self.U_f = torch.nn.Parameter(Uf.to('cuda'))
  45.  
  46.         if Uo_attr is None:
  47.             Uo = torch.zeros(size=[hidden_size, hidden_size], dtype=torch.float32)
  48.         else:
  49.             Uo = torch.tensor(Uo_attr, dtype=torch.float32)
  50.         self.U_o = torch.nn.Parameter(Uo.to('cuda'))
  51.  
  52.         if Uc_attr is None:
  53.             Uc = torch.zeros(size=[hidden_size, hidden_size], dtype=torch.float32)
  54.         else:
  55.             Uc = torch.tensor(Uc_attr, dtype=torch.float32)
  56.         self.U_c = torch.nn.Parameter(Uc.to('cuda'))
  57.  
  58.         if bi_attr is None:
  59.             bi = torch.zeros(size=[1, hidden_size], dtype=torch.float32)
  60.         else:
  61.             bi = torch.tensor(bi_attr, dtype=torch.float32)
  62.         self.b_i = torch.nn.Parameter(bi.to('cuda'))
  63.  
  64.         if bf_attr is None:
  65.             bf = torch.zeros(size=[1, hidden_size], dtype=torch.float32)
  66.         else:
  67.             bf = torch.tensor(bf_attr, dtype=torch.float32)
  68.         self.b_f = torch.nn.Parameter(bf.to('cuda'))
  69.  
  70.         if bo_attr is None:
  71.             bo = torch.zeros(size=[1, hidden_size], dtype=torch.float32)
  72.         else:
  73.             bo = torch.tensor(bo_attr, dtype=torch.float32)
  74.         self.b_o = torch.nn.Parameter(bo.to('cuda'))
  75.  
  76.         if bc_attr is None:
  77.             bc = torch.zeros(size=[1, hidden_size], dtype=torch.float32)
  78.         else:
  79.             bc = torch.tensor(bc_attr, dtype=torch.float32)
  80.         self.b_c = torch.nn.Parameter(bc.to('cuda'))
  81.  
  82.     # 初始化状态向量和隐状态向量
  83.     def init_state(self, batch_size):
  84.         hidden_state = torch.zeros(size=[batch_size, self.hidden_size], dtype=torch.float32).to('cuda')
  85.         cell_state = torch.zeros(size=[batch_size, self.hidden_size], dtype=torch.float32).to('cuda')
  86.         return hidden_state, cell_state
  87.  
  88.     # 定义前向计算
  89.     def forward(self, inputs, states=None):
  90.         # inputs: 输入数据，其shape为batch_size x seq_len x input_size
  91.         batch_size, seq_len, input_size = torch.tensor(inputs).shape
  92.  
  93.         # 初始化起始的单元状态和隐状态向量，其shape为batch_size x hidden_size
  94.         if states is None:
  95.             states = self.init_state(batch_size)
  96.         hidden_state, cell_state = states
  97.  
  98.         # 执行LSTM计算，包括：输入门、遗忘门和输出门、候选内部状态、内部状态和隐状态向量
  99.         for step in range(seq_len):
  100.             # 获取当前时刻的输入数据step_input: 其shape为batch_size x input_size
  101.             step_input = inputs[:, step, :]
  102.             # 计算输入门, 遗忘门和输出门, 其shape为：batch_size x hidden_size
  103.             I_gate = F.sigmoid(torch.matmul(step_input, self.W_i) + torch.matmul(hidden_state, self.U_i) + self.b_i)
  104.             F_gate = F.sigmoid(torch.matmul(step_input, self.W_f) + torch.matmul(hidden_state, self.U_f) + self.b_f)
  105.             O_gate = F.sigmoid(torch.matmul(step_input, self.W_o) + torch.matmul(hidden_state, self.U_o) + self.b_o)
  106.             # 计算候选状态向量, 其shape为：batch_size x hidden_size
  107.             C_tilde = F.tanh(torch.matmul(step_input, self.W_c) + torch.matmul(hidden_state, self.U_c) + self.b_c)
  108.             # 计算单元状态向量, 其shape为：batch_size x hidden_size
  109.             cell_state = F_gate * cell_state + I_gate * C_tilde
  110.             # 计算隐状态向量，其shape为：batch_size x hidden_size
  111.             hidden_state = O_gate * F.tanh(cell_state)
  112.  
  113.         return hidden_state

        接下来，修改Model_BiLSTM_FC模型，将`nn.LSTM`换为自己实现的LSTM模型，代码实现如下 :

  1. class AveragePooling(nn.Module):
  2.     def __init__(self):
  3.         super(AveragePooling, self).__init__()
  4.  
  5.     def forward(self, sequence_output, sequence_length):
  6.         # 假设 sequence_length 是一个 PyTorch 张量
  7.         sequence_length = sequence_length.unsqueeze(-1).to(torch.float32)
  8.         # 根据sequence_length生成mask矩阵，用于对Padding位置的信息进行mask
  9.         max_len = sequence_output.shape[1]
  10.  
  11.         mask = torch.arange(max_len, device='cuda') < sequence_length.to('cuda')
  12.         mask = mask.to(torch.float32).unsqueeze(-1)
  13.         # 对序列中paddling部分进行mask
  14.  
  15.         sequence_output = torch.multiply(sequence_output, mask.to('cuda'))
  16.         # 对序列中的向量取均值
  17.         batch_mean_hidden = torch.divide(torch.sum(sequence_output, dim=1), sequence_length.to('cuda'))
  18.         return batch_mean_hidden
  19.  
  20.  
  21. class Model_BiLSTM_FC(nn.Module):
  22.     def __init__(self, num_embeddings, input_size, hidden_size, num_classes=2):
  23.         super(Model_BiLSTM_FC, self).__init__()
  24.         # 词典大小
  25.         self.num_embeddings = num_embeddings
  26.         # 单词向量的维度
  27.         self.input_size = input_size
  28.         # LSTM隐藏单元数量
  29.         self.hidden_size = hidden_size
  30.         # 情感分类类别数量
  31.         self.num_classes = num_classes
  32.         # 实例化嵌入层
  33.         self.embedding_layer = nn.Embedding(num_embeddings, input_size, padding_idx=0)
  34.         # 实例化LSTM层
  35.         self.lstm_layer = nn.LSTM(input_size, hidden_size, batch_first=True, bidirectional=True)
  36.         # 实例化聚合层
  37.         self.average_layer = AveragePooling()
  38.         # 实例化输出层
  39.         self.output_layer = nn.Linear(hidden_size * 2, num_classes)
  40.  
  41.     def forward(self, inputs):
  42.         # 对模型输入拆分为序列数据和mask
  43.         input_ids, sequence_length = inputs
  44.         # 获取词向量
  45.         inputs_emb = self.embedding_layer(input_ids)
  46.  
  47.         packed_input = nn.utils.rnn.pack_padded_sequence(inputs_emb, sequence_length.cpu(), batch_first=True,
  48.                                                          enforce_sorted=False)
  49.         # 使用lstm处理数据
  50.         packed_output, _ = self.lstm_layer(packed_input)
  51.         # 解包输出
  52.         sequence_output, _ = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)
  53.         # 使用聚合层聚合sequence_output
  54.         batch_mean_hidden = self.average_layer(sequence_output, sequence_length)
  55.         # 输出文本分类logits
  56.         logits = self.output_layer(batch_mean_hidden)
  57.         return logits

        运行并测试，代码如下：

  1. np.random.seed(0)
  2. random.seed(0)
  3. torch.seed()
  4.  
  5. # 指定训练轮次
  6. num_epochs = 3
  7. # 指定学习率
  8. learning_rate = 0.001
  9. # 指定embedding的数量为词表长度
  10. num_embeddings = len(word2id_dict)
  11. # embedding向量的维度
  12. input_size = 256
  13. # LSTM网络隐状态向量的维度
  14. hidden_size = 256
  15.  
  16. # 实例化模型
  17. model = Model_BiLSTM_FC(num_embeddings, input_size, hidden_size).to('cuda')
  18. # 指定优化器
  19. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.999))
  20. # 指定损失函数
  21. loss_fn = nn.CrossEntropyLoss()
  22. # 指定评估指标
  23. metric = Accuracy()
  24. # 实例化Runner
  25. runner = RunnerV3(model, optimizer, loss_fn, metric)
  26. # 模型训练
  27. start_time = time.time()
  28. runner.train(train_loader, dev_loader, num_epochs=num_epochs, eval_steps=10, log_steps=10, save_path="./checkpoints/best_self_forward.pdparams")
  29. end_time = time.time()
  30. print("time: ", (end_time-start_time))
  31.  
  32.  
  33. model_path = "./checkpoints/best_self_forward.pdparams"
  34. runner.load_model(model_path)
  35. accuracy, _ =  runner.evaluate(test_loader)
  36. print(f"Evaluate on test set, Accuracy: {accuracy:.5f}")

        总结

        根据双向LSTM和单向LSTM的对比我们发现，正确率差距不大，但是速度缺相差较大,但理论上说双向LSTM具有比单向LSTM更多的参数，计算量更大，速度很慢，在这里却表现为速度大于单向，所以双向LSTM在有些时候是好于单向LSTM的，并且通过这次实验更能清晰的明白NLP的魅力

        我感觉这次的实验难度来说是我这么多次最难的一次，因为有两个函数在邱老师的《神经网络与深度学习》的书中没给代码，需要自己编写（虽然写完了才发现可以去飞浆搜原版paddle的代码，害傻了），并且如果不修改gpu代码跑起来真的很慢，真的体会到老师说的跑半天出去溜达会，回来发现错了，改完接着跑那种感觉，虽然没有半天，跑一次40分钟，最终我也被迫在现实面前低头改了半天gpu，但是伴随而来的又是需要在很多位置都修改变量在gpu，又花了很多时间，但是回顾一下，真的自己修改+编写，感觉这次实验真的很有意义，远远大于之前所有时间带给我的成就感。(PS:头一次这么快发博客，竟然是因为一宿舍等着我的代码，乐死了）

放一下所有代码

utils-data.py

  1. import os
  2.  
  3.  
  4. def load_vocab(path):
  5.     assert os.path.exists(path)
  6.     words = []
  7.     with open(path, "r", encoding="utf-8") as f:
  8.         words = f.readlines()
  9.         words = [word.strip() for word in words if word.strip()]
  10.     word2id = dict(zip(words, range(len(words))))
  11.     return word2id

nndl.py

  1. import torch
  2. import matplotlib.pyplot as plt
  3.  
  4. def draw_process(title,color,iters,data,label):
  5.     plt.title(title, fontsize=24)
  6.     plt.xlabel("iter", fontsize=20)
  7.     plt.ylabel(label, fontsize=20)
  8.     plt.plot(iters, data,color=color,label=label)
  9.     plt.legend()
  10.     plt.grid()
  11.     print(plt.show())
  12.  
  13.  
  14. def plot_training_loss_acc(runner, fig_name, fig_size=(16, 6), sample_step=10, loss_legend_loc="lower left",
  15.                            acc_legend_loc="lower left"):
  16.     plt.figure(figsize=fig_size)
  17.  
  18.     plt.subplot(1, 2, 1)
  19.     train_items = runner.train_step_losses[::sample_step]
  20.     train_steps = [x[0] for x in train_items]
  21.     train_losses = [x[1] for x in train_items]
  22.  
  23.     plt.plot(train_steps, train_losses, color='#8E004D', label="Train loss")
  24.  
  25.     while runner.dev_losses[-1][0] == -1:
  26.         runner.dev_losses.pop()
  27.         runner.dev_scores.pop()
  28.     dev_steps = [x[0] for x in runner.dev_losses]
  29.     dev_losses = [x[1] for x in runner.dev_losses]
  30.     plt.plot(dev_steps, dev_losses, color='#E20079', linestyle='--', label="Dev loss")
  31.     # 绘制坐标轴和图例
  32.     plt.ylabel("loss", fontsize='x-large')
  33.     plt.xlabel("step", fontsize='x-large')
  34.     plt.legend(loc=loss_legend_loc, fontsize='x-large')
  35.  
  36.     plt.subplot(1, 2, 2)
  37.     # 绘制评价准确率变化曲线
  38.     plt.plot(dev_steps, runner.dev_scores, color='#E20079', linestyle="--", label="Dev accuracy")
  39.  
  40.     # 绘制坐标轴和图例
  41.     plt.ylabel("score", fontsize='x-large')
  42.     plt.xlabel("step", fontsize='x-large')
  43.     plt.legend(loc=acc_legend_loc, fontsize='x-large')
  44.  
  45.     plt.savefig(fig_name)
  46.     plt.show()
  47.  
  48.  
  49. class RunnerV3(object):
  50.     def __init__(self, model, optimizer, loss_fn, metric, **kwargs):
  51.         self.model = model
  52.         self.optimizer = optimizer
  53.         self.loss_fn = loss_fn
  54.         self.metric = metric  # 只用于计算评价指标
  55.  
  56.         # 记录训练过程中的评价指标变化情况
  57.         self.dev_scores = []
  58.  
  59.         # 记录训练过程中的损失函数变化情况
  60.         self.train_epoch_losses = []  # 一个epoch记录一次loss
  61.         self.train_step_losses = []  # 一个step记录一次loss
  62.         self.dev_losses = []
  63.  
  64.         # 记录全局最优指标
  65.         self.best_score = 0
  66.  
  67.     def train(self, train_loader, dev_loader=None, **kwargs):
  68.         # 将模型切换为训练模式
  69.         self.model.train()
  70.  
  71.         # 传入训练轮数，如果没有传入值则默认为0
  72.         num_epochs = kwargs.get("num_epochs", 0)
  73.         # 传入log打印频率，如果没有传入值则默认为100
  74.         log_steps = kwargs.get("log_steps", 100)
  75.         # 评价频率
  76.         eval_steps = kwargs.get("eval_steps", 0)
  77.  
  78.         # 传入模型保存路径，如果没有传入值则默认为"best_model.pdparams"
  79.         save_path = kwargs.get("save_path", "best_model.pdparams")
  80.  
  81.         custom_print_log = kwargs.get("custom_print_log", None)
  82.  
  83.         # 训练总的步数
  84.         num_training_steps = num_epochs * len(train_loader)
  85.  
  86.         if eval_steps:
  87.             if self.metric is None:
  88.                 raise RuntimeError('Error: Metric can not be None!')
  89.             if dev_loader is None:
  90.                 raise RuntimeError('Error: dev_loader can not be None!')
  91.  
  92.         # 运行的step数目
  93.         global_step = 0
  94.         total_acces = []
  95.         total_losses = []
  96.         Iters = []
  97.  
  98.         # 进行num_epochs轮训练
  99.         for epoch in range(num_epochs):
  100.             # 用于统计训练集的损失
  101.             total_loss = 0
  102.  
  103.             for step, data in enumerate(train_loader):
  104.                 X, y = data
  105.                 # 获取模型预测
  106.                 # 计算logits
  107.                 logits = self.model(X)
  108.  
  109.                 # 将y转换为和logits相同的形状
  110.                 acc_y = y.view(-1, 1)
  111.  
  112.                 # 计算准确率
  113.                 probs = torch.softmax(logits, dim=1)
  114.                 pred = torch.argmax(probs, dim=1)
  115.                 correct = (pred == acc_y).sum().item()
  116.                 total = acc_y.size(0)
  117.                 acc = correct / total
  118.                 total_acces.append(acc)
  119.                 # print(acc.numpy()[0])
  120.  
  121.                 loss = self.loss_fn(logits, y)  # 默认求mean
  122.                 total_loss += loss
  123.                 total_losses.append(loss.item())
  124.                 Iters.append(global_step)
  125.  
  126.                 # 训练过程中，每个step的loss进行保存
  127.                 self.train_step_losses.append((global_step, loss.item()))
  128.  
  129.                 if log_steps and global_step % log_steps == 0:
  130.                     print(
  131.                         f"[Train] epoch: {epoch}/{num_epochs}, step: {global_step}/{num_training_steps}, loss: {loss.item():.5f}")
  132.                 # 梯度反向传播，计算每个参数的梯度值
  133.                 loss.backward()
  134.  
  135.                 if custom_print_log:
  136.                     custom_print_log(self)
  137.  
  138.                 # 小批量梯度下降进行参数更新
  139.                 self.optimizer.step()
  140.                 # 梯度归零
  141.                 self.optimizer.zero_grad()
  142.  
  143.                 # 判断是否需要评价
  144.                 if eval_steps > 0 and global_step != 0 and \
  145.                         (global_step % eval_steps == 0 or global_step == (num_training_steps - 1)):
  146.  
  147.                     dev_score, dev_loss = self.evaluate(dev_loader, global_step=global_step)
  148.                     print(f"[Evaluate]  dev score: {dev_score:.5f}, dev loss: {dev_loss:.5f}")
  149.  
  150.                     # 将模型切换为训练模式
  151.                     self.model.train()
  152.  
  153.                     # 如果当前指标为最优指标，保存该模型
  154.                     if dev_score > self.best_score:
  155.                         self.save_model(save_path)
  156.                         print(
  157.                             f"[Evaluate] best accuracy performence has been updated: {self.best_score:.5f} --> {dev_score:.5f}")
  158.                         self.best_score = dev_score
  159.  
  160.                 global_step += 1
  161.  
  162.             # 当前epoch 训练loss累计值
  163.             trn_loss = (total_loss / len(train_loader)).item()
  164.             # epoch粒度的训练loss保存
  165.             self.train_epoch_losses.append(trn_loss)
  166.  
  167.         draw_process("trainning acc", "green", Iters, total_acces, "trainning acc")
  168.         print("total_acc:")
  169.         print(total_acces)
  170.         print("total_loss:")
  171.  
  172.         print(total_losses)
  173.  
  174.         print("[Train] Training done!")
  175.  
  176.     # 模型评估阶段，使用'paddle.no_grad()'控制不计算和存储梯度
  177.     @torch.no_grad()
  178.     def evaluate(self, dev_loader, **kwargs):
  179.         assert self.metric is not None
  180.  
  181.         # 将模型设置为评估模式
  182.         self.model.eval()
  183.  
  184.         global_step = kwargs.get("global_step", -1)
  185.  
  186.         # 用于统计训练集的损失
  187.         total_loss = 0
  188.  
  189.         # 重置评价
  190.         self.metric.reset()
  191.  
  192.         # 遍历验证集每个批次
  193.         for batch_id, data in enumerate(dev_loader):
  194.             X, y = data
  195.  
  196.             # 计算模型输出
  197.             logits = self.model(X)
  198.  
  199.             # 计算损失函数
  200.             loss = self.loss_fn(logits, y).item()
  201.             # 累积损失
  202.             total_loss += loss
  203.  
  204.             # 累积评价
  205.             self.metric.update(logits, y)
  206.  
  207.         dev_loss = (total_loss / len(dev_loader))
  208.         self.dev_losses.append((global_step, dev_loss))
  209.  
  210.         dev_score = self.metric.accumulate()
  211.         self.dev_scores.append(dev_score)
  212.  
  213.         return dev_score, dev_loss
  214.  
  215.     # 模型评估阶段，使用'paddle.no_grad()'控制不计算和存储梯度
  216.     @torch.no_grad()
  217.     def predict(self, x, **kwargs):
  218.         # 将模型设置为评估模式
  219.         self.model.eval()
  220.         # 运行模型前向计算，得到预测值
  221.         logits = self.model(x)
  222.         return logits
  223.  
  224.     def save_model(self, save_path):
  225.         torch.save(self.model.state_dict(), save_path)
  226.  
  227.     def load_model(self, model_path):
  228.         model_state_dict = torch.load(model_path)
  229.         self.model.load_state_dict(model_state_dict)
  230.  
  231.  
  232. class Accuracy():
  233.     def __init__(self, is_logist=True):
  234.         # 用于统计正确的样本个数
  235.         self.num_correct = 0
  236.         # 用于统计样本的总数
  237.         self.num_count = 0
  238.  
  239.         self.is_logist = is_logist
  240.  
  241.     def update(self, outputs, labels):
  242.  
  243.         # 判断是二分类任务还是多分类任务，shape[1]=1时为二分类任务，shape[1]>1时为多分类任务
  244.         if outputs.shape[1] == 1:  # 二分类
  245.             outputs = torch.squeeze(outputs, dim=-1)
  246.             if self.is_logist:
  247.                 # logist判断是否大于0
  248.                 preds = torch.tensor((outputs >= 0), dtype=torch.float32)
  249.             else:
  250.                 # 如果不是logist，判断每个概率值是否大于0.5，当大于0.5时，类别为1，否则类别为0
  251.                 preds = torch.tensor((outputs >= 0.5), dtype=torch.float32)
  252.         else:
  253.             # 多分类时，使用'torch.argmax'计算最大元素索引作为类别
  254.             preds = torch.argmax(outputs, dim=1)
  255.  
  256.         # 获取本批数据中预测正确的样本个数
  257.         labels = torch.squeeze(labels, dim=-1)
  258.         batch_correct = torch.sum(torch.tensor(preds == labels, dtype=torch.float32)).cpu().numpy()
  259.         batch_count = len(labels)
  260.  
  261.         # 更新num_correct 和 num_count
  262.         self.num_correct += batch_correct
  263.         self.num_count += batch_count
  264.  
  265.     def accumulate(self):
  266.         # 使用累计的数据，计算总的指标
  267.         if self.num_count == 0:
  268.             return 0
  269.         return self.num_correct / self.num_count
  270.  
  271.     def reset(self):
  272.         # 重置正确的数目和总数
  273.         self.num_correct = 0
  274.         self.num_count = 0
  275.  
  276.     def name(self):
  277.         return "Accuracy"
  278.  
  279.

lstm.py

  1. import os
  2. import torch
  3. import torch.nn as nn
  4. from torch.utils.data import Dataset
  5. from utils.data import load_vocab
  6. from functools import partial
  7. import time
  8. import random
  9. import numpy as np
  10. from nndl import Accuracy, RunnerV3
  11.  
  12. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  13.  
  14.  
  15. # 加载数据集
  16. def load_imdb_data(path):
  17.     assert os.path.exists(path)
  18.     trainset, devset, testset = [], [], []
  19.     with open(os.path.join(path, "train.txt"), "r", encoding='utf-8') as fr:
  20.         for line in fr:
  21.             sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)
  22.             trainset.append((sentence, sentence_label))
  23.  
  24.     with open(os.path.join(path, "dev.txt"), "r", encoding='utf-8') as fr:
  25.         for line in fr:
  26.             sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)
  27.             devset.append((sentence, sentence_label))
  28.  
  29.     with open(os.path.join(path, "test.txt"), "r", encoding='utf-8') as fr:
  30.         for line in fr:
  31.             sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)
  32.             testset.append((sentence, sentence_label))
  33.  
  34.     return trainset, devset, testset
  35.  
  36.  
  37. # 加载IMDB数据集
  38. train_data, dev_data, test_data = load_imdb_data("./dataset/")
  39. # # 打印一下加载后的数据样式
  40. print(train_data[4])
  41.  
  42.  
  43. class IMDBDataset(Dataset):
  44.     def __init__(self, examples, word2id_dict):
  45.         super(IMDBDataset, self).__init__()
  46.         # 词典，用于将单词转为字典索引的数字
  47.         self.word2id_dict = word2id_dict
  48.         # 加载后的数据集
  49.         self.examples = self.words_to_id(examples)
  50.  
  51.     def words_to_id(self, examples):
  52.         tmp_examples = []
  53.         for idx, example in enumerate(examples):
  54.             seq, label = example
  55.             # 将单词映射为字典索引的ID， 对于词典中没有的单词用[UNK]对应的ID进行替代
  56.             seq = [self.word2id_dict.get(word, self.word2id_dict['[UNK]']) for word in seq.split(" ")]
  57.             label = int(label)
  58.             tmp_examples.append([seq, label])
  59.         return tmp_examples
  60.  
  61.     def __getitem__(self, idx):
  62.         seq, label = self.examples[idx]
  63.         return seq, label
  64.  
  65.     def __len__(self):
  66.         return len(self.examples)
  67.  
  68.  
  69. # 加载词表
  70. word2id_dict = load_vocab("./dataset/vocab.txt")
  71.  
  72. # 实例化Dataset
  73. train_set = IMDBDataset(train_data, word2id_dict)
  74. dev_set = IMDBDataset(dev_data, word2id_dict)
  75. test_set = IMDBDataset(test_data, word2id_dict)
  76.  
  77. print('训练集样本数：', len(train_set))
  78. print('样本示例：', train_set[4])
  79.  
  80.  
  81. def collate_fn(batch_data, pad_val=0, max_seq_len=256):
  82.     seqs, seq_lens, labels = [], [], []
  83.     max_len = 0
  84.     for example in batch_data:
  85.         seq, label = example
  86.         # 对数据序列进行截断
  87.         seq = seq[:max_seq_len]
  88.         # 对数据截断并保存于seqs中
  89.         seqs.append(seq)
  90.         seq_lens.append(len(seq))
  91.         labels.append(label)
  92.         # 保存序列最大长度
  93.         max_len = max(max_len, len(seq))
  94.     # 对数据序列进行填充至最大长度
  95.     for i in range(len(seqs)):
  96.         seqs[i] = seqs[i] + [pad_val] * (max_len - len(seqs[i]))
  97.  
  98.     # return (torch.tensor(seqs), torch.tensor(seq_lens)), torch.tensor(labels)
  99.     return (torch.tensor(seqs).to(device), torch.tensor(seq_lens)), torch.tensor(labels).to(device)
  100.  
  101. max_seq_len = 5
  102. batch_data = [[[1, 2, 3, 4, 5, 6], 1], [[2, 4, 6], 0]]
  103. (seqs, seq_lens), labels = collate_fn(batch_data, pad_val=word2id_dict["[PAD]"], max_seq_len=max_seq_len)
  104. print("seqs: ", seqs)
  105. print("seq_lens: ", seq_lens)
  106. print("labels: ", labels)
  107.  
  108. max_seq_len = 256
  109. batch_size = 128
  110. collate_fn = partial(collate_fn, pad_val=word2id_dict["[PAD]"], max_seq_len=max_seq_len)
  111. train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size,
  112.                                            shuffle=True, drop_last=False, collate_fn=collate_fn)
  113. dev_loader = torch.utils.data.DataLoader(dev_set, batch_size=batch_size,
  114.                                          shuffle=False, drop_last=False, collate_fn=collate_fn)
  115. test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size,
  116.                                           shuffle=False, drop_last=False, collate_fn=collate_fn)
  117.  
  118.  
  119. class AveragePooling(nn.Module):
  120.     def __init__(self):
  121.         super(AveragePooling, self).__init__()
  122.  
  123.     def forward(self, sequence_output, sequence_length):
  124.         # 假设 sequence_length 是一个 PyTorch 张量
  125.         sequence_length = sequence_length.unsqueeze(-1).to(torch.float32)
  126.         # 根据sequence_length生成mask矩阵，用于对Padding位置的信息进行mask
  127.         max_len = sequence_output.shape[1]
  128.  
  129.         mask = torch.arange(max_len, device='cuda') < sequence_length.to('cuda')
  130.         mask = mask.to(torch.float32).unsqueeze(-1)
  131.         # 对序列中paddling部分进行mask
  132.  
  133.         sequence_output = torch.multiply(sequence_output, mask.to('cuda'))
  134.         # 对序列中的向量取均值
  135.         batch_mean_hidden = torch.divide(torch.sum(sequence_output, dim=1), sequence_length.to('cuda'))
  136.         return batch_mean_hidden
  137.  
  138.  
  139. class Model_BiLSTM_FC(nn.Module):
  140.     def __init__(self, num_embeddings, input_size, hidden_size, num_classes=2):
  141.         super(Model_BiLSTM_FC, self).__init__()
  142.         # 词典大小
  143.         self.num_embeddings = num_embeddings
  144.         # 单词向量的维度
  145.         self.input_size = input_size
  146.         # LSTM隐藏单元数量
  147.         self.hidden_size = hidden_size
  148.         # 情感分类类别数量
  149.         self.num_classes = num_classes
  150.         # 实例化嵌入层
  151.         self.embedding_layer = nn.Embedding(num_embeddings, input_size, padding_idx=0)
  152.         # 实例化LSTM层
  153.         self.lstm_layer = nn.LSTM(input_size, hidden_size, batch_first=True, bidirectional=True)
  154.         # 实例化聚合层
  155.         self.average_layer = AveragePooling()
  156.         # 实例化输出层
  157.         self.output_layer = nn.Linear(hidden_size * 2, num_classes)
  158.  
  159.     def forward(self, inputs):
  160.         # 对模型输入拆分为序列数据和mask
  161.         input_ids, sequence_length = inputs
  162.         # 获取词向量
  163.         inputs_emb = self.embedding_layer(input_ids)
  164.  
  165.         packed_input = nn.utils.rnn.pack_padded_sequence(inputs_emb, sequence_length.cpu(), batch_first=True,
  166.                                                          enforce_sorted=False)
  167.         # 使用lstm处理数据
  168.         packed_output, _ = self.lstm_layer(packed_input)
  169.         # 解包输出
  170.         sequence_output, _ = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)
  171.         # 使用聚合层聚合sequence_output
  172.         batch_mean_hidden = self.average_layer(sequence_output, sequence_length)
  173.         # 输出文本分类logits
  174.         logits = self.output_layer(batch_mean_hidden)
  175.         return logits
  176.  
  177.  
  178.  
  179. np.random.seed(0)
  180. random.seed(0)
  181. torch.seed()
  182.  
  183. # 指定训练轮次
  184. num_epochs = 3
  185. # 指定学习率
  186. learning_rate = 0.001
  187. # 指定embedding的数量为词表长度
  188. num_embeddings = len(word2id_dict)
  189. # embedding向量的维度
  190. input_size = 256
  191. # LSTM网络隐状态向量的维度
  192. hidden_size = 256
  193.  
  194. # 实例化模型
  195. model = Model_BiLSTM_FC(num_embeddings, input_size, hidden_size).to(device)
  196. # 指定优化器
  197. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.999))
  198. # 指定损失函数
  199. loss_fn = nn.CrossEntropyLoss()
  200. # 指定评估指标
  201. metric = Accuracy()
  202. # 实例化Runner
  203. runner = RunnerV3(model, optimizer, loss_fn, metric)
  204. # 模型训练
  205. start_time = time.time()
  206. runner.train(train_loader, dev_loader, num_epochs=num_epochs, eval_steps=10, log_steps=10, save_path="./checkpoints/best.pdparams")
  207. end_time = time.time()
  208. print("time: ", (end_time-start_time))
  209.  
  210. from nndl import plot_training_loss_acc
  211.  
  212. # 图像名字
  213. fig_name = "./images/6.16.pdf"
  214. # sample_step: 训练损失的采样step，即每隔多少个点选择1个点绘制
  215. # loss_legend_loc: loss 图像的图例放置位置
  216. # acc_legend_loc： acc 图像的图例放置位置
  217. plot_training_loss_acc(runner, fig_name, fig_size=(16,6), sample_step=10, loss_legend_loc="lower left", acc_legend_loc="lower right")
  218.  
  219.  
  220. model_path = "./checkpoints/best.pdparams"
  221. runner.load_model(model_path)
  222. accuracy, _ =  runner.evaluate(test_loader)
  223. print(f"Evaluate on test set, Accuracy: {accuracy:.5f}")
  224.  
  225.  
  226. id2label={0:"消极情绪", 1:"积极情绪"}
  227. text = "this movie is so great. I watched it three times already"
  228. # 处理单条文本
  229. sentence = text.split(" ")
  230. words = [word2id_dict[word] if word in word2id_dict else word2id_dict['[UNK]'] for word in sentence]
  231. words = words[:max_seq_len]
  232. sequence_length = torch.tensor([len(words)], dtype=torch.int64)
  233. words = torch.tensor(words, dtype=torch.int64).unsqueeze(0)
  234. # 使用模型进行预测
  235. logits = runner.predict((words.to(device), sequence_length.to(device)))
  236. max_label_id = torch.argmax(logits, dim=-1).cpu().numpy()[0]
  237. pred_label = id2label[max_label_id]
  238. print("Label: ", pred_label)
  239.

extend_1.py(展现可以不这么多，自行取消图片的显示)

  1. import os
  2. import torch
  3. import torch.nn as nn
  4. from torch.utils.data import Dataset
  5. from utils.data import load_vocab
  6. from functools import partial
  7. import time
  8. import random
  9. import numpy as np
  10. from nndl import Accuracy, RunnerV3
  11.  
  12. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  13.  
  14.  
  15. # 加载数据集
  16. def load_imdb_data(path):
  17.     assert os.path.exists(path)
  18.     trainset, devset, testset = [], [], []
  19.     with open(os.path.join(path, "train.txt"), "r", encoding='utf-8') as fr:
  20.         for line in fr:
  21.             sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)
  22.             trainset.append((sentence, sentence_label))
  23.  
  24.     with open(os.path.join(path, "dev.txt"), "r", encoding='utf-8') as fr:
  25.         for line in fr:
  26.             sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)
  27.             devset.append((sentence, sentence_label))
  28.  
  29.     with open(os.path.join(path, "test.txt"), "r", encoding='utf-8') as fr:
  30.         for line in fr:
  31.             sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)
  32.             testset.append((sentence, sentence_label))
  33.  
  34.     return trainset, devset, testset
  35.  
  36.  
  37. # 加载IMDB数据集
  38. train_data, dev_data, test_data = load_imdb_data("./dataset/")
  39. # # 打印一下加载后的数据样式
  40. # print(train_data[4])
  41.  
  42.  
  43. class IMDBDataset(Dataset):
  44.     def __init__(self, examples, word2id_dict):
  45.         super(IMDBDataset, self).__init__()
  46.         # 词典，用于将单词转为字典索引的数字
  47.         self.word2id_dict = word2id_dict
  48.         # 加载后的数据集
  49.         self.examples = self.words_to_id(examples)
  50.  
  51.     def words_to_id(self, examples):
  52.         tmp_examples = []
  53.         for idx, example in enumerate(examples):
  54.             seq, label = example
  55.             # 将单词映射为字典索引的ID， 对于词典中没有的单词用[UNK]对应的ID进行替代
  56.             seq = [self.word2id_dict.get(word, self.word2id_dict['[UNK]']) for word in seq.split(" ")]
  57.             label = int(label)
  58.             tmp_examples.append([seq, label])
  59.         return tmp_examples
  60.  
  61.     def __getitem__(self, idx):
  62.         seq, label = self.examples[idx]
  63.         return seq, label
  64.  
  65.     def __len__(self):
  66.         return len(self.examples)
  67.  
  68.  
  69. # 加载词表
  70. word2id_dict = load_vocab("./dataset/vocab.txt")
  71.  
  72. # 实例化Dataset
  73. train_set = IMDBDataset(train_data, word2id_dict)
  74. dev_set = IMDBDataset(dev_data, word2id_dict)
  75. test_set = IMDBDataset(test_data, word2id_dict)
  76.  
  77. print('训练集样本数：', len(train_set))
  78. print('样本示例：', train_set[4])
  79.  
  80.  
  81. def collate_fn(batch_data, pad_val=0, max_seq_len=256):
  82.     seqs, seq_lens, labels = [], [], []
  83.     max_len = 0
  84.     for example in batch_data:
  85.         seq, label = example
  86.         # 对数据序列进行截断
  87.         seq = seq[:max_seq_len]
  88.         # 对数据截断并保存于seqs中
  89.         seqs.append(seq)
  90.         seq_lens.append(len(seq))
  91.         labels.append(label)
  92.         # 保存序列最大长度
  93.         max_len = max(max_len, len(seq))
  94.     # 对数据序列进行填充至最大长度
  95.     for i in range(len(seqs)):
  96.         seqs[i] = seqs[i] + [pad_val] * (max_len - len(seqs[i]))
  97.  
  98.     # return (torch.tensor(seqs), torch.tensor(seq_lens)), torch.tensor(labels)
  99.     return (torch.tensor(seqs).to(device), torch.tensor(seq_lens)), torch.tensor(labels).to(device)
  100.  
  101. max_seq_len = 5
  102. batch_data = [[[1, 2, 3, 4, 5, 6], 1], [[2, 4, 6], 0]]
  103. (seqs, seq_lens), labels = collate_fn(batch_data, pad_val=word2id_dict["[PAD]"], max_seq_len=max_seq_len)
  104. print("seqs: ", seqs)
  105. print("seq_lens: ", seq_lens)
  106. print("labels: ", labels)
  107.  
  108. max_seq_len = 256
  109. batch_size = 128
  110. collate_fn = partial(collate_fn, pad_val=word2id_dict["[PAD]"], max_seq_len=max_seq_len)
  111. train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size,
  112.                                            shuffle=True, drop_last=False, collate_fn=collate_fn)
  113. dev_loader = torch.utils.data.DataLoader(dev_set, batch_size=batch_size,
  114.                                          shuffle=False, drop_last=False, collate_fn=collate_fn)
  115. test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size,
  116.                                           shuffle=False, drop_last=False, collate_fn=collate_fn)
  117.  
  118.  
  119. class AveragePooling(nn.Module):
  120.     def __init__(self):
  121.         super(AveragePooling, self).__init__()
  122.  
  123.     def forward(self, sequence_output, sequence_length):
  124.         # 假设 sequence_length 是一个 PyTorch 张量
  125.         sequence_length = sequence_length.unsqueeze(-1).to(torch.float32)
  126.         # 根据sequence_length生成mask矩阵，用于对Padding位置的信息进行mask
  127.         max_len = sequence_output.shape[1]
  128.  
  129.         mask = torch.arange(max_len, device='cuda') < sequence_length.to('cuda')
  130.         mask = mask.to(torch.float32).unsqueeze(-1)
  131.         # 对序列中paddling部分进行mask
  132.  
  133.         sequence_output = torch.multiply(sequence_output, mask.to('cuda'))
  134.         # 对序列中的向量取均值
  135.         batch_mean_hidden = torch.divide(torch.sum(sequence_output, dim=1), sequence_length.to('cuda'))
  136.         return batch_mean_hidden
  137.  
  138.  
  139. class Model_BiLSTM_FC(nn.Module):
  140.     def __init__(self, num_embeddings, input_size, hidden_size, num_classes=2):
  141.         super(Model_BiLSTM_FC, self).__init__()
  142.         # 词典大小
  143.         self.num_embeddings = num_embeddings
  144.         # 单词向量的维度
  145.         self.input_size = input_size
  146.         # LSTM隐藏单元数量
  147.         self.hidden_size = hidden_size
  148.         # 情感分类类别数量
  149.         self.num_classes = num_classes
  150.         # 实例化嵌入层
  151.         self.embedding_layer = nn.Embedding(num_embeddings, input_size, padding_idx=0)
  152.         # 实例化LSTM层
  153.         self.lstm_layer = nn.LSTM(input_size, hidden_size, batch_first=True)
  154.         # 实例化聚合层
  155.         self.average_layer = AveragePooling()
  156.         # 实例化输出层
  157.         self.output_layer = nn.Linear(hidden_size, num_classes)
  158.  
  159.     def forward(self, inputs):
  160.         # 对模型输入拆分为序列数据和mask
  161.         input_ids, sequence_length = inputs
  162.         # 获取词向量
  163.         inputs_emb = self.embedding_layer(input_ids)
  164.  
  165.         packed_input = nn.utils.rnn.pack_padded_sequence(inputs_emb, sequence_length.cpu(), batch_first=True,
  166.                                                          enforce_sorted=False)
  167.         # 使用lstm处理数据
  168.         packed_output, _ = self.lstm_layer(packed_input)
  169.         # 解包输出
  170.         sequence_output, _ = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)
  171.         # 使用聚合层聚合sequence_output
  172.         batch_mean_hidden = self.average_layer(sequence_output, sequence_length)
  173.         # 输出文本分类logits
  174.         logits = self.output_layer(batch_mean_hidden)
  175.         return logits
  176.  
  177.  
  178.  
  179. np.random.seed(0)
  180. random.seed(0)
  181. torch.seed()
  182.  
  183. # 指定训练轮次
  184. num_epochs = 3
  185. # 指定学习率
  186. learning_rate = 0.001
  187. # 指定embedding的数量为词表长度
  188. num_embeddings = len(word2id_dict)
  189. # embedding向量的维度
  190. input_size = 256
  191. # LSTM网络隐状态向量的维度
  192. hidden_size = 256
  193.  
  194. # 实例化模型
  195. model = Model_BiLSTM_FC(num_embeddings, input_size, hidden_size).to(device)
  196. # 指定优化器
  197. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.999))
  198. # 指定损失函数
  199. loss_fn = nn.CrossEntropyLoss()
  200. # 指定评估指标
  201. metric = Accuracy()
  202. # 实例化Runner
  203. runner = RunnerV3(model, optimizer, loss_fn, metric)
  204. # 模型训练
  205. start_time = time.time()
  206. runner.train(train_loader, dev_loader, num_epochs=num_epochs, eval_steps=10, log_steps=10, save_path="./checkpoints/best_forward.pdparams")
  207. end_time = time.time()
  208. print("time: ", (end_time-start_time))
  209.  
  210. from nndl import plot_training_loss_acc
  211.  
  212. # 图像名字
  213. fig_name = "./images/6.16.pdf"
  214. # sample_step: 训练损失的采样step，即每隔多少个点选择1个点绘制
  215. # loss_legend_loc: loss 图像的图例放置位置
  216. # acc_legend_loc： acc 图像的图例放置位置
  217. plot_training_loss_acc(runner, fig_name, fig_size=(16,6), sample_step=10, loss_legend_loc="lower left", acc_legend_loc="lower right")
  218.  
  219.  
  220. model_path = "./checkpoints/best_forward.pdparams"
  221. runner.load_model(model_path)
  222. accuracy, _ =  runner.evaluate(test_loader)
  223. print(f"Evaluate on test set, Accuracy: {accuracy:.5f}")
  224.  
  225.  
  226. id2label={0:"消极情绪", 1:"积极情绪"}
  227. text = "this movie is so great. I watched it three times already"
  228. # 处理单条文本
  229. sentence = text.split(" ")
  230. words = [word2id_dict[word] if word in word2id_dict else word2id_dict['[UNK]'] for word in sentence]
  231. words = words[:max_seq_len]
  232. sequence_length = torch.tensor([len(words)], dtype=torch.int64)
  233. words = torch.tensor(words, dtype=torch.int64).unsqueeze(0)
  234. # 使用模型进行预测
  235. logits = runner.predict((words.to(device), sequence_length.to(device)))
  236. max_label_id = torch.argmax(logits, dim=-1).cpu().numpy()[0]
  237. pred_label = id2label[max_label_id]
  238. print("Label: ", pred_label)
  239.

extend2.py

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.functional as F
  4. import time
  5. import random
  6. import numpy as np
  7. from nndl import Accuracy, RunnerV3
  8. from functools import partial
  9. import os
  10. from torch.utils.data import Dataset
  11. from utils.data import load_vocab
  12.  
  13.  
  14. def load_imdb_data(path):
  15.     assert os.path.exists(path)
  16.     trainset, devset, testset = [], [], []
  17.     with open(os.path.join(path, "train.txt"), "r", encoding='utf-8') as fr:
  18.         for line in fr:
  19.             sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)
  20.             trainset.append((sentence, sentence_label))
  21.  
  22.     with open(os.path.join(path, "dev.txt"), "r", encoding='utf-8') as fr:
  23.         for line in fr:
  24.             sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)
  25.             devset.append((sentence, sentence_label))
  26.  
  27.     with open(os.path.join(path, "test.txt"), "r", encoding='utf-8') as fr:
  28.         for line in fr:
  29.             sentence_label, sentence = line.strip().lower().split("\t", maxsplit=1)
  30.             testset.append((sentence, sentence_label))
  31.  
  32.     return trainset, devset, testset
  33.  
  34.  
  35. # 加载IMDB数据集
  36. train_data, dev_data, test_data = load_imdb_data("./dataset/")
  37. # # 打印一下加载后的数据样式
  38. # print(train_data[4])
  39.  
  40.  
  41. class IMDBDataset(Dataset):
  42.     def __init__(self, examples, word2id_dict):
  43.         super(IMDBDataset, self).__init__()
  44.         # 词典，用于将单词转为字典索引的数字
  45.         self.word2id_dict = word2id_dict
  46.         # 加载后的数据集
  47.         self.examples = self.words_to_id(examples)
  48.  
  49.     def words_to_id(self, examples):
  50.         tmp_examples = []
  51.         for idx, example in enumerate(examples):
  52.             seq, label = example
  53.             # 将单词映射为字典索引的ID， 对于词典中没有的单词用[UNK]对应的ID进行替代
  54.             seq = [self.word2id_dict.get(word, self.word2id_dict['[UNK]']) for word in seq.split(" ")]
  55.             label = int(label)
  56.             tmp_examples.append([seq, label])
  57.         return tmp_examples
  58.  
  59.     def __getitem__(self, idx):
  60.         seq, label = self.examples[idx]
  61.         return seq, label
  62.  
  63.     def __len__(self):
  64.         return len(self.examples)
  65.  
  66.  
  67. # 加载词表
  68. word2id_dict = load_vocab("./dataset/vocab.txt")
  69.  
  70. # 实例化Dataset
  71. train_set = IMDBDataset(train_data, word2id_dict)
  72. dev_set = IMDBDataset(dev_data, word2id_dict)
  73. test_set = IMDBDataset(test_data, word2id_dict)
  74.  
  75. print('训练集样本数：', len(train_set))
  76. print('样本示例：', train_set[4])
  77.  
  78.  
  79. def collate_fn(batch_data, pad_val=0, max_seq_len=256):
  80.     seqs, seq_lens, labels = [], [], []
  81.     max_len = 0
  82.     for example in batch_data:
  83.         seq, label = example
  84.         # 对数据序列进行截断
  85.         seq = seq[:max_seq_len]
  86.         # 对数据截断并保存于seqs中
  87.         seqs.append(seq)
  88.         seq_lens.append(len(seq))
  89.         labels.append(label)
  90.         # 保存序列最大长度
  91.         max_len = max(max_len, len(seq))
  92.     # 对数据序列进行填充至最大长度
  93.     for i in range(len(seqs)):
  94.         seqs[i] = seqs[i] + [pad_val] * (max_len - len(seqs[i]))
  95.  
  96.     # return (torch.tensor(seqs), torch.tensor(seq_lens)), torch.tensor(labels)
  97.     return (torch.tensor(seqs).to('cuda'), torch.tensor(seq_lens)), torch.tensor(labels).to('cuda')
  98.  
  99. max_seq_len = 5
  100. batch_data = [[[1, 2, 3, 4, 5, 6], 1], [[2, 4, 6], 0]]
  101. (seqs, seq_lens), labels = collate_fn(batch_data, pad_val=word2id_dict["[PAD]"], max_seq_len=max_seq_len)
  102. print("seqs: ", seqs)
  103. print("seq_lens: ", seq_lens)
  104. print("labels: ", labels)
  105.  
  106. max_seq_len = 256
  107. batch_size = 128
  108. collate_fn = partial(collate_fn, pad_val=word2id_dict["[PAD]"], max_seq_len=max_seq_len)
  109. train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size,
  110.                                            shuffle=True, drop_last=False, collate_fn=collate_fn)
  111. dev_loader = torch.utils.data.DataLoader(dev_set, batch_size=batch_size,
  112.                                          shuffle=False, drop_last=False, collate_fn=collate_fn)
  113. test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size,
  114.                                           shuffle=False, drop_last=False, collate_fn=collate_fn)
  115.  
  116. class LSTM(nn.Module):
  117.     def __init__(self, input_size, hidden_size, Wi_attr=None, Wf_attr=None, Wo_attr=None, Wc_attr=None,
  118.                  Ui_attr=None, Uf_attr=None, Uo_attr=None, Uc_attr=None, bi_attr=None, bf_attr=None,
  119.                  bo_attr=None, bc_attr=None):
  120.         super(LSTM, self).__init__()
  121.         self.input_size = input_size
  122.         self.hidden_size = hidden_size
  123.  
  124.         # 初始化模型参数
  125.         if Wi_attr is None:
  126.             Wi = torch.zeros(size=[input_size, hidden_size], dtype=torch.float32)
  127.         else:
  128.             Wi = torch.tensor(Wi_attr, dtype=torch.float32)
  129.         self.W_i = torch.nn.Parameter(Wi.to('cuda'))
  130.  
  131.         if Wf_attr is None:
  132.             Wf = torch.zeros(size=[input_size, hidden_size], dtype=torch.float32)
  133.         else:
  134.             Wf = torch.tensor(Wf_attr, dtype=torch.float32)
  135.         self.W_f = torch.nn.Parameter(Wf.to('cuda'))
  136.  
  137.         if Wo_attr is None:
  138.             Wo = torch.zeros(size=[input_size, hidden_size], dtype=torch.float32)
  139.         else:
  140.             Wo = torch.tensor(Wo_attr, dtype=torch.float32)
  141.         self.W_o = torch.nn.Parameter(Wo.to('cuda'))
  142.  
  143.         if Wc_attr is None:
  144.             Wc = torch.zeros(size=[input_size, hidden_size], dtype=torch.float32)
  145.         else:
  146.             Wc = torch.tensor(Wc_attr, dtype=torch.float32)
  147.         self.W_c = torch.nn.Parameter(Wc.to('cuda'))
  148.  
  149.         if Ui_attr is None:
  150.             Ui = torch.zeros(size=[hidden_size, hidden_size], dtype=torch.float32)
  151.         else:
  152.             Ui = torch.tensor(Ui_attr, dtype=torch.float32)
  153.         self.U_i = torch.nn.Parameter(Ui.to('cuda'))
  154.  
  155.         if Uf_attr is None:
  156.             Uf = torch.zeros(size=[hidden_size, hidden_size], dtype=torch.float32)
  157.         else:
  158.             Uf = torch.tensor(Uf_attr, dtype=torch.float32)
  159.         self.U_f = torch.nn.Parameter(Uf.to('cuda'))
  160.  
  161.         if Uo_attr is None:
  162.             Uo = torch.zeros(size=[hidden_size, hidden_size], dtype=torch.float32)
  163.         else:
  164.             Uo = torch.tensor(Uo_attr, dtype=torch.float32)
  165.         self.U_o = torch.nn.Parameter(Uo.to('cuda'))
  166.  
  167.         if Uc_attr is None:
  168.             Uc = torch.zeros(size=[hidden_size, hidden_size], dtype=torch.float32)
  169.         else:
  170.             Uc = torch.tensor(Uc_attr, dtype=torch.float32)
  171.         self.U_c = torch.nn.Parameter(Uc.to('cuda'))
  172.  
  173.         if bi_attr is None:
  174.             bi = torch.zeros(size=[1, hidden_size], dtype=torch.float32)
  175.         else:
  176.             bi = torch.tensor(bi_attr, dtype=torch.float32)
  177.         self.b_i = torch.nn.Parameter(bi.to('cuda'))
  178.  
  179.         if bf_attr is None:
  180.             bf = torch.zeros(size=[1, hidden_size], dtype=torch.float32)
  181.         else:
  182.             bf = torch.tensor(bf_attr, dtype=torch.float32)
  183.         self.b_f = torch.nn.Parameter(bf.to('cuda'))
  184.  
  185.         if bo_attr is None:
  186.             bo = torch.zeros(size=[1, hidden_size], dtype=torch.float32)
  187.         else:
  188.             bo = torch.tensor(bo_attr, dtype=torch.float32)
  189.         self.b_o = torch.nn.Parameter(bo.to('cuda'))
  190.  
  191.         if bc_attr is None:
  192.             bc = torch.zeros(size=[1, hidden_size], dtype=torch.float32)
  193.         else:
  194.             bc = torch.tensor(bc_attr, dtype=torch.float32)
  195.         self.b_c = torch.nn.Parameter(bc.to('cuda'))
  196.  
  197.     # 初始化状态向量和隐状态向量
  198.     def init_state(self, batch_size):
  199.         hidden_state = torch.zeros(size=[batch_size, self.hidden_size], dtype=torch.float32).to('cuda')
  200.         cell_state = torch.zeros(size=[batch_size, self.hidden_size], dtype=torch.float32).to('cuda')
  201.         return hidden_state, cell_state
  202.  
  203.     # 定义前向计算
  204.     def forward(self, inputs, states=None):
  205.         # inputs: 输入数据，其shape为batch_size x seq_len x input_size
  206.         batch_size, seq_len, input_size = torch.tensor(inputs).shape
  207.  
  208.         # 初始化起始的单元状态和隐状态向量，其shape为batch_size x hidden_size
  209.         if states is None:
  210.             states = self.init_state(batch_size)
  211.         hidden_state, cell_state = states
  212.  
  213.         # 执行LSTM计算，包括：输入门、遗忘门和输出门、候选内部状态、内部状态和隐状态向量
  214.         for step in range(seq_len):
  215.             # 获取当前时刻的输入数据step_input: 其shape为batch_size x input_size
  216.             step_input = inputs[:, step, :]
  217.             # 计算输入门, 遗忘门和输出门, 其shape为：batch_size x hidden_size
  218.             I_gate = F.sigmoid(torch.matmul(step_input, self.W_i) + torch.matmul(hidden_state, self.U_i) + self.b_i)
  219.             F_gate = F.sigmoid(torch.matmul(step_input, self.W_f) + torch.matmul(hidden_state, self.U_f) + self.b_f)
  220.             O_gate = F.sigmoid(torch.matmul(step_input, self.W_o) + torch.matmul(hidden_state, self.U_o) + self.b_o)
  221.             # 计算候选状态向量, 其shape为：batch_size x hidden_size
  222.             C_tilde = F.tanh(torch.matmul(step_input, self.W_c) + torch.matmul(hidden_state, self.U_c) + self.b_c)
  223.             # 计算单元状态向量, 其shape为：batch_size x hidden_size
  224.             cell_state = F_gate * cell_state + I_gate * C_tilde
  225.             # 计算隐状态向量，其shape为：batch_size x hidden_size
  226.             hidden_state = O_gate * F.tanh(cell_state)
  227.  
  228.         return hidden_state
  229.  
  230.  
  231. class AveragePooling(nn.Module):
  232.     def __init__(self):
  233.         super(AveragePooling, self).__init__()
  234.  
  235.     def forward(self, sequence_output, sequence_length):
  236.         # 假设 sequence_length 是一个 PyTorch 张量
  237.         sequence_length = sequence_length.unsqueeze(-1).to(torch.float32)
  238.         # 根据sequence_length生成mask矩阵，用于对Padding位置的信息进行mask
  239.         max_len = sequence_output.shape[1]
  240.  
  241.         mask = torch.arange(max_len, device='cuda') < sequence_length.to('cuda')
  242.         mask = mask.to(torch.float32).unsqueeze(-1)
  243.         # 对序列中paddling部分进行mask
  244.  
  245.         sequence_output = torch.multiply(sequence_output, mask.to('cuda'))
  246.         # 对序列中的向量取均值
  247.         batch_mean_hidden = torch.divide(torch.sum(sequence_output, dim=1), sequence_length.to('cuda'))
  248.         return batch_mean_hidden
  249.  
  250.  
  251. class Model_BiLSTM_FC(nn.Module):
  252.     def __init__(self, num_embeddings, input_size, hidden_size, num_classes=2):
  253.         super(Model_BiLSTM_FC, self).__init__()
  254.         # 词典大小
  255.         self.num_embeddings = num_embeddings
  256.         # 单词向量的维度
  257.         self.input_size = input_size
  258.         # LSTM隐藏单元数量
  259.         self.hidden_size = hidden_size
  260.         # 情感分类类别数量
  261.         self.num_classes = num_classes
  262.         # 实例化嵌入层
  263.         self.embedding_layer = nn.Embedding(num_embeddings, input_size, padding_idx=0)
  264.         # 实例化LSTM层
  265.         self.lstm_layer = nn.LSTM(input_size, hidden_size, batch_first=True, bidirectional=True)
  266.         # 实例化聚合层
  267.         self.average_layer = AveragePooling()
  268.         # 实例化输出层
  269.         self.output_layer = nn.Linear(hidden_size * 2, num_classes)
  270.  
  271.     def forward(self, inputs):
  272.         # 对模型输入拆分为序列数据和mask
  273.         input_ids, sequence_length = inputs
  274.         # 获取词向量
  275.         inputs_emb = self.embedding_layer(input_ids)
  276.  
  277.         packed_input = nn.utils.rnn.pack_padded_sequence(inputs_emb, sequence_length.cpu(), batch_first=True,
  278.                                                          enforce_sorted=False)
  279.         # 使用lstm处理数据
  280.         packed_output, _ = self.lstm_layer(packed_input)
  281.         # 解包输出
  282.         sequence_output, _ = nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=True)
  283.         # 使用聚合层聚合sequence_output
  284.         batch_mean_hidden = self.average_layer(sequence_output, sequence_length)
  285.         # 输出文本分类logits
  286.         logits = self.output_layer(batch_mean_hidden)
  287.         return logits
  288.  
  289.  
  290. np.random.seed(0)
  291. random.seed(0)
  292. torch.seed()
  293.  
  294. # 指定训练轮次
  295. num_epochs = 3
  296. # 指定学习率
  297. learning_rate = 0.001
  298. # 指定embedding的数量为词表长度
  299. num_embeddings = len(word2id_dict)
  300. # embedding向量的维度
  301. input_size = 256
  302. # LSTM网络隐状态向量的维度
  303. hidden_size = 256
  304.  
  305. # 实例化模型
  306. model = Model_BiLSTM_FC(num_embeddings, input_size, hidden_size).to('cuda')
  307. # 指定优化器
  308. optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.999))
  309. # 指定损失函数
  310. loss_fn = nn.CrossEntropyLoss()
  311. # 指定评估指标
  312. metric = Accuracy()
  313. # 实例化Runner
  314. runner = RunnerV3(model, optimizer, loss_fn, metric)
  315. # 模型训练
  316. start_time = time.time()
  317. runner.train(train_loader, dev_loader, num_epochs=num_epochs, eval_steps=10, log_steps=10, save_path="./checkpoints/best_self_forward.pdparams")
  318. end_time = time.time()
  319. print("time: ", (end_time-start_time))
  320.  
  321.  
  322. model_path = "./checkpoints/best_self_forward.pdparams"
  323. runner.load_model(model_path)
  324. accuracy, _ =  runner.evaluate(test_loader)
  325. print(f"Evaluate on test set, Accuracy: {accuracy:.5f}")

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/421818
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号