机器学习与深度学习 / 系统课时

完成文本分类项目

完成文本分类项目

本课将完成一个最小但完整的文本分类项目:建立词表、批量填充文本、使用嵌入和 Transformer 编码器提取序列特征,再完成训练、验证与新文本推理。代码可直接运行,并保留继续替换真实数据集的接口。

学习目标

  • 串联文本编码、批处理、序列建模和分类输出
  • 编写训练与验证循环,并正确切换模型模式
  • 使用训练后的模型预测新的文本标签

明确最小项目结构

项目把一句文本映射为正面或负面标签。为了聚焦模型流程,示例使用空格分词和内存中的小型数据集,不引入外部分词库。完整数据流依次为:文本、词元编号、批量填充、词嵌入与位置嵌入、序列编码、掩码平均池化、线性分类。

文本分类训练与推理流程

训练集负责更新参数,验证集只衡量泛化效果。推理阶段不再计算损失,也不需要梯度,因此必须使用 model.eval() 和 torch.no_grad()。

实现完整训练流程

下面代码包含数据集、动态填充、模型、训练、验证和推理。示例依赖已安装的 PyTorch,可保存为 text_classifier.py 后直接运行。

python
import math
from collections import Counter
from typing import Iterable

import torch
from torch import nn
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data import DataLoader, Dataset

PAD_TOKEN = "<pad>"
UNK_TOKEN = "<unk>"
LABEL_NAMES = ["negative", "positive"]

TRAIN_SAMPLES = [
    ("i love this movie", 1),
    ("this film is wonderful", 1),
    ("what a great story", 1),
    ("the acting is excellent", 1),
    ("i hate this movie", 0),
    ("this film is terrible", 0),
    ("what a boring story", 0),
    ("the acting is awful", 0),
]

VALID_SAMPLES = [
    ("i love the story", 1),
    ("this movie is excellent", 1),
    ("i hate the acting", 0),
    ("this story is terrible", 0),
]

def tokenize(text: str) -> list[str]:
    return text.lower().split()

def build_vocab(samples: Iterable[tuple[str, int]]) -> dict[str, int]:
    counter = Counter()
    for text, _ in samples:
        counter.update(tokenize(text))

    # 固定保留填充和未知词编号,部署时必须复用同一份词表。
    vocab = {PAD_TOKEN: 0, UNK_TOKEN: 1}
    for token in sorted(counter):
        vocab[token] = len(vocab)
    return vocab

def encode(text: str, vocab: dict[str, int]) -> torch.Tensor:
    unk_id = vocab[UNK_TOKEN]
    token_ids = [vocab.get(token, unk_id) for token in tokenize(text)]
    # 空文本至少保留一个未知词,避免产生长度为零的序列。
    if not token_ids:
        token_ids = [unk_id]
    return torch.tensor(token_ids, dtype=torch.long)

class TextDataset(Dataset):
    def __init__(
        self,
        samples: list[tuple[str, int]],
        vocab: dict[str, int],
    ) -> None:
        self.items = [
            (encode(text, vocab), label)
            for text, label in samples
        ]

    def __len__(self) -> int:
        return len(self.items)

    def __getitem__(self, index: int) -> tuple[torch.Tensor, int]:
        return self.items[index]

def collate_batch(
    batch: list[tuple[torch.Tensor, int]],
) -> tuple[torch.Tensor, torch.Tensor]:
    sequences, labels = zip(*batch)
    # 每个批次只填充到当前最长文本,减少无效计算。
    tokens = pad_sequence(
        sequences,
        batch_first=True,
        padding_value=0,
    )
    return tokens, torch.tensor(labels, dtype=torch.long)

class TransformerClassifier(nn.Module):
    def __init__(self, vocab_size: int, pad_id: int) -> None:
        super().__init__()
        self.pad_id = pad_id
        self.d_model = 32
        self.max_length = 64
        self.embedding = nn.Embedding(
            vocab_size,
            self.d_model,
            padding_idx=pad_id,
        )
        self.position_embedding = nn.Embedding(
            self.max_length,
            self.d_model,
        )
        layer = nn.TransformerEncoderLayer(
            d_model=self.d_model,
            nhead=4,
            dim_feedforward=64,
            dropout=0.0,
            batch_first=True,
        )
        self.encoder = nn.TransformerEncoder(
            layer,
            num_layers=2,
            enable_nested_tensor=False,
        )
        self.classifier = nn.Linear(self.d_model, len(LABEL_NAMES))

    def forward(self, tokens: torch.Tensor) -> torch.Tensor:
        if tokens.size(1) > self.max_length:
            raise ValueError("sequence length exceeds max_length")

        padding_mask = tokens.eq(self.pad_id)
        positions = torch.arange(
            tokens.size(1),
            device=tokens.device,
        ).unsqueeze(0)
        # 词嵌入提供词义,位置嵌入提供词序信息。
        features = (
            self.embedding(tokens) * math.sqrt(self.d_model)
            + self.position_embedding(positions)
        )
        encoded = self.encoder(
            features,
            src_key_padding_mask=padding_mask,
        )

        # 只对真实词元求平均,避免填充位置影响句子表示。
        valid = (~padding_mask).unsqueeze(-1)
        summed = (encoded * valid).sum(dim=1)
        counts = valid.sum(dim=1).clamp(min=1)
        pooled = summed / counts
        return self.classifier(pooled)

