NLP-Beginner:自然语言处理入门练习----task 2基于机器学习的文本分类

数据集:http://链接:https://pan.baidu.com/s/1UIrk148uRGWKQBBQp-Q4RQ 提取码:o13v

上方为glove数据集。

任务:

1.熟悉Pytorch,用Pytorch重写《任务一》,实现CNN、RNN的文本分类

2.word embedding 的方式初始化

3.随机embedding的初始化方式

4.用glove 预训练的embedding进行初始化

 GloVe: Global Vectors for Word Representation

一、知识点:

1.word embedding(词嵌入):词嵌入模型即是把每一个词映射到一个高维空间里,每一个词代表着一个高维空间的向量词嵌入实际上是一类技术,单个词在预定义的向量空间中被表示为实数向量,每个单词都映射到一个向量。举个例子,比如在一个文本中包含“猫”“狗”“爱情”等若干单词,而这若干单词映射到向量空间中,“猫”对应的向量为(0.1 0.2 0.3),“狗”对应的向量为(0.2 0.2 0.4),“爱情”对应的映射为(-0.4 -0.5 -0.2)(本数据仅为示意)。像这种将文本X{x1,x2,x3,x4,x5……xn}映射到多维向量空间Y{y1,y2,y3,y4,y5……yn },这个映射的过程就叫做词嵌入。通过词嵌入这种方式将单词转变为词向量,机器便可对单词进行计算,通过计算不同词向量之间夹角余弦值cos而得出单词之间的相似性。

词嵌入模型的初始化:

(1)随机初始化:给定一个维度d,对于每一个词,随机生成一个d维的向量。这种初始方式非常简单,但是相对可能会产生较劣的初值,也没有一个良好的解释性。

(2)预训练模型初始化(Glove):拿别人已经训练好的模型作为初值,初始化时间会比较长,因为要从别人的词库里面找,但是这种初值无疑要比随机初始化好得多。

特征表示:给定每个词的词向量,可以把一个句子量化成一个ID列表,再变成特征,也就是矩阵,得到句子的特征矩阵X后,便可以把它放到神经网络中。

2.CNN/RNN

  1. CNN卷积神经网络:一般有3-4层,分别是卷积层,激活层,池化层,全连接层,具有局部连接,权重共享,汇聚等特性的深层前馈神经网络,这里的激活参数选择了ReLU函数,ReLu(x)=max(x,0)池化层相当于是对特征矩阵/向量提取出一些有用的信息,从而减少特征的规模,不仅减少了计算量,也能去除冗余特征。
  2. RNN循环神经网络:一般有2-3层,分别是隐藏层,激活曾,全连接层,具有短期记忆能力的神经网络。隐藏层的目的是为了实现记忆功能。

在CNN中,是直接对特征矩阵X进行操作,而在RNN中,是逐个对xi进行操作。

整个流程:句子x通过word embedding得出特征矩阵X在通过神经网络得到类别概率向量p。

3.Dropout(丢弃法)

Dropout (丢弃法) 是指在深度网络的训练中,以一定的概率随机地“临时丢弃”一部分神经元节点。 具体来讲,Dropout 作用于每份小批量训练数据,由于其随机丢弃部分神经元的机制,相当于每次迭代都在训练不同结构的神经网络。简单来讲,就是为了防止模型过拟合,且Dropout层在模型测试时不会有任何影响

二、实验数据设置

样本个数:约150000;

训练集:测试集: 7:3

alpha:10-3

lh,d:50

ll:最长句子的单词数目

Batch大小:500

三、代码

1.main.py

# -*- coding: GBK -*-
# -*- coding: UTF-8 -*-
# coding=gbk
import csv
import random
from feature import Random_embedding,Glove_embedding
from comparison_plot import NN_embedding_plot
# 数据读入
with open('train.tsv') as f :
    tsvreader = csv.reader(f,delimiter='\t')
    temp = list(tsvreader)

with open('glove.6B.50d.txt','rb') as f:  # glove embedding
    lines = f.readlines()

# 用Glove创建词典
trained_dict = dict()
n = len(lines)  # lines的长度
for i in range(n):  # 遍历
    line = lines[i].split()  # split分割  upper大写
    trained_dict[line[0].decode('utf-8').upper()] = [float(line[j]) for j in range(1,51)]

# 初始化
iter_times = 50  # 做50个epoch
alpha = 0.001  # 学习率

