简介:这是一份基于TensorFlow的LSTM情感分析模型完整项目,面向计算机相关专业学生及开发者,可用于毕业设计、课程设计、作业或初期项目演示。资源包含训练源码、部署教程文档、全部训练数据以及训练好的模型文件,涵盖LSTM模型构建、训练、评估与REST API调用等完整流程,可直接运行验证,也便于在此基础上二次开发。压缩包内共24个文件,以Python脚本、TensorFlow模型检查点(meta/index/data/checkpoint)、正负情感文本数据集和说明文档为主,整体大小约3.19MB,目录结构清晰,方便按需取用。作为高分毕业设计项目,代码经过测试运行正常,并配有部署教程,可帮助使用者快速搭建环境、理解模型训练与保存恢复的细节。目前已有121人学习浏览,适合希望掌握情感分析实践或借鉴完整项目流程的学习者。

1. 为什么情感分析要选 TensorFlow LSTM 而不是规则分词

在电商评论和舆情监控里,判断一段文本是正向还是负向,最直接的做法是维护一个关键词词典打正负分。真上线后会持续被反讽、否定和程度副词打脸,比如“物流慢得离谱,但客服处理很快”。基于 TensorFlow 的 LSTM 情感分析模型把整条评论建模成词向量序列,LSTM 在时间步上递归携带上下文信息,最后接 sigmoid 输出概率,端到端训练,不维护人工规则,分词只做预处理。这套资源是完整的课设毕设闭环:Neg.txt 与 Pos.txt 两份标注语料、train_lstm_model.py 训练脚本、test_lstm.py 预测脚本、rest_api.py 的 Flask 服务,以及训练到两万步左右的 checkpoint。下面按数据准备、模型结构、权重恢复和 HTTP 部署四条线拆开,每步给出可直接改路径跑通的代码和参数说明。

2. 数据准备:从 Neg.txt / Pos.txt 到可喂给 LSTM 的 batch

任何序列模型的第一道坎不是网络结构,而是数据管道。语料格式决定加载方式:Neg.txt 每行一条负向评论,Pos.txt 每行一条正向评论,标签由文件名隐含。先把它读成 texts 和 labels 两个列表,再做分词、词表截断、序列填充。这三个环节各有一个常见失误:直接按空格切分在中文语料上不可靠;词表不保留 PAD 位导致 id 0 被真实词占用;填充长度不统一导致 dynamic_rnn 计算错误或 loss 计算偏差。

2.1 语料读取与标签映射

读取时要注意编码,Windows 下另存的 txt 很可能是 GBK,项目里两份数据是 UTF-8 编码,统一用 encoding='utf-8' 打开。每一行 strip 掉换行符后,空行必须跳过,否则文件行数与标签列表错位,后面的数据对直接全部偏掉。

def load_corpus(neg_file='data/Neg.txt', pos_file='data/Pos.txt'):
    texts, labels = [], []
    for path, label in [(neg_file, 0), (pos_file, 1)]:
        with open(path, 'r', encoding='utf-8') as f:
            for line in f:
                line = line.strip()
                if line:
                    texts.append(line)
                    labels.append(label)
    return texts, labels

函数把文件路径和标签绑定成元组列表循环读取,标签 0 表示负向,1 表示正向。返回的两个列表顺序一一对应,后面 shuffle 时不能分开打乱,最稳妥的方式是先把两个列表 zip 在一起再打散,避免文本和标签错位。

文件 每行格式 标签
data/Neg.txt 一条负向评论文本 0
data/Pos.txt 一条正向评论文本 1

这个表看起来简单,但要注意两点:一是空行剔除逻辑不能省,某些编辑器在文件末尾会留空行;二是标签只取决于文件名,文件内容里即使出现“超值”“惊喜”这类词,该行仍然算负样本,这也是模型需要学习上下文而不是单纯查词的原因。

2.2 分词与词表构建

中文没有天然空格,词表构建前必须分词。项目用 jieba 默认词典,对电商、餐饮这种垂直领域,默认词典容易切错品牌词和商品词,进阶做法是加载自定义词典 jieba.load_userdict('dict.txt') ,把“退货险”“好评返现”这类复合词固化下来。词表按词频截断,只保留出现次数最多的前 N 个词,其余全部归为 OOV,PAD 位固定为 id 0。

