CNN-word2vec序列分类实战：从词向量到一维卷积的完整指南

简介：这份资源围绕CNN与word2vec结合的序列分类方案展开，面向具备一定深度学习基础、希望动手实践文本分类的NLP学习者与毕设开发者，可用于情感分析、主题识别及基因序列分类等场景。压缩包共5个文件，包含2个png、1个py、1个txt与1个fasta，约174KB：Python脚本承载数据预处理、模型定义、训练与评估流程，词表文件提供训练词汇，模型结构图与损失曲线图辅助理解网络组成与训练收敛情况，fasta文件则对应生物序列数据，便于将方法迁移到基因序列分类任务。已有168人学习下载。读者可据此掌握词向量生成、卷积与池化特征提取、全连接分类的完整链路，并借助模型图与loss曲线复盘调参思路，形成可复用的序列分类实践参考。

1. 从词向量到卷积核：一份能跑通的 CNN-word2vec 序列分类资源

文本分类做多了会发现一个尴尬事：TF-IDF 加朴素贝叶斯在短文本上快得飞起，但一碰到"这个评价到底是吐槽还是真香"这种带语序和上下文的任务，准确率就卡在 80% 上下上不去了。这时候多数人第一反应是换 BERT，可 BERT 那套东西对显存和推理延迟的要求，在很多边缘场景或者教学演示里并不划算。我手里这份 CNN-word2vec 的序列分类资源，走的是另一条路——用 word2vec 把词映射成稠密向量，再用一维卷积去抓 n-gram 级别的局部特征。它不追求 SOTA，但胜在结构清晰、依赖少、单卡甚至 CPU 都能跑通，特别适合想搞明白"词向量到底怎么喂进神经网络"的从业者和学生。这份资源包含完整的训练脚本、预训练词向量加载逻辑和一份小规模中文情感语料，下面我按实际拆包和复现的顺序，把关键环节和踩过的坑讲清楚。

2. 词向量与一维卷积的配合逻辑：为什么这样搭

2.1 word2vec 在这里扮演什么角色

word2vec 的核心产出是一张词表到向量的映射表。常见做法是拿 Skip-gram 或 CBOW 在大量无标注文本上预训练，得到每个词的 100 到 300 维稠密表示。这份资源里用的是一份已经训练好的 128 维中文词向量，文件格式是标准的文本格式，每行"词 空格 数值 数值 …"。加载的时候要注意，词表里不一定覆盖你任务里的所有词，所以代码里必须留一个<unk>向量兜底，通常用随机初始化或者全零向量。我一般会统计一下未登录词比例，超过 15% 就得考虑换词向量或者自己重新训一版。

把词向量层接进 CNN 的时候，有两种做法：一种是冻结词向量不参与训练，另一种是允许微调。资源里默认是冻结的，因为小语料上微调容易过拟合。如果你手头数据超过五万条，可以把trainable设成 True 试试，但学习率要调小一个量级。

2.2 一维卷积为什么能处理序列

一维卷积和二维卷积的区别在于卷积核只在时间步这一个维度上滑动。假设句子长度固定为 200，词向量维度 128，那么输入张量形状是(batch, 200, 128)。一个窗口大小为 3 的卷积核，每次覆盖 3 个连续词，输出一个标量。多个这样的核拼起来，就相当于在检测"三个词组成的短语模式"。窗口设 2、3、4 三种，分别对应 bigram、trigram、4-gram 的局部特征，这也是 TextCNN 那套思路的延续。

池化层用全局最大池化，把每个特征图压缩成一个值，这样不管句子多长，输出维度只和卷积核数量有关。最后接全连接层做分类。整个结构没有循环单元，所以训练速度比 LSTM 快不少，但代价是抓不到长距离依赖。如果你的任务里"不"和"好"隔了十几个词，CNN 大概率会翻车，这种场景还是老老实实上注意力机制。

2.3 资源里的文件结构与依赖

