一文讲懂大模型调优技术

from transformers import BertForSequenceClassification, BertTokenizer, Trainer, TrainingArguments  
from ray import tune  
from ray.tune.schedulers import ASHAScheduler  
from datasets import load_dataset  
  
# 加载数据集和预训练的BERT模型、tokenizer  
dataset = load_dataset('glue', 'sst2')  
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')  
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')  
  
# 定义一个函数来准备数据  
def preprocess_data(examples):  
    return tokenizer(examples['sentence'], padding=True, truncation=True)  
  
encoded_dataset = dataset.map(preprocess_data, batched=True)  
  
# 定义训练参数和超参数搜索空间  
def train_model(config):  
    training_args = TrainingArguments(  
        output_dir='./results',  
        evaluation_strategy='epoch',  
        learning_rate=config['learning_rate'],  
        per_device_train_batch_size=config['batch_size'],  
        per_device_eval_batch_size=config['batch_size'],  
        num_train_epochs=3,  
        weight_decay=0.01,  
    )  
      
    trainer = Trainer(  
        model=model,  
        args=training_args,  
        train_dataset=encoded_dataset['train'],  
        eval_dataset=encoded_dataset['validation'],  
    )  
      
    trainer.train()  
    eval_metrics = trainer.evaluate()  
    tune.report(accuracy=eval_metrics['eval_accuracy'])  
  
# 定义超参数搜索的配置  
config = {  
    'learning_rate': tune.loguniform(1e-5, 1e-3),  
    'batch_size': tune.choice([8, 16, 32]),  
}  
  
# 使用Ray Tune进行超参数搜索  
analysis = tune.run(  
    train_model,  
    resources_per_trial={'cpu': 4, 'gpu': 1},  # 假设每个试验使用4个CPU和1个GPU  
    config=config,  
    num_samples=10,  # 尝试10组不同的超参数  
    scheduler=ASHAScheduler(max_t=20),  # 使用ASHA调度器，最大试验时间为20个epoch  
)  
  
# 获取最佳超参数配置  
best_trial = analysis.get_best_trial('accuracy', 'max', 'last')  
print(f"Best hyperparameters: {best_trial.config}")

import torch  
import torch.nn as nn  
import torch.optim as optim  
from torch.utils.data import DataLoader, TensorDataset  
  
# 定义一个简单的神经网络模型  
class SimpleNN(nn.Module):  
    def __init__(self, input_size, hidden_size, output_size):  
        super(SimpleNN, self).__init__()  
        self.fc1 = nn.Linear(input_size, hidden_size)  
        self.relu = nn.ReLU()  
        self.fc2 = nn.Linear(hidden_size, output_size)  
      
    def forward(self, x):  
        x = self.fc1(x)  
        x = self.relu(x)  
        x = self.fc2(x)  
        return x  
  
# 生成一些随机数据  
input_size = 100  
hidden_size = 50  
output_size = 2  
num_samples = 1000  
  
X = torch.randn(num_samples, input_size)  
y = torch.randint(0, 2, (num_samples,))  
  
dataset = TensorDataset(X, y)  
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)  
  
# 定义训练函数  
def train_model(model, criterion, optimizer, dataloader, num_epochs=5):  
    model.train()  
    for epoch in range(num_epochs):  
        for inputs, labels in dataloader:  
            outputs = model(inputs)  
            loss = criterion(outputs, labels)  
            optimizer.zero_grad()  
            loss.backward()  
            optimizer.step()  
        print(f"Epoch {epoch+1}, Loss: {loss.item()}")  
  
# 初始化模型、损失函数和优化器  
model = SimpleNN(input_size, hidden_size, output_size)  
criterion = nn.CrossEntropyLoss()  
optimizer = optim.Adam(model.parameters(), lr=0.001)  
  
# 训练模型  
train_model(model, criterion, optimizer, dataloader)  
  
# 假设我们想要尝试不同的隐藏层大小，可以定义一个函数来进行架构搜索（这里简化为手动调整）  
def search_architecture():  
    hidden_sizes = [30, 50, 70]  
    for hidden_size in hidden_sizes:  
        model = SimpleNN(input_size, hidden_size, output_size)  
        criterion = nn.CrossEntropyLoss()  
        optimizer = optim.Adam(model.parameters(), lr=0.001)  
        print(f"Training model with hidden size {hidden_size}")  
        train_model(model, criterion, optimizer, dataloader)  
        # 这里可以添加代码来评估模型性能，并选择最佳架构  
  
# 执行架构搜索  
search_architecture()