使用LSTM进行情感分类：原理与实现剖析

1. 引言

情感分类是自然语言处理（NLP）中的一项基础而重要的任务，旨在自动判断文本的情感倾向（如正面或负面）。传统机器学习方法在处理此类任务时面临诸多挑战，尤其是在处理变长序列数据和捕捉长距离依赖关系方面。循环神经网络（RNN）及其改进型长短期记忆网络（LSTM）通过其序列建模能力，为这类问题提供了优雅的解决方案。本文将深入剖析一个基于PyTorch实现的LSTM情感分类器，从数据预处理到模型推理，逐层解析其背后的核心原理。

1.1. 任务背景与应用场景

情感分类在现实世界中有着广泛的应用，例如电商平台的产品评论分析、社交媒体的舆情监控、客户服务中的反馈自动归类等。本示例聚焦于二分类任务：判断英文电影评论的情感是正面（标签1）还是负面（标签0）。代码中的训练数据清晰展示了这一任务：

python 复制代码

# 训练数据：(评论, 标签)，0代表负面，1代表正面
train_data = [
  ("this movie is great", 1),
  ("i love this film", 1),
  ("what a fantastic show", 1),
  ("the plot is boring", 0),
  ("i did not like the acting", 0),
  ("it was a waste of time", 0),
]

尽管训练数据规模较小，但完整实现了从原始文本到预测输出的端到端流程，为理解更复杂的NLP系统奠定了坚实基础。

1.2. LSTM的演进与优势

基础RNN在处理长序列时容易遭遇梯度消失或爆炸问题，导致模型难以学习到远距离的依赖关系。LSTM通过引入门控机制（遗忘门、输入门、输出门）和细胞状态，有选择性地保留或丢弃信息，从而有效缓解了这些问题。这使得LSTM特别适合捕捉句子中单词间的长期语义关联。如代码注释所示：

python 复制代码

# 相比基础RNN，LSTM通过精巧的门控机制（遗忘门、输入门、输出门）来解决梯度消失问题，
# 从而能更好地捕捉句子中的长距离依赖关系。

2. 数据准备与预处理

文本数据不能直接输入神经网络，必须转化为数值形式。预处理阶段的目标是将人类可读的句子转换为模型可处理的张量，同时处理序列长度不一带来的挑战。

2.1. 词汇表构建与索引映射

代码首先构建了一个词汇表（word_to_idx），将每个唯一单词映射到一个整数索引。特殊标记<PAD>被赋予索引0，用于后续的序列填充操作：

python 复制代码

# 构建词汇表
word_to_idx = {"<PAD>": 0}  # <PAD> 是用于填充的特殊标记
for sentence, _ in train_data:
  for word in sentence.split():
    if word not in word_to_idx:
      word_to_idx[word] = len(word_to_idx)
vocab_size = len(word_to_idx)
idx_to_word = {i: w for w, i in word_to_idx.items()}

词汇表的大小（vocab_size）决定了词嵌入层的输入维度。这种索引化表示取代了高维稀疏的One-Hot编码，为后续的稠密向量表示奠定了基础。

2.2. 序列填充与批处理标准化

传统神经网络层（如全连接层）通常要求输入具有固定的维度。然而，自然语言句子长度可变。pad_sequence函数通过添加<PAD>标记，将所有序列填充到同一长度（本示例中为最长句子的长度）：

python 复制代码

# 将句子转换为索引序列
sequences = [torch.tensor([word_to_idx[w] for w in s.split()]) for s, _ in train_data]
labels = torch.tensor([label for _, label in train_data], dtype=torch.float32)

# 填充序列，使它们长度一致
# 传统的神经网络要求输入大小固定，因此我们需要将不同长度的句子填充到相同的长度。
# 这对应了PPT中提到的传统模型处理序列数据的挑战之一。
padded_sequences = pad_sequence(sequences, batch_first=True, padding_value=word_to_idx["<PAD>"])

batch_first=True参数确保了张量的形状为[batch_size, seq_len]，符合PyTorch中多数层对输入格式的预期。填充操作虽然引入了冗余信息，但通过padding_idx参数可在词嵌入层中忽略这些填充位置，避免其对模型学习产生干扰。

3. LSTM模型架构详解

