准备数据

电影评论数据下载地址
将文本数据处理成torch,我们希望可以得到的target是他的评论态度是积极还是消极,将数据分为2500训练,2500测试,这里网址下载的数据数量已经分好了,利用pytorch进行文本处理

处理数据

遇到这个问题
RuntimeError: each element in list of batch should be of equal size
这里重写一下Dataloader中的collate_fn方法

import os
import re
from lib import ws,max_len
import torch
from torch.utils.data import Dataset,DataLoader

# 将一个句子分为由单词组成的列表
def tokenize(str):
    # 这个是re库里的函数，其原型为re.sub(pattern, repl, string, count)
    # 第一个参数为正则表达式需要被替换的参数，第二个参数是替换后的字符串，
    # 第三个参数为输入的字符串，第四个参数指替换个数。默认为0，表示每个匹配项都替换。
    filter = ['!','"','#','$','%','&','\(','\)','\*','\+',',','-','\.','/',':',';','<','=','>','\?','@'
        ,'\[','\\','\]','^','_','`','\{','\|','\}','~','\t','\n','\x97','\x96','”','“']
    token = re.sub('|'.join(filter),'',str)
    token = token.strip()
    return token.split(' ')


class Datas(Dataset):
    def __init__(self,train=True):
        self.train_path = r'data/aclImdb/train'
        self.test_path = r'data/aclImdb/test'
        temp_path = self.train_path if train else self.test_path
        data_path = [temp_path+'/pos', temp_path+'/neg']
        # 将含评论的所有文件放在列表中
        self.files = []
        for i in data_path:
            listdirs = os.listdir(i)
            data_path2 = [i+'/'+j for j in listdirs]
            self.files.extend(data_path2)

    def __len__(self):
    # 有多少评论数据
        return len(self.files)

    def __getitem__(self, index):
        file_path = self.files[index]
        label = file_path.split('/')[-2]
        label = 1 if label == 'pos' else 0
        # 这里label就是我们想预测的
        # 从文件中读到的是真实值
        content = open(file_path,encoding='utf-8').read()
        # 返回经过分词的句子列表
        return label,tokenize(content)

# 需要重写collate_fn方法
def collate_fn(batch):
    #  batch是一个列表，其中是一个一个的元组，每个元组是dataset中_getitem__的结果
    batch = list(zip(*batch))
    labels = torch.tensor(batch[0], dtype=torch.int64)
    texts = batch[1]
    texts = [ws.transform(text,max_len=max_len) for text in texts]
    texts = torch.LongTensor(texts)
    # labels = torch.LongTensor(labels)
    del batch
    # 返回真实值,评论(特征值)
    return labels, texts


def get_dataloader():
    data = Datas(True)
    dataloader = DataLoader(dataset=data, batch_size=64, shuffle=True, collate_fn=collate_fn)
    # 传入经过分词的64个评论一个batch进入到数据加载器中
    return dataloader


if __name__ == '__main__':

    # print(tokenize("e D:/test/deep_learing/test/text_test.py data/aclImdb/train/pos/0_9.txt pos1"))
    for idx,(input,out) in enumerate(get_dataloader()):
        print(idx)
        print(input)
        print(out)
        break

结果是这样,第二行的tensor代表的是两个评论的label都是0因为,第三行是两个评论的文本分词
得到了评论的数据之后,我们需要对词语进行序列化
即把词语转换为数字

序列化