# 程序开始
data = temp[1:]
batch_size = 500  # 批大小

# 随机初始化
random.seed(2021)  # 随机种子
random_embedding = Random_embedding(data=data )  # 调用feature
random_embedding.get_words()  # 找到所有单词,并标记ID
random_embedding.get_id()  # 找到每个句子拥有的单词ID

# 预训练模型初始化
random.seed(2021)
glove_embedding = Glove_embedding(data=data,trained_dict=trained_dict)
glove_embedding.get_words()  # 找到所有单词并标记ID
glove_embedding.get_id()  # 找到每个句子拥有的单词ID

NN_embedding_plot(random_embedding,glove_embedding,alpha,batch_size,iter_times)

2.feature.py

# -*- coding: GBK -*-
# -*- coding: UTF-8 -*-
# coding=gbk
# 特征提取
import random
from torch.utils.data import Dataset,DataLoader
from torch.nn.utils.rnn import pad_sequence
import torch

# 将数据按照一定的比例分割为训练集和测试集
def data_split(data,test_rate=0.3):
    train = list()
    test = list()
    for datum in data:
        if random.random() > test_rate:
            train.append(datum)
        else:
            test.append(datum)
    return train,test


# 随机初始化
class Random_embedding():
    def __init__(self,data,test_rate=0.3):
        self.dict_words = dict()   # 单词->ID的映射
        data.sort(key=lambda x:len(x[2].split())) # 按照句子长度排序,短着在前,这样做可以避免后面一个batch内句子长短不一,导致padding过度
        self.data = data
        self.len_words = 0  # 单词数目(包括padding的ID:0)
        self.train,self.test = data_split(data,test_rate=test_rate) # 训练集测试集划分
        self.train_y = [int(term[3]) for term in self.train]  # 训练集类别
        self.test_y = [int(term[3]) for term in self.test] # 测试集类别
        self.train_matrix = list()  # 训练集的单词ID列表,叠成一个矩阵
        self.test_matrix = list()  # 测试集的单词ID列表,叠成一个矩阵
        self.longest = 0  # 记录最长的单词

    def get_words(self):
        for term in self.data:
            s = term[2]  # 取出句子
            s = s.upper()  # 将其转化为大写,避免识别i和I为不同的两个单词
            words = s.split()
            for word in words:  # 一个一个单词进行寻找
                if word not in self.dict_words:
                    self.dict_words[word] = len(self.dict_words) + 1  # padding是第0个,所以要+1
        self.len_words = len(self.dict_words)  # 单词数目,暂未包括padding的id0

    def get_id(self):
        for term in self.train:  # 训练集
            s = term[2]
            s = s.upper()
            words = s.split()
            item = [self.dict_words[word] for word in words] # 找到id列表(未进行padding)
            self.longest = max(self.longest,len(item))  # 记录最长的单词
            self.train_matrix.append(item)
        for term in self.test:  # 测试集
            s = term[2]
            s = s.upper()
            words = s.split()
            item = [self.dict_words[word] for word in words]  # 找到id列表(未进行padding)
            self.longest = max(self.longest,len(item))
            self.test_matrix.append(item)
        self.len_words += 1  # 单词数目,包含padding的id0


class Glove_embedding():
    def __init__(self,data,trained_dict,test_rate=0.3):
        self.dict_words = dict()  # 单词->ID的映射
        self.trained_dict = trained_dict  # 记录预训练词向量模型
        data.sort(key = lambda x:len(x[2].split()))  # 按照句子长度排序,短着在前,这样做可以避免后面一个batch内句子长短不一,导致padding过度
        self.data = data
        self.len_words = 0 # 单词数目(包含padding的id0)
        self.train,self.test = data_split(data,test_rate=test_rate)  # 测试集和训练集的划分
        self.train_y = [int(term[3]) for term in self.train]  # 训练集类别
        self.test_y = [int(term[3]) for term in self.test]  # 测试集类别
        self.train_matrix = list()
        self.test_matrix = list()
        self.longest = 0
        self.embedding = list()  # 抽取出用到的,即预训练模型的单词

    def get_words(self):
        self.embedding.append([0] * 50)  # 先加padding的词向量
        for term in self.data:
            s = term[2]  # 取出句子
            s = s.upper()
            words = s.split()
            for word in words:
                if word not in self.dict_words:
                    self.dict_words[word] = len(self.dict_words)+1  # padding是第0个所以要加一
                    if word in self.trained_dict:  # 如果预训练模型中有这个单词,直接记录词向量
                        self.embedding.append(self.trained_dict[word])
                    else:  # 如果预训练模型中没有这个单词,则初始化该词的对应词向量为0向量
                        self.embedding.append([0]*50)
        self.len_words = len(self.dict_words)  # 单词数目(暂未包括padding的id0)

    def get_id(self):
        for term in self.train:  # 训练集
            s = term[2]
            s = s.upper()
            words = s.split()
            item = [self.dict_words[word] for word in words]  # 找到id列表(未进行padding)
            self.longest = max(self.longest,len(item))  # 记录最长的单词
            self.train_matrix.append(item)
        for term in self.test:  # 测试集
            s = term[2]
            s = s.upper()
            words = s.split()
            item = [self.dict_words[word] for word in words]
            self.longest = max(self.longest,len(item))
            self.test_matrix.append(item)
        self.len_words += 1  # 单词数目(暂未包括padding的id0)