LSTMSentimentClassifier类定义了模型的核心结构，依次包含词嵌入层、LSTM层和全连接输出层。每一层都承担着特定的功能，共同完成从离散符号到连续情感概率的映射。

3.1. 词嵌入层：从离散符号到连续语义空间

nn.Embedding层是一个可训练的查找表，它将每个单词索引映射为一个固定大小的稠密向量（embedding_dim维）。如代码所示：

python 复制代码

# 词嵌入层 (Embedding Layer)
# 将每个单词的索引映射到一个密集的词向量。
# 这是比One-Hot更高效的表示方法。
self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=0)

与One-Hot编码相比，词嵌入具有以下优势：

维度更低：典型嵌入维度（如50-300）远小于词汇表大小（可能数万），大幅减少参数数量。
语义编码：在训练过程中，语义相似的单词（如"great"和"fantastic"）会逐渐在向量空间中靠近。
泛化能力：模型能够一定程度上理解未在训练集中出现但语义相近的单词。

3.2. LSTM层：序列信息的门控式传播

LSTM层是模型的核心，其输入为词嵌入序列（形状[batch_size, seq_len, embedding_dim]）。代码中的LSTM层定义和调用方式如下：

python 复制代码

# LSTM层
# 接收词向量序列作为输入，并输出隐藏状态。
# batch_first=True 表示输入的第一个维度是batch_size。
self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)

# 在前向传播中：
# LSTM的输出包括所有时间步的输出和最后一个时间步的隐藏状态(h_n)与细胞状态(c_n)
# 我们这里只需要最后一个隐藏状态 h_n 来代表整个句子。
lstm_out, (hidden, cell) = self.lstm(embedded)

在文本分类任务中，我们通常只关心整个句子的汇总表示。因此，代码仅取用LSTM最后一个时间步的隐藏状态（hidden.squeeze(0)），它承载了前面所有单词编码后的累积语义信息。如注释所述：

python 复制代码

# 我们只取用LSTM最后一个时间步的隐藏状态，因为它被认为是整个句子的语义摘要。
# 这对应PPT中提到的，在文本分类任务中，我们通常只关心 h_T。

3.3. 输出层与概率化

最后一个隐藏状态通过一个全连接层（nn.Linear）映射到一维输出，然后经过Sigmoid函数压缩到(0,1)区间：

python 复制代码

# 全连接层 (分类器)
self.fc = nn.Linear(hidden_dim, output_dim)

# 在前向传播的最后：
output = self.fc(final_hidden_state)
return torch.sigmoid(output)

这个值被解释为句子属于正面情感的概率。Sigmoid函数是二分类任务的理想选择，其输出可直接与二元标签（0或1）通过二元交叉熵损失进行比对。

4. 训练过程与优化策略

模型的训练是一个迭代优化过程，目标是调整参数以最小化预测误差。代码中定义了一个标准的监督学习流程。

4.1. 损失函数与优化器选择

nn.BCELoss（二元交叉熵损失）衡量了预测概率分布与真实标签分布之间的差异。优化器选用Adam：

python 复制代码

model = LSTMSentimentClassifier(vocab_size, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM)
optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
criterion = nn.BCELoss()  # 二元交叉熵损失，适用于二分类问题

nn.BCELoss的数学表达式为：Loss = -[y*log(p) + (1-y)*log(1-p)]，其中y是真实标签，p是预测概率。这种损失函数对概率的校准非常敏感，当预测概率与真实标签偏离时会产生较大的梯度。Adam优化器结合了动量（Momentum）和自适应学习率的优点，通常比标准随机梯度下降（SGD）收敛更快、更稳定。

4.2. 训练循环与性能监控

在训练循环中，每个周期（epoch）包含以下步骤：

python 复制代码

for epoch in range(EPOCHS):
  model.train()
  optimizer.zero_grad()

  # 前向传播
  predictions = model(padded_sequences).squeeze(1)

  # 计算损失
  loss = criterion(predictions, labels)

  # 反向传播
  loss.backward()
  optimizer.step()

  if (epoch + 1) % 20 == 0:
    # 计算准确率
    rounded_preds = torch.round(predictions)
    correct = (rounded_preds == labels).float()
    accuracy = correct.sum() / len(correct)
    print(f'Epoch: {epoch + 1:02}, Loss: {loss.item():.4f}, Accuracy: {accuracy.item() * 100:.2f}%')

