李宏毅机器学习2020春季作业三hw4

参考文章：
本文的原理及部分内容参考于大佬： https://blog.csdn.net/iteapoy/article/details/105931612
老师的标准参考答案，需（VPN）： https://colab.research.google.com/drive/16d1Xox0OW-VNuxDn1pvy2UXFIPfieCb9#scrollTo=CfGKiOitk5ob
推荐阅读（从word embedding到bert发展史）： https://zhuanlan.zhihu.com/p/49271699

作业介绍

题目要求：本次作业所用到的数据为Twitter上的推文，训练数据会被打上正面或负面的标签（正面标1，负面标0）通过循环神经网络（Recurrent Neural Networks, RNN）对句子进行情感分类，给定一句句子，判断这句句子是正面还是负面的。（也就是文本分类）

所需的数据资料点击此链接免费下载https://download.csdn.net/download/qq_46126258/20061245，解压后里面分別是 training_label.txt、training_nolabel.txt、testing_data.txt，将这三个文件放在代码的同级目录下。

分析数据：
①training_label.txt，包含label和文本的数据（共200000条数据）

②training_nolabel.txt，只包含文本数据（共1178614条数据）

③testing_data.txt，包含需要进行预测情感的语句，每个语句都有id来做区分（共200000条数据）

1、util

第一步创建utils.py，用来定义三个常用的函数，分别为：
①load_training_data(path='training_label.txt')（读取training data）②load_testing_data(path='testing_data.txt')（读取testing data）
③evaluation(outputs, labels)（评估测试集预测结果）

补充下此处python读取文件、分词的相关知识点：
下面是我拿testing_data.txt的前三组数据存入test.txt后在jupter上做的测试，非实际代码部分，理解即可。（前面少了一句with open('test.txt', 'r') as f:没有截全）

具体步骤解析：

（1） lines = f.readlines()： 此时每行数据都被视为一个字符串且末尾以\n结束，文件内容按照每行为一个字符串的形式存到列表lines里。
（2） X0=[line for line in lines[1:]]：去掉表头后依次遍历lines的每个元素（字符串）
（3）X1=[line.strip('\n').split(",")[1:] for line in lines[1:]]：在上一步遍历的过程中的每个字符串(每次遍历的对象)做如下操作。将该字符串以换行符\n为分割符号返回一个列表，列表内的字符串以逗号",“为分隔符拆分为多个字符串。【这么做是因为想要去除testing data中的id，只保留文字部分，每行的记录格式为id,xxx，所以以逗号”,"为分隔符。值得注意的是英文的逗号,后面还有个空格】
（4）X2=[line.strip('\n').split(",")[1:] for line in lines[1:]]：在上一步的基础上从第1维开始取，舍掉数字部分
（5）X3 = ["".join(line.strip('\n').split(",")[1:]).strip() for line in lines[1:]]：依次上一步中得到的多维列表时，每次遍历的对象都是一个列表，其中有多个字符串（因为第(3)步被逗号分割了），我们需要将这多个字符串拼接起来，根据空格来所有字符串进行拆分（此时每个字符串表示单词）然后再用空格连接每个单词，这样就还原回带空格的一句话了。
（6）X4 = [sen.split(' ') for sen in X3]：将完整的一句话以空格为分割，拆分为单词。

①读取training data（当读取training_label.txt时需要读label，读training_nolabel.txt时不需要）

import torch
import numpy as np
import pandas as pd
import torch.optim as optim
import torch.nn.functional as F


def load_training_data(path='training_label.txt'):
    t = 0
    # 读取training data（training_label.txt或training_nolabel.txt），默认读带label的
    if 'training_label' in path:
        with open(path, 'r') as f:
            lines = f.readlines()
            lines = [line.strip('\n').split(' ') for line in lines]

        x = [line[2:] for line in lines]
        y = [line[0] for line in lines]

        return x, y
    else:  # 读取training_nolabel.txt
        with open(path, 'r') as f:
            lines = f.readlines()
            x = [line.strip('\n').split(' ') for line in lines]
        return x

②读取testing data

