• 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

    1. # -*- coding: GBK -*-
    2. # -*- coding: UTF-8 -*-
    3. # coding=gbk
    4. import csv
    5. import random
    6. from feature import Random_embedding,Glove_embedding
    7. from comparison_plot import NN_embedding_plot
    8. # 数据读入
    9. with open('train.tsv') as f :
    10.     tsvreader = csv.reader(f,delimiter='\t')
    11.     temp = list(tsvreader)
    12.  
    13. with open('glove.6B.50d.txt','rb') as f:  # glove embedding
    14.     lines = f.readlines()
    15.  
    16. # 用Glove创建词典
    17. trained_dict = dict()
    18. n = len(lines)  # lines的长度
    19. for i in range(n):  # 遍历
    20.     line = lines[i].split()  # split分割  upper大写
    21.     trained_dict[line[0].decode('utf-8').upper()] = [float(line[j]) for j in range(1,51)]
    22.  
    23. # 初始化
    24. iter_times = 50  # 做50个epoch
    25. alpha = 0.001  # 学习率
    26.  
    27. # 程序开始
    28. data = temp[1:]
    29. batch_size = 500  # 批大小
    30.  
    31. # 随机初始化
    32. random.seed(2021)  # 随机种子
    33. random_embedding = Random_embedding(data=data )  # 调用feature
    34. random_embedding.get_words()  # 找到所有单词，并标记ID
    35. random_embedding.get_id()  # 找到每个句子拥有的单词ID
    36.  
    37. # 预训练模型初始化
    38. random.seed(2021)
    39. glove_embedding = Glove_embedding(data=data,trained_dict=trained_dict)
    40. glove_embedding.get_words()  # 找到所有单词并标记ID
    41. glove_embedding.get_id()  # 找到每个句子拥有的单词ID
    42.  
    43. NN_embedding_plot(random_embedding,glove_embedding,alpha,batch_size,iter_times)

    2.feature.py

    1. # -*- coding: GBK -*-
    2. # -*- coding: UTF-8 -*-
    3. # coding=gbk
    4. # 特征提取
    5. import random
    6. from torch.utils.data import Dataset,DataLoader
    7. from torch.nn.utils.rnn import pad_sequence
    8. import torch
    9.  
    10. # 将数据按照一定的比例分割为训练集和测试集
    11. def data_split(data,test_rate=0.3):
    12.     train = list()
    13.     test = list()
    14.     for datum in data:
    15.         if random.random() > test_rate:
    16.             train.append(datum)
    17.         else:
    18.             test.append(datum)
    19.     return train,test
    20.  
    21.  
    22. # 随机初始化
    23. class Random_embedding():
    24.     def __init__(self,data,test_rate=0.3):
    25.         self.dict_words = dict()   # 单词->ID的映射
    26.         data.sort(key=lambda x:len(x[2].split())) # 按照句子长度排序，短着在前，这样做可以避免后面一个batch内句子长短不一，导致padding过度
    27.         self.data = data
    28.         self.len_words = 0  # 单词数目（包括padding的ID：0）
    29.         self.train,self.test = data_split(data,test_rate=test_rate) # 训练集测试集划分
    30.         self.train_y = [int(term[3]) for term in self.train]  # 训练集类别
    31.         self.test_y = [int(term[3]) for term in self.test] # 测试集类别
    32.         self.train_matrix = list()  # 训练集的单词ID列表，叠成一个矩阵
    33.         self.test_matrix = list()  # 测试集的单词ID列表，叠成一个矩阵
    34.         self.longest = 0  # 记录最长的单词
    35.  
    36.     def get_words(self):
    37.         for term in self.data:
    38.             s = term[2]  # 取出句子
    39.             s = s.upper()  # 将其转化为大写，避免识别i和I为不同的两个单词
    40.             words = s.split()
    41.             for word in words:  # 一个一个单词进行寻找
    42.                 if word not in self.dict_words:
    43.                     self.dict_words[word] = len(self.dict_words) + 1  # padding是第0个，所以要+1
    44.         self.len_words = len(self.dict_words)  # 单词数目，暂未包括padding的id0
    45.  
    46.     def get_id(self):
    47.         for term in self.train:  # 训练集
    48.             s = term[2]
    49.             s = s.upper()
    50.             words = s.split()
    51.             item = [self.dict_words[word] for word in words] # 找到id列表（未进行padding）
    52.             self.longest = max(self.longest,len(item))  # 记录最长的单词
    53.             self.train_matrix.append(item)
    54.         for term in self.test:  # 测试集
    55.             s = term[2]
    56.             s = s.upper()
    57.             words = s.split()
    58.             item = [self.dict_words[word] for word in words]  # 找到id列表（未进行padding）
    59.             self.longest = max(self.longest,len(item))
    60.             self.test_matrix.append(item)
    61.         self.len_words += 1  # 单词数目，包含padding的id0
    62.  
    63.  
    64. class Glove_embedding():
    65.     def __init__(self,data,trained_dict,test_rate=0.3):
    66.         self.dict_words = dict()  # 单词->ID的映射
    67.         self.trained_dict = trained_dict  # 记录预训练词向量模型
    68.         data.sort(key = lambda x:len(x[2].split()))  # 按照句子长度排序，短着在前，这样做可以避免后面一个batch内句子长短不一，导致padding过度
    69.         self.data = data
    70.         self.len_words = 0 # 单词数目（包含padding的id0）
    71.         self.train,self.test = data_split(data,test_rate=test_rate)  # 测试集和训练集的划分
    72.         self.train_y = [int(term[3]) for term in self.train]  # 训练集类别
    73.         self.test_y = [int(term[3]) for term in self.test]  # 测试集类别
    74.         self.train_matrix = list()
    75.         self.test_matrix = list()
    76.         self.longest = 0
    77.         self.embedding = list()  # 抽取出用到的，即预训练模型的单词
    78.  
    79.     def get_words(self):
    80.         self.embedding.append([0] * 50)  # 先加padding的词向量
    81.         for term in self.data:
    82.             s = term[2]  # 取出句子
    83.             s = s.upper()
    84.             words = s.split()
    85.             for word in words:
    86.                 if word not in self.dict_words:
    87.                     self.dict_words[word] = len(self.dict_words)+1  # padding是第0个所以要加一
    88.                     if word in self.trained_dict:  # 如果预训练模型中有这个单词，直接记录词向量
    89.                         self.embedding.append(self.trained_dict[word])
    90.                     else:  # 如果预训练模型中没有这个单词，则初始化该词的对应词向量为0向量
    91.                         self.embedding.append([0]*50)
    92.         self.len_words = len(self.dict_words)  # 单词数目（暂未包括padding的id0）
    93.  
    94.     def get_id(self):
    95.         for term in self.train:  # 训练集
    96.             s = term[2]
    97.             s = s.upper()
    98.             words = s.split()
    99.             item = [self.dict_words[word] for word in words]  # 找到id列表（未进行padding）
    100.             self.longest = max(self.longest,len(item))  # 记录最长的单词
    101.             self.train_matrix.append(item)
    102.         for term in self.test:  # 测试集
    103.             s = term[2]
    104.             s = s.upper()
    105.             words = s.split()
    106.             item = [self.dict_words[word] for word in words]
    107.             self.longest = max(self.longest,len(item))
    108.             self.test_matrix.append(item)
    109.         self.len_words += 1  # 单词数目（暂未包括padding的id0）
    110.  
    111.  
    112. # 自定义数据集的结构
    113. class ClsDataset(Dataset):
    114.         def __init__(self,sentence,emotion):
    115.             self.sentence = sentence
    116.             self.emotion = emotion
    117.  
    118.         def __getitem__(self, item):
    119.             return self.sentence[item],self.emotion[item]
    120.  
    121.         def __len__(self):
    122.             return len(self.emotion)
    123.  
    124.  
    125. # 自定义数据集的内数据返回类型，并进行padding
    126. def collate_fn(batch_data):
    127.     sentence,emotion = zip(*batch_data)
    128.     sentences = [torch.LongTensor(sent) for sent in sentence]  # 把句子变成LongTensor类型
    129.     padded_sents = pad_sequence(sentences,batch_first=True,padding_value=0)  # 自动padding操作
    130.     return torch.LongTensor(padded_sents),torch.LongTensor(emotion)
    131.  
    132.  
    133. # 利用dataloader划分batch
    134. def get_batch(x,y,batch_size):
    135.     dataset = ClsDataset(x,y)
    136.     dataloader = DataLoader(dataset,batch_size=batch_size,shuffle=False,drop_last=True,collate_fn=collate_fn)
    137.     return dataloader
    138.     # shuffle是指每个epoch都随机打乱数据再分batch，设置成False，否则之前的顺序会直接打乱
    139.     # drop_last是指不利用最后一个不完整的batch（数据大小不能被batch_size整除）

    3.comparison_plot.py

    1. # -*- coding: GBK -*-
    2. # -*- coding: UTF-8 -*-
    3. # coding=gbk
    4.  
    5. import matplotlib.pyplot
    6. import torch
    7. import torch.nn.functional as F
    8. from torch import optim
    9. from Neural_network import RNN, CNN
    10. from feature import get_batch
    11.  
    12.  
    13. def NN_embdding(model, train, test, learning_rate, iter_times):
    14.     # 定义优化器（求参数）
    15.     optimizer = optim.Adam(model.parameters(), lr=learning_rate)
    16.     # 损失函数
    17.     loss_fun = F.cross_entropy
    18.     # 损失值记录
    19.     train_loss_record = list()
    20.     test_loss_record = list()
    21.     long_loss_record = list()
    22.     # 准确率记录
    23.     train_record = list()
    24.     test_record = list()
    25.     long_record = list()
    26.     # torch.autograd.set_detect_anomaly(True)
    27.     # 训练阶段
    28.     for iteration in range(iter_times):
    29.         model.train()  # 重要！！！进入非训练模式
    30.         for i, batch in enumerate(train):
    31.             x, y = batch  # 取一个batch
    32.             # y = y.cuda()
    33.             pred = model(x)  # 计算输出
    34.             optimizer.zero_grad()  # 梯度初始化
    35.             loss = loss_fun(pred, y)  # 损失值计算
    36.             loss.backward()  # 反向传播梯度
    37.             optimizer.step()  # 更新参数
    38.  
    39.         model.eval()  # 重要！！！进入非训练模式（测试模式）
    40.         # 本轮正确率记录
    41.         train_acc = list()
    42.         test_acc = list()
    43.         long_acc = list()
    44.         length = 20
    45.         # 本轮损失值记录
    46.         train_loss = 0
    47.         test_loss = 0
    48.         long_loss = 0
    49.         for i, batch in enumerate(train):
    50.             x, y = batch  # 取一个batch
    51.             # y = y.cuda()
    52.             pred = model(x)  # 计算输出
    53.             loss = loss_fun(pred, y)  # 损失值计算
    54.             train_loss += loss.item()  # 损失值累加
    55.             _, y_pre = torch.max(pred, -1)
    56.             # 计算本batch准确率
    57.             acc = torch.mean((torch.tensor(y_pre == y, dtype=torch.float)))
    58.             train_acc.append(acc)
    59.  
    60.         for i, batch in enumerate(test):
    61.             x, y = batch  # 取一个batch
    62.             # y = y.cuda()
    63.             pred = model(x) # 计算输出
    64.             loss = loss_fun(pred, y)  # 损失值计算
    65.             test_loss += loss.item()  # 损失值累加
    66.             _, y_pre = torch.max(pred, -1)
    67.             # 计算本batch准确率
    68.             acc = torch.mean((torch.tensor(y_pre == y, dtype=torch.float)))
    69.             test_acc.append(acc)
    70.             if (len(x[0])) > length:  # 长句子侦测
    71.                 long_acc.append(acc)
    72.                 long_loss += loss.item()
    73.  
    74.         trains_acc = sum(train_acc) / len(train_acc)
    75.         tests_acc = sum(test_acc) / len(test_acc)
    76.         longs_acc = sum(long_acc) / len(long_acc)
    77.  
    78.         train_loss_record.append(train_loss / len(train_acc))
    79.         test_loss_record.append(test_loss / len(test_acc))
    80.         long_loss_record.append(long_loss / len(long_acc))
    81.         train_record.append(trains_acc)
    82.         test_record.append(tests_acc)
    83.         long_record.append(longs_acc)
    84.         print("---------- Iteration", iteration + 1, "----------")
    85.         print("Train loss:", train_loss / len(train_acc))
    86.         print("Test loss:", test_loss / len(test_acc))
    87.         print("Train accuracy:", trains_acc)
    88.         print("Test accuracy:", tests_acc)
    89.         print("Long sentence accuracy:", longs_acc)
    90.  
    91.     return train_loss_record, test_loss_record, long_loss_record, train_record, test_record, long_record
    92.  
    93.  
    94. def NN_embedding_plot(random_embedding, glove_embedding, learning_rate, batch_size, iter_times):
    95.     # 获得训练集和测试集的batch
    96.     train_random = get_batch(random_embedding.train_matrix,
    97.                              random_embedding.train_y, batch_size)
    98.     test_random = get_batch(random_embedding.test_matrix,
    99.                             random_embedding.test_y, batch_size)
    100.     train_glove = get_batch(glove_embedding.train_matrix,
    101.                             glove_embedding.train_y, batch_size)
    102.     test_glove = get_batch(random_embedding.test_matrix,
    103.                            glove_embedding.test_y, batch_size)
    104.     # 模型建立
    105.     torch.manual_seed(2021)
    106.     torch.manual_seed(2021)
    107.     random_rnn = RNN(50, 50, random_embedding.len_words)
    108.     torch.manual_seed(2021)
    109.     torch.manual_seed(2021)
    110.     random_cnn = CNN(50, random_embedding.len_words, random_embedding.longest)
    111.     torch.manual_seed(2021)
    112.     torch.manual_seed(2021)
    113.     glove_rnn = RNN(50, 50, glove_embedding.len_words,
    114.                        weight=torch.tensor(glove_embedding.embedding, dtype=torch.float))
    115.     torch.manual_seed(2021)
    116.     torch.manual_seed(2021)
    117.     glove_cnn = CNN(50, glove_embedding.len_words, glove_embedding.longest,
    118.                        weight=torch.tensor(glove_embedding.embedding, dtype=torch.float))
    119.     # rnn+random
    120.     torch.manual_seed(2021)
    121.     torch.manual_seed(2021)
    122.     trl_ran_rnn, tel_ran_rnn, lol_ran_rnn, tra_ran_rnn, tes_ran_rnn, lon_ran_rnn = \
    123.         NN_embdding(random_rnn, train_random, test_random, learning_rate, iter_times)
    124.     # cnn+random
    125.     torch.manual_seed(2021)
    126.     torch.manual_seed(2021)
    127.     trl_ran_cnn, tel_ran_cnn, lol_ran_cnn, tra_ran_cnn, tes_ran_cnn, lon_ran_cnn = \
    128.         NN_embdding(random_cnn, train_random, test_random, learning_rate, iter_times)
    129.     # rnn+glove
    130.     torch.manual_seed(2021)
    131.     torch.manual_seed(2021)
    132.     trl_glo_rnn, tel_glo_rnn, lol_glo_rnn, tra_glo_rnn, tes_glo_rnn, lon_glo_rnn = \
    133.         NN_embdding(glove_rnn, train_glove, test_glove, learning_rate, iter_times)
    134.     # cnn+glove
    135.     torch.manual_seed(2021)
    136.     torch.manual_seed(2021)
    137.     trl_glo_cnn, tel_glo_cnn, lol_glo_cnn, tra_glo_cnn, tes_glo_cnn, lon_glo_cnn = \
    138.         NN_embdding(glove_cnn, train_glove, test_glove, learning_rate, iter_times)
    139.     # 画图部分
    140.     x = list(range(1, iter_times + 1))
    141.     matplotlib.pyplot.subplot(2, 2, 1)
    142.     matplotlib.pyplot.plot(x, trl_ran_rnn, 'r--', label='RNN+random')
    143.     matplotlib.pyplot.plot(x, trl_ran_cnn, 'g--', label='CNN+random')
    144.     matplotlib.pyplot.plot(x, trl_glo_rnn, 'b--', label='RNN+glove')
    145.     matplotlib.pyplot.plot(x, trl_glo_cnn, 'y--', label='CNN+glove')
    146.     matplotlib.pyplot.legend()
    147.     matplotlib.pyplot.legend(fontsize=10)
    148.     matplotlib.pyplot.title("Train Loss")
    149.     matplotlib.pyplot.xlabel("Iterations")
    150.     matplotlib.pyplot.ylabel("Loss")
    151.     matplotlib.pyplot.subplot(2, 2, 2)
    152.     matplotlib.pyplot.plot(x, tel_ran_rnn, 'r--', label='RNN+random')
    153.     matplotlib.pyplot.plot(x, tel_ran_cnn, 'g--', label='CNN+random')
    154.     matplotlib.pyplot.plot(x, tel_glo_rnn, 'b--', label='RNN+glove')
    155.     matplotlib.pyplot.plot(x, tel_glo_cnn, 'y--', label='CNN+glove')
    156.     matplotlib.pyplot.legend()
    157.     matplotlib.pyplot.legend(fontsize=10)
    158.     matplotlib.pyplot.title("Test Loss")
    159.     matplotlib.pyplot.xlabel("Iterations")
    160.     matplotlib.pyplot.ylabel("Loss")
    161.     matplotlib.pyplot.subplot(2, 2, 3)
    162.     matplotlib.pyplot.plot(x, tra_ran_rnn, 'r--', label='RNN+random')
    163.     matplotlib.pyplot.plot(x, tra_ran_cnn, 'g--', label='CNN+random')
    164.     matplotlib.pyplot.plot(x, tra_glo_rnn, 'b--', label='RNN+glove')
    165.     matplotlib.pyplot.plot(x, tra_glo_cnn, 'y--', label='CNN+glove')
    166.     matplotlib.pyplot.legend()
    167.     matplotlib.pyplot.legend(fontsize=10)
    168.     matplotlib.pyplot.title("Train Accuracy")
    169.     matplotlib.pyplot.xlabel("Iterations")
    170.     matplotlib.pyplot.ylabel("Accuracy")
    171.     matplotlib.pyplot.ylim(0, 1)
    172.     matplotlib.pyplot.subplot(2, 2, 4)
    173.     matplotlib.pyplot.plot(x, tes_ran_rnn, 'r--', label='RNN+random')
    174.     matplotlib.pyplot.plot(x, tes_ran_cnn, 'g--', label='CNN+random')
    175.     matplotlib.pyplot.plot(x, tes_glo_rnn, 'b--', label='RNN+glove')
    176.     matplotlib.pyplot.plot(x, tes_glo_cnn, 'y--', label='CNN+glove')
    177.     matplotlib.pyplot.legend()
    178.     matplotlib.pyplot.legend(fontsize=10)
    179.     matplotlib.pyplot.title("Test Accuracy")
    180.     matplotlib.pyplot.xlabel("Iterations")
    181.     matplotlib.pyplot.ylabel("Accuracy")
    182.     matplotlib.pyplot.ylim(0, 1)
    183.     matplotlib.pyplot.tight_layout()
    184.     fig = matplotlib.pyplot.gcf()
    185.     fig.set_size_inches(8, 8, forward=True)
    186.     matplotlib.pyplot.savefig('main_plot.jpg')
    187.     matplotlib.pyplot.show()
    188.     matplotlib.pyplot.subplot(2, 1, 1)
    189.     matplotlib.pyplot.plot(x, lon_ran_rnn, 'r--', label='RNN+random')
    190.     matplotlib.pyplot.plot(x, lon_ran_cnn, 'g--', label='CNN+random')
    191.     matplotlib.pyplot.plot(x, lon_glo_rnn, 'b--', label='RNN+glove')
    192.     matplotlib.pyplot.plot(x, lon_glo_cnn, 'y--', label='CNN+glove')
    193.     matplotlib.pyplot.legend()
    194.     matplotlib.pyplot.legend(fontsize=10)
    195.     matplotlib.pyplot.title("Long Sentence Accuracy")
    196.     matplotlib.pyplot.xlabel("Iterations")
    197.     matplotlib.pyplot.ylabel("Accuracy")
    198.     matplotlib.pyplot.ylim(0, 1)
    199.     matplotlib.pyplot.subplot(2, 1, 2)
    200.     matplotlib.pyplot.plot(x, lol_ran_rnn, 'r--', label='RNN+random')
    201.     matplotlib.pyplot.plot(x, lol_ran_cnn, 'g--', label='CNN+random')
    202.     matplotlib.pyplot.plot(x, lol_glo_rnn, 'b--', label='RNN+glove')
    203.     matplotlib.pyplot.plot(x, lol_glo_cnn, 'y--', label='CNN+glove')
    204.     matplotlib.pyplot.legend()
    205.     matplotlib.pyplot.legend(fontsize=10)
    206.     matplotlib.pyplot.title("Long Sentence Loss")
    207.     matplotlib.pyplot.xlabel("Iterations")
    208.     matplotlib.pyplot.ylabel("Loss")
    209.     matplotlib.pyplot.tight_layout()
    210.     fig = matplotlib.pyplot.gcf()
    211.     fig.set_size_inches(8, 8, forward=True)
    212.     matplotlib.pyplot.savefig('sub_plot.jpg')
    213.     matplotlib.pyplot.show()

    4.Neural_network.py

    1. # -*- coding: GBK -*-
    2. # -*- coding: UTF-8 -*-
    3. # coding=gbk
    4. import torch
    5. import torch.nn as nn
    6. import torch.nn.functional as F
    7.  
    8.  
    9. # 设计RNN网络
    10. class RNN(nn.Module):
    11.     def __init__(self,len_feature,len_hidden,len_words,typenum=5,weight=None,layer=1,nonlinearity='tanh',batch_first=True,drop_out=0.5):
    12.         super(RNN, self).__init__()
    13.         self.len_feature = len_feature  # d的大小
    14.         self.len_hidden = len_hidden  # l_h的大小
    15.         self.len_words = len_words  # 单词的个数，包含padding
    16.         self.layer = layer  # 隐藏层层数
    17.         self.dropout = nn.Dropout(drop_out)  # dropout层
    18.         if weight is None:  # 随机初始化
    19.             x = nn.init.xavier_normal_(torch.Tensor(len_words,len_feature))
    20.             self.embedding = nn.Embedding(num_embeddings=len_words,embedding_dim=len_feature,_weight=x)
    21.         else:  # Glove初始化
    22.             self.embedding = nn.Embedding(num_embeddings=len_words,embedding_dim=len_feature,_weight=weight)
    23.  
    24.         # 用nn.Module的内置函数定义隐藏层
    25.         self.rnn = nn.RNN(input_size=len_feature,hidden_size=len_hidden,num_layers=layer,nonlinearity=nonlinearity,batch_first=batch_first,dropout=drop_out)
    26.  
    27.         # 全连接层
    28.         self.fc = nn.Linear(len_hidden,typenum)
    29.         # softmax层冗余，可以不加
    30.         # self.act = nn.softmax(dim=1)
    31.  
    32.     def forward(self,x):
    33.         # x：数据，维度为[batch_size,句子长度]
    34.         x = torch.LongTensor(x)
    35.         batch_size = x.size(0)
    36.         # 经过词嵌入后，维度为[batch_size,句子长度,d]
    37.         out_put = self.embedding(x)  # 词嵌入
    38.         out_put = self.dropout(out_put)  # dropout层
    39.  
    40.         h0 = torch.autograd.Variable(torch.zeros(self.layer,batch_size,self.len_hidden))
    41.         # dropout层不变，经过隐藏层后，维度变成[1,batch_size,l_h]
    42.         _,hn = self.rnn(out_put,h0)  # 隐藏层计算
    43.         # 经过全连接后，维度变成[1,batch_size,5]
    44.         out_put = self.fc(hn).squeeze(0)  # 全连接层
    45.         # 挤掉第0维度，返回[batch_size,5]的数据
    46.         return out_put
    47.  
    48.  
    49. # 设计CNN网络
    50. class CNN(nn.Module):
    51.     def __init__(self,len_feature,len_words,longest,typenum=5,weight=None,drop_out=0.5):
    52.         super(CNN, self).__init__()
    53.         self.len_feature = len_feature  # d的大小
    54.         self.len_words = len_words  # 单词数目
    55.         self.longest = longest  # 最长句子单词数目
    56.         self.dropout = nn.Dropout(drop_out)  # dropout层
    57.         if weight is None:  # 随机初始化
    58.             x = nn.init.xavier_normal(torch.Tensor(len_words,len_feature))
    59.             self.embedding = nn.Embedding(num_embeddings=len_words,embedding_dim=len_feature,_weight=x)
    60.         else:  # Glove初始化
    61.             self.embedding = nn.Embedding(num_embeddings=len_words,embedding_dim=len_feature,_weight=weight)
    62.         # Conv2d参数详解：（输入通道数：1，输出通道数：l_l，卷积核大小：（行数，列数））
    63.         # padding是指往句子两侧加 0，因为有的句子只有一个单词
    64.         # 那么 X 就是 1*50 对 W=2*50 的卷积核根本无法进行卷积操作
    65.         # 因此要在X两侧行加0（两侧列不加），（padding=（1，0））变成 3*50
    66.         # 又比如 padding=（2，0）变成 5*50
    67.         self.conv1 = nn.Sequential(nn.Conv2d(1,longest,(2,len_feature),padding=(1,0)),nn.ReLU())  # 序列，relu激活函数  第1个卷积核+激活层
    68.         self.conv2 = nn.Sequential(nn.Conv2d(1,longest,(3,len_feature),padding=(1,0)),nn.ReLU())  # 第2个卷积核+激活层
    69.         self.conv3 = nn.Sequential(nn.Conv2d(1,longest,(4,len_feature),padding=(2,0)),nn.ReLU())  # 第3个卷积核+激活层
    70.         self.conv4 = nn.Sequential(nn.Conv2d(1,longest,(5,len_feature),padding=(2,0)),nn.ReLU())  # 第4个卷积核+激活层
    71.  
    72.         # 全连接层
    73.         self.fc = nn.Linear(4 * longest,typenum)
    74.  
    75.     def forward(self,x):
    76.         # x：数据，维度为[batch_size,句子长度]
    77.         x = torch.LongTensor(x)
    78.         # 通过词嵌入后，维度为[batch_size,1,句子长度，d]
    79.         out_put = self.embedding(x).view(x.shape[0],1,x.shape[1],self.len_feature)  # 词嵌入
    80.         # dropout后不变，记为x
    81.         out_put = self.dropout(out_put)  # dropout层
    82.  
    83.         """X经过2*d卷积后，维度为[batch_size，l_l，句子长度+2-1，1]"""
    84.         """挤掉第三维度（维度从0开始），[batch_size，l_l，句子长度+2-1]记为Y_1"""
    85.         """注意：句子长度+2-1的2是padding造成的行数扩张"""
    86.         conv1 = self.conv1(out_put).squeeze(3)  # 第1个卷积
    87.  
    88.         """X经过3*d卷积后，维度为[batch_size，l_l，句子长度+2-2，1]"""
    89.         """挤掉第三维度（维度从0开始），[batch_size，l_l，句子长度+2-2]记为Y_2"""
    90.         conv2 = self.conv2(out_put).squeeze(3)  # 第2个卷积
    91.  
    92.         """X经过4*d卷积后，维度为[batch_size，l_l，句子长度+4-3，1]"""
    93.         """挤掉第三维度（维度从0开始），[batch_size，l_l，句子长度+4-3]记为Y_3"""
    94.         conv3 = self.conv3(out_put).squeeze(3)  # 第3个卷积
    95.  
    96.         """X经过5*d卷积后，维度为[batch_size，l_l，句子长度+4-4，1]"""
    97.         """挤掉第三维度（维度从0开始），[batch_size，l_l，句子长度+4-4]记为Y_4"""
    98.         conv4 = self.conv4(out_put).squeeze(3)  # 第4个卷积
    99.  
    100.         """分别对（Y_1,Y_2,Y_3,Y_4）的第二维（维度从0开始）进行pooling"""
    101.         """得到4个[batch_size,，l_l，1]的向量"""
    102.         pool1 = F.max_pool1d(conv1, conv1.shape[2])
    103.         pool2 = F.max_pool1d(conv2, conv2.shape[2])
    104.         pool3 = F.max_pool1d(conv3, conv3.shape[2])
    105.         pool4 = F.max_pool1d(conv4, conv4.shape[2])
    106.  
    107.         # 拼接得到[batch_size,l_l*4,1]的向量
    108.         # 挤掉第二维（维度从0开始）为[batch_size,l_l*4]
    109.         pool = torch.cat([pool1,pool2,pool3,pool4],1).squeeze(2)  # 拼接起来
    110.         # 经过全连接层后，维度为[batch_size,5]
    111.         out_put = self.fc(pool)
    112.         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。

  • 相关阅读:
    sql 常用命令-----增删查改
    UVA 439 骑士的移动 Knight Moves
    域名解析DNS：如何查询txt类型的解析记录
    【算法】PTA刷题记录
    firewalld防火墙基础
    elementUI的table使用展开功能( type=“expand“ ),展开时合起上一次展开的内容,始终保持展开内容为一个,并且再次点击合起自身
    Linux配置成代理服务器
    蓝牙SDK状态机与车载音频HSM状态机比较
    【JSON2WEB】11 基于 Amis 角色功能权限设置页面
    Improving Transferability of Adversarial Examples with Input Diversity
  • 原文地址：https://blog.csdn.net/soobinnim/article/details/126187449