每20个周期打印一次损失和准确率，方便开发者监控训练过程。准确率的计算通过四舍五入预测概率得到0/1预测，再与真实标签比较。在小型数据集上，模型通常能快速达到较高的准确率，但需注意过拟合风险。

5. 推理阶段与模型泛化

训练好的模型需应用于未见过的数据。predict_sentiment函数封装了推理流程，体现了模型的实际使用方式。

5.1. 推理模式与梯度计算禁用

model.eval()将模型设置为评估模式，这会关闭Dropout、BatchNorm等层在训练和评估阶段的不同行为。with torch.no_grad()上下文管理器会禁用梯度计算：

python 复制代码

def predict_sentiment(model, sentence):
  model.eval()
  with torch.no_grad():
    # 将句子转换为索引序列
    words = sentence.split()
    indexed = [word_to_idx.get(w, 0) for w in words]  # 如果词不在词汇表中，用<PAD>索引
    tensor = torch.LongTensor(indexed).unsqueeze(0)  # 增加batch维度
    # 预测
    prediction = model(tensor)
    return "正面" if prediction.item() > 0.5 else "负面"

5.2. 处理未登录词与动态输入

在将新句子转换为索引序列时，使用word_to_idx.get(w, 0)处理词汇表外的单词（未登录词），将其映射为<PAD>的索引（0）。这是一种简单的处理策略，在实际应用中可能需要更复杂的方法。unsqueeze(0)为输入增加一个批次维度，即使只有单个句子也符合模型对输入形状[batch_size, seq_len]的预期。

推理示例展示了模型的应用：

python 复制代码

# 测试新句子
test_sentence_1 = "this film is fantastic"
print(f"'{test_sentence_1}' 的情感是: {predict_sentiment(model, test_sentence_1)}")

test_sentence_2 = "the acting was terrible"
print(f"'{test_sentence_2}' 的情感是: {predict_sentiment(model, test_sentence_2)}")

6. 总结与扩展思考

本示例实现了一个完整的LSTM情感分类流水线，涵盖了从原始文本到情感预测的全过程。虽然基于小型合成数据，但它清晰地演示了关键概念：序列填充、词嵌入、LSTM门控机制以及端到端训练。

6.1. 模型局限性与改进方向

当前实现有几个可扩展的方向：

使用预训练词向量：如GloVe或Word2Vec，可提升模型对词汇语义的理解，尤其利于小数据集场景。
双向LSTM：同时考虑前后文信息，能更好地捕获句子整体语义。
注意力机制：允许模型动态聚焦于句子中更重要的单词，而非仅仅依赖最后一个隐藏状态。
更大规模的数据集：如IMDb电影评论数据集，能训练出更稳健的模型。

6.2. 在生产环境中的考量

部署到生产环境时，还需考虑模型序列化、API封装、并发处理以及持续监控模型性能漂移等问题。此外，对于中文等非空格分隔的语言，需要引入分词步骤作为预处理的一部分。

通过剖析这段代码，我们不仅理解了LSTM情感分类器的实现细节，更深化了对序列模型如何从原始文本中提取语义并做出决策的认识。这为探索更先进的Transformer架构（如BERT）奠定了坚实的基础。

7. 源码附录

python 复制代码

import torch
import torch.nn as nn
import torch.optim as optim
from torch.nn.utils.rnn import pad_sequence
import sys


# 解决输出汉字显示问题
if sys.stdout.encoding != 'utf-8':
  sys.stdout.reconfigure(encoding='utf-8')
if sys.stderr.encoding != 'utf-8':
  sys.stderr.reconfigure(encoding='utf-8')


# 数据准备
# 训练数据：(评论, 标签)，0代表负面，1代表正面
train_data = [
  ("this movie is great", 1),
  ("i love this film", 1),
  ("what a fantastic show", 1),
  ("the plot is boring", 0),
  ("i did not like the acting", 0),
  ("it was a waste of time", 0),
]

# 构建词汇表
word_to_idx = {"<PAD>": 0}  # <PAD> 是用于填充的特殊标记
for sentence, _ in train_data:
  for word in sentence.split():
    if word not in word_to_idx:
      word_to_idx[word] = len(word_to_idx)
vocab_size = len(word_to_idx)
idx_to_word = {i: w for w, i in word_to_idx.items()}