def load_testing_data(path='testing_data.txt'):
    # 读取testing data
    with open(path, 'r') as f:
        lines = f.readlines()
        X = ["".join(line.strip('\n').split(",")[1:]).strip() for line in lines[1:]]
        print(X)
        X = [sen.split(' ') for sen in X]
    return X

③定义评估函数

def evaluation(outputs, labels):
    # outputs => probability (float)
    outputs[outputs >= 0.5] = 1  # >=0.5 为正面
    outputs[outputs < 0.5] = 0  # <0.5 为负面
    correct = torch.sum(torch.eq(outputs, labels)).item()
    return correct

torch.eq(outputs, labels))：具体参考链接

2、Train Word to Vector

word2vec又叫word to vector是一个将单词转换成向量形式的工具。其本身是一个简单神经网络，作用是根据输入的上下文来预测的空缺的句子。此处直接使用了gensim库中的word2vec模型来训练，我们所需要的“词向量”便作为副产物直接存储在模型中，将处理好的word2vec模型存到w2v_all.model目录下方便下一步读取。

创建w2v.py文件，其中包含2个函数：
①train_word2vec(x)（训练 word to vector 的 word embedding）
②初始化train_x, y、train_x_no_label、test_x，并将其转为词向量。

补充知识点： gensim.models.word2vec详细使用方法：参考链接

python model = word2vec.Word2Vec(x, size=250, window=5,min_count=5, workers=12, iter=10, sg=1)
（1）sentences: 我们要分析的语料，可以是一个列表，或者从文件中遍历读出。对于大语料集，建议使用BrownCorpus,Text8Corpus或lineSentence构建。
（2） size: 词向量的维度，默认值是100。这个维度的取值一般与我们的语料的大小相关，视语料库的大小而定。
（3）window： 即词向量上下文最大距离，skip-gram和cbow算法是基于滑动窗口来做预测。默认值为5。在实际使用中，可以根据实际的需求来动态调整这个window的大小。对于一般的语料这个值推荐在[5,10]之间。
（4）min_count： 可以对字典做截断. 词频少于min_count次数的单词会被丢弃掉, 默认值为5。
（5）workers： 用于控制训练的并行数。
（6）iter: 随机梯度下降法中迭代的最大次数，默认是5。对于大语料，可以增大这个值。
（7）sg: 即我们的word2vec两个模型的选择了。如果是0，
则是CBOW模型，是1则是Skip-Gram模型，默认是0即CBOW模型。

# 這個 block 是用來訓練 word to vector 的 word embedding
from gensim.models import word2vec
from utils import load_training_data, load_testing_data
import os

def train_word2vec(x):
    # 训练 word to vector 的 word embedding
    model = word2vec.Word2Vec(x, size=250, window=5, min_count=5, workers=12, iter=10, sg=1)
    return model


if __name__ == "__main__":
    path_prefix = './'
    print("loading training data ...")
    train_x, y = load_training_data('training_label.txt')
    train_x_no_label = load_training_data('training_nolabel.txt')

    print("loading testing data ...")
    test_x = load_testing_data('testing_data.txt')

    model = train_word2vec(train_x + train_x_no_label + test_x) # w2v_all
    # model = train_word2vec(train_x + test_x) # w2v

    print("saving model ...")
    # model.save(os.path.join(path_prefix, 'model/w2v_all.model'))
    # model.save('w2v.model')
    model.save(os.path.join(path_prefix, 'w2v_all.model'))
    print('finished')

3、Data Preprocess(数据预处理)

创建process.py文件，内部定义一个预处理的类Preprocess()，此处目的是从训练好的word2vec模型中提取出长度相同的词向量表示，并创建字典 其主要变量的含义如下：

• w2v_path：word2vec的存储路径
• sentences：句子
• sen_len：句子的固定长度 （超过则截取丢掉）
• idx2word：是一个列表，比如：self.idx2word[1] = ‘he’（根据下标找单词）
• word2idx：是一个字典，记录单词在idx2word中的下标，比如：self.word2idx[‘he’] = 1 （根据单词找下标）
• embedding_matrix：是一个列表，按句子顺序记录词嵌入的向量，比如：self.embedding_matrix[1] = ‘he’ vector
• sentence_list：存储句子的下标
  对于句子，我们就可以通过 embedding_matrix[word2idx[‘he’] ] 找到 ‘he’ 的词嵌入向量。

