大型语言模型 (LLM) 入门与训练实战指南

2. 全模型训练

顾名思义，我们在该技术中在自定义数据集上训练每个模型层特定数量的时期。我们根据新的自定义数据集调整模型中所有层的参数。这可以提高模型对数据和我们想要执行的特定任务的准确性。考虑到训练大型语言模型中有数十亿个参数，计算成本很高，并且需要大量时间来训练模型。

3. 基于适配器的训练

基于适配器的训练是一个相对较新的概念，其中将额外的随机初始化层或模块添加到网络中，然后针对特定任务进行训练。在这种技术中，模型的参数不受干扰，或者我们可以说模型的参数没有改变或调整。相反，适配器层参数是经过训练的。该技术有助于以计算有效的方式调整模型。

实施：在下游任务上训练 BERT

现在我们知道了训练技术，让我们使用 BERT 对 IMDB 电影评论进行情感分析。BERT 是一种大型语言模型，结合了转换器层并且仅包含编码器。谷歌开发了它，并已证明在各种任务上表现良好。BERT 有不同的大小和变体，例如 BERT-base-uncased、BERT Large、RoBERTa、LegalBERT 等等。

1. BERT 模型进行情感分析

我们使用 BERT 模型对 IMDB 电影评论进行情感分析。如需免费使用 GPU，建议使用 Google Colab。让我们通过加载一些重要的库来开始训练。

由于 BERT（编码器的双向编码器表示）基于 Transformer，因此第一步是在我们的环境中安装 Transformers。

!pip install transformers

让我们加载一些库，这些库将帮助我们加载 BERT 模型所需的数据、对加载的数据进行分词、加载我们将用于分类的模型、执行训练 - 测试 - 分割、加载 CSV 文件以及其他一些功能。

import pandas as pd
import numpy as np
import os
from sklearn.model_selection import train_test_split
import torch
import torch.nn as nn
from transformers import BertTokenizer, BertModel, BertForSequenceClassification

为了更快的计算，我们必须将设备从 CPU 更改为 GPU。

device = torch.device("cuda")

下一步是加载数据集并查看数据集中的前 5 条记录。

df = pd.read_csv('/content/drive/MyDrive/movie.csv')
df.head()

我们将把数据集分成训练集和验证集。您还可以将数据拆分为训练集、验证集和测试集，但为了简单起见，我只是将数据集拆分为训练集和验证集。

x_train, x_val, y_train, y_val = train_test_split(df.text, df.label, random_state=42, test_size=0.2, stratify=df.label)

2. 导入并加载 BERT 模型

让我们导入并加载 BERT 模型和分词器。

# Load the BERT tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

我们将使用分词器将文本转换为最大长度为 250 的 token，并在需要时进行填充和截断。

train_tokens = tokenizer.batch_encode_plus(x_train.tolist(), max_length=250, pad_to_max_length=True, truncation=True)
val_tokens = tokenizer.batch_encode_plus(x_val.tolist(), max_length=250, pad_to_max_length=True, truncation=True)

分词器返回一个字典，其中包含三个键值对，其中包含 input_ids，它们是与特定单词相关的 token；token_type_ids，它是区分输入的不同段或部分的整数列表。Attention_mask 指示要关注哪个 token。

将这些值转换为张量。

train_ids = torch.tensor(train_tokens['input_ids'])
train_masks = torch.tensor(train_tokens['attention_mask'])
train_label = torch.tensor(y_train.tolist())
val_ids = torch.tensor(val_tokens['input_ids'])
val_masks = torch.tensor(val_tokens['attention_mask'])
val_label = torch.tensor(y_val.tolist())

加载 TensorDataset 和 DataLoaders 以进一步预处理数据并使其适合模型。

from torch.utils.data import TensorDataset, DataLoader

train_data = TensorDataset(train_ids, train_masks, train_label)
val_data = TensorDataset(val_ids, val_masks, val_label)
train_loader = DataLoader(train_data, batch_size=32, shuffle=True)
val_loader = DataLoader(val_data, batch_size=32, shuffle=True)

我们的任务是使用分类器冻结 BERT 的参数，然后在自定义数据集上训练这些层。那么，让我们冻结模型的参数。

for param in BERT.parameters():
    param.requires_grad = False

现在，我们必须为我们添加的层定义前向和后向传递。BERT 模型将充当特征提取器，而我们必须明确定义分类的前向和后向传递。

class Model(nn.Module):
    def __init__(self, bert):
        super(Model, self).__init__()
        self.bert = bert
        self.dropout = nn.Dropout(0.1)
        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(768, 512)
        self.fc2 = nn.Linear(512, 2)
        self.softmax = nn.LogSoftmax(dim=1)

    def forward(self, sent_id, mask):
        # Pass the inputs to the model
        outputs = self.bert(sent_id, mask)
        cls_hs = outputs.last_hidden_state[:, 0, :]
        x = self.fc1(cls_hs)
        x = self.relu(x)
        x = self.dropout(x)
        x = self.fc2(x)
        x = self.softmax(x)
        return x

