编辑

🍊作者最近在看了大量论文的源代码后，被它们干净利索的代码风格深深吸引，因此也想做一个结构比较规范而且内容较为经典的任务

🍊本项目使用Pytorch框架，使用上游语言模型+下游网络模型的结构实现IMDB情感分析

🍊语言模型可选择Bert、Roberta

🍊主神经网络模型可选择BiLstm、LSTM、TextCNN、Rnn、Gru、FNN、Attention共7种

🍊语言模型和网络模型扩展性较好

🍊最终的准确率均在90%以上

🍊项目已开源，clone下来再配个简单环境就能跑

很高兴能够帮到大家，也希望大家可以动动小手，在Github上给个小星星

一、Introduction

1.1 网络架构图

该网络主要使用上游预训练模型+下游情感分类模型组成

编辑

1.2 快速使用

该项目已开源在Github上，地址为 sentiment_analysis_Imdb

编辑

主要环境要求如下（环境不要太老基本没啥问题的）

编辑

下载该项目后，配置相对应的环境，在config.py文件中选择所需的语言模型和神经网络模型如下图所示，运行main.py文件即可

编辑

1.3 工程结构

编辑

logs 每次运行程序后的日志文件集合

config.py 全局配置文件

data.py 数据读取、数据清洗、数据格式转换、制作DataSet和DataLoader

main.py 主函数，负责全流程项目运行，包括语言模型的转换，模型的训练和测试

model.py 神经网络模型的设计和读取

二、Config

看了很多论文源代码中都使用parser容器进行全局变量的配置，因此作者也照葫芦画瓢编写了config.py文件

import argparse
import logging
import os
import random
import sys
import time
from datetime import datetime
import torch
def get_config():
    parser = argparse.ArgumentParser()
    '''Base'''
    parser.add_argument('--num_classes', type=int, default=2)
    parser.add_argument('--model_name', type=str, default='bert',
                        choices=['bert', 'roberta'])
    parser.add_argument('--method_name', type=str, default='fnn',
                        choices=['gru', 'rnn', 'bilstm', 'lstm', 'fnn', 'textcnn', 'attention', 'lstm+textcnn',
                                 'lstm_textcnn_attention'])
    '''Optimization'''
    parser.add_argument('--train_batch_size', type=int, default=4)
    parser.add_argument('--test_batch_size', type=int, default=16)
    parser.add_argument('--num_epoch', type=int, default=50)
    parser.add_argument('--lr', type=float, default=1e-5)
    parser.add_argument('--weight_decay', type=float, default=0.01)
    '''Environment'''
    parser.add_argument('--device', type=str, default='cpu')
    parser.add_argument('--backend', default=False, action='store_true')
    parser.add_argument('--workers', type=int, default=0)
    parser.add_argument('--timestamp', type=int, default='{:.0f}{:03}'.format(time.time(), random.randint(0, 999)))
    args = parser.parse_args()
    args.device = torch.device(args.device)
    '''logger'''
    args.log_name = '{}_{}_{}.log'.format(args.model_name, args.method_name,
                                          datetime.now().strftime('%Y-%m-%d_%H-%M-%S')[2:])
    if not os.path.exists('logs'):
        os.mkdir('logs')
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    logger.addHandler(logging.StreamHandler(sys.stdout))
    logger.addHandler(logging.FileHandler(os.path.join('logs', args.log_name)))
    return args, logger

三、Data

3.1 数据准备

首先需要下载IMDB数据集，并对其进行初步处理，其处理过程可参考一下文章IMDB数据预处理

也可以直接从Github上获取已处理好的数据集，处理好的数据格式如下

编辑

3.2 数据预处理

由于IMDB数据量非常庞大，使用全数据的训练时间非常长（算力好的小伙伴可忽略），因此这里使用10%的数据量进行训练

data = pd.read_csv('datasets.csv', sep=None, header=0, encoding='utf-8', engine='python')
    len1 = int(len(list(data['labels'])) * 0.1)
    labels = list(data['labels'])[0:len1]
    sentences = list(data['sentences'])[0:len1]
    # split train_set and test_set
    tr_sen, te_sen, tr_lab, te_lab = train_test_split(sentences, labels, train_size=0.8)