以下属于个人对该步骤的理解： 此时上一步已经将每个单词的embedding训练好了，这里需要对其进一步加工，如统一每句话的单词数量（少了添加“PAD”，多了截取不要），将处理好的embedding存入embedding_matrix。idx2word与word2idx是作为查询字典配合使用，在训练时字典word2idx以word为关键字存储其下标idx，再用列表idx2word绑定该下标的存储数据为word，这样在测试时先找某单词的vector(即上述的word)是否存在于字典中，如果存在将该单词在字典word2idx的下标存储到sentence_list中，否则将字典word2idx中“UNK”的下标存储到sentence_list中，这样通过记录字典的下标就得到了一句话对应的定长vector表示。

所以对Preprocess()的调用分为两步：
训练模型：preprocess = Preprocess(train_x, sen_len, w2v_path=w2v_path)
测试模型：preprocess = Preprocess(test_x, sen_len, w2v_path=w2v_path)

补充知识点：
（1）model.save、Word2Vec.load：分别表示存储与读取。更多参考链接后半段
（2）torch.nn.init.uniform_(vector)：初始化向量vector其内部数值服从均匀分布。
更多初始化方式参考链接
（3）torch.cat([self.embedding_matrix, vector], 0)：将两个张量（tensor）按行拼接在一起。具体参考链接
（4）assert：检查异常，更多用法查看链接
（5）这里除了出现在 train_x 和 test_x 中的单词外，还需要两个单词（或者叫特殊符号）：
“PAD”：Padding的缩写，把所有句子都变成一样长度时，需要用"PAD"补上空白符
“UNK”：Unknown的缩写，凡是在 train_x 和 test_x 中没有出现过的单词，都用"UNK"来表示

创建w2v.py

import torch
from gensim.models import Word2Vec


class Preprocess():
    def __init__(self, sentences, sen_len, w2v_path):
        self.w2v_path = w2v_path
        self.sentences = sentences
        self.sen_len = sen_len
        self.idx2word = []
        self.word2idx = {}
        self.embedding_matrix = []

    def get_w2v_model(self):
        # 把之前训练好的 word to vec 模型读进来，服务于make_embedding
        self.embedding = Word2Vec.load(self.w2v_path)
        self.embedding_dim = self.embedding.vector_size  # 记录embedding向量的维度

    def add_embedding(self, word):
        # 把一个随机生成的表征向量 vector 作为"" 或 "" 的嵌入，加进 embedding，服务于make_embedding
        vector = torch.empty(1, self.embedding_dim)  # 初始化一个全为1的向量
        torch.nn.init.uniform_(vector)  # 而后初始化为均匀分布
        self.word2idx[word] = len(self.word2idx)  # key=word value=len
        self.idx2word.append(word)  # 列表中下标为len的字符串为word
        self.embedding_matrix = torch.cat([self.embedding_matrix, vector], 0)

    def make_embedding(self, load=True):
        # 制作 word2vector 的 list
        print("Get embedding ...")
        # 取得训练好的 Word2vec word embedding
        if load:
            print("loading word to vec model ...")
            self.get_w2v_model()
        else:
            raise NotImplementedError
        # 制作一个 word2idx 的 dictionary
        # 制作一个 idx2word 的 list
        # 制作 word2vector 的 list
        for i, word in enumerate(self.embedding.wv.vocab):
            print('get words #{}'.format(i + 1), end='\r')
            self.word2idx[word] = len(self.word2idx)
            self.idx2word.append(word)
            self.embedding_matrix.append(self.embedding[word])

        print('')
        self.embedding_matrix = torch.tensor(self.embedding_matrix)
        # 将 "" 、"" 加进 embedding
        self.add_embedding("")
        self.add_embedding("")
        print("total words: {}".format(len(self.embedding_matrix)))
        return self.embedding_matrix

    def pad_sequence(self, sentence):
        # 将每个句子变成一样的长度，服务于sentence_word2idx
        if len(sentence) > self.sen_len:
            sentence = sentence[:self.sen_len]
        else:
            pad_len = self.sen_len - len(sentence)
            for _ in range(pad_len):
                sentence.append(self.word2idx[""])
        assert len(sentence) == self.sen_len  # 检查添加padding后、截取后长度是否准确
        return sentence

    def sentence_word2idx(self):
        # 利用word2idx[]把句子里面的字转成对应的index
        sentence_list = []  # 存储最终结果
        for i, sen in enumerate(self.sentences):
            print('sentence count #{}'.format(i + 1), end='\r')
            sentence_idx = []
            # 按顺序读取
            for word in sen:
                if (word in self.word2idx.keys()):  # 若该词是字典word2idx的key
                    sentence_idx.append(self.word2idx[word])  # 则将其index加入列表sentence_idx中
                else:  # 否则将unknow的index加入
                    sentence_idx.append(self.word2idx[""])
            # 将每句转为一样的长度
            sentence_idx = self.pad_sequence(sentence_idx)
            sentence_list.append(sentence_idx)
        return torch.LongTensor(sentence_list)

    def labels_to_tensor(self, y):
        # 把 labels 转为 tensor
        y = [int(label) for label in y]
        return torch.LongTensor(y)