class word2sequense():
# 定义当我们训练出来的词典的两个关键词:UNK就是字典里没有出现的,APP就是由于句子长度不够,填充的符号
    unknown_tag = 'UNK'
    append_tag = 'APP'
    UNK = 0
    APP = 1

    def __init__(self):
    # 定义词典
        self.dict = {
            self.unknown_tag:self.UNK,
            self.append_tag:self.APP

        }
    # 统计词频
    count = {}

    def fit(self,sentence):
        for word in sentence:
            self.count[word] = self.count.get(word,0) + 1

    def filter_count(self,min=5,max=None,max_features=None):
        """
        :param min:最小词频
        :param max: 最大词频
        :param max_features:一共保存的词语个数
        :return:
        """
        # 去掉词频小于min的
        self.count = {word:value for word,value in self.count.items() if value > min}
        # 去掉大于max的
        if max is not None:
            self.count = {word: value for word, value in self.count.items() if value < max}
        if max_features is not None:
            # 把count进行排序,取出前max_features个
            temp = sorted(self.count.items(),key=lambda x:x[-1],reverse=True)[:max_features]
            # 转回字典
            self.count = dict(temp)
        # 将单词用数字表示,数字就是第几个加到词典的
        for word in self.count:
            self.dict[word] = len(self.dict)
        # 将数字用单词表示
        self.dict2 = dict(zip(self.dict.values(),self.dict.keys()))

    def transform(self,sentence,max_len=None):
        if max_len is not None:
            # 将句子长度统一
            if max_len>len(sentence):
            # 当长度不够的时候,在句子后面加上对应数量的app符号
                sentence += [self.APP]*(max_len-len(sentence))
            if max_len<len(sentence):
                # 裁剪后面的
                sentence = sentence[:max_len]
        # 将句子转换成序列
        # for word in sentence:
        #     self.dict.get(word,self.UNK)
        return [self.dict.get(word,self.UNK) for word in sentence]
        # 从dict里找单词的编号,找不到为0

    def inverse_trans(self,indics):
        # 将序列转换成句子
        return [self.dict2.get(indx) for indx in indics]
 
    def __len__(self):
        return len(self.dict)


if __name__ == '__main__':
    word2 = word2sequense()
    word2.fit(['日','你','妈'])
    word2.fit(['退','钱'])
    word2.fit(['中','果','足','球','冲','进','世界','杯'])
    word2.filter_count(min=0)
    print(word2.dict)
    print(word2.dict2)

结果是这样

在这里将使用pickle将以上保存起来

import pickle
from tqdm import tqdm
# 显示进度
import os
from text_test import tokenize
from word2 import word2sequense
ws = word2sequense()
# ws就是我们的序列化器
# 传入要训练的句子,从train文件中将所有的评论文件放入
train_path = r'data/aclImdb/train'
data_path = [train_path + '/pos', train_path + '/neg']
files = []
for i in data_path:
    listdirs = os.listdir(i)
    datas_path = [i + '/' + j for j in listdirs]
    for data in tqdm(datas_path):
        sentence = tokenize(open(data,encoding='UTF-8').read())
        ws.fit(sentence)
ws.filter_count()
# 将训练好的词典保存起来
pickle.dump(ws, open(r'model/ws.okl','wb'))
print(len(ws))

在这里如果出现了open error找不到文件,创建就好了不知道为什么wb模式自动创建没有成功,不过我们手动创建的小效果一样
如果出现了编码的问题,open的时候加入encoding='utf-8’即可,具体情况具体分析.
在这里保存之后,后续使用pickle.load(model/ws.okl)进行载入
去之前的最开始的地方进行检测
对前面的collate_fn进行部分修改

def collate_fn(batch):
    #  batch是一个列表，其中是一个一个的元组，每个元组是dataset中_getitem__的结果
    batch = list(zip(*batch))
    labels = torch.tensor(batch[0], dtype=torch.int32)
    texts = batch[1]
    texts = [ws.transform(text) for text in texts]
    del batch
    return labels, texts

修改后的运行结果

从之前的词语成功的变为数字,达到了目的
,至此数据处理完成

模型建立

模型建立之后遇到了问题,注意以下label和text的顺序,就好了

import torch.nn as nn
from lib import ws,max_len
import torch.nn.functional as f
from torch.optim import Adam


class mymodel(nn.Module):
    def __init__(self):
        super(mymodel, self).__init__()
        self.embedding = nn.Embedding(len(ws),100)
        # 传入参数:词的数量,多少个词形成一个向量
        self.fc = nn.Linear(max_len*100,2)

    def forward(self,input):
        """
        :param input:[batch_size,句子长度(max_size)]
        :return:
        """
        x = self.embedding(input)  # x的形状为[batch_size,句子长度(max_size),100]
        # 变换形状
        x = x.view([-1,max_len*100])
        out = self.fc(x)
        return f.log_softmax(out)


from text_test import get_dataloader

model = mymodel()
# 优化器,传入参数和学习率
optimizer= Adam(model.parameters(),0.001)


