循环神经网络（RNN）+pytorch实现情感分析

**Deep Input-to-Hidden Function：**它在循环层之前加入多个全连接层，将输入向量进行多层映射之后再送入循环层进行处理。

**Deep Hidden-to-Hidden Transition：**它使用多个循环层，这与前馈型神经网络类似，唯一不同的是计算隐含层输出的时候需要利用本隐含层上一时刻的值。

**Deep Hidden-to-Output Function：**它在循环层到输出层之间加入多个全连接层。

三、网络的训练

循环神经网络（RNN）处理序列数据，每个训练样本是一个时间序列，包含多个相同维度的向量。训练使用BPTT算法**（Back Propagation Through Time 算法）**，先对序列中每个时刻的输入进行正向传播，再通过反向传播计算梯度并更新参数。每个训练样本的序列长度可以不同，前后时刻的输入值有关联。

3.1 训练过程举例

网络结构如下：

有一个训练样本，其序列值为：。其中，为输入向量，为标签向量。循环层状态的初始值设置为 0。

在 t=1 时刻，网络的输出为：

在 t=2 时刻，网络的输出为：

在 t=3 时刻，网络的输出为：

对单个样本的序列数据，定义 t 时刻的损失函数为：

样本的总损失函数为各个时刻损失函数之和：

1）输出层

如果输出层使用 softmax 变换，则损失函数为 softmax 交叉熵：

梯度的计算公式为：

根据之前全连接神经网络中的推论：，

可以得到t 时刻：

损失函数对输出层权重的梯度：
损失函数对偏置项的梯度为：

故得到总时刻：

总损失函数对权重的梯度为：
总损失函数对偏置项的梯度为：

2）循环层

按时间序列展开之后，各个时刻在循环层的输出值是权重矩阵和偏置项的复合函数。

在 t=1 时刻，

根据全连接神经网络中的推论

可以得到损失函数对的梯度：

由于 t=1 时循环层的输出值与无关，因此：

对偏置项的偏导为：

在 t=2 时刻，。当前式子中出现了两次，因此损失函数对的梯度为：

又由于：，故有

可以得到损失函数对的梯度为：

损失函数对的梯度为：

在 t=3 时刻，。当前式子中出现了三次，因此损失函数对的梯度为：

类似地，可以计算出：

由此可以计算出和。在计算出每个时刻的损失函数对各个参数的梯度之后，把它们加起来得到总损失函数对各个参数的梯度：

接下来用梯度下降法更新参数。

3.2 BPTT 算法

将上面的例子推广到一般情况，得到通用的 BPTT 算法。

循环神经网络的反向传播是基于时间轴进行的，我们需要计算所有时刻的总损失函数对所有参数的梯度，然后用梯度下降法进行更新。另外循环神经网络在各个时刻的权重、偏置都是相同的。

设 t 时刻的损失函数为：

总损失函数为：

1）输出层

首先计算输出层偏置项的梯度 ：

如果选择 softmax 作为输出层的激活函数，交叉熵作为损失函数，则上面的梯度为：

对输出层权重矩阵的梯度 为：

2）循环层

因此有：

由此建立了与之间的递推关系。定义误差项为：

在总损失函数中，比更早的时刻的损失函数不含有，因此与无关。由于由决定，因此与直接相关。比晚的时刻的， ...，都与有关，因此有：

存在

从而得到：

由此建立了误差项沿时间轴的递推公式，递推的起点是最后一个时刻的误差：

根据误差项可以计算出损失函数对权重和偏置的梯度：

3）算法流程

四、循环神经网络实现情感分析

4.1 实验介绍

通过 RNN 模型对电影评论进行情感分类，判断评论是正面还是负面。

4.2 数据集介绍

IMDB 数据集包含 50,000 条电影评论，其中一半用于训练（25,000 条），另一半用于测试（25,000 条）。每条评论都附带一个标签，要么是'pos'表示正面评价，要么是'neg'表示负面评价。这些评论通常以文本文件的形式存在，每个文件中包含一条评论。

4.3 Embedding操作

Embedding 过程：计算机无法直接处理一个单词或者一个汉字，需要把一个 token 转化成计算机可以识别的向量。