4、Dataset（创建该类方便使用dataloader）

在 Pytorch 中，我们可以利用 torch.utils.data 的 Dataset 及 DataLoader 来"包装" data，使后续的 training 和 testing 更方便。使用原因可参考之前的文章

Dataset 需要 overload 两个函数：len 及 getitem

len 必须要传回 dataset 的大小
getitem 则定义了当函数利用 [ ] 取值时，dataset 应该要怎么传回数据。
实际上，在我们的代码中并不会直接使用到这两个函数，但是当 DataLoader 在 enumerate Dataset 时会使用到，如果没有这样做，程序运行阶段会报错。

# 改写 dataset 所需要的 '__init__', '__getitem__', '__len__'
import torch
from torch.utils import data

class TwitterDataset(data.Dataset):
    """
    Expected data shape like:(data_num, data_len)
    Data can be a list of numpy array or a list of lists
    input data shape : (data_num, seq_len, feature_dim)
    __len__ will return the number of data
    """

    def __init__(self, X, y):
        self.data = X
        self.label = y

    def __getitem__(self, idx):
        if self.label is None: return self.data[idx]
        return self.data[idx], self.label[idx]

    def __len__(self):
        return len(self.data)

5、model

创建model.py，定义类LSTM_Net该类继承自nn.Module。具体步骤：把句子的embedding丢到LSTM后变成一个输出向量，再把这个输出丢到分类器classifier中，进行二元分类。
init函数的参数如下：

• embedding：词向量
• embedding_dim：= embedding.size(1)即属性维度
• hidden_dim：隐藏层的维度
• num_layers：隐藏层的个数
• dropout=0.5：dropout率
• fix_embedding=True：是否固定word embedding层，下游NLP任务在使用Word Embedding的时候有两种做法，一种是Frozen，就是Word Embedding那层网络参数固定不动；另外一种是Fine-Tuning，就是Word Embedding这层参数使用新的训练集合训练也需要跟着训练过程更新掉（意味着此时该句子的embedding会被更新）。

补充知识点：