3.3 制作DataSet

划分训练集和测试集之后就可以制作自己的DataSet

# Dataset
    train_set = MyDataset(tr_sen, tr_lab, method_name, model_name)
    test_set = MyDataset(te_sen, te_lab, method_name, model_name)

MyDataset的结构如下

使用split方法将每个单词提取出来作为后续bertToken的输入
后续制作DataLoader需要使用collate_fn函数因此需要重写__getitem__方法

class MyDataset(Dataset):
    def __init__(self, sentences, labels, method_name, model_name):
        self.sentences = sentences
        self.labels = labels
        self.method_name = method_name
        self.model_name = model_name
        dataset = list()
        index = 0
        for data in sentences:
            tokens = data.split(' ')
            labels_id = labels[index]
            index += 1
            dataset.append((tokens, labels_id))
        self._dataset = dataset
    def __getitem__(self, index):
        return self._dataset[index]
    def __len__(self):
        return len(self.sentences)

3.4 制作DataLoader

得到DataSet之后就可以制作DataLoader了

首先需要编写my_collate函数，该函数的功能是对每一个batch的数据进行处理
在这里的数据处理是将文本数据进行Tokenizer化作为后续Bert模型的输入
通过计算可得知80%句子的长度低于320，因此将句子长度固定为320，多截少补
partial是Python偏函数，使用该函数后，my_collate的输入参数只有一个batch

def my_collate(batch, tokenizer):
    tokens, label_ids = map(list, zip(*batch))
    text_ids = tokenizer(tokens,
                         padding=True,
                         truncation=True,
                         max_length=320,
                         is_split_into_words=True,
                         add_special_tokens=True,
                         return_tensors='pt')
    return text_ids, torch.tensor(label_ids)

# DataLoader
    collate_fn = partial(my_collate, tokenizer=tokenizer)
    train_loader = DataLoader(train_set, batch_size=train_batch_size, shuffle=True, num_workers=workers,
                              collate_fn=collate_fn, pin_memory=True)
    test_loader = DataLoader(test_set, batch_size=test_batch_size, shuffle=True, num_workers=workers,
                             collate_fn=collate_fn, pin_memory=True)

到此我们就完成制作了DataLoader，后续从DataLoader中可获取一个个batch经Tokenizer化后的数据

四、Language model

对于网络模型来说，只能接受数字数据类型，因此我们需要建立一个语言模型，目的是将每个单词变成一个向量，每个句子变成一个矩阵。关于语言模型，其已经发展历史非常悠久了（发展历史如下），其中Bert模型是Google大神出的具有里程碑性质的模型，因此本篇博客也主要采用此模型

编辑

所用的模型都是通过API从 Hugging Face官网中直接下载的

Hugging Face中有非常多的好用的语言模型，小伙伴们也可尝试其他模型

编辑

使用AutoModel.from_pretrained接口下载预训练模型

使用AutoTokenizere.from_pretrained接口下载预训练模型的分词器

# Create model
        if args.model_name == 'bert':
            self.tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
            self.input_size = 768
            base_model = AutoModel.from_pretrained('bert-base-uncased')
        elif args.model_name == 'roberta':
            self.tokenizer = AutoTokenizer.from_pretrained('roberta-base', add_prefix_space=True)
            self.input_size = 768
            base_model = AutoModel.from_pretrained('roberta-base')
        else:
            raise ValueError('unknown model')

下载创建好Bert之后，在训练和测试的时候，每次从DataLoadr中获取一个个经过Tokenizer分词之后Batch的数据，随后将其投放到语言模型中

** input ：input的数据是Tokenizer化后的数据如{ 'input_id' : ~ , 'token_type_ids' : ~ , 'attention_mask' : ~}，**是将里面的三个dict分成一个个独立的dict，即{ 'input_id' : ~} ，{ 'token_type_ids' : ~} ，{ 'attention_mask' : ~}

raw_outputs获取的是Bert的输出，Bert的输出主要有四个，其中last_hidden_state表示的是最后一层隐藏层的状态，也就是每个单词的Token的集合

raw_outputs = self.base_model(**inputs)
tokens = raw_outputs.last_hidden_state

到此，上游语言模型全部结束，得到了一个个经过Bert后维度为[batch大小，句子长度，单词维度]的数据