import jieba
from collections import Counter

def build_vocab(texts, vocab_size=50000):
    counter = Counter()
    for text in texts:
        counter.update(jieba.cut(text))
    most_common = counter.most_common(vocab_size)
    word2id = {word: idx + 1 for idx, (word, _) in enumerate(most_common)}
    return word2id

word2id 从 1 开始编号,把 0 留给 PAD。这样 embedding 矩阵第一行是恒为 0 的向量,padding 位置不会学到有效语义。vocab_size 设成 50000,对一万条级别的评论数据已经能覆盖全部高频词,继续调大只会增加 embedding 层参数量和训练时间,准确率提升很有限。训练和预测必须使用同一份 word2id,否则预测时会抛 KeyError,或者更隐蔽地产生大量 OOV,导致预测概率整体失真。保存方案是在训练脚本里把 word2id dump 成 json:

import json
with open('word2id.json', 'w', encoding='utf-8') as f:
    json.dump(word2id, f, ensure_ascii=False)

预测脚本加载同一份 json,这份文件和 checkpoint 是配套产物,丢失后模型基本作废。答辩时“如何保证线上预测与训练时的预处理一致”这个问题,答案就在这个 json 和下面要讲的序列填充逻辑里。

2.3 序列填充与训练样本生成

LSTM 要求一个 batch 内序列等长,做法是设定 max_len=50,超过截断,不足补 0。文本越长信息越多,但 LSTM 在长序列上容易出现梯度衰减,短文本情感任务 50 已经够用,超过 80 之后收益递减。填充逻辑要同时返回序列长度,dynamic_rnn 依赖它跳过 padding:

def pad_sequences(seqs, max_len=50):
    padded = np.zeros((len(seqs), max_len), dtype=np.int32)
    lengths = np.zeros(len(seqs), dtype=np.int32)
    for i, seq in enumerate(seqs):
        seq = seq[:max_len]
        padded[i, :len(seq)] = seq
        lengths[i] = len(seq)
    return padded, lengths

padded 的每一行是一个样本的整数序列,lengths 记录每个样本真实 token 数。实现时先截断再填充,避免 numpy 赋值越界。生成 batch 时把 padded、labels、lengths 三个数组同时按批次切片,喂给三个 placeholder。手写这个函数替代 Keras 的 pad_sequences ,好处是同时能拿到长度数组,省一次 numpy 往返,在 TensorFlow 1.x graph mode 下数据管线的这一步很关键。

3. LSTM 网络结构与训练脚本拆解

3.1 为什么是单向 LSTM 而不是 BiLSTM 或 TextCNN

情感分类任务里,BiLSTM 的收益主要来自后文信息,比如“服务一般但速度很快”里“但”之后的信息决定最终极性,单向 LSTM 也能部分携带这种信息,只是方向不同。对一万条规模的课设语料,单向 LSTM 验证集准确率通常在 85% 上下,BiLSTM 大概能提高 1 到 2 个点,但参数量翻倍、训练时间翻倍,在小数据上更容易过拟合。TextCNN 训练速度快得多,但对较长距离依赖建模弱,答辩评审常追问“为什么不用注意力机制”,LSTM 在结构复杂度和可解释性上更适合毕设叙事。如果想把项目升级成双向结构,只需要把 cell 定义换成 tf.nn.rnn_cell.BidirectionalRNNCell 的等价写法,或者直接用 tf.keras.layers.Bidirectional 包裹,但注意单元输出维度会翻倍,Dense 层输入要对应调整。

3.2 模型定义与损失计算

train_lstm_model.py 里 build_model 的核心链路是 embedding_lookup、dynamic_rnn、取最后有效时间步、dense、sigmoid。这里最容易错的地方是“最后一步”的取法:必须按 sequence_length 定位到真实文本末尾,而不是固定取序列最后一个位置,因为 padding 位置没有语义,取错位置等于让模型学习占位符。

def build_model(vocab_size, embedding_dim=128, hidden_dim=128):
    tf.reset_default_graph()
    inputs = tf.placeholder(tf.int32, [None, None], name='inputs')
    labels = tf.placeholder(tf.float32, [None], name='labels')
    seq_len = tf.placeholder(tf.int32, [None], name='seq_len')

    embedding = tf.get_variable(
        'embedding', [vocab_size + 1, embedding_dim],
        initializer=tf.random_uniform_initializer(-0.1, 0.1)
    )
    embeds = tf.nn.embedding_lookup(embedding, inputs)

    lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(hidden_dim)
    outputs, state = tf.nn.dynamic_rnn(
        lstm_cell, embeds, sequence_length=seq_len, dtype=tf.float32
    )

    # 取每个序列最后一个有效时间步的隐状态
    batch_size = tf.shape(outputs)[0]
    flat = tf.reshape(outputs, [-1, hidden_dim])
    last_idx = tf.range(batch_size) * tf.shape(outputs)[1] + (seq_len - 1)
    last_output = tf.gather(flat, last_idx)

    logits = tf.layers.dense(last_output, 1)
    logits = tf.squeeze(logits, axis=1)
    probs = tf.sigmoid(logits)

    loss = tf.reduce_mean(
        tf.nn.sigmoid_cross_entropy_with_logits(labels=labels, logits=logits)
    )
    train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)
    return inputs, labels, seq_len, probs, loss, train_op

embedding 矩阵是 vocab_size+1 行,对应 id 0 到 vocab_size,random_uniform_initializer 把初始词向量限制在 [-0.1, 0.1],避免过大初始化值破坏早期梯度。BasicLSTMCell 默认激活函数是 tanh,输出维度即 hidden_dim。gather 那三行是在算每个样本在其真实长度位置的输出:outputs 形状是 [batch, max_len, hidden],reshape 成二维后,第 i 个样本的最后有效输出位于第 i 行、第 seq_len[i]-1 列,last_idx 就是它在一维数组里的偏移。这个写法直观展示了 mask 原理,也可以直接用返回的 state.h ,二者等价。损失用 sigmoid_cross_entropy_with_logits 而不是 softmax,本质是二分类,softmax 的冗余参数只会增加过拟合风险。Adam 初始学习率 1e-3,训练后期 loss 震荡时把学习率降到 3e-4 后继续从 checkpoint 恢复训练。

3.3 训练循环与 checkpoint 保存策略

训练循环的结构是外层 epoch、内层按 batch_size 切数据,每 100 个 step 打印一次 loss,每个 epoch 结束保存一次 checkpoint。Saver 的参数决定了磁盘占用和历史节点保留策略。

saver = tf.train.Saver(max_to_keep=5, keep_checkpoint_every_n_hours=1)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for epoch in range(10):
        for step in range(num_steps):
            _, loss_val = sess.run(
                [train_op, loss],
                feed_dict={inputs: batch_x, labels: batch_y, seq_len: batch_len}
            )
        saver.save(sess, './ckpt/mnist.ckpt', global_step=global_step)

max_to_keep=5 表示最多保留 5 份完整 checkpoint,更早的会被自动清理,防止磁盘被 meta 和数据文件占满。keep_checkpoint_every_n_hours=1 表示哪怕步数还没到,每小时也强制存一份,方便中断后回退。global_step 传的是完整训练步数,项目里出现 mnist.ckpt-16001 到 mnist.ckpt-20001 就是这种命名方式产生的,checkpoint 目录下的 checkpoint 文件记录了哪个才是最新的,恢复时优先选它。

超参数 推荐值 说明
vocab_size 50000 词表容量,按词频截断
embedding_dim 128 词向量维度,加到 256 收益有限
hidden_dim 128 LSTM 隐层单元数
max_len 50 单条评论最大 token 数
batch_size 64 4G 显存可跑,调大收敛更波动
learning_rate 1e-3 Adam 初始值,后期可降到 3e-4
max_to_keep 5 保留 checkpoint 份数
epoch 10 小语料防过拟合,观察验证 loss