# 将句子转换为索引序列
sequences = [torch.tensor([word_to_idx[w] for w in s.split()]) for s, _ in train_data]
labels = torch.tensor([label for _, label in train_data], dtype=torch.float32)

# 填充序列，使它们长度一致
# 传统的神经网络要求输入大小固定，因此我们需要将不同长度的句子填充到相同的长度。
# 这对应了PPT中提到的传统模型处理序列数据的挑战之一。
padded_sequences = pad_sequence(sequences, batch_first=True, padding_value=word_to_idx["<PAD>"])


# 定义LSTM模型
# 相比基础RNN，LSTM通过精巧的门控机制（遗忘门、输入门、输出门）来解决梯度消失问题，
# 从而能更好地捕捉句子中的长距离依赖关系。
class LSTMSentimentClassifier(nn.Module):
  def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim):
    super(LSTMSentimentClassifier, self).__init__()
    # 词嵌入层 (Embedding Layer)
    # 将每个单词的索引映射到一个密集的词向量。
    # 这是比One-Hot更高效的表示方法。
    self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=0)

    # LSTM层
    # 接收词向量序列作为输入，并输出隐藏状态。
    # batch_first=True 表示输入的第一个维度是batch_size。
    self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)

    # 全连接层 (分类器)
    # 我们只取用LSTM最后一个时间步的隐藏状态，因为它被认为是整个句子的语义摘要。
    # 这对应PPT中提到的，在文本分类任务中，我们通常只关心 h_T。
    self.fc = nn.Linear(hidden_dim, output_dim)

  def forward(self, text):
    # text: [batch_size, seq_len]
    embedded = self.embedding(text)
    # embedded: [batch_size, seq_len, embedding_dim]

    # LSTM的输出包括所有时间步的输出和最后一个时间步的隐藏状态(h_n)与细胞状态(c_n)
    # 我们这里只需要最后一个隐藏状态 h_n 来代表整个句子。
    lstm_out, (hidden, cell) = self.lstm(embedded)

    # hidden: [num_layers, batch_size, hidden_dim]
    # 我们只需要最后一个隐藏状态，所以取 hidden.squeeze(0)
    final_hidden_state = hidden.squeeze(0)

    # 通过全连接层和Sigmoid函数得到最终的概率
    output = self.fc(final_hidden_state)
    return torch.sigmoid(output)


# 训练模型
# 定义模型参数
EMBEDDING_DIM = 10
HIDDEN_DIM = 32
OUTPUT_DIM = 1
LEARNING_RATE = 0.1
EPOCHS = 200

model = LSTMSentimentClassifier(vocab_size, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM)
optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)
criterion = nn.BCELoss()  # 二元交叉熵损失，适用于二分类问题

print("开始训练LSTM情感分类模型...")
for epoch in range(EPOCHS):
  model.train()
  optimizer.zero_grad()

  # 前向传播
  predictions = model(padded_sequences).squeeze(1)

  # 计算损失
  loss = criterion(predictions, labels)

  # 反向传播
  loss.backward()
  optimizer.step()

  if (epoch + 1) % 20 == 0:
    # 计算准确率
    rounded_preds = torch.round(predictions)
    correct = (rounded_preds == labels).float()
    accuracy = correct.sum() / len(correct)
    print(f'Epoch: {epoch + 1:02}, Loss: {loss.item():.4f}, Accuracy: {accuracy.item() * 100:.2f}%')

print("训练完成！")


# 测试模型 (推理)
def predict_sentiment(model, sentence):
  model.eval()
  with torch.no_grad():
    # 将句子转换为索引序列
    words = sentence.split()
    indexed = [word_to_idx.get(w, 0) for w in words]  # 如果词不在词汇表中，用<PAD>索引
    tensor = torch.LongTensor(indexed).unsqueeze(0)  # 增加batch维度
    # 预测
    prediction = model(tensor)
    return "正面" if prediction.item() > 0.5 else "负面"

# 测试新句子
test_sentence_1 = "this film is fantastic"
print(f"'{test_sentence_1}' 的情感是: {predict_sentiment(model, test_sentence_1)}")

test_sentence_2 = "the acting was terrible"
print(f"'{test_sentence_2}' 的情感是: {predict_sentiment(model, test_sentence_2)}")