Embedding 是一种将高维数据（如文本或图像）转换为较低维度的向量表示的技术。这种表示捕捉了数据的关键特征，使得在处理、分析和机器学习任务中更加高效。通常用于将离散的、非连续的数据转换为连续的向量表示，以便于计算机进行处理。

Embedding 技术通常会捕获数据的语义信息。在 NLP 中，这意味着相似的单词或短语在嵌入空间中会更接近，而不同的单词或短语会远离彼此。这有助于模型理解语言的含义和语义关系。

Embedding 技术通常是上下文感知的，它们可以捕获数据点与其周围数据点的关系。在 NLP 中，单词的嵌入会考虑其周围的单词，以更好地表示语法和语义。

简单的说， Embedding 就是把一个东西映射到一个向量 X。如果这个东西很像，那么得到的向量 x1 和 x2 的欧式距离就很小。

4.4 pytorch实现

1）数据处理

首先对数据集进行处理，提取单词表，单词表的最大尺寸是 10000。

python 复制代码

# 加载数据
def load_data(data_dir):
    texts = []  # 存储文本数据
    labels = []  # 存储标签数据
    for label_type in ['neg', 'pos']:  # 遍历负面和正面评论目录
        dir_name = os.path.join(data_dir, label_type)  # 构建目录路径  /IMDB/train/neg/0_2.txt
        for fname in os.listdir(dir_name):  # 遍历目录中的文件
            if fname.endswith('.txt'):  # 只处理文本文件
                with open(os.path.join(dir_name, fname), encoding="utf-8") as f:
                    texts.append(f.read())  # 读取文本内容
                labels.append(0 if label_type == 'neg' else 1)  # 根据目录确定标签（负面：0，正面：1）
    return texts, labels  # 返回文本和标签


# 加载训练和测试数据
train_texts, train_labels = load_data('./IMDB/train')
test_texts, test_labels = load_data('./IMDB/test')

# 构建词汇表
max_features = 10000  # 词汇表大小，最多包含10000个单词
maxlen = 150  # 每个文本的最大长度为150

tokenizer = Counter(" ".join(train_texts).split())  # 统计词频
# print(tokenizer.most_common(100))
# [('the', 287032), ('a', 155096), ('and', 152664), ('of', 142972),
# ('to', 132568), ('is', 103229), ('in', 85580), ('I', 65973), ('that', 64560), ('this', 57199), ('it', 54439), ('/><br', 50935), ('was', 46698), ('as', 42510), ('with', 41721), ('for', 41070), ('but', 33790), ('The', 33762), ('on', 30767), ('movie', 30506), ('are', 28499), ('his', 27687), ('film', 27402), ('have', 27126), ('not', 26266), ('be', 25512), ('you', 25123), ('he', 21676), ('by', 21426), ('at', 21295), ('one', 20692), ('an', 20626), ('from', 19239), ('who', 18838), ('like', 18133), ('all', 18048), ('they', 17840), ('has', 16472), ('so', 16336), ('just', 16326), ('about', 16286), ('or', 16224), ('her', 15830), ('out', 14368), ('some', 14207), ('very', 13082), ('more', 12950), ('This', 12279), ('would', 11923), ('what', 11685), ('when', 11488), ('good', 11436), ('only', 11106), ('their', 11008), ('It', 10952), ('if', 10899), ('had', 10876), ('really', 10815), ("it's", 10727), ('up', 10658), ('which', 10658), ('even', 10607), ('can', 10560), ('were', 10460), ('my', 10166), ('see', 10155), ('no', 10062), ('she', 9933), ('than', 9772), ('-', 9355), ('been', 9050), ('there', 9036), ('into', 8950), ('get', 8777), ('will', 8558), ('story', 8527), ('much', 8507), ('because', 8357), ('other', 7917), ('most', 7859), ('we', 7808), ('time', 7765), ('me', 7540), ('make', 7485), ('could', 7462), ('also', 7422), ('do', 7408), ('how', 7403), ('first', 7339), ('people', 7335), ('its', 7323), ('/>The', 7243), ('any', 7232), ('great', 7191), ("don't", 7007), ('made', 6962), ('think', 6659), ('bad', 6506), ('him', 6347), ('being', 6202)]
vocab = [word for word, num in tokenizer.most_common(max_features)]  # 取出前10000个常用词
# print(vocab)
word_index = {word: idx + 1 for idx, word in enumerate(vocab)}  # 为每个词分配一个索引
# print(word_index)


