BERT入门实战：从零开始构建基于Transformer的预训练模型

1次阅读

共计 2833 个字符，预计需要花费 8 分钟才能阅读完成。

自然语言处理（NLP）领域近年来经历了巨大的变革，从早期的词袋模型到如今的预训练语言模型。传统的单向语言模型（如 GPT）只能从左到右或从右到左进行建模，这限制了模型对上下文的理解能力。BERT（Bidirectional Encoder Representations from Transformers）通过双向预训练解决了这一问题，成为 NLP 领域的重要里程碑。

Transformer 是 BERT 的基础架构，其核心是 Self-Attention 机制。Self-Attention 允许模型在处理每个词时，同时关注输入序列中的所有其他词，从而捕获全局依赖关系。

Self-Attention 机制 ：通过计算查询（Query）、键（Key）和值（Value）之间的注意力权重，模型可以动态地关注输入序列中的不同部分。
多头注意力 ：将注意力机制扩展到多个头，使模型能够从不同角度捕获信息。

BERT 通过双向预训练，即同时考虑左右上下文，从而更全面地理解语言。这与传统的单向语言模型（如 GPT）形成鲜明对比。

MLM 任务 ：随机掩盖输入序列中的部分词，模型需要预测这些被掩盖的词。这种任务迫使模型学习上下文的深层表示。
NSP 任务 ：模型需要判断两个句子是否连续，从而学习句子间的关系。

import torch
import torch.nn as nn
from torch.nn import TransformerEncoder, TransformerEncoderLayer

class BERTModel(nn.Module):
    def __init__(self, vocab_size, hidden_size, num_layers, num_heads):
        super(BERTModel, self).__init__()
        self.embedding = nn.Embedding(vocab_size, hidden_size)
        encoder_layers = TransformerEncoderLayer(hidden_size, num_heads)
        self.transformer_encoder = TransformerEncoder(encoder_layers, num_layers)
        self.fc = nn.Linear(hidden_size, vocab_size)

    def forward(self, x):
        x = self.embedding(x)
        x = self.transformer_encoder(x)
        x = self.fc(x)
        return x

from torch.utils.data import DataLoader, Dataset

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

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

    def __getitem__(self, idx):
        text = self.texts[idx]
        tokens = self.tokenizer.tokenize(text)
        tokens = ["[CLS]"] + tokens[:self.max_len-2] + ["[SEP]"]
        input_ids = self.tokenizer.convert_tokens_to_ids(tokens)
        return torch.tensor(input_ids)

# 训练循环
def train(model, dataloader, optimizer, criterion, epochs):
    model.train()
    for epoch in range(epochs):
        for batch in dataloader:
            optimizer.zero_grad()
            output = model(batch)
            loss = criterion(output, batch)
            loss.backward()
            optimizer.step()

在下游任务（如文本分类）中，可以通过在 BERT 模型后添加一个分类层来微调模型。

class BERTForClassification(nn.Module):
    def __init__(self, bert_model, num_classes):
        super(BERTForClassification, self).__init__()
        self.bert = bert_model
        self.classifier = nn.Linear(bert_model.hidden_size, num_classes)

    def forward(self, x):
        x = self.bert(x)
        x = self.classifier(x[:, 0, :])  # 使用 [CLS]token 进行分类
        return x

HuggingFace Transformers 库提供了预训练的 BERT 模型和方便的接口，可以快速实现 BERT 的应用。

from transformers import BertTokenizer, BertForSequenceClassification

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')