def train():
    for idx,(out,input) in enumerate(get_dataloader()):
        optimizer.zero_grad()
        pre = model(input)
        # 计算损失
        loss = f.nll_loss(pre,out)
        loss.backward()
        optimizer.step()
        print(loss.item())


if __name__ == '__main__':
    train()

运行结果:

RNN循环神经网络的使用进行优化

这里只是将几个单词看成一个向量,训练的效果并不好
循环神经网络的使用,可以让数据具有时序性,即考虑的不仅仅是当前的输入,也考虑之前的输入来调节参数的概率从而使训练效果更好
具有短期记忆–rnn循环神经网络

RNN分类

使用LSTM解决RNN中的长期依赖问题（long-Term Dependencies）

rnn存在间隔长的词语,导致前面的词语对后面的影响小的问题,即长期依赖问题
LSTM的三个输入:
上一次的隐藏状态+上一次的细胞状态(记忆)+本次的输入
三个输出:
隐藏状态+细胞状态+输出,输出和隐藏状态是一样的
输入的形状:
input : [seq_len,batch,embedding size]
输出的形状:
output：[seq_len, batch, num_directions * hidden_size]—>batch_first=False
,/其中hidden_size为一层神经系统里有多少lstm,num_direction是由单向lstm还是双向决定的
单向为1,双向为2
h_n(隐藏状态):(num_layers * num_directions, batch, hidden_size)
c_n(细胞状态): (num_layers * num_directions, batch, hidden_size)
num_layers为有多少层神经系统

实例化LSTM

torch.nn.LSTM(input_size,hidden_size,num_layers,batch_first,dropout,bidirectional)

input_size：输入数据的形状，即embedding_dim
hidden_size：隐藏层神经元的数量，即每一层有多少个LSTM单元
num_layer ：即RNN的中LSTM单元的层数
batch_first：默认值为False，输入的数据需要[seq_len,batch,feature],如果为True，则为[batch,seq_len,feature]
dropout:dropout的比例，默认值为0。dropout是一种训练过程中让部分参数随机失活的一种方式，能够提高训练速度，同时能够解决过拟合的问题。这里是在LSTM的最后一层，对每个输出进行dropout
bidirectional：是否使用双向LSTM,默认是False

import os

import torch
import torch.nn as nn
from lib import ws,max_len
import torch.nn.functional as f
from torch.optim import Adam
import lib


class mymodel(nn.Module):
    def __init__(self):
        super(mymodel, self).__init__()
        self.embedding = nn.Embedding(len(ws),100)
        # 传入参数:词的数量,多少个词形成一个向量
        self.fc = nn.Linear(lib.hidden_size*2,2)
        # LSTM优化,实例化
        self.LSTM= nn.LSTM(input_size=100,hidden_size=lib.hidden_size,
                           num_layers=lib.layer_num,bidirectional=lib.biderational,
                           batch_first=True,dropout=lib.dropout)

    def forward(self,input):
        """
        :param input:[batch_size,句子长度(max_size)]
        :return:
        """
        x = self.embedding(input)  # x的形状为[batch_size,句子长度(max_size),100]
        # 变换形状
        # lstm处理
        x,(h_n,c_n) = self.LSTM(x)
        # x的形状[batch_size,句子长度(max_size),batch_size*2(方向)],h_n的形状[方向*层数(4),batch_size,hidden_size,]
        # c_n的形状[方向*层数(4),batch_size,hidden_size]
        # 获取两个方向的output进行拼接,第一维是层数,第一层正向的最后一个,即层数-2,第二层就是-1
        output_fw = h_n[-2,:,:]
        output_bw = h_n[-1,:,:]
        output = torch.cat((output_fw,output_bw),dim=-1)
        # output形状为[batch_size,hidden_size*2]
        # x = x.view([-1,max_len*100])
        out = self.fc(output)
        return f.log_softmax(out)


from text_test import get_dataloader

model = mymodel()
# 优化器,传入参数和学习率
optimizer= Adam(model.parameters(),0.001)
if os.path.exists('model/model1.okl'):
    model.load_state_dict(torch.load('model/model1.kl'))
    optimizer.load_state_dict(torch.load('model/opt1.kl'))