（1）torch.nn.Embedding 模块可以看做一个字典，字典中每个索引对应一个词和词的embedding形式。利用这个模块，可以给词做embedding的初始化操作。更多请参考文章1、参考文章2
torch.nn.Embedding(embedding.size(0),embedding.size(1))：embedding.size(0)=行数，表示num_embeddings（几个embedding单词）, embedding.size(1)=列数，表示embedding_dim（每个词对应的表示维度），这里使用的目的是初始化训练时的句子的embedding。
（2）torch.nn.Parameter(embedding)：对embedding的weight进行初始化
（3）torch.nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True) :现成的LSTM网络，只需设置参数即可得到结果，其参数如下：
input_size(此处的embedding_dim) ：输入数据的特征维数。
hidden_size(hidden_dim)：LSTM中隐层的维度。
num_layers：循环神经网络的层数。
batch_first：通常我们输入的数据shape=(batch_size,seq_length,embedding_dim),而batch_first默认是False,所以我们的输入数据最好送进LSTM之前将batch_size与seq_length这两个维度调换。
更多参数的使用参考文章
（4）nn.Sequential(nn.Dropout(dropout),nn.Linear(hidden_dim, 1),nn.Sigmoid())：nn.Sequential()可以将一系列的操作打包，这些操作可以包括Conv2d()、ReLU()、Maxpool2d()等，打包后方便调用。此处定义了一个简单的一层线性分类器。

import torch
from torch import nn


class LSTM_Net(nn.Module):
    def __init__(self, embedding, embedding_dim, hidden_dim, num_layers, dropout=0.5, fix_embedding=True):
        super(LSTM_Net, self).__init__()
        # 制作 embedding layer
        self.embedding = torch.nn.Embedding(embedding.size(0), embedding.size(1))  # 设置放入模型的embedding维度
        self.embedding.weight = torch.nn.Parameter(embedding)  # 初始化embedding的weight
        # 是否将 embedding 固定住，如果 fix_embedding 为 False，在训练过程中，embedding 也会跟着被训练
        self.embedding.weight.requires_grad = False if fix_embedding else True
        self.embedding_dim = embedding.size(1)
        self.hidden_dim = hidden_dim
        self.num_layers = num_layers
        self.dropout = dropout
        # 丢入LSTM进行训练
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True)
        # 丢入分类器（一层）
        self.classifier = nn.Sequential(nn.Dropout(dropout),
                                        nn.Linear(hidden_dim, 1),
                                        nn.Sigmoid())

    def forward(self, inputs):
        inputs = self.embedding(inputs)
        x, _ = self.lstm(inputs, None)
        # x 的 dimension (batch, seq_len, hidden_size)
        # 取用 LSTM 最后一层的 hidden state 丢入分类器
        x = x[:, -1, :]
        x = self.classifier(x)
        return x

6、train

创建train_own.py，此部分使用之前定义的函数及类来训练模型，将 training 训练过程和 validation 的验证过程封装成函数（具体步骤和之前写的Pytorch训练模型框架基本类似）

import torch
from torch import nn
import torch.optim as optim
from utils import evaluation


