深度学习：对评论信息的情感分析，建立模型，自动识别评论信息的情绪状态完整代码实现

评论

思考：向模型中传递数据时，需要提前处理好数据

1、目标：将评论内容转换为词向量。

2、每个词/字转换为词向量长度(维度)200

3、每一次传入的词/字的个数是否就是评论的长度?     

        应该是固定长度，每次传入数据与图像相似。例如选择长度为70。则传入的数据为70*200

4、一条评论如果超过70个词/字怎么处理？     

        直接删除后面的内容

5、一条评论如果没有70个词/字怎么处理？     

        缺少的内容，统一使用一个数字（非词/字的数字）替代。

6、如果语料库中的词/字太多是否可以压缩？     

        可以，某些词/字出现的频率比较低，可能训练不出特征。因此可以选择频率比较高的词来训练。例如选择4760个。

7、被压缩的词/字如何处理？     

        可以统一使用一个数字（非词/字的数字）替代。

1.处理文本数据集，将其分为训练集、验证集和测试集

处理文本数据集，将其分为训练集、验证集和测试集

初始化一个空列表，用于存储处理后的数据。

from tqdm import tqdm
import pickle as pkl
import random
import torch
unk,pad='<UNK>','<PAD>'
def load_dataset(path,pad_size=70):
    contents=[]
    #加载文件：4760个最多的字
    vocab=pkl.load(open('simplifyweibo_4_moods.pkl','rb'))
    #定义一个函数，加载预训练的词汇表
    tokenizer=lambda x:[y for y in x]

读取和处理数据遍历每行提取标签，评论内容，每行的字符数目

    # 读取文件里面的评论
    with open(path,'r',encoding='UTF-8') as f:
        i=0
        # 遍历每行
        for line in tqdm(f):
            #第一行不是评论
            if i==0:
                i+=1
                continue
            if not line:
                continue
            # 标签
            label=int(line[0])
            # 内容
            content=line[2:].strip('\n')
            words_line=[]
            #将每行内容拆分
            token=tokenizer(content)
            #每行的字符数目
            seq_len=len(token)

对序列不足的进行填充或序列过多的截断

            if pad_size:
                #小于70增加pad
                if len(token)<pad_size:
                    token.extend([pad]*(pad_size-len(token)))
                # 大于70，去除70后的
                else:
                    token=token[:pad_size]
                    seq_len=pad_size

遍历每个词，使用词汇表将其转换为索引，如果词不在词汇表中，则使用 <UNK> 的索引,将字符串，标签，数目组成一个元组放入列表

            for word in token:
                # 将在4760里面的字符加入列表，不在里面的定义为unk
                words_line.append(vocab.get(word,vocab.get(unk)))
            # 将字符串，标签，数目组成一个元组放入列表
            contents.append((words_line,int(label),seq_len))

随机打乱数据集划分训练集、验证集和测试集

 # 随机打乱
        random.shuffle(contents)
        train_data=contents[:int(len(contents)*0.8)]
        dev_data=contents[int(len(contents)*0.8):int(len(contents)*0.9)]
        test_data = contents[int(len(contents) * 0.9):]
    return vocab,train_data,dev_data,test_data

对于生成的训练集、验证集和测试集进行数据转换成LongTensor类型

代码

定义了一个名为 DatasetIterater 的类，它是一个迭代器，用于在深度学习任务中批量处理数据。

class DatasetIterater(object):
    def __init__(self,batches,batch_size,device):
        self.batch_size = batch_size
        self.batches = batches
        #设置批次大小和数据批次。
        self.n_batches = len(batches) // batch_size
        self.residue = False
        #如果有一个包没有存完
        if len(batches) % self.n_batches != 0:  # 表示有余数
            self.residue = True
        self.index = 0
        self.device = device

内容，标签，数目转化为LongTensor类型

    def _to_tensor(self,datas):
        #内容，标签，数目转化为LongTensor类型
        x=torch.LongTensor([_[0] for _ in datas]).to(self.device)
        y=torch.LongTensor([_[1] for _ in datas]).to(self.device)
        seq_len=torch.LongTensor([_[2] for _ in datas]).to(self.device)
        return (x,seq_len),y

逐个处理数据集中的批次

如果当前索引大于完整批次的数量，处理最后一个不完整的批次。

    def __next__(self):
        #如果当前索引大于完整批次的数量，处理最后一个不完整的批次。
        if self.residue and self.index ==self.n_batches: