手把手教你使用 BERT 进行文本分类——代码逐行注释讲解

最新推荐文章于 2025-03-26 16:05:45 发布

我爱学大模型

最新推荐文章于 2025-03-26 16:05:45 发布

阅读量3.4k

点赞数 16

文章标签： bert 分类人工智能大模型 ai LLM 深度学习

本文链接：https://blog.csdn.net/python1234_/article/details/144824558

版权

文本分类是什么？
文本分类是机器学习的一个子领域，其主要任务是教会计算机如何将文本划分到不同的类别中。

它通常被作为一种监督学习技术，这意味着我们需要用已经标注好类别的文本数据对算法进行训练。

在模型训练完成后，它就能够根据所学到的规律对新的、未标注的文本进行分类。
算法通过寻找文本中的模式来决定文本属于哪个类别，就像我们学习辨别某种花的类型时，会观察花的特征一样，文本分类的算法也是通过分析单词和短语中的特征来完成分类任务的。 文本分类有许多实际应用，例如：垃圾邮件过滤： 电子邮件被分为垃圾邮件或非垃圾邮件，这就是基于特定词语或短语模式（例如“恭喜中奖”）的分类算法在起作用。
情感分析： 分析社交媒体上的帖子情感，如检测仇恨言论或负面情绪。
新闻分类： 将新闻或视频分类为不同主题（如科技、体育或娱乐），帮助用户快速找到感兴趣的内容。
文本分类是一种功能强大的工具，在各个领域中都有广泛的应用。

什么是 BERT？ BERT（Bidirectional Encoder Representations from Transformers，全称“基于双向编码器表示的变换器”）是 Google 开发的一种强大的自然语言处理（NLP）模型，基于 Transformer 的深度神经网络架构。

为什么 BERT 优秀？
与传统的 NLP 模型按顺序处理文本不同，BERT 能够一次性处理整个输入文本，因此可以更有效地捕捉单词之间的上下文关系。

BERT是一个预训练模型，这意味着它已经在大规模的语料（如书籍、文章和网页）上训练过，掌握了语言的结构和语义。

BERT 在文本分类中的作用 BERT 可以通过微调（fine-tuning）的方式，适应特定的下游任务，例如文本分类。通过利用其预训练获得的强大语言理解能力，我们可以快速构建高效的分类器。
BERT 有两种主要版本：BERT base和 BERT large。

本文将使用计算要求更低但性能强大的BERTbase来完成 IMDB 电影评论数据集上的情感分类任务。

使用 BERT 进行文本分类的教程
数据集简介 IMDB 电影评论数据集包含 50,000 条评论，其中标注了评论的情感（正面或负面）。

通过微调 BERT，我们将使其能够根据输入的评论预测情感。 第一步：导入必要的库 以下是所需库的导入，包含 PyTorch（深度学习框架）、Transformers（BERT 模型的库）、以及 scikit-learn（数据处理与评估工具）。

import os
import torch  # 深度学习框架
from torch import nn  # 神经网络模块
from torch.utils.data import DataLoader, Dataset  # 数据加载和自定义数据集
from transformers import BertTokenizer, BertModel, AdamW, get_linear_schedule_with_warmup  # BERT相关工具
from sklearn.model_selection import train_test_split  # 数据集划分
from sklearn.metrics import accuracy_score, classification_report  # 评估指标
import pandas as pd  # 数据处理

第二步：加载并预处理 IMDB 数据集 以下函数会加载 IMDB 数据集并进行处理：
1. 将评论文本存储在 `texts` 中。
2. 将情感转换为数值（正面为 1，负面为 0），存储在 `labels` 中。

def load_imdb_data(data_file):
    df = pd.read_csv(data_file)  # 读取CSV文件    
    texts = df['review'].tolist()  # 提取评论文本    
    labels = [1 if sentiment == "positive" else 0 for sentiment in df['sentiment'].tolist()]  # 将情感转化为数值    
    return texts, labels
    
# 指定数据集路径并加载数据
data_file = "IMDB Dataset.csv"
texts, labels = load_imdb_data(data_file)

第三步：定义自定义数据集类 以下是一个自定义的 PyTorch 数据集类，用于对文本进行编码、填充和生成模型所需的输入：

class TextClassificationDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length):    
        self.texts = texts        
        self.labels = labels        
        self.tokenizer = tokenizer        
        self.max_length = max_length
        
    def __len__(self):    
        return len(self.texts)
        
    def __getitem__(self, idx):    
        text = self.texts[idx]        
        label = self.labels[idx]        
        # 将文本转化为 BERT 可接受的输入格式        
        encoding = self.tokenizer(text, return_tensors='pt', max_length=self.max_length,
                                  padding='max_length', truncation=True)        
        return {      
            'input_ids': encoding['input_ids'].squeeze(0),  # 输入 ID            
            'attention_mask': encoding['attention_mask'].squeeze(0),  # 注意力掩码            
            'label': torch.tensor(label)  # 标签        
        }

第四步：构建自定义 BERT 分类器 以下是基于预训练 BERT 模型的自定义分类器，添加了 Dropout 层和全连接层：