def training(batch_size, n_epoch, lr, model_dir, train, valid, model, device):
    # 输出模型总的参数数量、可训练的参数数量
    total = sum(p.numel() for p in model.parameters())
    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
    print('\nstart training, parameter total:{}, trainable:{}\n'.format(total, trainable))

    criterion = nn.BCELoss()  # 定义损失函数为二元交叉熵损失 binary cross entropy loss
    t_batch = len(train)  # training 数据的batch size大小
    v_batch = len(valid)  # validation 数据的batch size大小
    optimizer = optim.Adam(model.parameters(), lr=lr)  # optimizer用Adam，设置适当的学习率lr
    total_loss, total_acc, best_acc = 0, 0, 0

    model.train()  # 將 model 的模式设为 train 可以更新 model 的参数
    for epoch in range(n_epoch):
        total_loss, total_acc = 0, 0
        for i, (inputs, labels) in enumerate(train):
            inputs = inputs.to(device, dtype=torch.long)  # 因为 device 为 "cuda"，将 inputs 转成 torch.cuda.LongTensor
            labels = labels.to(device,  # 因为 device 为 "cuda"，将 labels 转成 torch.cuda.FloatTensor，criterion需要float
                               dtype=torch.float)
            optimizer.zero_grad()
            outputs = model(inputs)
            outputs = outputs.squeeze()  # 去掉最外面的 dimension，好让 outputs 可以丢进 criterion()
            loss = criterion(outputs, labels)  # 计算此时的 training loss
            loss.backward()
            optimizer.step()
            correct = evaluation(outputs, labels)  # 计算此时training的 training accuracy
            total_acc += (correct / batch_size)
            total_loss += loss.item()
            print('[ Epoch{}: {}/{} ] loss:{:.3f} acc:{:.3f} '.format(
                epoch + 1, i + 1, t_batch, loss.item(), correct * 100 / batch_size), end='\r')
        print('\nTrain | Loss:{:.5f} Acc: {:.3f}'.format(total_loss / t_batch, total_acc / t_batch * 100))

        # 做validation
        model.eval()  # 将 model 的模式设为 eval，这样 model 的参数就会被固定住
        with torch.no_grad():
            total_loss, total_acc = 0, 0
            for i, (inputs, labels) in enumerate(valid):
                inputs = inputs.to(device, dtype=torch.long)
                labels = labels.to(device,
                                   dtype=torch.float)
                outputs = model(inputs)
                outputs = outputs.squeeze()
                loss = criterion(outputs, labels)  # 计算此时的 validation loss
                correct = evaluation(outputs, labels)  # 计算此时training的 validation accuracy
                total_acc += (correct / batch_size)
                total_loss += loss.item()

            print("Valid | Loss:{:.5f} Acc: {:.3f} ".format(total_loss / v_batch, total_acc / v_batch * 100))
            if total_acc > best_acc:
                # 如果 validation 的结果优于之前所有的結果，就把当下的模型保存下来，用于之后的testing
                best_acc = total_acc
                # torch.save(model, "{}/val_acc_{:.3f}.model".format(model_dir,total_acc/v_batch*100))
                torch.save(model, "{}/ckpt.model".format(model_dir))
                print('saving model with acc {:.3f}'.format(total_acc / v_batch * 100))
        print('-----------------------------------------------')
        model.train()  #将 model 的模式 设为 train（刚刚转为了eval）

7、test

创建test_own.py，将 testing 封装成函数

（1） outputs.squeeze()：移除数组中维度为1的维度。更多实例详见链接

# 這個 block 用來對 testing_data.txt 做預測
import torch


def testing(batch_size, test_loader, model, device):
    model.eval()
    ret_output = []
    with torch.no_grad():
        for i, inputs in enumerate(test_loader):
            inputs = inputs.to(device, dtype=torch.long)  # 转为tensor数据
            outputs = model(inputs)  # 放入模型得到分类值
            outputs = outputs.squeeze()  # 将维度为1的去掉
            outputs[outputs >= 0.5] = 1  # >=0.5 为正面
            outputs[outputs < 0.5] = 0  # <=0.5 为负面
            print("**********")
            print(outputs.shape)
            print("**********")
            ret_output += outputs.int().tolist()  # 转为列表

    return ret_output

8、main函数

先运行w2v.py得到w2v_all.txt文件（会运行很久），然后运行main函数

# main.py
import os
import torch
import pandas as pd

from utils import load_training_data, load_testing_data
from preprocess import Preprocess
from model import LSTM_Net
from data import TwitterDataset
from train_own import training
from test_own import testing


# 通过 torch.cuda.is_available() 的值判断是否可以使用 GPU ，如果可以的话 device 就设为 "cuda"，没有的话就设为 "cpu"
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 定义句子长度、要不要固定 embedding、batch 大小、要训练几个 epoch、 学习率的值、 w2v的路径
path_prefix = './'  # 路径前缀
train_with_label = os.path.join(path_prefix, 'training_label.txt')
train_no_label = os.path.join(path_prefix, 'training_nolabel.txt')
testing_data = os.path.join(path_prefix, 'testing_data.txt')
w2v_path = os.path.join(path_prefix, 'w2v_all.model')  # 處理 word to vec model 的路徑

# 定义句子长度、要不要固定 embedding、batch 大小、要训练几个 epoch、 学习率的值、
sen_len = 20
fix_embedding = True  # fix embedding during training
batch_size = 128
epoch = 5
lr = 0.001
# model_dir = os.path.join(path_prefix, 'model/') # model directory for checkpoint model
model_dir = path_prefix  # model directory for checkpoint model

print("loading data ...")  # 读取 'training_label.txt'  'training_nolabel.txt'
train_x, y = load_training_data(train_with_label)
train_x_no_label = load_training_data(train_no_label)