def train():
    for idx,(out,input) in enumerate(get_dataloader()):
        optimizer.zero_grad()
        pre = model(input)
        # 计算损失
        loss = f.nll_loss(pre,out)
        loss.backward()
        optimizer.step()
        print(loss.item())
        # 保存模型
        if idx % 100 == 0:
            torch.save(model.state_dict(),'model/model1.okl')
            torch.save(optimizer.state_dict(),'model/opt1.okl')


if __name__ == '__main__':
    train()

进行训练的时候.使用cpu训练的时间较长采用gpu计算

校验模型

模型的检验使用训练好的模型,将test数据放入,获取到误差的平均值和准确值作为模型评判

一点感想

这是本人的内容安全课堂作业，参考一些网上代码与文章，汇报时排在前面的大佬都是各种深度学习曲线分析，参数调整，获得了教辅博士的大力表扬，本人啥也不会，只能选择一篇简单的论文进行复现，并且进行若干改进，在此记录以避免踩坑。

涉及知识点

中文分词（词性分析），TF-IDF，朴素贝叶斯，人工神经网络

论文内容

进入正文，首先进行论文复现，本论文是基于表情符分析的情感关键句提取方法，里面用到了基于表情符分析的句子情感极性计算、关键词计算、位置信息计算
其中基于表情符分析的句子情感极性计算是对现有方法的改进，通过融入表情符分析提升情感关键句提取的正确率，论文如下

这篇文章主要是介绍表情符分类的若干新方式与新模型,并未提出实现的具体方式，故代码实现时做了一些变化。

论文复现

表情符处理

首先是进行表情符的提取，因为表情符都有[]包裹，所以根据此特征进行匹配提取，所有数据集里的表情符都存至一个数组中，供后面进行处理，首先是第一个函数pre_processer.py介绍

然后将这些表情符进行存储，避免后面进行重复读取，浪费时间

下一个函数进行表情的分类，这里参考论文中的共现率判断方式来评判未知表情的情感，但需要说明的是这里和论文中的复现基础不同，论文中的数据集是采用词向量的训练集，而这里给出的是句向量的标签信息，所以方式做了一个调整，判断该表情在积极句子中出现的次数与消极句子中出现的次数，同时也有中性的句子

当积极占比大于0.8时就是积极表情，消极同理，其余的由于情感不明显，归入中立的表情当中，分别存入三个数组，至此，表情的情感分类已经完成

文本处理

下面是文字处理的部分，也就是specialize.py部分，复现了论文中的一些关于文字权重的操作，并且进行了一些改进。首先由于给的数据集是句子，而且其中有很多诸如@、//之类的杂质对分析不利

所以首先应该做的就是数据清洗的工作，首先进行匹配过滤与正则过滤，把一些肉眼可见出现频率很高的无意义符号给去除

随后使用停词过滤

这里发现之前的停用词表存在一些不足, 具体停用词表可自行百度，因为其中存在一些诸如“很”、“特别”之类代表感情的词语，而在这里过滤掉之后影响后文分析,所以手动删除了所有的情感词，只留下一部分过滤无用词与符号，随后进行jieba分词，用作词性的标注

之后是常规程序TF-IDF选择每个句子的重要词成分，这里每个句子选择5个关键词，以避免后面的训练太慢

这里面也用到了论文中所说的副词重要性与位置的重要性进行权重的调整，比如说下面的权重数组

并且进行权重的修正，例如写一个简单的权重返回函数

还有尾词语比中部词语权重增加一倍，生成一个speciallist的特征向量，在后面进行训练的时候加入。这部分是对文字的训练。

构建模型训练

随后就是进行训练的部分，首先是读取数据集，定义初始权重

正面负面与中性的词语和表情权重分别为1、0、-1,然后先直接进行朴素贝叶斯训练，方便与后文实验效果做对比，值得一提的是文中是对词语进行分别打分计算权重，但这里复现时数据集不具备条件，于是赋予基础权重，也就是该词语所在句子超过80%情感的权重。

这里的六万条数据集进行交叉选取数据集与训练集，并且调库进行打分

而后的分类是对普通朴素贝叶斯的一个权重修正

可以看到加入了前面进行处理的特征向量，并且与正确结果进行对比，直接算比例，这里结果中可以看见提升非常明显，从百分之五十多直接提升到百分之八十多，说明论文中提出的方法明显有效（结果写在后文）。

前面都是定义方法，主体函数如下

三个类型分别进行训练并且叠加，因为实验二使用人工神经网络效果还不错，所以这里在后面也加了一个人工神经网络进行处理

也没有用工具进行调参，自己写了两个循环跑了一晚上,写入文件自己去判断参数优化情况，得出得分较高的参数组合，得出的结果也有了比较明显的优化。

结果

运行代码，得运行结果：

可以看出，用表情辅助对文本数据进行分类情感分析的效果，比单独的朴素贝叶斯分类效果要好一些。

而深度学习又比单纯朴素贝叶斯效果要更好

代码

表情处理

import csv
# 获取某一评论中存在的表情 参数：path：文件路径 emotion_set：用来存储表情列表
def get_emotion(path, emotion_set):
    with open(path, encoding= 'utf-8-sig') as f:
        reader = csv.reader(f)
        rows=[row for row in  reader]
        for each in rows:
            for i in range(len(each[0])):
                if each[0][i] == '[' : # 判断是否为表情符号
                    temp = ''
                    for k in range(100):
                        if i+k > len(each[0]) - 1:
                            break
                        temp = temp + each[0][i+k]
                        # print(each[i+k])
                        if each[0][i+k] == ']':
                            if temp not in emotion_set:
                                emotion_set.append(temp) # 若为表情符号则存储在该列表中，使每个符号只出现一次
                            # print(temp)
                            break
    return emotion_set


# 整合三个文件获取的表情存储于emotion_result_sat，存储于csv
def Save_as_File(save_path, emotion_result_set):  
    emotion_set = []
    Star_emotion_set = get_emotion('明星.csv', emotion_set)
    Hotspot_emotion_set = get_emotion('热点.csv', emotion_set)
    Epidemic_emotion_set = get_emotion('疫情.csv', emotion_set)
    for each in Star_emotion_set:
        if each not in emotion_result_set:
            emotion_result_set.append(each)
    for each in Hotspot_emotion_set:
        if each not in emotion_result_set:
            emotion_result_set.append(each)
    for each in Epidemic_emotion_set:
        if each not in emotion_result_set:
            emotion_result_set.append(each)
            
    with open(save_path, 'w', encoding='utf-8-sig') as f:
        for each in emotion_result_set:
            write=csv.writer(f)
            write.writerow(each)
    return emotion_result_set


# 根据评论标签1或-1的多少判断表情是积极还是负面，积极的存储于PE_set,负面的存储于NE_set
def creat_Respiratory(emotion_result_set):
    PE_set = []
    NE_set = []
    Neu_set = []
    with open('明星.csv',encoding= 'utf-8-sig') as f1:
        reader1 = csv.reader(f1)
        rows1=[row for row in  reader1]      
        with open('热点.csv',encoding= 'utf-8-sig') as f2:
            reader2 = csv.reader(f2)
            rows2=[row for row in  reader2]  
            with open('疫情.csv',encoding= 'utf-8-sig') as f3:
                reader3 = csv.reader(f3)
                rows3=[row for row in  reader3]
        
                temp_set = []
                for a in rows1:
                    temp_set.append(a)
                for b in rows2:
                    temp_set.append(b)
                for c in rows3:
                    temp_set.append(c) #将所有评论存储在一个列表temp_set内
    # print(temp_set)
    for emotion in emotion_result_set:
        positive = 0
        negtive = 0
        for critic in temp_set:
            # print(emotion)
            if emotion in critic[0]:
                if critic[1] == '1':
                    positive = positive + 1
                if critic[1] == '-1':
                    negtive = negtive + 1
        if positive + negtive == 0:
            Neu_set.append(emotion)
        else:
            if (positive/(positive + negtive)) > 0.8:
                PE_set.append(emotion)
            elif (negtive/(positive + negtive)) > 0.8:
                NE_set.append(emotion)
            else:
                Neu_set.append(emotion)
    with open('Positive_emotion.csv', 'w', encoding='utf-8-sig') as f:
        for each in PE_set:
            write=csv.writer(f)
            write.writerow(each)
        
    with open('Negtive_emotion.csv', 'w', encoding='utf-8-sig') as f:
        for each in NE_set:
            write=csv.writer(f)
            write.writerow(each)
        
    with open('Neu_emotion.csv', 'w', encoding='utf-8-sig') as f:
        for each in Neu_set:
            write=csv.writer(f)
            write.writerow(each)

    return PE_set, NE_set, Neu_set
    
    

