（6-1-01）学习与自适应机制：迁移学习与领域适应（1）预训练模型迁移策略

在通用 AI Agent 中，迁移学习通过知识迁移提高新任务的学习效率，加速模型适应新场景。在线学习实时更新模型，使其动态适应环境变化，增强系统的实时性和灵活性。自适应机制让智能体根据反馈自动调整策略和参数，提升性能和鲁棒性，确保在复杂多变环境中有效运行。

6.1  迁移学习与领域适应

在通用 AI Agent 中，迁移学习通过将一个任务中学到的知识应用到另一个相关任务中，显著减少新任务的学习成本，提高学习效率和模型的泛化能力。领域适应则专注于解决源领域和目标领域数据分布不匹配的问题，通过学习领域间的对抗性特征表示，使模型能够更好地适应新的领域和任务。

6.1.1  预训练模型迁移策略

在通用 AI Agent 中，预训练模型的迁移策略是一种高效的方法，用于将一个任务中学到的知识应用到另一个相关任务中，从而减少新任务的学习成本并提高模型的泛化能力。迁移学习可以通过微调预训练模型或将其作为特征提取器来实现，具体选择哪种方式取决于目标任务的数据量和复杂性。 

1. 迁移学习的背景与意义

预训练模型在大规模数据集上学习通用特征表示，这些特征在许多任务中都具有通用性。通过迁移学习，我们可以在新任务上利用这些预训练模型，只需少量数据进行微调，从而节省计算资源并提高模型性能。

2. 特征迁移（Feature Transfer）

将源领域预训练模型的底层特征提取能力迁移到目标领域，通过调整顶层任务相关层实现适配。特征迁移的实现方式如下：

（1）特征提取（Feature Extraction）

1. 方法：冻结预训练模型的底层权重（如CNN的卷积层或Transformer的前几层），仅训练新增的顶层分类器（如全连接层）。
2. 适用场景：目标领域数据量较小，但与源领域数据分布相似（如从ImageNet迁移到医疗影像分类）。

（2）特征对齐（Feature Alignment）

1. 方法：通过域适应（Domain Adaptation）技术（如最大均值差异-MMD）减少源领域和目标领域特征分布的差异。
2. 案例：在跨语言NLP任务中，通过调整词向量空间对齐不同语言的语义特征。

3. 模型迁移（Model Transfer）

直接使用预训练模型的参数作为初始权重，并在目标领域数据上进行微调（Fine-tuning）。模型迁移的实现方式如下：

（1）全模型微调（Full Fine-tuning）

1. 方法：解冻所有层，使用目标领域数据重新训练整个模型。
2. 优点：能最大化利用目标领域数据，但计算成本高，需大量数据。
3. 案例：在GPT-3基础上微调，适配特定领域的对话Agent（如金融客服）。

（2）部分微调（Partial Fine-tuning）

1. 方法：仅微调模型顶层或特定模块（如Transformer的最后几层），底层保持冻结。
2. 适用场景：计算资源有限或目标领域数据量中等。

4. 知识迁移（Knowledge Transfer）

通过知识蒸馏（Knowledge Distillation）将复杂模型（教师模型）的知识迁移到轻量级模型（学生模型）。知识迁移的实现方式如下：

（1）软标签蒸馏（Soft Label Distillation）

1. 方法：使用教师模型（如BERT）在源领域生成软标签（概率分布），学生模型（如TinyBERT）同时学习源领域数据的软标签和目标领域数据的硬标签。
2. 优势：减少计算开销，提升推理速度。

（2）特征蒸馏（Feature Distillation）：

1. 方法：强制学生模型的中间层特征与教师模型对齐，增强特征表达能力。
2. 案例：在视觉Agent中，将ResNet-152的特征迁移到MobileNetV3。

例如下面的实例实现流一个通用 AI Agent 应用程序，演示了通过预训练模型迁移策略（以图像分类任务为例）实现模型适配的过程。

实例6-1：通过预训练模型迁移策略实现模型适配（源码路径：codes\6\Qian.py）

首先使用 Kaggle的宠物图像数据集（需自行下载并解压到 data/pets 目录，结构如下）：

data/
├── pets/
│   ├── train/
│   │   ├── cats/
│   │   └── dogs/
│   └── test/
│       ├── cats/
│       └── dogs/

然后编写实例文件Qian.py，具体实现代码如下所示。

import os
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import models, transforms
from torch.utils.data import DataLoader, Dataset
import matplotlib.pyplot as plt
import numpy as np
from PIL import Image
import pandas as pd

# 1. 定义数据集类
class PetDataset(Dataset):
    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir
        self.transform = transform
        self.classes = ['cats', 'dogs']
        self.class_to_idx = {cls: idx for idx, cls in enumerate(self.classes)}
        self.images = []
        for cls in self.classes:
            cls_dir = os.path.join(root_dir, cls)
            for img_name in os.listdir(cls_dir):
                self.images.append((os.path.join(cls_dir, img_name), self.class_to_idx[cls]))

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

    def __getitem__(self, idx):
        img_path, label = self.images[idx]
        image = Image.open(img_path).convert("RGB")
        if self.transform:
            image = self.transform(image)
        return image, label