# 自定义数据集的结构
class ClsDataset(Dataset):
        def __init__(self,sentence,emotion):
            self.sentence = sentence
            self.emotion = emotion

        def __getitem__(self, item):
            return self.sentence[item],self.emotion[item]

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


# 自定义数据集的内数据返回类型,并进行padding
def collate_fn(batch_data):
    sentence,emotion = zip(*batch_data)
    sentences = [torch.LongTensor(sent) for sent in sentence]  # 把句子变成LongTensor类型
    padded_sents = pad_sequence(sentences,batch_first=True,padding_value=0)  # 自动padding操作
    return torch.LongTensor(padded_sents),torch.LongTensor(emotion)


# 利用dataloader划分batch
def get_batch(x,y,batch_size):
    dataset = ClsDataset(x,y)
    dataloader = DataLoader(dataset,batch_size=batch_size,shuffle=False,drop_last=True,collate_fn=collate_fn)
    return dataloader
    # shuffle是指每个epoch都随机打乱数据再分batch,设置成False,否则之前的顺序会直接打乱
    # drop_last是指不利用最后一个不完整的batch(数据大小不能被batch_size整除)

3.comparison_plot.py

# -*- coding: GBK -*-
# -*- coding: UTF-8 -*-
# coding=gbk

import matplotlib.pyplot
import torch
import torch.nn.functional as F
from torch import optim
from Neural_network import RNN, CNN
from feature import get_batch


def NN_embdding(model, train, test, learning_rate, iter_times):
    # 定义优化器(求参数)
    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
    # 损失函数
    loss_fun = F.cross_entropy
    # 损失值记录
    train_loss_record = list()
    test_loss_record = list()
    long_loss_record = list()
    # 准确率记录
    train_record = list()
    test_record = list()
    long_record = list()
    # torch.autograd.set_detect_anomaly(True)
    # 训练阶段
    for iteration in range(iter_times):
        model.train()  # 重要!!!进入非训练模式
        for i, batch in enumerate(train):
            x, y = batch  # 取一个batch
            # y = y.cuda()
            pred = model(x)  # 计算输出
            optimizer.zero_grad()  # 梯度初始化
            loss = loss_fun(pred, y)  # 损失值计算
            loss.backward()  # 反向传播梯度
            optimizer.step()  # 更新参数

        model.eval()  # 重要!!!进入非训练模式(测试模式)
        # 本轮正确率记录
        train_acc = list()
        test_acc = list()
        long_acc = list()
        length = 20
        # 本轮损失值记录
        train_loss = 0
        test_loss = 0
        long_loss = 0
        for i, batch in enumerate(train):
            x, y = batch  # 取一个batch
            # y = y.cuda()
            pred = model(x)  # 计算输出
            loss = loss_fun(pred, y)  # 损失值计算
            train_loss += loss.item()  # 损失值累加
            _, y_pre = torch.max(pred, -1)
            # 计算本batch准确率
            acc = torch.mean((torch.tensor(y_pre == y, dtype=torch.float)))
            train_acc.append(acc)

        for i, batch in enumerate(test):
            x, y = batch  # 取一个batch
            # y = y.cuda()
            pred = model(x) # 计算输出
            loss = loss_fun(pred, y)  # 损失值计算
            test_loss += loss.item()  # 损失值累加
            _, y_pre = torch.max(pred, -1)
            # 计算本batch准确率
            acc = torch.mean((torch.tensor(y_pre == y, dtype=torch.float)))
            test_acc.append(acc)
            if (len(x[0])) > length:  # 长句子侦测
                long_acc.append(acc)
                long_loss += loss.item()

        trains_acc = sum(train_acc) / len(train_acc)
        tests_acc = sum(test_acc) / len(test_acc)
        longs_acc = sum(long_acc) / len(long_acc)

        train_loss_record.append(train_loss / len(train_acc))
        test_loss_record.append(test_loss / len(test_acc))
        long_loss_record.append(long_loss / len(long_acc))
        train_record.append(trains_acc)
        test_record.append(tests_acc)
        long_record.append(longs_acc)
        print("---------- Iteration", iteration + 1, "----------")
        print("Train loss:", train_loss / len(train_acc))
        print("Test loss:", test_loss / len(test_acc))
        print("Train accuracy:", trains_acc)
        print("Test accuracy:", tests_acc)
        print("Long sentence accuracy:", longs_acc)

    return train_loss_record, test_loss_record, long_loss_record, train_record, test_record, long_record


