李宏毅机器学习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, ytrain_x_no_labeltest_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.saveWord2Vec.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 作为"<PAD>" 或 "<UNK>" 的嵌入,加进 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)
        # 将 "<PAD>" 、"<UNK>" 加进 embedding
        self.add_embedding("<PAD>")
        self.add_embedding("<UNK>")
        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["<PAD>"])
        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["<UNK>"])
            # 将每句转为一样的长度
            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 两个函数:lengetitem

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
在这里插入图片描述

  • 2
    点赞
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值