# 对 input 跟 labels 做预处理
preprocess = Preprocess(train_x, sen_len, w2v_path=w2v_path)  # 传入实参
embedding = preprocess.make_embedding(load=True)  # 得到每句话的embedding（规范化长度）
train_x = preprocess.sentence_word2idx()  # 得到已有单词的字典
y = preprocess.labels_to_tensor(y)  # 将training data的y转为tensor数据

# 实例化一个model对象，传入实参
model = LSTM_Net(embedding, embedding_dim=250, hidden_dim=150, num_layers=1, dropout=0.5, fix_embedding=fix_embedding)
model = model.to(device)  # device为 "cuda"，model 使用 GPU 来训练（inputs 也需要是 cuda tensor）

# 把 data 分为 training data 和 validation data（将一部分 training data 作为 validation data）
X_train, X_val, y_train, y_val = train_x[:180000], train_x[180000:], y[:180000], y[180000:]

# 把分好的 data 做成 dataset 供 dataloader 取用
train_dataset = TwitterDataset(X=X_train, y=y_train)
val_dataset = TwitterDataset(X=X_val, y=y_val)

# 把 data 转成 batch of tensors
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True,
                                           num_workers=8)  # 并行数量

val_loader = torch.utils.data.DataLoader(dataset=val_dataset,
                                         batch_size=batch_size,
                                         shuffle=False,
                                         num_workers=8)

# 用训练集、测试集同时训练
training(batch_size, epoch, lr, model_dir, train_loader, val_loader, model, device)

# 上传 testing data ，进行预处理得到句子的embedding，转为 Dataset 供 dataloader 取用
print("loading testing data ...")
test_x = load_testing_data(testing_data)
preprocess = Preprocess(test_x, sen_len, w2v_path=w2v_path)
embedding = preprocess.make_embedding(load=True)
test_x = preprocess.sentence_word2idx()
test_dataset = TwitterDataset(X=test_x, y=None)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size,
                                          shuffle=False,
                                          num_workers=8)
# 上传训练好的模型，准备使用
print('\nload model ...')
model = torch.load(os.path.join(model_dir, 'ckpt.model'))
outputs = testing(batch_size, test_loader, model, device)

# 结果保存到 csv 文件供上传 Kaggle
tmp = pd.DataFrame({"id": [str(i) for i in range(len(test_x))], "label": outputs})
print("save csv ...")
tmp.to_csv(os.path.join(path_prefix, 'predict.csv'), index=False)
print("Finish Predicting")

输出：

loading data ...
Get embedding ...
loading word to vec model ...
get words #55777
total words: 55779

start training, parameter total:14186101, trainable:241351

[ Epoch1: 1407/1407 ] loss:0.521 acc:19.531 
Train | Loss:0.49252 Acc: 75.305
Valid | Loss:0.44846 Acc: 78.747 
saving model with acc 78.747
-----------------------------------------------
[ Epoch2: 1407/1407 ] loss:0.462 acc:17.969 
Train | Loss:0.43654 Acc: 79.498
Valid | Loss:0.43550 Acc: 79.339 
saving model with acc 79.339
-----------------------------------------------
[ Epoch3: 1407/1407 ] loss:0.420 acc:20.312 
Train | Loss:0.41999 Acc: 80.511
Valid | Loss:0.42184 Acc: 80.270 
saving model with acc 80.270
-----------------------------------------------
[ Epoch4: 1407/1407 ] loss:0.308 acc:21.875 
Train | Loss:0.40620 Acc: 81.284
Valid | Loss:0.41996 Acc: 80.250 
-----------------------------------------------
[ Epoch5: 1407/1407 ] loss:0.378 acc:22.656 
Train | Loss:0.39340 Acc: 82.011
Valid | Loss:0.41503 Acc: 80.543 
saving model with acc 80.543
-----------------------------------------------
loading testing data ...
Get embedding ...
loading word to vec model ...
get words #55777
total words: 55779

load model ...
save csv ...
Finish Predicting

Process finished with exit code 0

在predict.csv中有id对应的预测label