解压后目录大致是这样：

依赖只有 PyTorch、numpy、jieba 和 tqdm，没有那些花里胡哨的框架。我实测在 PyTorch 1.13 和 2.0 上都能跑，Python 3.8 以上即可。

3. 从原始语料到模型输入：数据管道的四个关键步骤

3.1 分词与标签映射

中文任务绕不开分词。资源里用的是 jieba，但你要注意，如果词向量是用其他工具切出来的，分词方式必须和词向量训练时保持一致，否则同一个词对不上号。我见过有人词向量用 jieba 切，推理时用空格切，结果未登录词比例飙到 40%，模型直接废掉。

标签映射很简单，把类别名转成 0 到 N-1 的整数。但要注意保存这个映射关系，推理的时候得反向查回来。

import jieba def load_corpus(path): texts, labels = [], [] label2id = {} with open(path, 'r', encoding='utf-8') as f: for line in f: line = line.strip() if not line: continue label, text = line.split('\t', 1) if label not in label2id: label2id[label] = len(label2id) # 分词后去掉空白符 words = [w for w in jieba.lcut(text) if w.strip()] texts.append(words) labels.append(label2id[label]) return texts, labels, label2id

这段代码里split('\t', 1)只切第一个制表符，防止文本里本身带制表符导致切错。jieba.lcut返回列表，过滤掉纯空白的分词结果。label2id动态构建，保证类别编号连续。

3.2 构建词表与加载预训练向量

词表要包含<pad>和<unk>两个特殊符号。<pad>的 id 设为 0，因为后面 padding 用 0 填充，这样 embedding 查表时 pad 位置自然对应到第 0 行。加载词向量时，逐行读，遇到词表里的词就填入对应行，没遇到的保持随机初始化。

import numpy as np import torch def build_vocab(texts, w2v_path, emb_dim=128): word2id = {'<pad>': 0, '<unk>': 1} # 先统计语料里的词 for words in texts: for w in words: if w not in word2id: word2id[w] = len(word2id) # 初始化 embedding 矩阵 vocab_size = len(word2id) emb_matrix = np.random.normal(0, 0.1, (vocab_size, emb_dim)).astype(np.float32) emb_matrix[0] = 0 # pad 向量置零 hit = 0 with open(w2v_path, 'r', encoding='utf-8') as f: for line in f: parts = line.strip().split(' ') if len(parts) != emb_dim + 1: continue w = parts[0] if w in word2id: emb_matrix[word2id[w]] = np.array(parts[1:], dtype=np.float32) hit += 1 print(f'词向量命中率: {hit / (vocab_size - 2):.2%}') return word2id, torch.tensor(emb_matrix)

np.random.normal(0, 0.1, ...)给未登录词一个小的随机初始值，比全零好，因为全零向量在卷积里不产生任何信号。emb_matrix[0] = 0强制 pad 位置为零向量。命中率打印出来低于 70% 就要警惕了，要么换词向量，要么检查分词。

3.3 序列截断与 padding

CNN 要求输入长度固定，所以要么截断要么补齐。资源里设的最大长度是 200。截断策略我一般用"掐头去尾"——保留前 100 个词和后 100 个词，因为中文文本里开头和结尾往往信息量最大。padding 用 0 在末尾补。

def pad_sequence(seq, max_len=200, pad_id=0): if len(seq) > max_len: half = max_len // 2 seq = seq[:half] + seq[-(max_len - half):] return seq + [pad_id] * (max_len - len(seq))

注意seq[-(max_len - half):]这里取的是后一半，如果序列刚好比 max_len 长一点点，这样切不会丢太多。padding 放在末尾而不是开头，是因为全局最大池化对位置不敏感，但卷积窗口在末尾会扫到 pad，所以更稳妥的做法是用 mask 把 pad 位置的输出置为负无穷再池化。资源里为了简化没做 mask，短文本任务影响不大，长文本建议补上。

