NLP实战(3)：RNN英文名国家分类

[1. 项目需求](#1. 项目需求)

[2. 模型解析](#2. 模型解析)

[2.1 网络模型](#2.1 网络模型)

[2.2 准备数据](#2.2 准备数据)

[2.3 双向循环神经网络](#2.3 双向循环神经网络)

[3. 代码解析](#3. 代码解析)

[4. 完整代码](#4. 完整代码)

[5. 结果](#5. 结果)

1. 项目需求

对名字的分类，几千个名字，总共来自于18个国家

2. 模型解析

对于自然语言处理来说，输入是一个序列，需要编码成one-hot的形式

由于其是一个高维的稀疏的向量，所以通常经过embed层变成稀疏的稠密的向量

经过RNN循环神经网络后，对其分类

但是对本文的任务，输出的o1、o2我们不在乎，因为这是序列的分类形式，而不是对自然语言的序列进行字词的重组等

所以网络可以进行优化

网络的结构：

2.1 网络模型

输入虽然是单个名字，但是因为名字的长短不一样，因此要进行处理

2.2 准备数据

这里通过ASCII变成字符序列

因为数据的长短不一，要进行padding

分类的类别索引：18类别

2.3 双向循环神经网络

一般的RNN，Xn-1 只是和之前的信息有关

双向的循环神经网络就是反向来一次传播，把h的结果进行concat拼接

3. 代码解析

本文实现了一个基于双向GRU的RNN模型，用于对名字进行国家分类。

以下是详细的模块解析和功能说明：

1. 环境配置与设备检测

环境变量 ：KMP_DUPLICATE_LIB_OK用于避免OpenMP库重复加载的冲突。
设备选择：自动检测GPU（CUDA）是否可用，优先使用GPU加速计算。

2. 模型定义（RNNClassifier）

复制代码

class RNNClassifier(torch.nn.Module):
    def __init__(self, input_size, hidden_size, output_size, n_layers=1, bidirectional=True):
        super(RNNClassifier, self).__init__()
        self.hidden_size = hidden_size
        self.n_layers = n_layers
        self.n_directions = 2 if bidirectional else 1
        self.embedding = torch.nn.Embedding(input_size, hidden_size)
        self.gru = torch.nn.GRU(hidden_size, hidden_size, n_layers,
                                bidirectional=bidirectional)
        self.fc = torch.nn.Linear(hidden_size * self.n_directions, output_size)

    def _init_hidden(self, batch_size):
        return torch.zeros(self.n_layers * self.n_directions,
                           batch_size,
                           self.hidden_size).to(device)

    def forward(self, input, seq_lengths):
        # 确保lengths在CPU上
        seq_lengths = seq_lengths.cpu()  # 关键修复

        input = input.t()
        batch_size = input.size(1)
        hidden = self._init_hidden(batch_size)
        embedding = self.embedding(input)

        # 打包序列（lengths必须在CPU）
        packed = pack_padded_sequence(embedding, seq_lengths)
        output, hidden = self.gru(packed, hidden)

        # 处理双向输出
        if self.n_directions == 2:
            hidden = torch.cat([hidden[-1], hidden[-2]], dim=1)
        else:
            hidden = hidden[-1]

        return self.fc(hidden)

结构：
- Embedding层 ：将输入的ASCII字符编码映射到隐藏空间（input_size=128对应ASCII字符数）。
- GRU层 ：支持双向设置（bidirectional=True），通过n_layers指定层数。
- 全连接层：将GRU的最终隐藏状态映射到国家分类的输出维度。
核心逻辑：
- 前向传播 ：输入序列通过Embedding层后，使用pack_padded_sequence处理变长序列，提升计算效率。GRU的输出经过双向拼接（如果是双向），最终通过全连接层生成分类结果。
- 隐藏状态初始化 ：初始隐藏状态为全零张量，形状为(n_layers * n_directions, batch_size, hidden_size)。

3. 数据加载与处理（NameDataset）

复制代码

class NameDataset(Dataset):
    def __init__(self, is_train_set=True):
        filename = './data/names_train.csv' if is_train_set else './data/names_test.csv'
        with open(filename, 'r') as f:
            lines = f.read().splitlines()
        self.names = [line.split(',')[0] for line in lines]
        self.countries = [line.split(',')[1] for line in lines]
        self.country_list = sorted(set(self.countries))
        self.country_dict = {c: i for i, c in enumerate(self.country_list)}
        self.n_countries = len(self.country_list)

    def __getitem__(self, index):
        return self.names[index], self.country_dict[self.countries[index]]

    def __len__(self):
        return len(self.names)

    def getCountriesNum(self):
        return self.n_countries

    def idx2country(self, index):
        return self.country_list[index]

数据格式 ：从CSV文件加载数据，格式为名字,国家（如"John,USA"）。
功能：
- 国家编码 ：将国家名称转换为唯一的整数索引（通过country_dict）。
- 数据集接口 ：继承Dataset类，实现__getitem__和__len__方法，支持PyTorch的DataLoader。
- 辅助方法 ：getCountriesNum获取国家数量，idx2country通过索引反向查询国家名称。

4. 数据预处理（name2list与make_tensors）

字符编码 ：name2list将名字转换为ASCII码列表（如"John"→[74, 111, 104, 110]）并记录长度。
张量生成 ：make_tensors将数据填充为等长张量，并按序列长度降序排列（优化pack_padded_sequence性能）：
- 填充：短序列补零，长序列截断。
- 设备分配 ：数据张量（seq_tensor和countries）移动到指定设备（GPU/CPU），lengths保留在CPU（因pack_padded_sequence要求）。

5. 训练与测试流程

复制代码

def train():
    total_loss = 0
    for i, (names, countries) in enumerate(train_loader, 1):
        inputs, lengths, labels = make_tensors(names, countries)

        outputs = model(inputs, lengths)
        loss = criterion(outputs, labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_loss += loss.item()
        if i % 10 == 0:
            print(f'[{time_since(start)}] Epoch {epoch} '
                  f'[{i * len(inputs)}/{len(train_set)}] '
                  f'loss={total_loss / (i * len(inputs)):.4f}')
    return total_loss / len(train_set)

训练函数（train）：
- 前向计算：输入数据通过模型，计算交叉熵损失。
- 反向传播：优化器（Adam）更新参数，每10个batch输出平均损失。
- 损失计算：累积损失除以总样本数，确保不同batch大小的可比性。
测试函数（test）：
- 推理模式：禁用梯度计算，计算测试集准确率。
- 结果输出：打印正确样本数和总准确率。
  
  def test():
  correct = 0
  with torch.no_grad():
  for names, countries in test_loader:
  inputs, lengths, labels = make_tensors(names, countries)
  outputs = model(inputs, lengths)
  pred = outputs.argmax(dim=1)
  correct += (pred == labels).sum().item()
  acc = correct / len(test_set)
  print(f'Test Accuracy: {correct}/{len(test_set)} ({acc:.2%})\n')
  return acc

6. 主程序与超参数

超参数：
- HIDDEN_SIZE=128：GRU隐藏层维度。
- BATCH_SIZE=256：批量大小。
- N_LAYERS=2：GRU层数。
- N_EPOCHS=50：训练轮次。
- N_CHARS=128：输入字符的ASCII码范围（0-127）。
训练循环：
- 初始化模型、损失函数（交叉熵）和优化器（学习率0.001）。
- 每个epoch结束后在测试集上评估准确率，记录到acc_history。
结果可视化 ：使用matplotlib绘制准确率随epoch变化的曲线。

7. 关键实现细节

变长序列处理 ：通过pack_padded_sequence压缩填充后的序列，避免无效计算。
双向GRU输出拼接 ：双向GRU的最终隐藏状态是前向和后向的拼接（hidden[-1]和hidden[-2]）。
设备管理 ：数据张量（输入、标签）和模型参数需在同一设备（GPU/CPU），但lengths必须保留在CPU。

8. 潜在优化点

学习率调整 ：可引入学习率调度器（如ReduceLROnPlateau）提升收敛性。
早停机制：根据验证集准确率提前终止训练，防止过拟合。
字符嵌入维度 ：调整Embedding层的输出维度（hidden_size）可能影响模型表达能力。
数据增强：对名字进行扰动（如增删字符）提升泛化性。

9. 代码执行流程

加载训练集和测试集。
初始化模型并移至GPU（若可用）。
训练50个epoch，每个epoch结束后测试准确率。
绘制准确率变化曲线，观察模型性能。

该代码完整实现了从数据加载、模型定义到训练测试的全流程，适用于基于字符级别的短文本分类任务（如名字国籍分类）。通过调整超参数和模型结构，可适配其他类似场景。

4. 完整代码

完整代码：

python 复制代码

import os
os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'  # 允许重复加载OpenMP库

import torch
import time
import matplotlib.pyplot as plt
import math
from torch.utils.data import DataLoader, Dataset
from torch.nn.utils.rnn import pack_padded_sequence

# 设备检测
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")


class RNNClassifier(torch.nn.Module):
    def __init__(self, input_size, hidden_size, output_size, n_layers=1, bidirectional=True):
        super(RNNClassifier, self).__init__()
        self.hidden_size = hidden_size
        self.n_layers = n_layers
        self.n_directions = 2 if bidirectional else 1
        self.embedding = torch.nn.Embedding(input_size, hidden_size)
        self.gru = torch.nn.GRU(hidden_size, hidden_size, n_layers,
                                bidirectional=bidirectional)
        self.fc = torch.nn.Linear(hidden_size * self.n_directions, output_size)

    def _init_hidden(self, batch_size):
        return torch.zeros(self.n_layers * self.n_directions,
                           batch_size,
                           self.hidden_size).to(device)

    def forward(self, input, seq_lengths):
        # 确保lengths在CPU上
        seq_lengths = seq_lengths.cpu()  # 关键修复

        input = input.t()
        batch_size = input.size(1)
        hidden = self._init_hidden(batch_size)
        embedding = self.embedding(input)

        # 打包序列（lengths必须在CPU）
        packed = pack_padded_sequence(embedding, seq_lengths)
        output, hidden = self.gru(packed, hidden)

        # 处理双向输出
        if self.n_directions == 2:
            hidden = torch.cat([hidden[-1], hidden[-2]], dim=1)
        else:
            hidden = hidden[-1]

        return self.fc(hidden)


class NameDataset(Dataset):
    def __init__(self, is_train_set=True):
        filename = './data/names_train.csv' if is_train_set else './data/names_test.csv'
        with open(filename, 'r') as f:
            lines = f.read().splitlines()
        self.names = [line.split(',')[0] for line in lines]
        self.countries = [line.split(',')[1] for line in lines]
        self.country_list = sorted(set(self.countries))
        self.country_dict = {c: i for i, c in enumerate(self.country_list)}
        self.n_countries = len(self.country_list)

    def __getitem__(self, index):
        return self.names[index], self.country_dict[self.countries[index]]

    def __len__(self):
        return len(self.names)

    def getCountriesNum(self):
        return self.n_countries

    def idx2country(self, index):
        return self.country_list[index]


def name2list(name):
    return [ord(c) for c in name], len(name)


def make_tensors(names, countries):
    # 生成序列和长度
    sequences_and_lengths = [name2list(name) for name in names]
    sequences = [s[0] for s in sequences_and_lengths]
    lengths = torch.LongTensor([s[1] for s in sequences_and_lengths])
    countries = torch.LongTensor(countries)

    # 创建填充张量
    seq_tensor = torch.zeros(len(sequences), lengths.max()).long()
    for idx, (seq, length) in enumerate(zip(sequences, lengths)):
        seq_tensor[idx, :length] = torch.LongTensor(seq)

    # 按长度排序（保持lengths在CPU）
    lengths, perm_idx = lengths.sort(dim=0, descending=True)
    seq_tensor = seq_tensor[perm_idx].to(device)  # 数据到GPU
    countries = countries[perm_idx].to(device)  # 数据到GPU

    return seq_tensor, lengths, countries  # lengths保留在CPU


def time_since(since):
    s = time.time() - since
    m = math.floor(s / 60)
    s -= m * 60
    return f'{m}m {s:.0f}s'


def train():
    total_loss = 0
    for i, (names, countries) in enumerate(train_loader, 1):
        inputs, lengths, labels = make_tensors(names, countries)

        outputs = model(inputs, lengths)
        loss = criterion(outputs, labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_loss += loss.item()
        if i % 10 == 0:
            print(f'[{time_since(start)}] Epoch {epoch} '
                  f'[{i * len(inputs)}/{len(train_set)}] '
                  f'loss={total_loss / (i * len(inputs)):.4f}')
    return total_loss / len(train_set)


def test():
    correct = 0
    with torch.no_grad():
        for names, countries in test_loader:
            inputs, lengths, labels = make_tensors(names, countries)
            outputs = model(inputs, lengths)
            pred = outputs.argmax(dim=1)
            correct += (pred == labels).sum().item()
    acc = correct / len(test_set)
    print(f'Test Accuracy: {correct}/{len(test_set)} ({acc:.2%})\n')
    return acc


if __name__ == '__main__':
    # 超参数
    HIDDEN_SIZE = 128
    BATCH_SIZE = 256
    N_LAYERS = 2
    N_EPOCHS = 50
    N_CHARS = 128  # ASCII字符数

    # 数据加载
    train_set = NameDataset(is_train_set=True)
    train_loader = DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True)
    test_set = NameDataset(is_train_set=False)
    test_loader = DataLoader(test_set, batch_size=BATCH_SIZE)
    N_COUNTRIES = train_set.getCountriesNum()

    # 模型初始化
    model = RNNClassifier(N_CHARS, HIDDEN_SIZE, N_COUNTRIES, N_LAYERS).to(device)
    criterion = torch.nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

    # 训练循环
    start = time.time()
    acc_history = []
    for epoch in range(1, N_EPOCHS + 1):
        print(f"=== Epoch {epoch}/{N_EPOCHS} ===")
        train_loss = train()
        val_acc = test()
        acc_history.append(val_acc)

    # 结果可视化
    plt.plot(acc_history)
    plt.title('Training Accuracy')
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')
    plt.show()

5. 结果

下载：基于RNN循环神经网络实现的时间序列英文name国家分类资源-CSDN文库

如下：

日志：

Using device: cuda

=== Epoch 1/50 ===