这批参数是这份语料下的经验值。batch_size 调到 128 后训练时间接近减半,但 loss 曲线明显更毛糙;hidden_dim 增大到 256 没有带来准确率提升,训练时间却接近翻倍,说明 128 的容量对短文本情感信号已经够用。真正影响收敛的是 max_len:把 50 改到 100,训练时间翻倍,而尾部大量是 padding,模型有效信息密度反而下降。

3.4 TensorFlow 版本坑:1.x graph mode 与 2.x

训练代码里 tf.placeholder 、 tf.nn.rnn_cell 都是 TensorFlow 1.x API,项目跑通的环境是 TensorFlow 1.15 配 Python 3.7,低于 1.13 或高于 1.15 都可能报错。用 anaconda 安装 TensorFlow 时务必新建独立环境并 pin 版本,直接装最新的 2.x 会碰到 tf.contrib 不存在的导入错误。想在 2.x 下运行,脚本开头要加兼容层声明:

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

开启后 placeholder、Session、Saver 都能继续用,但注意 2.x 的 RNN cell 接口做了调整, tf.nn.rnn_cell 仍然存在只是位置变动,如果后续还要做模型迁移,建议把整个训练脚本升级到 tf.keras 风格,checkpoint 结构会完全不同,不能混用。

4. 从 checkpoint 恢复模型:test_lstm.py 的工作方式

4.1 两种恢复路径

训练完成后预测阶段不能重新训练模型,而是加载 checkpoint 里的权重。test_lstm.py 用的是 tf.train.latest_checkpoint 找到目录下最新一份,再做恢复。恢复有两条路径:重建图再 restore,以及直接从 meta 文件导入图。重建图更常见,因为词表、max_len、hidden_dim 这些形状参数都来自训练脚本,重建时保持一致即可。

latest = tf.train.latest_checkpoint('./ckpt')
print(latest)  # ./ckpt/mnist.ckpt-20001

_, _, _, probs, _, _ = build_model(vocab_size, embedding_dim=128, hidden_dim=128)
saver = tf.train.Saver()

with tf.Session() as sess:
    saver.restore(sess, latest)
    feed = {input_ids: padded, seq_len: lengths}
    pred_probs = sess.run(probs, feed_dict=feed)

latest_checkpoint 读取的是 ckpt 目录下 checkpoint 文件里的路径记录,不传完整文件名,避免手写版本号出错。restore 之前必须先把图和变量建出来,Saver 默认收集当前图里的全部变量。这里有个隐蔽问题:如果 build_model 里执行了 tf.reset_default_graph() ,会把已有的变量丢干净,所以预测脚本里不能再次调用会重置图的函数,推荐的做法是把模型构建包在一个函数里,预测脚本只调用它一次。

第二条路径是 import_meta_graph:

saver = tf.train.import_meta_graph(latest + '.meta')
with tf.Session() as sess:
    saver.restore(sess, latest)
    graph = tf.get_default_graph()
    inputs = graph.get_tensor_by_name('inputs:0')
    seq_len = graph.get_tensor_by_name('seq_len:0')
    probs = graph.get_tensor_by_name('Sigmoid:0')

这种方式的优点是省去重建图的代码,但必须通过 tensor name 找节点,训练脚本里 name 参数写错或漏写,这里就取不到。项目里给 placeholder 都显式加了 name,就是为这条路准备的。两种方式二选一即可,重建图更可控,import_meta_graph 更适合快速验证模型文件是否完整。

4.2 checkpoint 三件套的角色

checkpoint 目录里每个版本对应三个文件,很多新手只拷了 data 文件忘拷 meta,恢复时直接报错。三者分工如下:

文件类型 内容 恢复时的作用
.meta 完整计算图结构 import_meta_graph 必需,重建图方式可不用
.data-00000-of-00001 变量取值,权重数值 restore 的数据来源
.index 变量名到数据偏移的索引 restore 定位变量

只保留 data 和 index 在重建图方式下可以恢复,但一旦换了机器、换了 TensorFlow 小版本,meta 文件缺失会丢失图里的细节。完整备份时三个文件加 checkpoint 记录文件一起拷,部署到服务器上结构不变即可。另外注意项目里的 checkpoint 前缀名是 mnist.ckpt ,这是早期模板沿用的命名,不影响恢复,但答辩提问时会问,如实说明命名是历史遗留即可。