3.4 封装 Dataset 和 DataLoader

PyTorch 的 Dataset 要返回张量，注意 id 序列转成 LongTensor，标签转成 LongTensor。DataLoader 的collate_fn默认就能处理，因为我们已经 padding 到等长了。

from torch.utils.data import Dataset, DataLoader class TextDataset(Dataset): def __init__(self, texts, labels, word2id, max_len=200): self.data = [] for words, label in zip(texts, labels): ids = [word2id.get(w, 1) for w in words] # 1 是 <unk> ids = pad_sequence(ids, max_len) self.data.append((torch.tensor(ids, dtype=torch.long), torch.tensor(label, dtype=torch.long))) def __len__(self): return len(self.data) def __getitem__(self, idx): return self.data[idx]

word2id.get(w, 1)里 1 就是<unk>的 id，这样未登录词统一走同一个向量。整个 Dataset 在初始化时就把所有样本转好了，内存占用不大，十万条以内没问题。

4. 模型搭建与训练：卷积核数量、学习率与早停

4.1 CNN 分类器的结构定义

模型部分我习惯单独放一个文件。核心就是 Embedding 层加载预训练矩阵，然后三个并行的 Conv1d，每个后面接 ReLU 和全局最大池化，最后拼接送全连接。

import torch.nn as nn import torch.nn.functional as F class TextCNN(nn.Module): def __init__(self, emb_matrix, num_classes, kernel_sizes=(2,3,4), num_filters=128, dropout=0.5): super().__init__() vocab_size, emb_dim = emb_matrix.shape self.embedding = nn.Embedding.from_pretrained(emb_matrix, freeze=True, padding_idx=0) self.convs = nn.ModuleList([ nn.Conv1d(in_channels=emb_dim, out_channels=num_filters, kernel_size=k) for k in kernel_sizes ]) self.dropout = nn.Dropout(dropout) self.fc = nn.Linear(num_filters * len(kernel_sizes), num_classes) def forward(self, x): # x: (batch, seq_len) emb = self.embedding(x) # (batch, seq_len, emb_dim) emb = emb.transpose(1, 2) # (batch, emb_dim, seq_len) conv_outs = [] for conv in self.convs: c = F.relu(conv(emb)) # (batch, num_filters, L') c = F.max_pool1d(c, c.size(2)).squeeze(2) # (batch, num_filters) conv_outs.append(c) out = torch.cat(conv_outs, dim=1) out = self.dropout(out) return self.fc(out)

nn.Embedding.from_pretrained的freeze=True表示不更新词向量。padding_idx=0让 pad 位置的梯度不参与更新，虽然冻结了也没梯度，但这是个好习惯。transpose(1, 2)是因为 Conv1d 要求通道维度在第二维。max_pool1d的窗口大小设成特征图长度，就是全局池化。

4.2 训练循环与关键超参数

训练脚本里我一般把学习率设成 1e-3，优化器用 Adam，batch size 64。损失函数就是交叉熵。早停的 patience 设 5，验证集损失连续 5 轮不降就停。

import torch.optim as optim def train(model, train_loader, val_loader, epochs=30, lr=1e-3, patience=5): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model.to(device) optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=lr) criterion = nn.CrossEntropyLoss() best_val_loss = float('inf') wait = 0 for epoch in range(epochs): model.train() total_loss = 0 for x, y in train_loader: x, y = x.to(device), y.to(device) optimizer.zero_grad() logits = model(x) loss = criterion(logits, y) loss.backward() optimizer.step() total_loss += loss.item() # 验证 model.eval() val_loss = 0 with torch.no_grad(): for x, y in val_loader: x, y = x.to(device), y.to(device) val_loss += criterion(model(x), y).item() val_loss /= len(val_loader) print(f'epoch {epoch+1} train_loss {total_loss/len(train_loader):.4f} val_loss {val_loss:.4f}') if val_loss < best_val_loss: best_val_loss = val_loss torch.save(model.state_dict(), 'best_model.pt') wait = 0 else: wait += 1 if wait >= patience: print('早停触发') break