def train_one_epoch(
    model: nn.Module,
    loader: DataLoader,
    optimizer: torch.optim.Optimizer,
    loss_fn: nn.Module,
) -> float:
    model.train()
    total_loss = 0.0

    for tokens, labels in loader:
        # 清空旧梯度后,再执行前向、反向和参数更新。
        optimizer.zero_grad()
        logits = model(tokens)
        loss = loss_fn(logits, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()

    return total_loss / len(loader)

def evaluate(model: nn.Module, loader: DataLoader) -> float:
    model.eval()
    correct = 0
    total = 0

    # 验证只统计预测结果,不创建反向传播所需的计算图。
    with torch.no_grad():
        for tokens, labels in loader:
            predictions = model(tokens).argmax(dim=1)
            correct += (predictions == labels).sum().item()
            total += labels.numel()

    return correct / total

def predict(
    model: nn.Module,
    texts: list[str],
    vocab: dict[str, int],
) -> list[str]:
    model.eval()
    sequences = [encode(text, vocab) for text in texts]
    tokens = pad_sequence(
        sequences,
        batch_first=True,
        padding_value=vocab[PAD_TOKEN],
    )

    with torch.no_grad():
        label_ids = model(tokens).argmax(dim=1).tolist()
    return [LABEL_NAMES[label_id] for label_id in label_ids]

def main() -> None:
    # 固定随机种子便于复现实验,真实结果仍可能因环境略有差异。
    torch.manual_seed(0)
    vocab = build_vocab(TRAIN_SAMPLES)

    train_loader = DataLoader(
        TextDataset(TRAIN_SAMPLES, vocab),
        batch_size=4,
        shuffle=True,
        collate_fn=collate_batch,
        generator=torch.Generator().manual_seed(0),
    )
    valid_loader = DataLoader(
        TextDataset(VALID_SAMPLES, vocab),
        batch_size=4,
        shuffle=False,
        collate_fn=collate_batch,
    )

    model = TransformerClassifier(
        vocab_size=len(vocab),
        pad_id=vocab[PAD_TOKEN],
    )
    optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
    loss_fn = nn.CrossEntropyLoss()

    for epoch in range(1, 21):
        train_loss = train_one_epoch(
            model,
            train_loader,
            optimizer,
            loss_fn,
        )
        if epoch in {1, 10, 20}:
            accuracy = evaluate(model, valid_loader)
            print(
                f"epoch={epoch:02d} "
                f"train_loss={train_loss:.4f} "
                f"val_accuracy={accuracy:.2f}"
            )

    texts = [
        "what a great film",
        "this movie is awful",
    ]
    for text, label in zip(texts, predict(model, texts, vocab)):
        print(f"text={text!r} prediction={label}")

if __name__ == "__main__":
    main()

预期输出格式:

text
epoch=01 train_loss=<FLOAT> val_accuracy=<FLOAT>
epoch=10 train_loss=<FLOAT> val_accuracy=<FLOAT>
epoch=20 train_loss=<FLOAT> val_accuracy=<FLOAT>
text='what a great film' prediction=<positive|negative>
text='this movie is awful' prediction=<positive|negative>

损失、准确率和最终标签会受 PyTorch 版本及底层计算差异影响,因此用占位符表示动态值。正常情况下,训练损失应整体下降;这个微型数据集只用于验证流程,不代表真实模型效果。

验证训练与推理是否正确

运行后先检查三件事:训练损失是否总体下降、验证准确率是否在合理范围内、两条新文本是否都返回合法标签。若损失完全不变,应依次检查标签类型、优化器是否收到模型参数,以及是否遗漏 loss.backward() 或 optimizer.step()。

验证阶段必须调用 model.eval(),否则包含 Dropout 等随机层时结果会波动。推理阶段还应使用 torch.no_grad(),避免构建计算图并浪费内存。

从示例迁移到真实项目

真实项目通常需要替换三处。第一,把内存样本改成文件或数据库数据,并严格划分训练集、验证集和测试集。第二,使用适合业务语言的分词器和预训练词表。第三,保存词表、模型参数和标签映射,保证部署时的预处理规则与训练阶段完全一致。

当类别分布不均衡时,不能只看准确率,还应增加精确率、召回率和 F1。文本较长时,应设定最大长度并执行截断,否则注意力的计算量会随序列长度平方增长。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

完成文本分类项目

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通