# 2. 定义迁移学习策略
class TransferAgent:
    def __init__(self, model_name="resnet18", num_classes=2):
        # 加载预训练模型（如ResNet-18）
        self.model = getattr(models, model_name)(pretrained=True)
        
        # 特征提取策略：冻结所有层
        for param in self.model.parameters():
            param.requires_grad = False
        
        # 替换最后的全连接层（适配目标任务）
        num_features = self.model.fc.in_features
        self.model.fc = nn.Linear(num_features, num_classes)
        
        # 微调策略：解冻最后几层（可选）
        # for name, param in self.model.named_parameters():
        #     if "layer4" in name or "fc" in name:
        #         param.requires_grad = True
        
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.model.to(self.device)
        self.criterion = nn.CrossEntropyLoss()
        self.optimizer = optim.Adam(self.model.fc.parameters(), lr=0.001)

    def train(self, train_loader, epochs=10):
        self.model.train()
        history = {"loss": [], "accuracy": []}
        for epoch in range(epochs):
            running_loss = 0.0
            correct = 0
            total = 0
            for images, labels in train_loader:
                images, labels = images.to(self.device), labels.to(self.device)
                self.optimizer.zero_grad()
                outputs = self.model(images)
                loss = self.criterion(outputs, labels)
                loss.backward()
                self.optimizer.step()
                
                running_loss += loss.item()
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()
            
            epoch_loss = running_loss / len(train_loader)
            epoch_acc = 100 * correct / total
            history["loss"].append(epoch_loss)
            history["accuracy"].append(epoch_acc)
            print(f"Epoch {epoch+1}/{epochs}: Loss={epoch_loss:.4f}, Accuracy={epoch_acc:.2f}%")
        
        return history

    def evaluate(self, test_loader):
        self.model.eval()
        correct = 0
        total = 0
        with torch.no_grad():
            for images, labels in test_loader:
                images, labels = images.to(self.device), labels.to(self.device)
                outputs = self.model(images)
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()
        accuracy = 100 * correct / total
        print(f"Test Accuracy: {accuracy:.2f}%")
        return accuracy

    def save_model(self, path="model.pth"):
        torch.save(self.model.state_dict(), path)
        print(f"Model saved to {path}")

    def load_model(self, path="model.pth"):
        self.model.load_state_dict(torch.load(path))
        print(f"Model loaded from {path}")

# 3. 数据预处理与加载
def get_data_loaders(root_dir, batch_size=32):
    transform = transforms.Compose([
        transforms.Resize((224, 224)),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
    ])
    
    train_dataset = PetDataset(os.path.join(root_dir, "train"), transform=transform)
    test_dataset = PetDataset(os.path.join(root_dir, "test"), transform=transform)
    
    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
    return train_loader, test_loader

# 4. 主程序
if __name__ == "__main__":
    # 配置参数
    data_dir = "data/pets"
    epochs = 10
    batch_size = 32
    
    # 加载数据
    train_loader, test_loader = get_data_loaders(data_dir, batch_size)
    
    # 初始化Agent并迁移模型
    agent = TransferAgent(model_name="resnet18", num_classes=2)
    
    # 训练并保存模型
    history = agent.train(train_loader, epochs)
    agent.save_model()
    
    # 评估模型
    test_acc = agent.evaluate(test_loader)
    
    # 可视化训练过程
    plt.figure(figsize=(12, 4))
    plt.subplot(1, 2, 1)
    plt.plot(history["loss"], label="Training Loss")
    plt.xlabel("Epoch"), plt.ylabel("Loss"), plt.legend()
    
    plt.subplot(1, 2, 2)
    plt.plot(history["accuracy"], label="Training Accuracy")
    plt.xlabel("Epoch"), plt.ylabel("Accuracy (%)"), plt.legend()
    plt.show()

对上述代码的具体说明如下所示：

（1）数据集类 PetDataset：实现数据集的加载和预处理，能够处理分类任务中的图像数据。

（2）迁移学习策略类 TransferAgent：实现了迁移学习的核心流程，包括模型加载、参数冻结、全连接层替换、训练和评估等。

（3）数据预处理与加载函数 get_data_loaders：实现了数据的预处理和数据加载器的创建，使用了常见的图像变换操作。

（4）主程序：设置训练流程，包括数据加载、模型初始化、训练、保存和评估等步骤。执行后会输出训练过程：

Epoch 1/10: Loss=1.1324, Accuracy=58.33%
...
Epoch 10/10: Loss=0.0456, Accuracy=98.21%
Test Accuracy: 97.45%

总之，预训练模型的迁移策略在通用 AI Agent 中具有重要意义，通过微调或特征提取的方法，可以有效地将知识从一个任务迁移到另一个任务，提高模型的适应性和性能。在实际应用中，选择合适的迁移学习策略需要考虑目标任务的特点和可用资源。