def NN_embedding_plot(random_embedding, glove_embedding, learning_rate, batch_size, iter_times):
    # 获得训练集和测试集的batch
    train_random = get_batch(random_embedding.train_matrix,
                             random_embedding.train_y, batch_size)
    test_random = get_batch(random_embedding.test_matrix,
                            random_embedding.test_y, batch_size)
    train_glove = get_batch(glove_embedding.train_matrix,
                            glove_embedding.train_y, batch_size)
    test_glove = get_batch(random_embedding.test_matrix,
                           glove_embedding.test_y, batch_size)
    # 模型建立
    torch.manual_seed(2021)
    torch.manual_seed(2021)
    random_rnn = RNN(50, 50, random_embedding.len_words)
    torch.manual_seed(2021)
    torch.manual_seed(2021)
    random_cnn = CNN(50, random_embedding.len_words, random_embedding.longest)
    torch.manual_seed(2021)
    torch.manual_seed(2021)
    glove_rnn = RNN(50, 50, glove_embedding.len_words,
                       weight=torch.tensor(glove_embedding.embedding, dtype=torch.float))
    torch.manual_seed(2021)
    torch.manual_seed(2021)
    glove_cnn = CNN(50, glove_embedding.len_words, glove_embedding.longest,
                       weight=torch.tensor(glove_embedding.embedding, dtype=torch.float))
    # rnn+random
    torch.manual_seed(2021)
    torch.manual_seed(2021)
    trl_ran_rnn, tel_ran_rnn, lol_ran_rnn, tra_ran_rnn, tes_ran_rnn, lon_ran_rnn = \
        NN_embdding(random_rnn, train_random, test_random, learning_rate, iter_times)
    # cnn+random
    torch.manual_seed(2021)
    torch.manual_seed(2021)
    trl_ran_cnn, tel_ran_cnn, lol_ran_cnn, tra_ran_cnn, tes_ran_cnn, lon_ran_cnn = \
        NN_embdding(random_cnn, train_random, test_random, learning_rate, iter_times)
    # rnn+glove
    torch.manual_seed(2021)
    torch.manual_seed(2021)
    trl_glo_rnn, tel_glo_rnn, lol_glo_rnn, tra_glo_rnn, tes_glo_rnn, lon_glo_rnn = \
        NN_embdding(glove_rnn, train_glove, test_glove, learning_rate, iter_times)
    # cnn+glove
    torch.manual_seed(2021)
    torch.manual_seed(2021)
    trl_glo_cnn, tel_glo_cnn, lol_glo_cnn, tra_glo_cnn, tes_glo_cnn, lon_glo_cnn = \
        NN_embdding(glove_cnn, train_glove, test_glove, learning_rate, iter_times)
    # 画图部分
    x = list(range(1, iter_times + 1))
    matplotlib.pyplot.subplot(2, 2, 1)
    matplotlib.pyplot.plot(x, trl_ran_rnn, 'r--', label='RNN+random')
    matplotlib.pyplot.plot(x, trl_ran_cnn, 'g--', label='CNN+random')
    matplotlib.pyplot.plot(x, trl_glo_rnn, 'b--', label='RNN+glove')
    matplotlib.pyplot.plot(x, trl_glo_cnn, 'y--', label='CNN+glove')
    matplotlib.pyplot.legend()
    matplotlib.pyplot.legend(fontsize=10)
    matplotlib.pyplot.title("Train Loss")
    matplotlib.pyplot.xlabel("Iterations")
    matplotlib.pyplot.ylabel("Loss")
    matplotlib.pyplot.subplot(2, 2, 2)
    matplotlib.pyplot.plot(x, tel_ran_rnn, 'r--', label='RNN+random')
    matplotlib.pyplot.plot(x, tel_ran_cnn, 'g--', label='CNN+random')
    matplotlib.pyplot.plot(x, tel_glo_rnn, 'b--', label='RNN+glove')
    matplotlib.pyplot.plot(x, tel_glo_cnn, 'y--', label='CNN+glove')
    matplotlib.pyplot.legend()
    matplotlib.pyplot.legend(fontsize=10)
    matplotlib.pyplot.title("Test Loss")
    matplotlib.pyplot.xlabel("Iterations")
    matplotlib.pyplot.ylabel("Loss")
    matplotlib.pyplot.subplot(2, 2, 3)
    matplotlib.pyplot.plot(x, tra_ran_rnn, 'r--', label='RNN+random')
    matplotlib.pyplot.plot(x, tra_ran_cnn, 'g--', label='CNN+random')
    matplotlib.pyplot.plot(x, tra_glo_rnn, 'b--', label='RNN+glove')
    matplotlib.pyplot.plot(x, tra_glo_cnn, 'y--', label='CNN+glove')
    matplotlib.pyplot.legend()
    matplotlib.pyplot.legend(fontsize=10)
    matplotlib.pyplot.title("Train Accuracy")
    matplotlib.pyplot.xlabel("Iterations")
    matplotlib.pyplot.ylabel("Accuracy")
    matplotlib.pyplot.ylim(0, 1)
    matplotlib.pyplot.subplot(2, 2, 4)
    matplotlib.pyplot.plot(x, tes_ran_rnn, 'r--', label='RNN+random')
    matplotlib.pyplot.plot(x, tes_ran_cnn, 'g--', label='CNN+random')
    matplotlib.pyplot.plot(x, tes_glo_rnn, 'b--', label='RNN+glove')
    matplotlib.pyplot.plot(x, tes_glo_cnn, 'y--', label='CNN+glove')
    matplotlib.pyplot.legend()
    matplotlib.pyplot.legend(fontsize=10)
    matplotlib.pyplot.title("Test Accuracy")
    matplotlib.pyplot.xlabel("Iterations")
    matplotlib.pyplot.ylabel("Accuracy")
    matplotlib.pyplot.ylim(0, 1)
    matplotlib.pyplot.tight_layout()
    fig = matplotlib.pyplot.gcf()
    fig.set_size_inches(8, 8, forward=True)
    matplotlib.pyplot.savefig('main_plot.jpg')
    matplotlib.pyplot.show()
    matplotlib.pyplot.subplot(2, 1, 1)
    matplotlib.pyplot.plot(x, lon_ran_rnn, 'r--', label='RNN+random')
    matplotlib.pyplot.plot(x, lon_ran_cnn, 'g--', label='CNN+random')
    matplotlib.pyplot.plot(x, lon_glo_rnn, 'b--', label='RNN+glove')
    matplotlib.pyplot.plot(x, lon_glo_cnn, 'y--', label='CNN+glove')
    matplotlib.pyplot.legend()
    matplotlib.pyplot.legend(fontsize=10)
    matplotlib.pyplot.title("Long Sentence Accuracy")
    matplotlib.pyplot.xlabel("Iterations")
    matplotlib.pyplot.ylabel("Accuracy")
    matplotlib.pyplot.ylim(0, 1)
    matplotlib.pyplot.subplot(2, 1, 2)
    matplotlib.pyplot.plot(x, lol_ran_rnn, 'r--', label='RNN+random')
    matplotlib.pyplot.plot(x, lol_ran_cnn, 'g--', label='CNN+random')
    matplotlib.pyplot.plot(x, lol_glo_rnn, 'b--', label='RNN+glove')
    matplotlib.pyplot.plot(x, lol_glo_cnn, 'y--', label='CNN+glove')
    matplotlib.pyplot.legend()
    matplotlib.pyplot.legend(fontsize=10)
    matplotlib.pyplot.title("Long Sentence Loss")
    matplotlib.pyplot.xlabel("Iterations")
    matplotlib.pyplot.ylabel("Loss")
    matplotlib.pyplot.tight_layout()
    fig = matplotlib.pyplot.gcf()
    fig.set_size_inches(8, 8, forward=True)
    matplotlib.pyplot.savefig('sub_plot.jpg')
    matplotlib.pyplot.show()