# emotion_result_set = []
# emotion_result_set = Save_as_File('.//emotion//All_emotion.csv', emotion_result_set)
# PE_set, NE_set = creat_Respiratory(emotion_result_set)

文本处理

import pre_professer
import jieba
import csv
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfTransformer

list3=['最','最为','极','极其','极为','极度']
list2_5=['太','至','至为','顶','过','过于','过份','分外','万分']
list2=['很','挺','怪','非常','特别','相当','十分','甚为','够','多','多么']
list1_5=['不甚','不胜','好','好不','颇','颇为','大','大为']
list1_1=['稍','比较','较为','还']
list0_8=['稍稍','稍微','稍许','略微','多少']
list0_5=['有点','有些']
list_1=['甭', '别', '不', '不曾', '不必', '非', '没', '没有', '莫', '未必', '未尝', '无从', '无须', '不要', '不用', '不再', '不很', '不太', '绝非', '决非', '并非', '不能', '不常', '不会', '不可能', '何曾', '何尝', '勿']

def PLfenci(emotion_result_set, _class): #遍历每一条评论分词处理并去杂(去除表情、去除@内容、去除停用词)
    label_list = [] # 一维列表，存储评论标签
    with open('明星.csv',encoding= 'utf-8-sig') as f1:
        reader1 = csv.reader(f1)
        rows1=[row for row in  reader1]      
        with open('热点.csv',encoding= 'utf-8-sig') as f2:
            reader2 = csv.reader(f2)
            rows2=[row for row in  reader2]  
            with open('疫情.csv',encoding= 'utf-8-sig') as f3:
                reader3 = csv.reader(f3)
                rows3=[row for row in  reader3]
        
                temp_set = []
                for a in rows1:
                    if _class == 'Star' or _class == 'All':
                        temp_set.append(a)
                    label_list.append(a[1])
                for b in rows2:
                    if _class == 'Hotspot' or _class == 'All':
                        temp_set.append(b)
                    label_list.append(b[1])
                for c in rows3:
                    if _class == 'Epidemic' or _class == 'All':
                        temp_set.append(c) #将评论存储在一个列表temp_set内
                    label_list.append(c[1])
                if _class == 'All':
                    return temp_set, label_list
# 去除表情，去除@信息和停用表词
    for i in range(len(temp_set)):
        for emotion in emotion_result_set:
            if emotion in temp_set[i][0]:
                temp_set[i][0] = temp_set[i][0].replace(emotion, '')

    for each in temp_set:
        for m in range(len(each[0])):
            if (each[0][m] == '/') and (each[0][m+1] == '/') and (each[0][m+2] == '@'):
                while m < len(each[0]):
                    each[0] = each[0].replace(each[0][m], '')
                    m+=1
                break    
            
    for each in temp_set:
        for i in range(len(each[0])):
            if i < len(each[0]) and each[0][i] == '@':
                temp = ''
                while i < len(each[0]) and (each[0][i] != '：' or each[0][i] == ' '): # 注意要使用中文'：'
                    temp = temp + each[0][i]
                    i = i + 1
                each[0] = each[0].replace(temp, '')
           
    stop_list = []
    f_stop = open('.\\停用词表.txt', 'r', encoding = 'UTF-8')
    #获取停用词列表
    for each in f_stop:
        each = each.strip()#去除尾字符中的换行符
        stop_list.append(each)
    for each in temp_set:
        for k in stop_list:
            if k in each[0]:
                each[0] = each[0].replace(k, '')
    
# 进行jieba分词
    speciallist=[]
    data_list = [] # 二维列表，每个元素为一个评论预处理后的结果，每个结果也是一个列表，用','分割。
    for k in range(len(temp_set)):
        data_list.append([])
    k = 0
    for each in temp_set:
        a=checkpoint(each)
        speciallist.append(a)
        generator = jieba.cut(each[0])
        for i in generator:
            data_list[k].append(i)
        k = k + 1
    

# 预处理结果写入segment文件
    with open('.\\segment.csv', 'w', newline = '',encoding = 'utf-8-sig') as f:
        write = csv.writer(f)
        for each in data_list:
            write.writerow(each)

    return data_list, label_list,speciallist


