基于BERT的文本分类——附-简单的示例代码

**BERT（Bidirectional Encoder Representations from Transformers）**是一种预训练的自然语言处理模型，由Google于2018年提出。BERT通过在大规模文本语料上进行预训练，学习了深层次的语言表示，然后可以通过微调用于各种下游任务，包括文本分类。

文本分类是一个常见的自然语言处理任务，它涉及将文本分为不同的类别或标签。BERT在文本分类任务中表现出色，其双向（bidirectional）的注意力机制允许模型捕捉上下文信息，同时避免了传统模型中的单向限制。以下是BERT文本分类的一般步骤：

1. 预训练BERT模型： 在大规模文本语料上，BERT模型进行了预训练。这个过程使得BERT能够学到深层次的语言表示，理解单词和短语之间的复杂关系。

2. 微调： 针对特定的文本分类任务，使用预训练好的BERT模型，通过在带有标签的任务数据上进行微调。这意味着使用任务特定的标签数据，调整模型参数以适应具体的分类任务。

3. 输入表示： 对于文本分类任务，输入文本需要经过一些处理，以适应BERT的输入格式。通常，文本被分成标记（tokens）并加上特殊的标记，如[CLS]（用于表示分类任务的开始）。

4. 获取输出： BERT模型的输出通常是每个输入标记的隐藏表示。为了进行文本分类，可以采用一些策略，例如取[CLS]标记的输出作为整个句子的表示，然后将其输入到分类器中。

5. 分类器： 在BERT的输出之上，添加一个分类器（如全连接层），以将句子映射到相应的类别。这个分类器是在微调过程中学到的。

6. 训练和评估： 使用标记的训练数据对整个模型进行训练，并使用验证集或测试集来评估模型的性能。常见的损失函数包括交叉熵损失。

BERT的优势在于其能够捕捉上下文信息，使得在文本分类等任务中能够更好地理解语境。然而，由于BERT模型参数较多，微调可能需要更多的标签数据和计算资源。最近，出现了一些基于BERT的轻量化模型，以降低计算成本并适应资源有限的环境。

BERT及其变体

1. bert-base-uncased:

编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共110M参数量, 在小写的英文文本上进行训练而得到.

2. bert-large-uncased:

编码器具有24个隐层, 输出1024维张量, 16个自注意力头, 共340M参数量, 在小写的英文文本上进行训练而得到.

3. bert-base-cased:

编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共110M参数量, 在不区分大小写的英文文本上进行训练而得到.

4. bert-large-cased:

编码器具有24个隐层, 输出1024维张量, 16个自注意力头, 共340M参数量, 在不区分大小写的英文文本上进行训练而得到.

5. bert-base-multilingual-uncased:

编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共110M参数量, 在小写的102种语言文本上进行训练而得到.

6. bert-large-multilingual-uncased:

编码器具有24个隐层, 输出1024维张量, 16个自注意力头, 共340M参数量, 在小写的102种语言文本上进行训练而得到.

7. bert-base-chinese:

编码器具有12个隐层, 输出768维张量, 12个自注意力头, 共110M参数量, 在简体和繁体中文文本上进行训练而得到.

BERT的base模型可以在这里下载：

BERT基础模型 https://github.com/google-research/bert?tab=readme-ov-file

以下是一段我写的示例代码：

import torch
from transformers import BertTokenizer, BertForSequenceClassification
from torch.utils.data import DataLoader, Dataset
from torch.optim import AdamW,SGD,Adam
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

class TextClassificationDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_len):
        self.texts = texts
        self.labels = labels
        self.tokenizer = tokenizer
        self.max_len = max_len

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

    def __getitem__(self, idx):
        text = str(self.texts[idx])
        label = self.labels[idx]

        encoding = self.tokenizer.encode_plus(
            text,
            add_special_tokens=True,
            max_length=self.max_len,
            return_token_type_ids=False,
            padding='max_length',
            return_attention_mask=True,
            return_tensors='pt',
        )

        return {
            'text': text,
            'input_ids': encoding['input_ids'].flatten(),
            'attention_mask': encoding['attention_mask'].flatten(),
            'label': torch.tensor(label, dtype=torch.long)
        }

tokenizer = BertTokenizer.from_pretrained('bert-base-chinese')#如果自动下载失败，请手动访问https://github.com/google-research/bert?tab=readme-ov-file下载到本地，并修改目录路径
model = BertForSequenceClassification.from_pretrained('bert-base-chinese', num_labels=2)

