大模型初学之finetune的一个小example

finutune指的是教会模型如何取处理输入的query和怎么去表达response。

目前读的文章还比较少，对这一块儿认知不多，借用GPT工具写了一个finutune的小例子。

以下这段代码中的微调（Fine-tuning）主要体现在以下几个方面(gpt生成，正确性未考证)： 加载预训练模型：代码中的 model 通常是在像ImageNet这样的大型数据集上预先训练过的。

修改最后的层：对于微调，我们通常会替换预训练模型的最后一层（或几层），以适应我们的特定任务（例如改变输出类的数量）。这就是模型从原始训练适应到新任务的地方。

在新数据集上训练：在 trainloader 上的循环表明模型正在新数据集上进行训练（或微调）。微调通常涉及到在更小的、特定任务的数据集上进行较短时间的训练。

冻结层（可选）：有时，在微调中，模型的早期层会被冻结，只有新添加的该项目中，只有最后一个全连接层没有被冻结。学到的特征。

低学习率（通常）：微调通常涉及到使用比初始训练时更小的学习率，以对权重的一个典型特点。

import torch
import torchvision
import torchvision.transforms as transforms

transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

trainset = torchvision.datasets.CIFAR10(root='./data',train=True,download=True,transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True)

testset = torchvision.datasets.CIFAR10(root='./data',train=False,download=True,transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False)
trainset, testset

# Load the pre-trained model
model = torchvision.models.mobilenet_v2(pretrained=True)
model.classifier

#Freeze the layers
for param in model.parameters():
    param.requires_grad = False

## Replace the final layer for the new task,修改输出为10
model.classifier[1] = torch.nn.Linear(model.classifier[1].in_features, 10)
model.classifier[1].requires_grad = True  # Unfreeze the new layer
model.classifier[1]

# Define loss function and optimizer with a smaller learning rate
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.classifier.parameters(), lr=0.0001)  # Only optimize the new layer
#optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
criterion,optimizer

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model.to(device)
device

for epoch in range(2):  # Train for a few epochs
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data[0].to(device), data[1].to(device)
        optimizer.zero_grad()
        # Forward pass
        outputs = model(inputs)
        loss = criterion(outputs, labels)

        # Backward and optimize
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 2000 == 1999:  # Print every 2000 mini-batches
            print(f'[{epoch + 1}, {i + 1}]: loss: {running_loss / 2000:.3f}')
            running_loss = 0.0
print('Finished Training')

### Evaluate the Model on Test Data
correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data[0].to(device), data[1].to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy of the network on the 10000 test images: {100 * correct / total}%')