1.数据修改

在前面（NLP01）使用了embedding去实现toy级别的文本情感分类，那么现在我们在这个模型加上LSTM层，观察分类效果。

为了达到更好的效果，对之前的模型做如下修改

1. MAX_LEN = 200
2. 构建Dataset的过程，把数据转化为2分类问题，pos为1，neg为0，都在25000个样本完成是个类别的划分数据量是不够的
3. 在实例化LSTM的时候，使用dropout=0.5，在model.eval()的过程中，dropout自动会为0

1.1 修改模型

total loss, acc: 0.5381448226315635 0.8486507733662924

# -*- coding = utf-8 -*-
# @Time : 2022/10/3 14:27
# @Author : 头发没了还会再长
# @File : model.py
# @Software : PyCharm

import torch
import torch.nn as nn
from lib import ws, max_len
import torch.nn.functional as F
from torch.optim import Adam
from Dataset import get_dataLoader
import lib
import os
import numpy as np

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.embedding = nn.Embedding(len(ws), 100)
        self.lstm = nn.LSTM(input_size=100, hidden_size=lib.hidden_size,num_layers=lib.num_layers, batch_first=True, bidirectional=lib.bidriectional, dropout=lib.dropout)
        self.fc = nn.Linear(lib.hidden_size*2, 2) # 二分类

    def forward(self, input):
        """
        :param input: [natch_size, max_len]
        :return:
        """
        x = self.embedding(input) # 进行embedding操作，形状：[batch_zise, max_len, 100]
        # x:[batch_size, max_len, 2*hidden_size] h_n :[2*2, batch_zise, hidden_size]
        x, (h_n, c_n) = self.lstm(x)
        # 获取两个方向最后一次的output，进行concat
        output_fw = h_n[-2, :, :] # 正向
        output_bw = h_n[-1, :, :] # 反向
        output = torch.cat([output_fw, output_bw], dim=-1) #[batch_size, hidden_size*2]

        # 将三维的x转化为二维 这样才能作为输入
        #x = x.view([-1, max_len*100])
        out = self.fc(output)
        return F.log_softmax(out, dim=-1)

model = MyModel().to(lib.device)

optimizer = Adam(model.parameters())
if os.path.exists("./model/model.pkl"):
    model.load_state_dict(torch.load("./model/model.pkl"))
if os.path.exists("./model/optimizer.pkl"):
    optimizer.load_state_dict(torch.load("./model/optimizer.pkl"))

def train(epoch):
    for idx, (input, target) in enumerate(get_dataLoader(train=True)):
        input = input.to(lib.device)
        target = target.to(lib.device)
        # 梯度归零
        optimizer.zero_grad()
        output = model(input)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        print(epoch, idx, loss.item())

        if idx%100 == 0:
            torch.save(model.state_dict(), "./model/model.pkl")
            torch.save(optimizer.state_dict(), "./model/optimizer.pkl")
def eval():
    loss_lsit = []
    acc_list = []
    for idx, (input, target) in enumerate(get_dataLoader(train=False, batch_size=lib.test_batch_size)):
        input = input.to(lib.device)
        target = target.to(lib.device)
        with torch.no_grad():
            output = model(input)
            cur_loss = F.nll_loss(output, target)
            loss_lsit.append(cur_loss.cpu().item())
            pred = output.max(dim=-1)[-1] #output是一个2行n列的 在行方向上找到最大值看是否和真实值一样
            cur_acc = pred.eq(target).float().mean()
            acc_list.append(cur_acc.cpu().item())
    print("total loss, acc:", np.mean(loss_lsit), np.mean(acc_list))

if __name__ == '__main__':
    # for i in range(10):
    #     train(i)
    eval()