让我们将模型移至 GPU。

model = Model(BERT)
# push the model to GPU
model = model.to(device)

3. 定义优化器

# optimizer from hugging face transformers
from transformers import AdamW
# define the optimizer
optimizer = AdamW(model.parameters(), lr=1e-5)

到目前为止，我们已经预处理了数据集并定义了我们的模型。现在是训练模型的时候了。我们必须编写代码来训练和评估模型。

训练函数

def train():
    model.train()
    total_loss, total_accuracy = 0, 0
    total_preds = []
    for step, batch in enumerate(train_loader):
        # Move batch to GPU if available
        batch = [item.to(device) for item in batch]
        sent_id, mask, labels = batch
        # Clear previously calculated gradients
        optimizer.zero_grad()
        # Get model predictions for the current batch
        preds = model(sent_id, mask)
        # Calculate the loss between predictions and labels
        loss_function = nn.CrossEntropyLoss()
        loss = loss_function(preds, labels)
        # Add to the total loss
        total_loss += loss.item()
        # Backward pass and gradient update
        loss.backward()
        optimizer.step()
        # Move predictions to CPU and convert to numpy array
        preds = preds.detach().cpu().numpy()
        # Append the model predictions
        total_preds.append(preds)
    # Compute the average loss
    avg_loss = total_loss / len(train_loader)
    # Concatenate the predictions
    total_preds = np.concatenate(total_preds, axis=0)
    # Return the average loss and predictions
    return avg_loss, total_preds

评估函数

def evaluate():
    model.eval()
    total_loss, total_accuracy = 0, 0
    total_preds = []
    for step, batch in enumerate(val_loader):
        # Move batch to GPU if available
        batch = [item.to(device) for item in batch]
        sent_id, mask, labels = batch
        # Clear previously calculated gradients
        optimizer.zero_grad()
        # Get model predictions for the current batch
        preds = model(sent_id, mask)
        # Calculate the loss between predictions and labels
        loss_function = nn.CrossEntropyLoss()
        loss = loss_function(preds, labels)
        # Add to the total loss
        total_loss += loss.item()
        # Backward pass and gradient update
        loss.backward()
        optimizer.step()
        # Move predictions to CPU and convert to numpy array
        preds = preds.detach().cpu().numpy()
        # Append the model predictions
        total_preds.append(preds)
    # Compute the average loss
    avg_loss = total_loss / len(val_loader)
    # Concatenate the predictions
    total_preds = np.concatenate(total_preds, axis=0)
    # Return the average loss and predictions
    return avg_loss, total_preds

我们现在将使用这些函数来训练模型：

# set initial loss to infinite
best_valid_loss = float('inf')
# defining epochs
epochs = 5
# empty lists to store training and validation loss of each epoch
train_losses=[]
valid_losses=[]
# for each epoch
for epoch in range(epochs):
    print('\n Epoch {:} / {:}'.format(epoch + 1, epochs))
    # train model
    train_loss, _ = train()
    # evaluate model
    valid_loss, _ = evaluate()
    # save the best model
    if valid_loss < best_valid_loss:
        best_valid_loss = valid_loss
        torch.save(model.state_dict(), 'saved_weights.pt')
    # append training and validation loss
    train_losses.append(train_loss)
    valid_losses.append(valid_loss)
    print(f'\nTraining Loss: {train_loss:.3f}')
    print(f'Validation Loss: {valid_loss:.3f}')

4. 模型推理

训练完成后，您可以使用保存的权重加载模型并对新数据进行推理。

# Load the saved weights
model.load_state_dict(torch.load('saved_weights.pt'))
model.eval()

# Example inference text
test_text = "This movie was absolutely fantastic and I loved every minute of it."
inputs = tokenizer(test_text, return_tensors="pt", truncation=True, padding=True, max_length=250)
with torch.no_grad():
    outputs = model(inputs['input_ids'].to(device), inputs['attention_mask'].to(device))
    predictions = torch.argmax(outputs.logits, dim=1).item()
    print(f"Prediction: {'Positive' if predictions == 1 else 'Negative'}")

结论

本文探讨了训练大型语言模型 (LLM) 的世界及其对自然语言处理 (NLP) 的重大影响。讨论了预训练过程，其中 LLM 使用自我监督学习对大量未标记文本进行训练。我们还深入研究了微调，其中涉及针对特定任务调整预先训练的模型，以及提示工程，即为模型提供上下文以生成相关输出。此外，我们还研究了不同的训练技术，例如特征提取、完整模型训练和基于适配器的训练。大型语言模型已经彻底改变了 NLP，并继续推动各种应用程序的进步。通过上述 BERT 情感分析的实战案例，开发者可以更直观地理解如何将预训练模型应用于具体的下游任务中。