def tfidf_get(data_list, _class): # 实现3，4功能 data_list即为前面获取的数据列表, 类名（和前一函数一致）
    transfer_data_list = [] #将data_list转化为tfidf可以看懂的格式
    for each in data_list:
        x = ' '.join(each)
        transfer_data_list.append(x)
    vectorizer = CountVectorizer() # 将文本中的词语转换为词频矩阵
    X = vectorizer.fit_transform(transfer_data_list) # 计算个词语出现的次数
    word_list = vectorizer.get_feature_names()  # 获取词袋中所有文本关键词
    transformer = TfidfTransformer() #类调用
    tfidf = transformer.fit_transform(X) #将词频矩阵X统计成TF-IDF值
    feature = [] # 存储所有评论的feature， 每个元素为一条评论的feature，每条评论5个feature。
    length = len(word_list)
    s = 0
    for each in tfidf.toarray():#进入二维列表tfidf_list的每一项中，遍历每一句的tfidf
        feature_list = []    #对于每一评论，初始特征置空
        item = 0#特征值计数变量，满5个为止
        while item < 5:
            max_tfidf = 0#最大值置零
            for i in range(length):#每一次循环找出一个最大tfidf值对应的word并存入feature_list列表中，并置该tfidf = 0
                if each[i] >= max_tfidf:
                    max_tfidf = each[i] 
                    m = i#记录相应索引号
                if i == (length - 1):# i = length - 1说明句子已经遍历到末尾了，此时最大的tfidf值就可以确定了
                    feature_list.append(word_list[m])
                    each[m] = 0
                    item = item + 1
        v = ' '.join(feature_list)
        feature.append(v)
        s = s + 1
    with open('.\\特征数据\\' + _class + '.csv', 'w', newline = '',encoding = 'utf-8-sig') as f:
        write = csv.writer(f)
        for each in feature:
            write.writerow(each)

def checkpoint(str):
    if str in list3:
        return 3
    elif str in list2_5:
        return 2.5
    elif str in list2:
        return 2
    elif str in list1_5:
        return 1.5
    elif str in list1_1:
        return 1.1
    elif str in list0_8:
        return 0.8
    elif str in list0_5:
        return 0.5
    elif str in list_1:
        return -1
    else:
        return 0

建模训练

import pre_professer
import specialize
from sklearn.model_selection import  train_test_split #数据集划分
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer  # 从sklearn.feature_extraction.text里导入文本特征向量化模块
from sklearn.metrics import classification_report
from sklearn.neural_network import MLPClassifier
import time

data = []#数据集
def Contribute_data(data, _class): # 获取class类别的数据
    with open('\\特征数据\\' + _class + '.csv', 'r', encoding = 'utf-8-sig') as fr:
        for tem in fr:
            tem = tem.replace(',', '')
            tem = tem.replace('\n', '')
            data.append(tem)
    return ''  
def get_target(lebal_list):
    target = []
    for each in lebal_list:
        if each == '1':
            target.append('积极')
        elif each == '0':
            target.append('中性')
        elif each == '-1':
            target.append('消极')
        else:
            target.append('中性')
    return target

def Bayesian(data, target):
    #数据预处理：训练集和测试集分割，文本特征向量化
    #X_train,X_test,y_train,y_test = train_test_split(data, target, test_size=30000 ,random_state=4) # 随机采样数据样本作为测试集
    X_train = data[10000:20000] + data[30000:40000] + data[60000: 80000]
    X_test = data[0:10000] + data[20000:30000] + data[50000: 60000]
    y_train = target[10000:20000] + target[30000:40000] + target[60000: 80000]
    y_test = target[0:10000] + target[20000:30000] + target[50000: 60000]
    k = X_test
    #文本特征向量化
    vec = CountVectorizer()
    X_train = vec.fit_transform(X_train)
    X_test = vec.transform(X_test)
    #print(y_test)
    #print(y_train)
    #使用朴素贝叶斯进行训练
    mnb = MultinomialNB()   # 使用默认配置初始化朴素贝叶斯
    mnb.fit(X_train,y_train)    # 利用训练数据对模型参数进行估计
    y_predict = mnb.predict(X_test)     # 对参数进行预测
    #print(y_predict)
    #获取结果报告
    print ('不带表情的朴素贝叶斯:', mnb.score(X_test,y_test))
    print ('其它指标:\n',classification_report(y_test, y_predict, target_names = ['积极', '中性', '消极']))
    
    return k, y_test, y_predict