五、Neural network model

关于RNN的原理解释，小伙伴可以看以下文章

【Deep Learning 7】RNN循环神经网络

5.1 RNN

Bilstm、lstm、gru本质上来说都是属于RNN模型，因此我们就以RNN模型为例子看看上游任务的数据是如何进入到下游文本分类的

RNN输入参数

input_size：每个单词维度

hidden_size：隐含层的维度（一般设置与句子长度一致）

num_layers：RNN层数，默认是1，单层LSTM

bias：是否使用bias

batch_first：默认为False，如果设置为True，则表示第一个维度表示的是batch_size

dropout：随机失活

bidirectional：是否使用BiLSTM

由于是情感分析文本二分类任务，因此还需要一个FNN+Softmax模块进行分类预测

class Rnn_Model(nn.Module):
    def __init__(self, base_model, num_classes, input_size):
        super().__init__()
        self.base_model = base_model
        self.num_classes = num_classes
        self.input_size = input_size
        self.Rnn = nn.RNN(input_size=self.input_size,
                          hidden_size=320,
                          num_layers=1,
                          batch_first=True)
        self.fc = nn.Sequential(nn.Dropout(0.5),
                                nn.Linear(320, 80),
                                nn.Linear(80, 20),
                                nn.Linear(20, self.num_classes),
                                nn.Softmax(dim=1))
        for param in base_model.parameters():
            param.requires_grad = (True)

再来看看RNN的传播过程

RNN输出参数

output, (hn, cn) = lstm(inputs)

output_last = output[:,-1,:]

output：每个时间步输出

output_last：最后一个时间步隐藏层神经元输出，也就是最终的特征表示

hn：最后一个时间步隐藏层的状态

cn：最后一个时间步隐藏层的遗忘门值

由于我们用不到hn和cn，因此直接使用_来代替

def forward(self, inputs):
        # 上游任务
        raw_outputs = self.base_model(**inputs)
        cls_feats = raw_outputs.last_hidden_state
        # 下游任务
        outputs, _ = self.Rnn(cls_feats)
        outputs = outputs[:, -1, :]
        outputs = self.fc(outputs)
        return outputs

输出的outputs就是预测结果

5.2 GRU

其实熟悉了RNN网络模块之后，其他几个网络模块的也就非常好理解了

将nn.RNN修改为nn.GRU

class Gru_Model(nn.Module):
    def __init__(self, base_model, num_classes, input_size):
        super().__init__()
        self.base_model = base_model
        self.num_classes = num_classes
        self.input_size = input_size
        self.Gru = nn.GRU(input_size=self.input_size,
                          hidden_size=320,
                          num_layers=1,
                          batch_first=True)
        self.fc = nn.Sequential(nn.Dropout(0.5),
                                nn.Linear(320, 80),
                                nn.Linear(80, 20),
                                nn.Linear(20, self.num_classes),
                                nn.Softmax(dim=1))
        for param in base_model.parameters():
            param.requires_grad = (True)
    def forward(self, inputs):
        raw_outputs = self.base_model(**inputs)
        tokens = raw_outputs.last_hidden_state
        gru_output, _ = self.Gru(tokens)
        outputs = gru_output[:, -1, :]
        outputs = self.fc(outputs)
        return outputs

5.3 LSTM

将nn.RNN修改为nn.LSTM

class Lstm_Model(nn.Module):
    def __init__(self, base_model, num_classes, input_size):
        super().__init__()
        self.base_model = base_model
        self.num_classes = num_classes
        self.input_size = input_size
        self.Lstm = nn.LSTM(input_size=self.input_size,
                            hidden_size=320,
                            num_layers=1,
                            batch_first=True)
        self.fc = nn.Sequential(nn.Dropout(0.5),
                                nn.Linear(320, 80),
                                nn.Linear(80, 20),
                                nn.Linear(20, self.num_classes),
                                nn.Softmax(dim=1))
        for param in base_model.parameters():
            param.requires_grad = (True)
    def forward(self, inputs):
        raw_outputs = self.base_model(**inputs)
        tokens = raw_outputs.last_hidden_state
        lstm_output, _ = self.Lstm(tokens)
        outputs = lstm_output[:, -1, :]
        outputs = self.fc(outputs)
        return outputs