## 读取Excel文件
#df = pd.read_excel('train_data.xlsx')
## 提取标签和文本数据
#labels = df.iloc[1:, 0].values
#texts = df.iloc[1:, 1].values
## 创建一个字典，其中键是标签，值是一个唯一的数字
#label_dict = {label: i for i, label in enumerate(set(labels))}


# print(label_dict)
## 使用字典将文本标签转换为数字
# labels = [label_dict[label] for label in labels]

texts = ["你好，世界！", "机器学习太棒了！"]
labels = [0, 1]

## 将数据集分为训练集和测试集
#train_texts, test_texts, train_labels, test_labels = train_test_split(texts, labels, #test_size=0.2, random_state=13)

## 使用训练集创建训练数据加载器
#train_dataset = TextClassificationDataset(train_texts, train_labels, tokenizer, max_len=128)
#train_data_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)

## 使用测试集创建测试数据加载器
#test_dataset = TextClassificationDataset(test_texts, test_labels, tokenizer, max_len=128)
#test_data_loader = DataLoader(test_dataset, batch_size=128)

# 使用提取的标签和文本数据创建数据集
all_dataset = TextClassificationDataset(texts, labels, tokenizer, max_len=128)
all_data_loader = DataLoader(all_dataset , batch_size=2, shuffle=True)

# 检查是否有可用的CUDA设备
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# 加载保存的状态字典
# model.load_state_dict(torch.load('my_model.pth'))

# 将模型移动到CUDA设备上
model = model.to(device)

optimizer = AdamW(model.parameters(), lr=1e-4)
epochs = 10  # 定义训练的轮数

for epoch in range(epochs):
    total_loss = 0
    model.train()
    for batch in all_data_loader :
        # 将输入数据移动到CUDA设备上
        input_ids = batch['input_ids'].to(device)
        attention_mask = batch['attention_mask'].to(device)
        labels = batch['label'].to(device)

        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)

        loss = outputs.loss
        total_loss += loss.item()

        loss.backward()

        optimizer.step()
        optimizer.zero_grad()


    avg_train_loss = total_loss / len(train_data_loader)
    print(f"Epoch {epoch+1} / {epochs}, Training Loss: {avg_train_loss}")

    # 评估模型
    model.eval()
    correct_predictions = 0
    total_predictions = 0
    with torch.no_grad():
        for batch in all_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, attention_mask=attention_mask)

            predicted_class = torch.argmax(outputs.logits, dim=1)
            correct_predictions += (predicted_class == labels).sum().item()
            total_predictions += labels.size(0)

    # 计算准确率
    accuracy = correct_predictions / total_predictions
    print(f"Accuracy: {accuracy}")



print("Training complete.")
# 将模型移动到CPU设备上
model = model.to('cpu')
# 在训练结束后保存模型的状态字典
torch.save(model.state_dict(), 'my_model.pth')

print("Model saved to model.pth.")

#----------------------------------------------------
# 初始化一个新的模型实例
model = BertForSequenceClassification.from_pretrained('bert-base-chinese', num_labels=2)

# 加载保存的状态字典
model.load_state_dict(torch.load('my_model.pth'))

# 将模型移动到CUDA设备上
model = model.to(device)

print("Model loaded from model.pth.")
model.eval()
new_text = "你好，世界！"

encoding = tokenizer.encode_plus(
    new_text,
    add_special_tokens=True,
    max_length=128,
    return_token_type_ids=False,
    padding='max_length',
    return_attention_mask=True,
    return_tensors='pt',
)

input_ids = encoding['input_ids']
attention_mask = encoding['attention_mask']

with torch.no_grad():
    # 将输入数据移动到CUDA设备上
    input_ids = input_ids.to(device)
    attention_mask = attention_mask.to(device)
    outputs = model(input_ids, attention_mask=attention_mask)

predicted_class = torch.argmax(outputs.logits, dim=1)
# 创建一个反向字典，其中键是数字，值是文本标签
# reverse_label_dict = {v: k for k, v in label_dict.items()}

# 使用反向字典将预测的类别转换回文本标签
# predicted_class = predicted_class.item()
# predicted_label = reverse_label_dict[predicted_class]

#print(f"The predicted class for the text '{new_text}' is {predicted_label}.")
print(f"The predicted class for the text '{new_text}' is {predicted_class.item()}.")