4.Neural_network.py

# -*- coding: GBK -*-
# -*- coding: UTF-8 -*-
# coding=gbk
import torch
import torch.nn as nn
import torch.nn.functional as F


# 设计RNN网络
class RNN(nn.Module):
    def __init__(self,len_feature,len_hidden,len_words,typenum=5,weight=None,layer=1,nonlinearity='tanh',batch_first=True,drop_out=0.5):
        super(RNN, self).__init__()
        self.len_feature = len_feature  # d的大小
        self.len_hidden = len_hidden  # l_h的大小
        self.len_words = len_words  # 单词的个数,包含padding
        self.layer = layer  # 隐藏层层数
        self.dropout = nn.Dropout(drop_out)  # dropout层
        if weight is None:  # 随机初始化
            x = nn.init.xavier_normal_(torch.Tensor(len_words,len_feature))
            self.embedding = nn.Embedding(num_embeddings=len_words,embedding_dim=len_feature,_weight=x)
        else:  # Glove初始化
            self.embedding = nn.Embedding(num_embeddings=len_words,embedding_dim=len_feature,_weight=weight)

        # 用nn.Module的内置函数定义隐藏层
        self.rnn = nn.RNN(input_size=len_feature,hidden_size=len_hidden,num_layers=layer,nonlinearity=nonlinearity,batch_first=batch_first,dropout=drop_out)

        # 全连接层
        self.fc = nn.Linear(len_hidden,typenum)
        # softmax层冗余,可以不加
        # self.act = nn.softmax(dim=1)

    def forward(self,x):
        # x:数据,维度为[batch_size,句子长度]
        x = torch.LongTensor(x)
        batch_size = x.size(0)
        # 经过词嵌入后,维度为[batch_size,句子长度,d]
        out_put = self.embedding(x)  # 词嵌入
        out_put = self.dropout(out_put)  # dropout层

        h0 = torch.autograd.Variable(torch.zeros(self.layer,batch_size,self.len_hidden))
        # dropout层不变,经过隐藏层后,维度变成[1,batch_size,l_h]
        _,hn = self.rnn(out_put,h0)  # 隐藏层计算
        # 经过全连接后,维度变成[1,batch_size,5]
        out_put = self.fc(hn).squeeze(0)  # 全连接层
        # 挤掉第0维度,返回[batch_size,5]的数据
        return out_put