filter(lambda p: p.requires_grad, ...)只把需要梯度的参数交给优化器，冻结的 embedding 不参与。早停保存的是验证损失最低的模型，不是最后一轮的。这里有个细节：验证损失用criterion(model(x), y).item()累加，最后除以 batch 数，得到平均损失。

4.3 类别不平衡的处理

如果语料里正负样本比例超过 3:1，交叉熵会被多数类主导。资源里没默认开启权重，但你可以手动算一下类别频率，传给CrossEntropyLoss(weight=...)。权重一般设成总样本数 / (类别数 * 该类样本数)。我试过一个二分类任务，正负比 5:1，加上权重后 F1 从 0.72 提到 0.81，效果立竿见影。

5. 避坑与排查：那些让模型不收敛的细节

5.1 损失不降反升

现象：训练头几轮 loss 从 0.69 涨到 2.3。原因通常是学习率太大，或者词向量没归一化导致数值爆炸。解决：把学习率降到 1e-4 试试，同时检查词向量文件里有没有异常大的数值，必要时对 embedding 做 L2 归一化。

5.2 验证集准确率远低于训练集

现象：训练集 99%，验证集 65%。原因：模型参数量相对语料太大，过拟合了。解决：把 dropout 从 0.5 提到 0.7，减少卷积核数量从 128 降到 64，或者加 L2 正则。如果语料本身只有几千条，建议冻结词向量并且只训练全连接层。

5.3 未登录词比例过高

现象：打印命中率只有 50% 出头。原因：分词工具和词向量训练时的分词方式不一致，或者词向量覆盖领域和任务领域差太远。解决：统一分词工具，或者用任务语料自己训一版 word2vec。自己训的话，语料至少要有几十兆，维度 100 到 200 之间。

5.4 推理时长度不一致报错

现象：RuntimeError: Expected tensor of size ...。原因：推理时没做 padding，或者 max_len 和训练时不一致。解决：把训练时的 max_len 存进配置文件，推理脚本读同一个值。padding 函数直接复用训练时的。

5.5 GPU 显存够但速度慢

现象：batch size 64 跑一个 epoch 要十几分钟。原因：数据在 CPU 和 GPU 之间频繁拷贝，或者 num_workers 设成 0。解决：DataLoader 的num_workers设成 4 或 8，pin_memory=True。另外把词向量矩阵转成 float32，别用 float64。

6. 进阶技巧：用滑动窗口池化替代全局池化

全局最大池化有个问题：它只保留每个特征图最强的那个信号，如果一句话里出现了两次关键模式，第二次就被丢了。一个改进做法是滑动窗口池化，窗口大小设 3，步长 1，然后对窗口结果再做一次最大池化。这样能保留更多局部信息。我试过一个情感分类任务，全局池化 F1 是 0.84，换成滑动窗口池化后到了 0.86，提升不大但稳定。

另一个技巧是词向量微调。如果你有至少五万条标注数据，可以把freeze设成 False，学习率设成 1e-5，让词向量跟着任务稍微调整。注意这时候优化器要分参数组，embedding 的学习率比其他层小一个量级。

optimizer = optim.Adam([ {'params': model.embedding.parameters(), 'lr': 1e-5}, {'params': model.convs.parameters(), 'lr': 1e-3}, {'params': model.fc.parameters(), 'lr': 1e-3} ])

验证方法上，我习惯在验证集上不光看准确率，还要看每个类别的 F1。如果某个类别 F1 特别低，多半是样本太少或者标注噪声大。这时候别急着调模型，先回去看数据。

从那以后我每次拿到新语料，都强制先跑一遍未登录词统计和类别分布，这两个数不对劲，后面调参全是白费功夫。希望帮到你。

本文还有配套的精品资源，点击获取