简介：一份基于深度学习的电影评论情感分析系统完整项目，面向Python毕业设计、课程设计或希望入门情感分析、Web开发的读者。系统功能完善、界面美观，操作简单，管理便捷，前端采用HTML/CSS/JavaScript，后端为Python，数据库脚本与说明文档一并打包。压缩包共290个文件，大小约122.97MB，包含23个Python源码文件、17个HTML页面、30余个CSS/JS样式文件、75个GIF操作演示、8个npy与4个pkl等模型数据文件，以及SQL数据库脚本，类型覆盖前端页面、后端逻辑、交互演示与模型推理，目录结构清晰，便于按模块阅读和二次开发。项目经过严格调试，确保可运行，可搭配Navicat等工具查看数据库，适合快速搭建同类型情感分析应用，也可作为毕业设计的完整参考方案。压缩包内还集成软件工具与使用说明，目前已有136人学习下载，具备实践参考价值。
1. 用 Python 做电影评论情感分析：为什么技术选型比模型调参更决定成败
拿到「基于深度学习的电影评论情感分析系统（完整源码+说明）.zip」这样的压缩包，很多人第一反应是赶紧解压、跑通、看准确率。但我做了几年 NLP 落地，想先泼一盆冷水：这类项目真正值钱的不是那个 .py 文件里的模型结构，而是三件事——数据怎么清洗、训练集和验证集的划分逻辑是否干净、以及最终部署时怎么处理长度不一的评论。如果你拿到的源码里这三块是糊的，那模型再花哨也只是一堆不能复用的黑匣子参数。
电影评论情感分析本质上是一个文本二分类任务：给定一句评论，判断它是正向还是负向。难点不在“分类”本身，而在于电影评论的语言极其随意——缩写、俚语、反讽、长句夹杂短句、中英文混用。深度学习模型（LSTM、注意力机制、BERT 等）能自动学习这些特征，前提是你把数据管线搭对。这篇文章我会从解压完 zip 开始，一步步带你拆解这个系统的数据层、模型层和训练层，把参数、坑、验证方法都讲透，适合两类人：想拿成熟方案做课程设计的学生，以及想在本地快速验证深度学习文本分类流程的工程师。
2. 拆解 zip 里的源码结构：先看数据管线和模型文件再碰依赖
2.1 解压后第一件事：核对目录树，别急着 pip install
拿到 zip 后，我一般会先建一个干净的虚拟环境，然后只做一件事：把源码目录结构完整列出来。一个规范的中小型深度学习项目，压缩包解开后至少应该有这几个部分：数据文件夹（raw 和 processed 分层）、模型定义文件（一般是 model.py 或网络结构类）、训练脚本、预测脚本、以及一份 requirements.txt。如果只有一两个孤零零的 .py 文件和几个 .csv，那就要警惕——这不是完整的「系统」，顶多算一段演示代码。
# 解压到指定目录，避免当前目录被文件冲散 mkdir -p sentiment_system && unzip 基于深度学习的电影评论情感分析系统.zip -d sentiment_system cd sentiment_system # 查看完整目录树，只显示 3 级，避免被无关文件刷屏 find . -maxdepth 3 -type f | sort | head -50# 检查是否包含依赖清单 ls requirements.txt 2>/dev/null || ls environment.yml 2>/dev/null || echo "未发现依赖清单，需要手动确认版本"逻辑说明：第一步是隔离环境，避免把 zip 里自带的一堆旧版本库直接装进全局 Python。第二步是用find看文件分布，重点确认三样东西——训练数据是否齐全、是否有独立的模型结构文件、是否有训练入口脚本。我见过不少源码包，模型文件和训练脚本写在一个文件里，耦合严重，改一个参数就得全局搜。
参数说明：maxdepth 3是防止进入数据子目录的深层嵌套；head -50是截断输出，因为有些源码包会带.git历史或者缓存文件，没必要全看。如果发现requirements.txt缺失，不要慌，后面可以按主流版本手工补，但版本对齐要做好记录。
2.2 requirements.txt 里最容易踩的雷：torch 和 transformers 的版本锁
这一步直接决定你能不能把代码跑起来。这个时间点，PyTorch 和 Hugging Face transformers 的版本迭代很快，如果你的源码包里锁的是老版本，而你的机器上是新版本，最常见的翻车姿势是：torch.nn.LSTM的某些参数行为变了，或者transformers.AutoModel加载权重时提示key mismatch。所以不要无脑安装requirements.txt里写死的版本，先看它依赖什么深度学习框架，再决定是直接装还是手动做版本映射。
# 如果 requirements.txt 存在，先查看框架相关行 grep -iE "torch|tensorflow|transformers|keras" requirements.txt# 在 Python 里快速核对本机框架版本，判断是否满足源码最低要求 python -c "import torch; print('torch', torch.__version__)" python -c "import transformers; print('transformers', transformers.__version__)" 2>/dev/null || echo "transformers 未安装"逻辑说明：很多打包源码的人习惯用pip freeze > requirements.txt，这会把本机一大堆无关包也带进来，其中可能有和你现有环境冲突的版本。所以先 grep 出和深度学习相关的核心依赖，再看是否需要隔离环境。
参数说明：如果源码用的是 TensorFlow 1.x 的tf.contrib，那基本没法在现代环境里跑，需要优先考虑有没有代替方案；如果核心是torch，则注意 CUDA 版本。这一步不解决，后面所有训练都会在import阶段就报ModuleNotFoundError或者底层库的undefined symbol，跟模型本身没关系，纯属环境玄学。
2.3 数据长什么样：IMDb、中文评论和其他语料的区别
这个系统如果叫「电影评论情感分析」，最常见的公开数据集是 IMDb 的 50K 影评，或者斯坦福的 Sentiment 140。但中文项目往往自带爬虫抓取的豆瓣评论，格式可能是 CSV，一列是评论文本，一列是标签（0 负向、1 正向），也可能存在多类别标签比如 0-4 星。先用pandas把数据读进来做个概览，确认列名、数据类型、标签分布和样本长度，这一步能避免后续 80% 的模型训练异常。
import pandas as pd # 假设源码包里的数据名为 data.csv，先读前 5 行和统计信息 df = pd.read_csv('data/data.csv', encoding='utf-8-sig', nrows=5) print(df.head()) print("列名:", df.columns.tolist()) # 如果数据是 JSON 行格式，则适合流式读取 # df = pd.read_json('data/data.jsonl', lines=True)import pandas as pd # 全量读入，做标签分布和长度分析 df = pd.read_csv('data/data.csv', encoding='utf-8-sig') print("标签分布:\n", df['label'].value_counts()) df['text_len'] = df['text'].astype(str).apply(len) print(df['text_len'].describe())逻辑说明：nrows=5是快速试探编码格式，因为很多中文 CSV 的encoding可能是gbk或utf-8-sig，直接用utf-8读会报UnicodeDecodeError。读完前 5 行确认没有乱码后，再做全量统计。
参数说明：utf-8-sig是为了处理带 BOM 的文件，如果列名出现\ufeff前缀就要用这个编码。label列分布不均匀时，后面训练要设定class_weight，否则模型会偏向多数类，准确率虚高。
3. 从原始文本到词向量：分词、序列填充和 Embedding 的落地配置
3.1 深度学习文本分类绕不开的分词：英文按空格，中文按 jieba
模型不能直接吃字符串，必须把句子切成 token 序列。英文电影评论本身有空格分隔，外加标点符号清理就行；中文评论需要分词，常见做法是用jieba。这个环节最常见的坑是：词表忘记加UNK（未知词）和PAD（填充符），导致预测时碰到新词直接报KeyError或者索引越界。
import jieba def tokenize_text(text, is_chinese=True): if not isinstance(text, str): text = str(text) text = text.lower().strip() # 清理多余的标点，保留基本句意 text = re.sub(r'[^\w\u4e00-\u9fa5\s]', ' ', text) if is_chinese: return list(jieba.cut(text)) return text.split()# 示例：单独验证分词结果 sample = "这部电影太棒了，剧情紧凑，演员演技在线" print(tokenize_text(sample)) # 输出: ['这部', '电影', '太棒', '了', '剧情', '紧凑', '演员', '演技', '在线']逻辑说明：这里用正则把所有非中英文、非空格的符号替换成空格，避免标点被当成 token。is_chinese参数控制了是走 jieba 还是按空白切分，在混合语料里可以按列判断。需要留意的是 jieba 的默认词典对电影专有名词、人名可能切分不准确，比如「漫威」可能被切成「漫」和「威」，后续可以在自定义词典里补充。
参数说明：re.sub的正则[^\w\u4e00-\u9fa5\s]是保留单词字符、中文和空格，其他全部替换为空格。\w在 Python 3 里默认包含下划线汉字，所以中文不会丢，不过这也可导致英文词内下划线被保留，在情感分析场景下无伤大雅。若你的语料有表情符号，建议另外处理，否则会被清成空格。
3.2 序列填充和截断：为什么max_len不能拍脑袋
RNN 家族和 Transformer 通常要求一个 batch 内的序列等长，所以需要定义一个max_len。大于它的评论截断，小于它的补PAD。这个值怎么选？直接取数据长度分布的 95 分位数，而不是平均数，否则长评论会被大量截断，丢失关键转折信息。电影评论里有些用户会写几百字小作文，如果max_len设 128，那些转折句可能被切在后半段，模型根本看不到。
import numpy as np # 根据第 2.3 节的 text_len 列计算 95 分位 max_len = int(np.percentile(df['text_len'], 95)) print("建议 max_len:", max_len)from tensorflow.keras.preprocessing.sequence import pad_sequences # token 序列列表 sequences = [tokenize_text(t) for t in df['text']] # 先用词表映射为索引，这里假设 w2idx 是已经构建好的 词->编号 字典 seq_idx = [[w2idx.get(w, w2idx['<UNK>']) for w in seq] for seq in sequences] # 填充和截断 X = pad_sequences(seq_idx, maxlen=max_len, padding='post', truncating='post', value=w2idx['<PAD>']) print("X shape:", X.shape)逻辑说明：pad_sequences的padding='post'表示在序列尾部补零，truncating='post'表示尾部截断。这里选择尾部因为习惯上模型最后一个时间步包含句末信息，如果把长句头部截断，句首的主旨词会丢。value=w2idx['<PAD>']确保填充值对应的是词表里PAD的索引，而不是默认的 0，避免和真实 token 冲突。
参数说明：max_len如果取 95 分位，通常能覆盖 95% 的样本，剩余 5% 的评论会被截断，这是可以接受的代价。如果要保留更多信息，可以提升到 99 分位，但显存占用会随之上涨。如果源码里写死了一个 128 或 256，建议按这个统计量重新算一下，模型性能可能有明显变化。
3.3 Embedding 层的选择：随机初始化还是加载预训练词向量
深度学习模型里 Embedding 层有两种做法：随机初始化，随训练更新；或者加载 GloVe、word2vec 或腾讯中文词向量做初始化。对于电影评论这种领域性很强的文本，预训练词向量能带来不错的提升，因为训练语料里很多词可能没出现过，但预训练向量里有语义近似。这里的坑在于：预训练词向量文件往往很大，而且词表覆盖不到你数据里的电影专名，所以加载后必须做unk映射。
import os # GloVe 文件格式: 词 向量...，一行一个词 def load_glove_embeddings(path, embedding_dim=300, vocab=None): embeddings_index = {} with open(path, 'r', encoding='utf-8') as f: for line in f: values = line.rstrip().split() word = values[0] coefs = np.asarray(values[1:], dtype='float32') if vocab is None or word in vocab: embeddings_index[word] = coefs # 构建 Embedding 矩阵 embedding_matrix = np.random.uniform(-0.05, 0.05, size=(len(vocab)+2, embedding_dim)) for word, i in w2idx.items(): vec = embeddings_index.get(word) if vec is not None: embedding_matrix[i] = vec return embedding_matrix逻辑说明：这里只保存vocab里出现过的词的向量，避免加载全部几百万词向量导致内存爆掉。embedding_matrix初始化为均匀分布小随机数，这样没有预训练向量的词也能有合理的初始表示，而不是全零。注意矩阵行数是len(vocab)+2，因为有UNK和PAD两个保留位。
参数说明：embedding_dim要和预训练文件维度一致，300 是 GloVe 常见配置，腾讯中文词向量是 200 维，如果匹配错，np.asarray会报错。如果不想引入外部文件，也可以让 Embedding 层随机初始化，省事但有代价：对于出现次数少的词，学习不到稳定的语义。
4. 构建与训练模型：LSTM / BiLSTM / Attention 的参数与评估配置
4.1 核心模型结构：双向 LSTM 为什么是电影评论的默认选择
对于短文本情感分析，BiLSTM 是性价比很高的方案：能够同时捕捉正向和反向的上下文信息。电影评论里「虽然演技差，但我很喜欢这部电影，因为剧情太好」这种转折句，只有双向机制才能在句子开头就感知到末尾的「喜欢」。nn.LSTM在 PyTorch 里实现很方便，但有两个参数必须设对：batch_first=True和bidirectional=True，否则训练时会报维度错或者训练无法收敛。
import torch.nn as nn class BiLSTMClassifier(nn.Module): def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers, num_classes=2, dropout=0.5): super().__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=1) # 假设 1 是 PAD 索引 self.lstm = nn.LSTM( embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True, bidirectional=True, dropout=dropout if num_layers > 1 else 0.0 ) # 双向 LSTM 最后一层输出维度是 hidden_dim * 2 self.fc = nn.Linear(hidden_dim * 2, num_classes) self.dropout = nn.Dropout(dropout) def forward(self, x): emb = self.embedding(x) # (batch, seq_len, embedding_dim) lstm_out, (h_n, c_n) = self.lstm(emb) # 两个方向的最后隐状态拼接：h_n[-1] 是正向，h_n[-2] 是反向 last_hidden = torch.cat((h_n[-2], h_n[-1]), dim=1) # (batch, hidden_dim*2) logits = self.fc(self.dropout(last_hidden)) return logits逻辑说明：关键在h_n的取法，双向 LSTM 的h_n形状是(num_layers * 2, batch, hidden_dim)。最后一层正向的隐状态是h_n[-2]，反向是h_n[-1]，拼出来才构成了分类用的句子表示。如果直接取h_n[-1]，那只是反向编码，会丢失正向信息，准确率会下降但没有报错，属于隐藏雷。
参数说明：padding_idx=1需要和词表构建时的PAD索引一致，我这里假设 0 是 UNK，1 是 PAD，不同源码可能相反。hidden_dim常见选 128 或 256，太小表示能力不足，太大容易过拟合且训练慢。num_layers=2时dropout会施加在两层之间，单层 LSTM 不需要 dropout。
4.2 训练循环里的三个必调参数：学习率、批次大小与损失函数权重
训练过程最影响最终得分的是学习率和批次大小。学习率过大会导致 loss 震荡，过小则收敛太慢。常见做法是初始lr=1e-3，训练几个 epoch 后降到 1e-4。批次大小受显存限制，一般 32 或 64，但这会让每个 epoch 的步数不同，需要对应调整学习率衰减的步数。对于情感分析这种二分类，损失函数用CrossEntropyLoss，但如果标签不平衡，需要给少数类更高的权重。
import torch import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset # 假设 X_train, y_train 都已经准备好 train_dataset = TensorDataset(torch.LongTensor(X_train), torch.LongTensor(y_train)) train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True) model = BiLSTMClassifier(vocab_size=len(w2idx), embedding_dim=300, hidden_dim=128, num_layers=2) optimizer = optim.Adam(model.parameters(), lr=1e-3) criterion = nn.CrossEntropyLoss() # 若标签分布不均，给少数类加权，这里以标签 1 是少数为例 class_counts = df['label'].value_counts() weight = torch.tensor([1.0, class_counts[0] / class_counts[1]], dtype=torch.float32) criterion = nn.CrossEntropyLoss(weight=weight) for epoch in range(10): model.train() total_loss = 0.0 for batch_x, batch_y in train_loader: optimizer.zero_grad() logits = model(batch_x) loss = criterion(logits, batch_y) loss.backward() optimizer.step() total_loss += loss.item() print(f"Epoch {epoch+1}, Loss: {total_loss / len(train_loader):.4f}")逻辑说明：TensorDataset把 X 和 y 包装成可迭代的数据集，DataLoader负责分批。model.train()开启 dropout 和 BatchNorm 的训练行为（这里暂时没有 BatchNorm）。每个 batch 清空梯度，前向、算损失、反向、更新参数。class_counts[0] / class_counts[1]算出多数类与少数类的比值，作为少数类的权重，把损失放大，逼模型更关注少数类。
参数说明：batch_size=64在大多数 8G 显存显卡上跑 300 维 BiLSTM 没问题，如果 OOM 就降一半且同步把 Adam 的lr调小，因为梯度噪声变大，学习率过大容易在 batch 间来回震荡。num_epochs=10是经验值，适合中小型数据集，我一般会在每轮结束保存一次模型，防止后面 epoch 过拟合没后悔药。
4.3 验证集与测试集：为什么源码头疼的是数据划分而非模型
很多课程设计源码把全部数据都丢去训练，然后在同一个数据集上打印准确率，这纯属自欺欺人。正确的划分是 8:1:1 或者 7:2:1，训练集用来更新权重，验证集用来选超参数，测试集只用来做最终评估。电影评论数据经常按时间排序，如果直接随机划分，会出现训练集和验证集评论风格重叠的问题，严谨做法是分组划分，避免同电影的评论同时出现在训练和测试里。
from sklearn.model_selection import train_test_split # 先划分出 train + val + test，注意 stratify 让标签分布一致 X_train, X_temp, y_train, y_temp = train_test_split( X, y, test_size=0.2, stratify=y, random_state=42 ) X_val, X_test, y_val, y_test = train_test_split( X_temp, y_temp, test_size=0.5, stratify=y_temp, random_state=42 ) print("训练/验证/测试:", X_train.shape, X_val.shape, X_test.shape)逻辑说明：stratify=y是必须的，保证划分后各个集合里的正负样本比例和总体一致，否则如果验证集恰好全是负例，准确率指标会严重失真。random_state=42固定随机种子，让实验可复现，否则每次跑结果都不一样，你就没法判断是模型改动还是数据随机性导致的指标变化。
参数说明：test_size=0.2表示先从全量分 20% 出来，再把被分的这部分一分为二得到验证和测试各 10%。如果你有充裕数据，可以扩大验证集到 15%，在调参时评估更稳定。验证集不能太小，否则 loss 曲线抖动大，看不出哪个 epoch 最优。
5. 避坑与排查：源码包跑不通时的五个常见问题
5.1 问题一：torch装了但import报OMP: Error #15
现象：在 Jupyter 或命令行里执行import torch直接崩，错误信息里带libiomp5相关，或者初始化失败。
原因：往往是系统中同时存在多个 OpenMP 运行库，比如 Anaconda 的libiomp5和 pytorch 自带的版本冲突，多发生在 mac 或部分 Linux 环境上。另外一个常见场景是源码包本身带了老版本 torch，而你按requirements.txt装了之后，环境和系统库不兼容。
解决：设置环境变量强制使用单一 OpenMP 库，或者在import torch之前先执行：
export KMP_DUPLICATE_LIB_OK=TRUE注意这只是掩盖问题，如果训练时出现随机崩溃，仍然建议用干净虚拟环境重装 torch，而不是强行KMP_DUPLICATE_LIB_OK=TRUE一把梭。我遇到过设置后训练中途不 crash，但结果异常，这其实是内存布局错乱的信号。
5.2 问题二：max_len设置过小导致验证集准确率只有 70%
现象：模型结构、损失函数都没问题，训练 loss 能降到 0.1，但验证集准确率一直徘徊在 70% 左右，低于预期。
原因：数据里有不少长评论，max_len设置成 64 或 128，长句后半段的有效信息被截断，模型只看到开头和一部分中间，自然学不到转折句。这属于数据预处理阶段的坑，很多人把锅甩给模型。
解决：重新统计text_len的分布，把max_len提到 95 分位数或更高。具体做法参考 3.2 节的代码，改完参数重训，通常能涨两三个点。如果显存不够大，可以换用 BiLSTM 输出最后一个有效 token 的表示，而不是 padding 后末尾位置。
5.3 问题三：加载预训练词向量时Embedding矩阵全零
现象：训练 loss 下降缓慢，准确率比随机初始化还差，打印embedding_matrix发现大部分词对应的向量是 0。
原因：你用了np.random.uniform初始化矩阵后，用循环给命中的词赋值，但词表里很多词的w2idx索引和预训练词表的索引没对齐，或者文件读取时values[1:]里包含了空字符串导致np.asarray的类型错乱。还有一个常见低级错误：padding_idx位置的向量更新是禁用的，如果你恰好把PAD索引设成了 0，而用一个全零加载好的矩阵，梯度永远不更新它，相当于模型固定了 0 向量。
解决：先验证load_glove_embeddings的返回矩阵里有多少行还是初始随机值，如果超过一半，大概率是词表不匹配。其次把Padding_idx单独设置，不要占用真实词的位置。代码上做一个统计：
nonzero_count = np.count_nonzero(np.linalg.norm(embedding_matrix, axis=1) > 0.0) print("非零向量行数:", nonzero_count, "/", embedding_matrix.shape[0])如果这个比例低于 70%，基本可以认定预训练词表太小或加载逻辑有 bug。
5.4 问题四：预测阶段只输出一个类别
现象：模型训练完，测试集准确率看着很高，但实际用它对一段新评论做预测时，永远输出“正向”，或者永远输出“负向”。
原因：标签分布严重不均衡，少数类占比低于 10%，而训练时没有做类别加权，模型学到的是把所有样本都预测为多数类，损失仍然很低。这属于典型的数据不均衡处理缺失。
解决：参考 4.2 节给损失函数加上weight，或者用Focal Loss处理更难分类的少数样本。第二种做法是对少数类做过采样，复制一些训练样本，但这种方法容易过拟合。最好的是在评估时同时看precision、recall和F1-score，如果只盯着准确率，会被假象骗过。
5.5 问题五：GPU 跑得比 CPU 还慢
现象：模型在 GPU 上训练，但一个 epoch 耗时比 CPU 还长，显卡利用率只有个位数。
原因：常见于序列长度参差不齐，且没有做bucket批处理。DataLoader默认会把一个 batch 内序列填充到一样长，如果其中一条特别长，其它短序列全部被 pad 到那么长，导致大量无效计算。另一个原因是数据加载和预处理成了瓶颈，GPU 在空转等 CPU 传数据。
解决：最简单的办法是按序列长度分批，让相近长度的评论放在同一个 batch，用torch.utils.data.sampler.BatchSampler实现。或者在构建序列时统一设置max_len，避免极端长序列拉高全 batch 的 padding 量。若数据量不大，num_workers=4也可以缓解。
from torch.utils.data import Sampler import random class LengthBatchSampler(Sampler): def __init__(self, lengths, batch_size, shuffle=True): self.lengths = lengths self.batch_size = batch_size self.shuffle = shuffle def __iter__(self): idx = sorted(range(len(self.lengths)), key=lambda i: self.lengths[i], reverse=True) batches = [idx[i:i+self.batch_size] for i in range(0, len(idx), self.batch_size)] if self.shuffle: random.shuffle(batches) for b in batches: yield b逻辑说明：按长度降序排序后，相邻样本长度接近，每个 batch 内部的 padding 率大幅下降，GPU 的利用率能上去。shuffle打乱的是 batch 的先后顺序，而不是 batch 内部的序列顺序，这样不破坏长度分组。
参数说明：这个 sampler 在DataLoader里通过batch_sampler传入，注意此时不能再传batch_size，否则DataLoader会冲突。如果显存比较紧，可以设置drop_last=False，让最后一个不足batch_size的 batch 正常运行。
6. 让系统具备可用性的最后一公里：预测脚本与模型导出
训练完只是拿到一堆权重，真正要交付的应该是一个命令行或 API 入口。常见做法是把BiLSTMClassifier的权重state_dict保存为.pth文件，同时把词表w2idx存成 json，预测脚本加载这两份文件，对用户输入的新评论做完整预处理到分类输出。这一步需要额外注意词表一致性——如果预测时用的分词、max_len和训练时不同，结果一定错乱。我习惯把分词和 padding 的逻辑抽成一个Preprocessor类，供训练和预测复用，这是减少白学重训的后悔药。
import json import torch def save_model(model, word_index, save_dir='./saved_model'): os.makedirs(save_dir, exist_ok=True) torch.save(model.state_dict(), os.path.join(save_dir, 'model.pth')) with open(os.path.join(save_dir, 'word_index.json'), 'w', encoding='utf-8') as f: json.dump(word_index, f, ensure_ascii=False, indent=2) print("模型和词表已保存到", save_dir) def load_model(model_class, save_dir='./saved_model', vocab_size=None, hidden_dim=128): model = model_class( vocab_size=vocab_size, embedding_dim=300, hidden_dim=hidden_dim, num_layers=2 ) model.load_state_dict(torch.load(os.path.join(save_dir, 'model.pth'), map_location='cpu')) model.eval() with open(os.path.join(save_dir, 'word_index.json'), 'r', encoding='utf-8') as f: w2idx = json.load(f) return model, w2idxdef predict_one(text, model, w2idx, max_len=256, is_chinese=True): model.eval() seq = tokenize_text(text, is_chinese=is_chinese) idx_seq = [w2idx.get(w, w2idx['<UNK>']) for w in seq] # 手工填充和截断，这里为了演示不使用 pad_sequences if len(idx_seq) < max_len: idx_seq += [w2idx['<PAD>']] * (max_len - len(idx_seq)) else: idx_seq = idx_seq[:max_len] input_tensor = torch.LongTensor([idx_seq]) with torch.no_grad(): logits = model(input_tensor) prob = torch.softmax(logits, dim=1) return prob[0].tolist()逻辑说明：保存模型时把state_dict和词表分开存储是工程上的好习惯，因为模型结构可以用代码定义，词表则取决于训练数据，二者必须严格对应。map_location='cpu'让你在没有 GPU 的生产环境也能加载模型推理。预测函数里补PAD的方式和训练时pad_sequences的行为保持一致，只是这里用 Python 列表手写，方便理解。
参数说明：max_len=256要和你训练时用的值一致，否则模型接收的序列长度分布完全变样，丢精度是必然的。is_chinese=True时走 jieba，若你的模型是纯英文评论训练的，这个参数要改成False。torch.no_grad()会切断梯度计算链，节省显存和内存，推理阶段必须加，否则遇到长评论可能直接 OOM。
最终，我习惯在交付前跑一组新评论冒烟测试，比如输入「剧情很拖沓，但主角演技不错」，期望输出概率接近 0.6 的负向和 0.4 的正向；再输入「年度最佳，没有之一」，期望负向概率极低。如果这两句输出反差不够大，说明模型明显过拟合训练集而泛化不足，需要重新考虑max_len或正则化参数。
这个项目若作为课程设计，做到这里已经是一个能讲清楚数据流、模型流和部署流的完整闭环。如果后续想换更强基线，可以把BiLSTM换成BertForSequenceClassification，但数据管线和评估方式基本复用。有一点我踩坑后一直遵守：训练前的数据质量检查（标签分布、长度分布、空值）永远比调网络结构更能影响最后的口碑。希望这篇实战笔记帮你在跑通这个 zip 时少绕几个弯。
本文还有配套的精品资源，点击获取
