pytorch 实现中文文本分类

•   🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍦 参考文章：TensorFlow入门实战｜第3周：天气识别
• 🍖 原作者：K同学啊|接辅导、项目定制

 

import torch
import torch.nn as nn
import torchvision
from torchvision import transforms, datasets
import os, PIL, pathlib, warnings

warnings.filterwarnings("ignore")  # 忽略警告信息

# win10系统
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)

train.csv 链接：https://pan.baidu.com/s/1Vnyvo5T5eSuzb0VwTsznqA?pwd=fqok 提取码：fqok 

import pandas as pd

# 加载自定义中文数据集
train_data = pd.read_csv('D:/train.csv', sep='\t', header=None)
train_data.head()

# 构建数据集迭代器
def coustom_data_iter(texts, labels):
    for x, y in zip(texts, labels):
        yield x, y

train_iter = coustom_data_iter(train_data[0].values[:], train_data[1].values[:])

1.构建词典：

from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator
import jieba

# 中文分词方法
tokenizer = jieba.lcut

def yield_tokens(data_iter):
    for text, in data_iter:
        yield tokenizer(text)

vocab = build_vocab_from_iterator(yield_tokens(train_iter), specials=["<unk>"])
vocab.set_default_index(vocab["<unk>"])

 调用vocab（词汇表）对一个中文句子进行索引转换，这个句子被分词后得到的词汇列表会被转换成它们在词汇表中的索引。

print(vocab(['我', '想', '看', '书', '和', '你', '一起', '看', '电影', '的', '新款', '视频']))

生成一个标签列表，用于查看在数据集中所有可能的标签类型。 

label_name = list(set(train_data[1].values[:]))
print(label_name)

 创建了两个lambda函数，一个用于将文本转换成词汇索引，另一个用于将标签文本转换成它们在label_name列表中的索引。

text_pipeline = lambda x: vocab(tokenizer(x))
label_pipeline = lambda x: label_name.index(x)

print(text_pipeline('我想看新闻或者上网站看最新的游戏视频'))
print(label_pipeline('Video-Play'))

2.生成数据批次和迭代器

from torch.utils.data import DataLoader

def collate_batch(batch):
    label_list, text_list, offsets = [], [], [0]

    for (_text, _label) in batch:
        # 标签列表
        label_list.append(label_pipeline(_label))
        
        # 文本列表
        processed_text = torch.tensor(text_pipeline(_text), dtype=torch.int64)
        text_list.append(processed_text)
        
        # 偏移量，即词汇的起始位置
        offsets.append(processed_text.size(0))

    label_list = torch.tensor(label_list, dtype=torch.int64)
    text_list = torch.cat(text_list)
    offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)  # 累计偏移量dim中维度元素的累计和
    
    return text_list.to(device), label_list.to(device), offsets.to(device)

# 数据加载器，调用示例
dataloader = DataLoader(train_iter,
                        batch_size=8,
                        shuffle=False,
                        collate_fn=collate_batch)

• collate_batch函数用于处理数据加载器中的批次。它接收一个批次的数据，处理它，并返回适合模型训练的数据格式。
• 在这个函数内部，它遍历批次中的每个文本和标签对，将标签添加到label_list，将文本通过text_pipeline函数处理后转换为tensor，并添加到text_list。
• offsets列表用于存储每个文本的长度，这对于后续的文本处理非常有用，尤其是当你需要知道每个文本在拼接的大tensor中的起始位置时。
• text_list用torch.cat进行拼接，形成一个连续的tensor。
• offsets列表的最后一个元素不包括，然后使用cumsum函数在第0维计算累积和，这为每个序列提供了一个累计的偏移量。

3.搭建模型与初始化

from torch import nn

class TextClassificationModel(nn.Module):
    def __init__(self, vocab_size, embed_dim, num_class):
        super(TextClassificationModel, self).__init__()
        self.embedding = nn.EmbeddingBag(vocab_size, embed_dim, sparse=False)
        self.fc = nn.Linear(embed_dim, num_class)
        self.init_weights()
    
    def init_weights(self):
        initrange = 0.5
        self.embedding.weight.data.uniform_(-initrange, initrange)
        self.fc.weight.data.uniform_(-initrange, initrange)
        self.fc.bias.data.zero_()
        
    def forward(self, text, offsets):
        embedded = self.embedding(text, offsets)
        return self.fc(embedded)

num_class = len(label_name)  # 类别数，根据label_name的长度确定
vocab_size = len(vocab)      # 词汇表的大小，根据vocab的长度确定
em_size = 64                 # 嵌入向量的维度设置为64
model = TextClassificationModel(vocab_size, em_size, num_class).to(device)  # 创建模型实例并移动到计算设备

4.模型训练及评估函数

train 和 evaluate分别用于训练和评估文本分类模型。

训练函数 train 的工作流程如下：

1. 将模型设置为训练模式。
2. 初始化总准确率、训练损失和总计数变量。
3. 记录训练开始的时间。
4. 遍历数据加载器，对每个批次：
   • 进行预测。
   • 清零优化器的梯度。
   • 计算损失（使用一个损失函数，例如交叉熵）。
   • 反向传播计算梯度。
   • 通过梯度裁剪防止梯度爆炸。
   • 执行一步优化器更新模型权重。
5. 更新总准确率和总损失。
6. 每隔一定间隔，打印训练进度和统计信息。

评估函数 evaluate 的工作流程如下：

1. 将模型设置为评估模式。
2. 初始化总准确率和总损失。
3. 不计算梯度（为了节省内存和计算资源）。
4. 遍历数据加载器，对每个批次：
   • 进行预测。
   • 计算损失。
   • 更新总准确率和总损失。
5. 返回整体的准确率和平均损失。

代码实现：

import time

def train(dataloader):
    model.train()  # 切换到训练模式
    total_acc, train_loss, total_count = 0, 0, 0
    log_interval = 50
    start_time = time.time()

    for idx, (text, label, offsets) in enumerate(dataloader):
        predicted_label = model(text, offsets)
        optimizer.zero_grad()  # 梯度归零
        loss = criterion(predicted_label, label)  # 计算损失
        loss.backward()  # 反向传播
        torch.nn.utils.clip_grad_norm_(model.parameters(), 0.1)  # 梯度裁剪
        optimizer.step()  # 优化器更新权重

        # 记录acc和loss
        total_acc += (predicted_label.argmax(1) == label).sum().item()
        train_loss += loss.item()
        total_count += label.size(0)
        
        if idx % log_interval == 0 and idx > 0:
            elapsed = time.time() - start_time
            print('| epoch {:3d} | {:5d}/{:5d} batches '
                  '| accuracy {:8.3f} | loss {:8.5f}'.format(
                      epoch, idx, len(dataloader),
                      total_acc/total_count, train_loss/total_count))
            total_acc, train_loss, total_count = 0, 0, 0
            start_time = time.time()

def evaluate(dataloader):
    model.eval()  # 切换到评估模式
    total_acc, total_count = 0, 0

    with torch.no_grad():
        for idx, (text, label, offsets) in enumerate(dataloader):
            predicted_label = model(text, offsets)
            loss = criterion(predicted_label, label)  # 计算loss
            total_acc += (predicted_label.argmax(1) == label).sum().item()
            total_count += label.size(0)

    return total_acc/total_count, total_count

5.模型训练

• 设置训练的轮数、学习率和批次大小。
• 定义交叉熵损失函数、随机梯度下降优化器和学习率调度器。
• 将训练数据转换为一个map样式的数