5.4 BILSTM

bilstm与其他几个网络模型稍微有点不同，需要修改的地方有三处

将nn.RNN修改为nn.LSTM
在nn.LSTM中添加 bidirectional=True
一个BILSTM是由两个LSTM组合而成的，因此FNN输入的维度也要乘2，即 nn.Linear(320 * 2, 80)

class BiLstm_Model(nn.Module):
    def __init__(self, base_model, num_classes, input_size):
        super().__init__()
        self.base_model = base_model
        self.num_classes = num_classes
        self.input_size = input_size
        # Open the bidirectional
        self.BiLstm = nn.LSTM(input_size=self.input_size,
                              hidden_size=320,
                              num_layers=1,
                              batch_first=True,
                              bidirectional=True)
        self.fc = nn.Sequential(nn.Dropout(0.5),
                                nn.Linear(320 * 2, 80),
                                nn.Linear(80, 20),
                                nn.Linear(20, self.num_classes),
                                nn.Softmax(dim=1))
        for param in base_model.parameters():
            param.requires_grad = (True)
    def forward(self, inputs):
        raw_outputs = self.base_model(**inputs)
        cls_feats = raw_outputs.last_hidden_state
        outputs, _ = self.BiLstm(cls_feats)
        outputs = outputs[:, -1, :]
        outputs = self.fc(outputs)
        return outputs

5.5 TextCNN

既然RNN可以做文本分类，那CNN呢？答案当然是可以的，早在2014年就出现了TextCNN，原模型如下

编辑

欸，看起来可能有点抽象，看另一篇解释该模型的图可能好理解多了

编辑

首先原句与卷积核分别为[2，768]、[3,768]、[4,768]且channels为2的filtet进行卷积运算得到6个一维向量
随后将每个一维向量中取出最大值，将这6个最大值拼接成[6，2]的Tensor
最后进行常规的分类预测
注意nn.ModuleList的Pytorch代码技巧，ModuleList可以理解为可存储卷积核的List

class TextCNN_Model(nn.Module):
    def __init__(self, base_model, num_classes):
        super().__init__()
        self.base_model = base_model
        self.num_classes = num_classes
        for param in base_model.parameters():
            param.requires_grad = (True)
        # Define the hyperparameters
        self.filter_sizes = [2, 3, 4]
        self.num_filters = 2
        self.encode_layer = 12
        # TextCNN
        self.convs = nn.ModuleList(
            [nn.Conv2d(in_channels=1, out_channels=self.num_filters,
                       kernel_size=(K, self.base_model.config.hidden_size)) for K in self.filter_sizes]
        )
        self.block = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(self.num_filters * len(self.filter_sizes), self.num_classes),
            nn.Softmax(dim=1)
        )
    def conv_pool(self, tokens, conv):
        tokens = conv(tokens)
        tokens = F.relu(tokens)
        tokens = tokens.squeeze(3)
        tokens = F.max_pool1d(tokens, tokens.size(2))
        out = tokens.squeeze(2)
        return out
    def forward(self, inputs):
        raw_outputs = self.base_model(**inputs)
        tokens = raw_outputs.last_hidden_state.unsqueeze(1)
        out = torch.cat([self.conv_pool(tokens, conv) for conv in self.convs],
                        1)
        predicts = self.block(out)
        return predicts

5.7 FNN

因为我们使用的是Bert模型，其模型本身是由12层Transformer组成，每层Transformer又由复杂的Attention网络组成，所以Bert模型本身就是一个非常好的网络模型，所以可能我不太需要加RNN、CNN这些操作，直接使用FNN或许也可以实现不错的效果（7.Result部分的消融实验也证实了该想法）。

在讲解这个代码之前，不得不再次提起Bert的输出了，输入一个句子，Bert的输出是

【CLS】token1 token 2 token3 token4 ... token n 【SEP】

token表示每个输入单词的向量，【CLS】表示整个句子的向量，做FNN需要整个句子的输入，因此我们需要获取的是【CLS】。【CLS】是隐层0号位的数据，因此具体获取【CLS】的代码是

cls_feats = raw_outputs.last_hidden_state[:, 0, :]

