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

CNN卷积神经网络：一般有3-4层，分别是卷积层，激活层，池化层，全连接层，具有局部连接，权重共享，汇聚等特性的深层前馈神经网络，这里的激活参数选择了ReLU函数，ReLu(x)=max(x,0)。池化层相当于是对特征矩阵/向量提取出一些有用的信息，从而减少特征的规模，不仅减少了计算量，也能去除冗余特征。
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 embeddinglines = 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()  # 找到每个句子拥有的单词IDNN_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 = dataself.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个，所以要+1self.len_words = len(self.dict_words)  # 单词数目，暂未包括padding的id0def 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的id0class 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 = dataself.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 = 0self.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 = sentenceself.emotion = emotiondef __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=gbkimport matplotlib.pyplot
import torch
import torch.nn.functional as F
from torch import optim
from Neural_network import RNN, CNN
from feature import get_batchdef 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 = 0test_loss = 0long_loss = 0for 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_recorddef NN_embedding_plot(random_embedding, glove_embedding, learning_rate, batch_size, iter_times):# 获得训练集和测试集的batchtrain_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+randomtorch.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+randomtorch.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+glovetorch.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+glovetorch.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  # 单词的个数，包含paddingself.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*50self.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后不变，记为xout_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

四、实验结果

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

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

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

五、总结

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

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

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

NLP-Beginner：自然语言处理入门练习----task 1基于机器学习的文本分类
任务一:基于机器学习的文本分类任务传送门项目是在github上的,数据集需要在kaggle上下载,稍微有些麻烦. wang盘:http://链接:https://pan.baidu.com/s/1 ...
自然语言处理入门实战1：基于机器学习的文本分类
基于机器学习的文本分类配置文件数据集数据预处理 model 模型主函数预测结果参考代码本文参考复旦大学自然语言处理入门练习,主要是实现用tensorflow实现基于logistic/s ...
【NLP】基于机器学习的文本分类！
作者:李露,西北工业大学,Datawhale优秀学习者据不完全统计,网民们平均每人每周收到的垃圾邮件高达10封左右.垃圾邮件浪费网络资源的同时,还消耗了我们大量的时间.大家对此深恶痛绝,于是识别垃圾 ...
NLP(新闻文本分类)——基于机器学习的文本分类
文本表示方法在机器学习算法的训练过程中,假设给定NNN个样本,每个样本有MMM个特征,这样组成了N×MN×MN×M的样本矩阵,然后完成算法的训练和预测.同样的在计算机视觉中可以将图片的像素看作特征, ...
Task03——零基础入门NLP - 基于机器学习的文本分类
学习目标学会TF-IDF使用原理使用sklearn的机器学习模型完成文本分类文本表示方法 one-hot bag of words N-grams TF-IDF 基于机器学习的文本分类代码
自然语言处理入门（7）——基于TF-IDF的文本自动打标
1. TF-IDF简介 TF-IDF(Term Frequency-Inverse Document Frequency)是一种统计方法,用以评估某一字词对于一个文件集或一个语料库中的其中一份文件的重 ...
NLP汉语自然语言处理入门基础知识介绍
NLP汉语自然语言处理入门基础知识介绍自然语言处理定义: 自然语言处理是一门计算机科学.人工智能以及语言学的交叉学科.虽然语言只是人工智能的一部分(人工智能还包括计算机视觉等),但它是非常独特的一部 ...
自然语言处理入门实战2：基于深度学习的文本分类
自然语言处理入门实战2:基于深度学习的文本分类数据集数据预处理模型模型训练模型测试参考本文参考复旦大学自然语言处理入门练习,主要是实现基于深度学习的文本分类. 环境:python3.7 ...
如何有效利用 LLM（大型语言模型）进行 B2B NLP（自然语言处理）—— LLM与人工智能和机器学习的有效结合，可以优化特定用例的工作流程
目录如何有效利用 LLM(大型语言模型)进行 B2B NLP(自然语言处理)? Introduction 介绍 H

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

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

最新文章

热门文章