# 设计CNN网络
class CNN(nn.Module):
    def __init__(self,len_feature,len_words,longest,typenum=5,weight=None,drop_out=0.5):
        super(CNN, self).__init__()
        self.len_feature = len_feature  # d的大小
        self.len_words = len_words  # 单词数目
        self.longest = longest  # 最长句子单词数目
        self.dropout = nn.Dropout(drop_out)  # dropout层
        if weight is None:  # 随机初始化
            x = nn.init.xavier_normal(torch.Tensor(len_words,len_feature))
            self.embedding = nn.Embedding(num_embeddings=len_words,embedding_dim=len_feature,_weight=x)
        else:  # Glove初始化
            self.embedding = nn.Embedding(num_embeddings=len_words,embedding_dim=len_feature,_weight=weight)
        # Conv2d参数详解:(输入通道数:1,输出通道数:l_l,卷积核大小:(行数,列数))
        # padding是指往句子两侧加 0,因为有的句子只有一个单词
        # 那么 X 就是 1*50 对 W=2*50 的卷积核根本无法进行卷积操作
        # 因此要在X两侧行加0(两侧列不加),(padding=(1,0))变成 3*50
        # 又比如 padding=(2,0)变成 5*50
        self.conv1 = nn.Sequential(nn.Conv2d(1,longest,(2,len_feature),padding=(1,0)),nn.ReLU())  # 序列,relu激活函数  第1个卷积核+激活层
        self.conv2 = nn.Sequential(nn.Conv2d(1,longest,(3,len_feature),padding=(1,0)),nn.ReLU())  # 第2个卷积核+激活层
        self.conv3 = nn.Sequential(nn.Conv2d(1,longest,(4,len_feature),padding=(2,0)),nn.ReLU())  # 第3个卷积核+激活层
        self.conv4 = nn.Sequential(nn.Conv2d(1,longest,(5,len_feature),padding=(2,0)),nn.ReLU())  # 第4个卷积核+激活层

        # 全连接层
        self.fc = nn.Linear(4 * longest,typenum)

    def forward(self,x):
        # x:数据,维度为[batch_size,句子长度]
        x = torch.LongTensor(x)
        # 通过词嵌入后,维度为[batch_size,1,句子长度,d]
        out_put = self.embedding(x).view(x.shape[0],1,x.shape[1],self.len_feature)  # 词嵌入
        # dropout后不变,记为x
        out_put = self.dropout(out_put)  # dropout层

        """X经过2*d卷积后,维度为[batch_size,l_l,句子长度+2-1,1]"""
        """挤掉第三维度(维度从0开始),[batch_size,l_l,句子长度+2-1]记为Y_1"""
        """注意:句子长度+2-1的2是padding造成的行数扩张"""
        conv1 = self.conv1(out_put).squeeze(3)  # 第1个卷积

        """X经过3*d卷积后,维度为[batch_size,l_l,句子长度+2-2,1]"""
        """挤掉第三维度(维度从0开始),[batch_size,l_l,句子长度+2-2]记为Y_2"""
        conv2 = self.conv2(out_put).squeeze(3)  # 第2个卷积

        """X经过4*d卷积后,维度为[batch_size,l_l,句子长度+4-3,1]"""
        """挤掉第三维度(维度从0开始),[batch_size,l_l,句子长度+4-3]记为Y_3"""
        conv3 = self.conv3(out_put).squeeze(3)  # 第3个卷积

        """X经过5*d卷积后,维度为[batch_size,l_l,句子长度+4-4,1]"""
        """挤掉第三维度(维度从0开始),[batch_size,l_l,句子长度+4-4]记为Y_4"""
        conv4 = self.conv4(out_put).squeeze(3)  # 第4个卷积

        """分别对(Y_1,Y_2,Y_3,Y_4)的第二维(维度从0开始)进行pooling"""
        """得到4个[batch_size,,l_l,1]的向量"""
        pool1 = F.max_pool1d(conv1, conv1.shape[2])
        pool2 = F.max_pool1d(conv2, conv2.shape[2])
        pool3 = F.max_pool1d(conv3, conv3.shape[2])
        pool4 = F.max_pool1d(conv4, conv4.shape[2])

        # 拼接得到[batch_size,l_l*4,1]的向量
        # 挤掉第二维(维度从0开始)为[batch_size,l_l*4]
        pool = torch.cat([pool1,pool2,pool3,pool4],1).squeeze(2)  # 拼接起来
        # 经过全连接层后,维度为[batch_size,5]
        out_put = self.fc(pool)
        return out_put