完整FNN网络模块代码如下

class Transformer(nn.Module):
    def __init__(self, base_model, num_classes, input_size):
        super().__init__()
        self.base_model = base_model
        self.num_classes = num_classes
        self.input_size = input_size
        self.linear = nn.Linear(base_model.config.hidden_size, num_classes)
        self.dropout = nn.Dropout(0.5)
        self.softmax = nn.Softmax()
        for param in base_model.parameters():
            param.requires_grad = (True)
    def forward(self, inputs):
        raw_outputs = self.base_model(**inputs)
        cls_feats = raw_outputs.last_hidden_state[:, 0, :]
        predicts = self.softmax(self.linear(self.dropout(cls_feats)))
        return predicts

5.8 Self-Attention

RNN和CNN都介绍过了，那作为当下最主流的Attention机制怎么能少呢？

关于Self-Attention的细节，可以参考这篇文章

在这里，为了方便对着公式阅读代码，我将Attention的公式放置如下

class Transformer_Attention(nn.Module):
    def __init__(self, base_model, num_classes):
        super().__init__()
        self.base_model = base_model
        self.num_classes = num_classes
        for param in base_model.parameters():
            param.requires_grad = (True)
        # Self-Attention
        self.key_layer = nn.Linear(self.base_model.config.hidden_size, self.base_model.config.hidden_size)
        self.query_layer = nn.Linear(self.base_model.config.hidden_size, self.base_model.config.hidden_size)
        self.value_layer = nn.Linear(self.base_model.config.hidden_size, self.base_model.config.hidden_size)
        self._norm_fact = 1 / math.sqrt(self.base_model.config.hidden_size)
        self.block = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(768, 128),
            nn.Linear(128, 16),
            nn.Linear(16, num_classes),
            nn.Softmax(dim=1)
        )
    def forward(self, inputs):
        raw_outputs = self.base_model(**inputs)
        tokens = raw_outputs.last_hidden_state
        K = self.key_layer(tokens)
        Q = self.query_layer(tokens)
        V = self.value_layer(tokens)
        attention = nn.Softmax(dim=-1)((torch.bmm(Q, K.permute(0, 2, 1))) * self._norm_fact)
        attention_output = torch.bmm(attention, V)
        attention_output = torch.mean(attention_output, dim=1)
        predicts = self.block(attention_output)
        return predicts

5.9 TextCNN+LSTM

在这里，我先抛出一个问题，我们为什么要用CNN和LSTM，它究竟有什么好处？

TextCNN是使用了卷积机制，提取了文本中最关键的信息，也就是最具有区分性的信息，比如5.5中的TextCNN展示图，一个7*5如此大的矩阵，最终竟然只用6*1的向量就可表征了

而LSTM恰巧相反，它是不断地关注了时间序列中每个隐藏层状态，目的是挖掘出深藏的语义信息

因此，我们可以将TextCNN和LSTM结合起来，就像你考CET6阅读理解一样一样，既要抓取最显著的信息快速判断，又要细读文章内容，理解内含的语义信息，二者结合来便于判断

说了这么多，看看代码到底如何实现

class Transformer_CNN_RNN(nn.Module):
    def __init__(self, base_model, num_classes):
        super().__init__()
        self.base_model = base_model
        self.num_classes = num_classes
        for param in base_model.parameters():
            param.requires_grad = (True)
        # Define the hyperparameters
        self.filter_sizes = [3, 4, 5]
        self.num_filters = 100
        # TextCNN
        self.convs = nn.ModuleList(
            [nn.Conv2d(in_channels=1, out_channels=self.num_filters,
                       kernel_size=(K, self.base_model.config.hidden_size)) for K in self.filter_sizes]
        )
        # LSTM
        self.lstm = nn.LSTM(input_size=self.base_model.config.hidden_size,
                            hidden_size=320,
                            num_layers=1,
                            batch_first=True)
        self.block = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(620, 128),
            nn.Linear(128, 16),
            nn.Linear(16, num_classes),
            nn.Softmax(dim=1)
        )
    def conv_pool(self, tokens, conv):
        # x -> [batch,1,text_length,768]
        tokens = conv(tokens)  # shape [batch_size, out_channels, x.shape[2] - conv.kernel_size[0] + 1, 1]
        tokens = F.relu(tokens)
        tokens = tokens.squeeze(3)  # shape [batch_size, out_channels, x.shape[2] - conv.kernel_size[0] + 1]
        tokens = F.max_pool1d(tokens, tokens.size(2))  # shape[batch, out_channels, 1]
        out = tokens.squeeze(2)  # shape[batch, out_channels]
        return out
    def forward(self, inputs):
        raw_outputs = self.base_model(**inputs)
        cnn_tokens = raw_outputs.last_hidden_state.unsqueeze(1)  # shape [batch_size, 1, max_len, hidden_size]
        cnn_out = torch.cat([self.conv_pool(cnn_tokens, conv) for conv in self.convs],
                            1)  # shape  [batch_size, self.num_filters * len(self.filter_sizes]
        rnn_tokens = raw_outputs.last_hidden_state
        rnn_outputs, _ = self.lstm(rnn_tokens)
        rnn_out = rnn_outputs[:, -1, :]
        # cnn_out --> [batch,300]
        # rnn_out --> [batch,320]
        out = torch.cat((cnn_out, rnn_out), 1)
        predicts = self.block(out)
        return predict

5.10 Attention+LSTM+TextCNN

既然我们的网络模型同时加了LSTM和TextCNN，那作为当前的前沿模型Attention怎么能少呢？

从IO角度来看Self-Attention，它输入是什么尺寸的矩阵，输出也是什么尺寸的矩阵，因此一个简单的做法就是将Bert的输出，先放到Attention模块中，将Attention的输出放到后续的Lstm和TexCNN

代码如下

class Transformer_CNN_RNN_Attention(nn.Module):
    def __init__(self, base_model, num_classes):
        super().__init__()
        self.base_model = base_model
        self.num_classes = num_classes
        for param in base_model.parameters():
            param.requires_grad = (True)
        # Define the hyperparameters
        self.filter_sizes = [3, 4, 5]
        self.num_filters = 100
        # TextCNN
        self.convs = nn.ModuleList(
            [nn.Conv2d(in_channels=1, out_channels=self.num_filters,
                       kernel_size=(K, self.base_model.config.hidden_size)) for K in self.filter_sizes]
        )
        # LSTM
        self.lstm = nn.LSTM(input_size=self.base_model.config.hidden_size,
                            hidden_size=320,
                            num_layers=1,
                            batch_first=True)
        # Self-Attention
        self.key_layer = nn.Linear(self.base_model.config.hidden_size, self.base_model.config.hidden_size)
        self.query_layer = nn.Linear(self.base_model.config.hidden_size, self.base_model.config.hidden_size)
        self.value_layer = nn.Linear(self.base_model.config.hidden_size, self.base_model.config.hidden_size)
        self._norm_fact = 1 / math.sqrt(self.base_model.config.hidden_size)
        self.block = nn.Sequential(
            nn.Dropout(0.5),
            nn.Linear(620, 128),
            nn.Linear(128, 16),
            nn.Linear(16, num_classes),
            nn.Softmax(dim=1)
        )
    def conv_pool(self, tokens, conv):
        # x -> [batch,1,text_length,768]
        tokens = conv(tokens)  # shape [batch_size, out_channels, x.shape[2] - conv.kernel_size[0] + 1, 1]
        tokens = F.relu(tokens)
        tokens = tokens.squeeze(3)  # shape [batch_size, out_channels, x.shape[2] - conv.kernel_size[0] + 1]
        tokens = F.max_pool1d(tokens, tokens.size(2))  # shape[batch, out_channels, 1]
        out = tokens.squeeze(2)  # shape[batch, out_channels]
        return out
    def forward(self, inputs):
        raw_outputs = self.base_model(**inputs)
        tokens = raw_outputs.last_hidden_state
        # Self-Attention
        K = self.key_layer(tokens)
        Q = self.query_layer(tokens)
        V = self.value_layer(tokens)
        attention = nn.Softmax(dim=-1)((torch.bmm(Q, K.permute(0, 2, 1))) * self._norm_fact)
        attention_output = torch.bmm(attention, V)
        # TextCNN
        cnn_tokens = attention_output.unsqueeze(1)  # shape [batch_size, 1, max_len, hidden_size]
        cnn_out = torch.cat([self.conv_pool(cnn_tokens, conv) for conv in self.convs],
                            1)  # shape  [batch_size, self.num_filters * len(self.filter_sizes]
        rnn_tokens = tokens
        rnn_outputs, _ = self.lstm(rnn_tokens)
        rnn_out = rnn_outputs[:, -1, :]
        # cnn_out --> [batch,300]
        # rnn_out --> [batch,320]
        out = torch.cat((cnn_out, rnn_out), 1)
        predicts = self.block(out)
        return predicts