# 将文本转换为序列
def texts_to_sequences(texts):
    return [[word_index.get(word, 0) for word in text.split()] for text in texts]


# 转换训练和测试文本为序列
x_train = texts_to_sequences(train_texts)#{}
x_test = texts_to_sequences(test_texts)

# 将序列填充到固定长度
x_train_padded = pad_sequence([torch.tensor(seq[:maxlen]) for seq in x_train], batch_first=True, padding_value=0)
x_test_padded = pad_sequence([torch.tensor(seq[:maxlen]) for seq in x_test], batch_first=True, padding_value=0)

y_train = torch.tensor(train_labels)  # 转换训练标签为张量
y_test = torch.tensor(test_labels)  # 转换测试标签为张量


# 创建 Dataset 和 DataLoader
class TextDataset(Dataset):
    def __init__(self, texts, labels):
        self.texts = texts  # 文本数据
        self.labels = labels  # 标签数据

    def __len__(self):
        return len(self.labels)  # 返回数据集大小

    def __getitem__(self, idx):
        return self.texts[idx], self.labels[idx]  # 返回指定索引的数据


train_dataset = TextDataset(x_train_padded, y_train)  # 创建训练数据集
test_dataset = TextDataset(x_test_padded, y_test)  # 创建测试数据集

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)  # 创建训练数据加载器
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)  # 创建测试数据加载器

2）模型设计

实现一个简单的循环神经网络，第一层是 embedding 层，词嵌入的大小是 100；第二层是循环层，循环层的输入尺寸是 100，神经元数量是 256；第三层是全连接层也就是输出层，输入尺寸是 256，输出是 1，因为这是一个二分类问题，所以输出尺寸是 1 即可。

python 复制代码

class SimpleRNN(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, output_dim):
        super(SimpleRNN, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)  # 词嵌入层
        self.rnn = nn.RNN(embed_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, text):
        embedded = self.embedding(text)
        output, hidden = self.rnn(embedded)
        out = self.fc(output[:, -1, :])
        return out

3）训练配置

设置损失函数和优化器。

python 复制代码

model = SimpleRNN(max_features + 1, 100, 256, 1)  # 创建模型实例
# 编译模型
criterion = nn.CrossEntropyLoss()  # 使用交叉熵损失函数
optimizer = optim.Adam(model.parameters())  # 使用 SGD/Adam 优化器

4）训练过程

训练并保存模型

python 复制代码

# 训练模型
def train(model, train_loader, optimizer, criterion, epochs):
    for epoch in range(epochs):  # 训练一个周期
        model.train()  # 设置模型为训练
        for texts, labels in train_loader:  # 遍历训练数据
            optimizer.zero_grad()  # 清零梯度
            outputs = model.forward(texts)  # 前向传播
            loss = criterion(outputs.squeeze(), labels.float())  # 计算损失
            loss.backward()  # 反向传播
            optimizer.step()  # 更新参数

# 训练并测试模型
train(model, train_loader, optimizer, criterion, epochs=1)
# 模型保存并测试
torch.save(model.state_dict(), 'rnn_state_dict.pth')

5）测试模型

评估模型性能

python 复制代码

# 测试模型
def predict(model, test_loader):
    model.eval()  # 设置模型为评估模式
    correct = 0
    total = 0
    with torch.no_grad():  # 不计算梯度
        for texts, labels in test_loader:  # 遍历测试数据
            outputs = model.forward(texts)  # 前向传播
            predicted = (outputs.squeeze() > 0.5).int()  # 预测标签
            total += labels.size(0)  # 总样本数
            correct += (predicted == labels).sum().item()  # 正确预测数
    print(f'测试准确率: {correct / total}')

# 模型评估
model = SimpleRNN(max_features + 1, 100, 256, 1)
model.load_state_dict(torch.load('rnn_state_dict.pth'))
predict(model, test_loader)