class BERTClassifier(nn.Module):
    def __init__(self, bert_model_name, num_classes):      
        super(BERTClassifier, self).__init__()        
        self.bert = BertModel.from_pretrained(bert_model_name)  # 加载预训练的 BERT        
        self.dropout = nn.Dropout(0.1)  # Dropout 防止过拟合        
        self.fc = nn.Linear(self.bert.config.hidden_size, num_classes)  # 全连接层
        
    def forward(self, input_ids, attention_mask):    
        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)        
        pooled_output = outputs.pooler_output  # 获取 BERT 的输出特征        
        x = self.dropout(pooled_output)        
        logits = self.fc(x)  # 分类得分        
        return logits

第五步：定义训练函数 以下代码定义了模型的训练过程：

def train(model, data_loader, optimizer, scheduler, device):
    model.train()    
    for batch in data_loader:    
        optimizer.zero_grad()  # 清除上一次的梯度        
        input_ids = batch['input_ids'].to(device)        
        attention_mask = batch['attention_mask'].to(device)        
        labels = batch['label'].to(device)        
        outputs = model(input_ids=input_ids, attention_mask=attention_mask)        
        loss = nn.CrossEntropyLoss()(outputs, labels)  # 计算交叉熵损失        
        loss.backward()  # 反向传播        
        optimizer.step()  # 优化器更新参数        
        scheduler.step()  # 调整学习率

第六步：定义评估函数

评估函数用于在验证集上测试模型的性能，包括计算准确率和生成分类报告：

def evaluate(model, data_loader, device):
    model.eval()  # 切换到评估模式    
    all_labels = []    
    all_preds = []
    
    with torch.no_grad():  # 禁用梯度计算，提升效率    
        for batch in data_loader:         
            input_ids = batch['input_ids'].to(device)            
            attention_mask = batch['attention_mask'].to(device)            
            labels = batch['label'].to(device)
            
            outputs = model(input_ids=input_ids, attention_mask=attention_mask)            
            preds = torch.argmax(outputs, dim=1)  # 获取预测标签
            
            all_labels.extend(labels.cpu().numpy())            
            all_preds.extend(preds.cpu().numpy())
            
    # 计算准确率    
    acc = accuracy_score(all_labels, all_preds)    
    report = classification_report(all_labels, all_preds, target_names=["负面", "正面"], digits=4)    
    return acc, report

第七步：设置模型参数和优化器

在这里，我们需要初始化模型、优化器、学习率调度器，并将其部署到 GPU 或 CPU 上运行。

# 定义参数
bert_model_name = "bert-base-uncased"
max_length = 128  # 文本最大长度
batch_size = 16  # 批次大小
num_epochs = 4  # 训练轮数
learning_rate = 2e-5  # 学习率

# 初始化 BERT 分类器
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = BERTClassifier(bert_model_name=bert_model_name, num_classes=2)
model.to(device)

# 优化器和学习率调度器
optimizer = AdamW(model.parameters(), lr=learning_rate, eps=1e-8)  # AdamW 优化器
total_steps = len(train_loader) * num_epochs
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=0, num_training_steps=total_steps)

第八步：划分数据集并创建数据加载器

将数据集分为训练集和验证集，并使用 PyTorch 的 DataLoader 进行批量加载。

# 划分训练集和验证集
train_texts, val_texts, train_labels, val_labels = train_test_split(texts, labels, test_size=0.2, random_state=42)

# 初始化分词器
tokenizer = BertTokenizer.from_pretrained(bert_model_name)

# 创建自定义数据集
train_dataset = TextClassificationDataset(train_texts, train_labels, tokenizer, max_length)
val_dataset = TextClassificationDataset(val_texts, val_labels, tokenizer, max_length)

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size)

第九步：训练模型

通过训练函数对模型进行多轮迭代，并在每个 epoch 结束后验证模型性能。

for epoch in range(num_epochs):
    print(f"训练第 {epoch+1}/{num_epochs} 轮...")    
    train(model, train_loader, optimizer, scheduler, device)  # 训练    
    acc, report = evaluate(model, val_loader, device)  # 评估
    
    print(f"验证集准确率: {acc:.4f}")    
    print(f"分类报告:\n{report}")

第十步：预测新数据

最后，我们可以使用训练好的模型对新数据进行预测。以下是一个简单的预测函数：

def predict(model, text, tokenizer, max_length, device):    
    model.eval()  # 切换到评估模式

    # 对输入文本进行编码    
    encoding = tokenizer(text, return_tensors='pt', max_length=max_length,
                         padding='max_length', truncation=True)    
    input_ids = encoding['input_ids'].to(device)    
    attention_mask = encoding['attention_mask'].to(device)

    # 获取模型预测    
    with torch.no_grad():    
        outputs = model(input_ids=input_ids, attention_mask=attention_mask)        
        pred = torch.argmax(outputs, dim=1).cpu().numpy()[0]
    
    return "正面" if pred == 1 else "负面"

 # 示例预测
 example_text = "The movie was absolutely amazing, I loved it!"
 print(f"评论: {example_text}")
 print(f"预测结果: {predict(model, example_text, tokenizer, max_length, device)}")