六、Train and Test

最后就是编写对应的训练函数和测试函数啦

可能有些小伙伴不懂tqdm函数，它的功能就是能显示动态进度，如下图所示

编辑

训练函数

注意要开启训练模式，即self.Mymodel.train()，如此有些层如dropout层参数可以进行更新

def _train(self, dataloader, criterion, optimizer):
        train_loss, n_correct, n_train = 0, 0, 0
        # Turn on the train mode
        self.Mymodel.train()
        for inputs, targets in tqdm(dataloader, disable=self.args.backend, ascii='>='):
            inputs = {k: v.to(self.args.device) for k, v in inputs.items()}
            targets = targets.to(self.args.device)
            predicts = self.Mymodel(inputs)
            loss = criterion(predicts, targets)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            train_loss += loss.item() * targets.size(0)
            n_correct += (torch.argmax(predicts, dim=1) == targets).sum().item()
            n_train += targets.size(0)
        return train_loss / n_train, n_correct / n_train

测试函数

注意要开启验证模式，即self.Mymodel.eval()，如此有些层如dropout参数不会更新了

def _test(self, dataloader, criterion):
        test_loss, n_correct, n_test = 0, 0, 0
        # Turn on the eval mode
        self.Mymodel.eval()
        with torch.no_grad():
            for inputs, targets in tqdm(dataloader, disable=self.args.backend, ascii=' >='):
                inputs = {k: v.to(self.args.device) for k, v in inputs.items()}
                targets = targets.to(self.args.device)
                predicts = self.Mymodel(inputs)
                loss = criterion(predicts, targets)
                test_loss += loss.item() * targets.size(0)
                n_correct += (torch.argmax(predicts, dim=1) == targets).sum().item()
                n_test += targets.size(0)
        return test_loss / n_test, n_correct / n_test

最后在run函数中进行多次训练和获取最佳训练准确率

# Get the best_loss and the best_acc
best_loss, best_acc = 0, 0
for epoch in range(self.args.num_epoch):
    train_loss, train_acc = self._train(train_dataloader, criterion, optimizer)
    test_loss, test_acc = self._test(test_dataloader, criterion)
    if test_acc > best_acc or (test_acc == best_acc and test_loss < best_loss):
          best_acc, best_loss = test_acc, test_loss

七、Result

到了最快乐的炼丹时间，看看最终的效果怎么样

编辑

分析

LSTM与BiLSTM的效果总体上要优于其他模型

Roberta比Bert的效果好，Roberta不愧是升级版Bert

FNN的效果好是因为Transformers本身就是LSTM的改进版

Roberta+LSTM/BiLSTM的组合效果是最优的

纯TextCNN的效果有点鸡肋，因为CNN主要关注局部而RNN关注全局。

新增的Attention、TextCNN+LSTM、Attention+TexCNN+LSTM还没有出结果，如果有其他小伙伴跑出来欢迎在评论区告诉我们

八、Conclusion

目前该数据集的SOTA是使用XLNet模型跑的96.21%，本模型只是用了10%的数据集+简单的网络架构+未调参就可以达到93%的准确率，效果还是不错的😁😁😁

编辑

在白嫖Github项目的时候，麻烦大家动动鼠标给个star，这对我很重要🥰🥰🥰

九、Reference

[1] Yoon Kim. 2014. Convolutional Neural Networks for Sentence Classification. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 1746–1751, Doha, Qatar. Association for Computational Linguistics.

[2] Vaswani, A. , Shazeer, N. , Parmar, N. , Uszkoreit, J. , Jones, L. , & Gomez, A. N. , et al. (2017). Attention is all you need. arXiv.