4.3 恢复失败的常见错误

最容易遇到的是 shape mismatch。报错信息类似 Assign requires shapes of both tensors to match ,原因通常是预测脚本里 hidden_dim 或 embedding_dim 和训练时不一致,权重矩阵对不上。排查方式是先打印 checkpoint 里每个变量的 shape:

from tensorflow.python.tools.inspect_checkpoint import print_tensors_in_checkpoint
print_tensors_in_checkpoint(latest, all_tensors=True)

对比当前重建图的变量 shape,逐一对齐。另一个高频错误是 placeholder 的 name 对不上,恢复时不会报错,但运行时 get_tensor_by_name 抛 KeyError。再有一个坑是环境 TensorFlow 版本跨度过大,1.15 保存的 meta 文件在 2.0 的 compat 模式里能加载,但在 2.5 之后可能因为 API 删除直接失败,生产环境固定镜像和版本能规避大多数问题。

5. 把模型封装成 REST API:rest_api.py 的部署细节

5.1 单例加载与接口设计

rest_api.py 用 Flask 起了一个最小服务,核心是避免每次请求都重新建 Session 和加载权重。模型加载耗时一般在百毫秒级,如果放在请求处理函数里,QPS 会掉到个位数。正确做法是全局加载一次,接口内只做推断。

from flask import Flask, request, jsonify
import numpy as np

app = Flask(__name__)
model = None

def get_model():
    global model
    if model is None:
        model = load_from_checkpoint('./ckpt')  # 内部完成分词、pad、restore
    return model

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json(force=True)
    text = data.get('text', '')
    if not text:
        return jsonify({'error': 'empty text'}), 400
    prob = get_model().predict(text)
    label = 1 if prob >= 0.5 else 0
    return jsonify({'label': label, 'prob': float(prob), 'text': text})

if __name__ == '__main__':
    get_model().predict('预热')  # 服务启动先跑一次,完成图初始化和显存分配
    app.run(host='0.0.0.0', port=5000, threaded=False)

get_model 的单例模式保证整个进程只加载一份模型权重。启动时的 predict 是 warmup,TensorFlow 首次 sess.run 会构建完整图执行路径,不预热的话第一个线上请求会明显超时。 threaded=False 是因为 TensorFlow 1.x 的 Session 不是线程安全的,多线程并发推断需要各自持有 Session 或加锁,Flask 默认单线程反而更稳。

5.2 接口验证与阈值选择

起服务后先用 curl 验证一次:

curl -X POST http://127.0.0.1:5000/predict \
  -H 'Content-Type: application/json' \
  -d '{"text": "快递慢但客服态度好"}'

正常返回 JSON 里的 label 和 prob 字段。单条通了之后,再做一次留出集回放,比值覆盖率更可靠。把测试语料按行变成 JSON 请求,统计预测结果和真实标签的一致性。在回放脚本里对阈值做扫描,而不是固定 0.5,差评识别偏保守时降低阈值即可换取更高召回:

for th in [0.3, 0.4, 0.5, 0.6, 0.7]:
    preds = (probs >= th).astype(int)
    acc = (preds == labels).mean()
    print(th, acc)

阈值扫描的结果可以画一条 P/R 曲线,项目文档里建议保留 scan 结果,答辩时能直接展示模型在不同业务偏好下的行为差异。

5.3 部署时的资源控制

生产环境如果起多个 worker 进程,每个进程都会加载一份图和权重,显存线性增长。用 gunicorn 起服务时把 worker 数控制在 1 到 2,并关掉 preload,避免 fork 时多个子进程同时初始化 TensorFlow 上下文。如果并发量高,优先把模型迁移到 TensorFlow Serving 或 ONNX Runtime,而不是硬扛多 worker。上线前把留出集按 0.5 阈值逐条请求接口,对比 test_lstm.py 的离线输出,两边结果完全一致再切流量,这是这个项目最值得保留的验证习惯。

本文还有配套的精品资源,点击获取 menu-r.4af5f7ec.gif

Logo

聚焦RDK与具身智能,汇集机器人开发教程、开源案例和技术交流

更多推荐