def Fenlei(emotion_X_test, emotion_y_test, emotion_y_predict, origin_list, PE_set, NE_set, Neu_set,specialist): # 运用表情训练
    o_list = origin_list[0:10000] + origin_list[20000:30000] + origin_list[50000: 60000]
    length = len(emotion_y_predict)
    for i in range(length):
        if emotion_y_test[i] != emotion_y_predict[i]:
            key = 0
            if '' in emotion_X_test[i]:

                for each in PE_set:
                    if each in o_list[i]:
                        key = key + 1
                for each in NE_set:
                    if each in o_list[i]:
                        key = key - 1
                key+=specialist[i]
                if key > 0:
                    emotion_y_predict[i] = '积极'
                if key < 0:
                    emotion_y_predict[i] = '消极'
                if key == 0:
                   emotion_y_predict[i] = '中性'
            else:
                key = 0.5
                for each in PE_set:
                    if each in o_list[i]:
                        key = key + 1
                for each in NE_set:
                    if each in o_list[i]:
                        key = key - 1
                for each in Neu_set:
                    if each in o_list[i]:
                        key = key - 0.5
                if key > 0:
                    emotion_y_predict[i] = '积极'
                if key < 0:
                    emotion_y_predict[i] = '消极'
                if key == 0:
                    emotion_y_predict[i] = '中性'
# 呈现分类结果
    rate = 0
    for p in range(length):
        if emotion_y_predict[p] == emotion_y_test[p]:
            rate += 1
    print('带表情的贝叶斯：%.8f'%(rate/30000))
                
    return ''
start=time.time()
print('开始预处理')
emotion_result_set = []
emotion_result_set = pre_professer.Save_as_File('All_emotion.csv', emotion_result_set)
PE_set, NE_set, Neu_set = pre_professer.creat_Respiratory(emotion_result_set)
print('预处理完毕')

Star_data_list,lebal_list ,specialkist= specialize.PLfenci(emotion_result_set, 'Star')
print('开始star处理')
feature = specialize.tfidf_get(Star_data_list, 'Star')
print('Star类别特征构建成功')
print('开始hotpot处理')
Hotspot_data_list,lebal_list ,specialkist= specialize.PLfenci(emotion_result_set, 'Hotspot')
feature = specialize.tfidf_get(Hotspot_data_list, 'Hotspot')
print('Hotspot特征构建成功')
Epidemic_data_list,lebal_list ,specialkist= specialize.PLfenci(emotion_result_set, 'Epidemic')
feature = specialize.tfidf_get(Epidemic_data_list, 'Epidemic')
print('Epidemic特征构建成功')

Contribute_data(data, 'Star')
Contribute_data(data, 'Hotspot')
Contribute_data(data, 'Epidemic')

origin_list, lebal_list = specialize.PLfenci(emotion_result_set, 'All')
target = get_target(lebal_list)
emotion_X_test, emotion_y_test, emotion_y_predict = Bayesian(data, target)
#print(len(emotion_y_test))
Fenlei(emotion_X_test, emotion_y_test, emotion_y_predict, origin_list, PE_set, NE_set, Neu_set,specialkist)
size = (10,10000)
iters = 10000
clf = MLPClassifier(activation='relu', alpha=1e-05, batch_size='auto', beta_1=0.9,
       beta_2=0.999, early_stopping=False, epsilon=1e-08,
       hidden_layer_sizes=size, learning_rate='constant',
       learning_rate_init=0.001, max_iter=iters, momentum=0.9,
       nesterovs_momentum=True, power_t=0.5, random_state=1, shuffle=True,
       solver='adam', tol=0.0001, validation_fraction=0.1, verbose=False,
       warm_start=False)#多层感知机
tv=specialize.tfidf_get()
print('深度学习:',clf.score(tv.transform(emotion_X_test),emotion_y_test))
from sklearn.metrics import classification_report
print('其它指标:\n',classification_report(emotion_y_predict,clf.predict(tv.transform(emotion_X_test))))
end=time.time()

参考论文：基于表情符分析的情感关键句提取方法
（提取码：3882）