十、Another question

在这里都是读者私发给我，抑或是在评论区中出现的问题，因此在此进行汇总

Question 1：How to add precision，recall，specificity and f1_scall

在文本分类中一般是只使用Accuracy作为评判标准，因此其他的标准就没有放到开源代码中了，若想实现这些功能，在train()、test()中进行修改代码即可，在这里我以train()函数为例

现放上修改后完整的train()代码

def _train(self, dataloader, criterion, optimizer):
        train_loss, n_correct, n_train = 0, 0, 0
        # Confusion matrix
        TP, TN, FP, FN = 0, 0, 0, 0
        # Turn on the train mode
        self.Mymodel.train()
        for inputs, targets in tqdm(dataloader, disable=self.args.backend, ascii='>='):
            inputs = {k: v.to(self.args.device) for k, v in inputs.items()}
            targets = targets.to(self.args.device)
            predicts = self.Mymodel(inputs)
            loss = criterion(predicts, targets)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            train_loss += loss.item() * targets.size(0)
            n_correct += (torch.argmax(predicts, dim=1) == targets).sum().item()
            n_train += targets.size(0)
            ground_truth = targets
            predictions = torch.argmax(predicts, dim=1)
            TP += torch.logical_and(predictions.bool(), ground_truth.bool()).sum().item()
            FP += torch.logical_and(predictions.bool(), ~ground_truth.bool()).sum().item()
            FN += torch.logical_and(~predictions.bool(), ground_truth.bool()).sum().item()
            TN += torch.logical_and(~predictions.bool(), ~ground_truth.bool()).sum().item()
        precision = TP / (TP + FP)
        recall = TP / (TP + FN)
        specificity = TN / (TN + FP)
        f1_score = 2 * precision * recall / (precision + recall)
        return train_loss / n_train, n_correct / n_train, precision, recall, specificity, f1_score

targets就是真实的标签，那预测结果呢，是predicts吗？当然不是，因为predicts中是预测每条句子的情感类别是positive和negative分别概率是多少，比如一条句子的预测结果是【0.2,0.8】，那么我们需要将该句的判定结果为0.8，也就是下标1，所以torch.argmax(predicts,dim=1)才是真正的预测结果。

有了这两个之后，我们便可以计算混淆矩阵，这里我使用了logical_and和bool()函数的技巧去实现它，而没有直接用各种库函数，目的是为了展示我是如何处理数据的，这样如果大家想要有其他评判标准也可以由此借鉴。

最后计算各个指标，返回即可。

Question 2：Why run so slowly

在config.py，我设置的默认环境是CPU，以及train_batch_size和test_batch_size都设置的比较小，目的是让大家都能先跑起来这个程序，然后根据自己设备资源的情况，来扩大batch_size以及将cpu改成cuda

编辑

Question 3：How to improve the acc on my dataset

可能很多小伙伴在用了自己的数据集后发现准确率可能停在80%，上不去了，其实这是非常正常的情况，该博客的目的就是让大家直接尝试学习最先进的大模型以及Encoder-Decoder结构，这是目前的趋势。

在该框架基础上可以衍生出无数的做法，你尽可尝试不同的网络模块，加些其他技巧，比如当下最前沿的Prompt learning、Contrastive learning、Diffusion model、Knowledge模型等等

当然你也可以尝试最简单的模块，比如Layer Normalization、Batch Normalization、新的激活函数等等

在这里我也展示Layer Normalization的技巧模块

以下取自LSTM的网络部分，大家需要关注的是#Layer Normalization下的两行代码

def forward(self, inputs):
        raw_outputs = self.base_model(**inputs)
        tokens = raw_outputs.last_hidden_state
        lstm_output, _ = self.Lstm(tokens)
        # Layer Normalization
        norm_lstm = nn.LayerNorm([lstm_output.shape[1], lstm_output.shape[2]], eps=1e-8).cuda()
        ln_lstm = norm_lstm(lstm_output)
        outputs = lstm_output[:, -1, :]
        outputs = self.fc(outputs)
        return outputs

【Deep Learning A情感文本分类实战】2023 Pytorch+Bert、Roberta+TextCNN、BiLstm、Lstm等实现IMDB情感文本分类完整项目（项目已开源）