四、实验结果

NLP-Beginner:自然语言处理入门练习----task 2基于机器学习的文本分类_第1张图片

 

在准确率上,测试集上RNN的准确率比CNN都要高,且测试集的损失值也要比CNN低。比较随机初始化与Glove初始化,在相同的模型下,Glove初始化比随机初始化的效果要好,也就是在测试集上准确率高,损失值小。测试集的准确率在60%左右。

通过上述的结果的显示并不能说明RNN在长句子情感分类方面的优势,因为RNN具有短期记忆,能够处理好词与词之间的关系,以下的结果是在长句子分类上两者的比较,是在测试集中单词数大于20的句子的损失值和正确率。

NLP-Beginner:自然语言处理入门练习----task 2基于机器学习的文本分类_第2张图片

 可以看出,RNN的效果并不比CNN好,无论是CNN还是RNN,长句子的情感分类准确率也只有大概55%左右,比总体的平均正确率低了均10%。

五、总结

这个实验可以使用cuda加速,但是由于我的电脑没有所以就跑得比较慢,只需要在comparison_plot和Neural_network中的一些代码加入.cuda()和.cpu()即可,也可以将代码放入kaggle中用gpu跑或者使用google,我这边也遇到了麻烦所以也没能进行。

在实际神经网络通常是输入一批样本然后得到输出,进行了一个padding操作,即补长,反正数据分batch失败,在实战中先把数据按照句子长度进行了排序,尽量使同一个batch句子长度一致,这样子可以避免零填充,同时设置padding的ID为0。

你可能感兴趣的:(自然语言处理,nlp)