引言：理解领域自适应与ADDA的核心价值

领域自适应（Domain Adaptation）是迁移学习中的重要分支，它解决了源域（source domain）和目标域（target domain）数据分布不一致的问题。在实际应用中，我们经常面临这样的困境：有大量标注的源域数据（如合成图像），但只有少量或没有标注的目标域数据（如真实场景图像）。ADDA（Adversarial Discriminative Domain Adaptation）正是为解决这一问题而提出的经典方法。

ADDA的核心思想是通过对抗训练的方式，学习一个领域不变的特征表示空间。与传统的领域自适应方法不同，ADDA采用生成对抗网络（GAN）的训练范式，通过一个判别器来区分特征来自源域还是目标域，同时训练特征提取器来”欺骗”判别器，最终使得两个域的特征分布对齐。

1. ADDA模型架构深度解析

1.1 整体架构设计

ADDA包含三个核心组件：

  • 源域特征提取器（Source Feature Extractor, M_s）：在源域数据上预训练好的特征提取器
  • 目标域特征提取器（Target Feature Extractor, M_t）：与M_s结构相同，但参数独立
  • 领域判别器（Domain Discriminator, D）：用于区分特征来自源域还是目标域
import torch
import torch.nn as nn

# 定义基础特征提取器（以LeNet为例）
class FeatureExtractor(nn.Module):
    def __init__(self):
        super(FeatureExtractor, self).__init__()
        self.conv1 = nn.Conv2d(1, 20, kernel_size=5)
        self.conv2 = nn.Conv2d(20, 50, kernel_size=5)
        self.fc1 = nn.Linear(50*4*4, 500)
        self.fc2 = nn.Linear(500, 10)  # 10维特征表示
        
    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.max_pool2d(x, 2)
        x = torch.relu(self.conv2(x))
        x = torch.max_pool2d(x, 2)
        x = x.view(x.size(0), -1)
        x = torch.relu(self.fc1(x))
        feature = self.fc2(x)  # 提取的特征
        return feature

# 定义领域判别器
class DomainDiscriminator(nn.Module):
    def __init__(self, input_dim=10, hidden_dim=100):
        super(DomainDiscriminator, self).__init__()
        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.layer2 = nn.Linear(hidden_dim, 1)
        self.dropout = nn.Dropout(0.5)
        
    def forward(self, x):
        x = torch.relu(self.layer1(x))
        x = self.dropout(x)
        x = torch.sigmoid(self.layer2(x))
        return x

1.2 架构设计的关键细节

特征提取器设计原则：

  • 源域和目标域使用相同结构的特征提取器，但参数完全独立
  • 源域特征提取器在源域数据上预训练完成，初始权重固定
  • 目标域特征提取器初始权重可选择复制源域或随机初始化

领域判别器设计要点：

  • 输入维度与特征提取器输出维度一致
  • 输出为0-1之间的概率值，0表示目标域，1表示源域
  • 通常使用LeakyReLU或ReLU作为激活函数
  • 最后一层使用Sigmoid激活函数

2. 训练策略与损失函数详解

2.1 三阶段训练流程

ADDA采用分阶段训练策略，这是其区别于其他对抗域自适应方法的重要特征：

阶段1：源域监督预训练

def pretrain_source_model(source_loader, source_model, classifier, optimizer, epochs=10):
    """
    在源域数据上预训练特征提取器和分类器
    """
    source_model.train()
    classifier.train()
    
    for epoch in range(epochs):
        for batch_idx, (data, target) in enumerate(source_loader):
            data, target = data.cuda(), target.cuda()
            
            # 前向传播
            features = source_model(data)
            output = classifier(features)
            
            # 计算分类损失
            loss = nn.CrossEntropyLoss()(output, target)
            
            # 反向传播
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            
            if batch_idx % 100 == 0:
                print(f"Epoch [{epoch}/{epochs}], Batch [{batch_idx}], Loss: {loss.item():.4f}")
    
    return source_model, classifier

# 使用示例
source_model = FeatureExtractor().cuda()
classifier = nn.Linear(10, 10).cuda()  # 假设10分类任务
optimizer = torch.optim.Adam(
    list(source_model.parameters()) + list(classifier.parameters()),
    lr=0.001
)

# 预训练源域模型
# source_model, classifier = pretrain_source_model(source_loader, source_model, classifier, optimizer)

关键要点：

  • 源域特征提取器和分类器在源域数据上进行充分训练
  • 训练目标是最小化分类损失，使模型在源域上达到较高精度
  • 预训练完成后，源域特征提取器参数固定，不再更新

阶段2：领域对抗训练

def adversarial_training(source_loader, target_loader, source_model, target_model, 
                        discriminator, optimizer_t, optimizer_d, epochs=20):
    """
    对抗训练阶段：同时训练目标域特征提取器和领域判别器
    """
    source_model.eval()  # 源域模型固定
    target_model.train()
    discriminator.train()
    
    # 标签定义：源域为1，目标域为0
    source_label = torch.ones(target_loader.batch_size, 1).cuda()
    target_label = torch.zeros(target_loader.batch_size, 1).cuda()
    
    for epoch in range(epochs):
        # 保证两个数据加载器长度一致
        source_iter = iter(source_loader)
        target_iter = iter(target_loader)
        
        for batch_idx in range(min(len(source_loader), len(target_loader))):
            # 读取数据
            try:
                source_data, _ = next(source_iter)
                target_data, _ = next(target_iter)
            except StopIteration:
                break
                
            source_data, target_data = source_data.cuda(), target_data.cuda()
            
            # ===== 训练领域判别器 =====
            # 提取特征
            with torch.no_grad():
                source_features = source_model(source_data)
            target_features = target_model(target_data)
            
            # 判别器预测
            source_pred = discriminator(source_features)
            target_pred = discriminator(target_features)
            
            # 计算判别器损失
            loss_d_source = nn.BCELoss()(source_pred, source_label)
            loss_d_target = nn.BCELoss()(target_pred, target_label)
            loss_d = loss_d_source + loss_d_target
            
            # 更新判别器
            optimizer_d.zero_grad()
            loss_d.backward()
            optimizer_d.step()
            
            # ===== 训练目标域特征提取器 =====
            # 重新提取目标域特征（需要梯度）
            target_features = target_model(target_data)
            target_pred = discriminator(target_features)
            
            # 目标域特征提取器希望"欺骗"判别器，使其预测为源域
            loss_g = nn.BCELoss()(target_pred, source_label)
            
            # 更新目标域特征提取器
            optimizer_t.zero_grad()
            loss_g.backward()
            optimizer_t.step()
            
            if batch_idx % 50 == 0:
                print(f"Epoch [{epoch}/{epochs}], Batch [{batch_idx}], "
                      f"D_Loss: {loss_d.item():.4f}, G_Loss: {loss_g.item():.4f}")
    
    return target_model, discriminator

阶段3：目标域评估

def evaluate_target_model(target_model, classifier, target_test_loader):
    """
    使用目标域测试集评估模型性能
    """
    target_model.eval()
    classifier.eval()
    correct = 0
    total = 0
    
    with torch.no_grad():
        for data, target in target_test_loader:
            data, target = data.cuda(), target.cuda()
            features = target_model(data)
            output = classifier(features)
            pred = output.argmax(dim=1)
            correct += (pred == target).sum().item()
            total += target.size(0)
    
    accuracy = 100.0 * correct / total
    print(f"Target Domain Accuracy: {accuracy:.2f}%")
    return accuracy

2.2 损失函数数学原理

判别器损失： $\(L_D = -\mathbb{E}_{x_s \sim p_{data}(x_s)}[\log D(M_s(x_s))] - \mathbb{E}_{x_t \sim p_{data}(x_t)}[\log(1 - D(M_t(x_t)))]\)$

生成器（目标域特征提取器）损失： $\(L_G = -\math2{E}_{x_t \sim p_{data}(x_t)}[\log D(M_t(x_t))]\)$

在实际代码中，我们使用二元交叉熵损失：

  • 判别器试图正确分类源域（标签1）和目标域（标签0）
  • 目标域特征提取器试图使判别器将目标域特征误判为源域（标签1）

3. 完整实战代码实现

3.1 数据准备与加载

from torch.utils.data import DataLoader, TensorDataset
import numpy as np

# 模拟源域和目标域数据（实际应用中应使用真实数据）
def prepare_mnist_m_data():
    """
    模拟MNIST（源域）和MNIST-M（目标域）数据
    MNIST: 灰度手写数字
    MNIST-M: 彩色手写数字（通过将MNIST与随机背景混合生成）
    """
    # 生成源域数据（MNIST风格）
    source_data = torch.randn(1000, 1, 28, 28)  # 1000个样本
    source_labels = torch.randint(0, 10, (1000,))
    
    # 生成目标域数据（MNIST-M风格，分布不同）
    target_data = torch.randn(1000, 1, 28, 28) * 1.5 + 0.5  # 不同的分布
    target_labels = torch.randint(0, 10, (1000,))  # 实际应用中可能无标签
    
    # 创建数据集
    source_dataset = TensorDataset(source_data, source_labels)
    target_dataset = TensorDataset(target_data, target_labels)
    
    # 创建数据加载器
    source_loader = DataLoader(source_dataset, batch_size=64, shuffle=True)
    target_loader = DataLoader(target_dataset, batch_size=64, shuffle=True)
    
    return source_loader, target_loader

# 实际应用中，可以使用torchvision.datasets.MNIST和自定义MNIST-M
# from torchvision.datasets import MNIST
# from torchvision import transforms

3.2 完整训练流程整合

class ADDATrainer:
    def __init__(self, source_loader, target_loader, lr=0.0002, betas=(0.5, 0.999)):
        self.source_loader = source_loader
        self.target_loader = target_loader
        
        # 初始化模型
        self.source_model = FeatureExtractor().cuda()
        self.target_model = FeatureExtractor().cuda()
        self.discriminator = DomainDiscriminator().cuda()
        self.classifier = nn.Linear(10, 10).cuda()
        
        # 优化器
        self.optimizer_source = torch.optim.Adam(
            list(self.source_model.parameters()) + list(self.classifier.parameters()),
            lr=lr, betas=betas
        )
        self.optimizer_target = torch.optim.Adam(
            self.target_model.parameters(),
            lr=lr, betas=betas
        )
        self.optimizer_discriminator = torch.optim.Adam(
            self.discriminator.parameters(),
            lr=lr, betas=betas
        )
        
        # 记录训练历史
        self.history = {
            'source_acc': [],
            'target_acc': [],
            'd_loss': [],
            'g_loss': []
        }
    
    def train(self, pretrain_epochs=10, adversarial_epochs=20):
        """完整训练流程"""
        
        # 阶段1：预训练源域模型
        print("=== 阶段1: 源域预训练 ===")
        for epoch in range(pretrain_epochs):
            self.source_model.train()
            self.classifier.train()
            
            for batch_idx, (data, target) in enumerate(self.source_loader):
                data, target = data.cuda(), target.cuda()
                
                features = self.source_model(data)
                output = self.classifier(features)
                loss = nn.CrossEntropyLoss()(output, target)
                
                self.optimizer_source.zero_grad()
                loss.backward()
                self.optimizer_source.step()
                
                if batch_idx % 100 == 0:
                    print(f"Pretrain Epoch [{epoch}/{pretrain_epochs}], "
                          f"Batch [{batch_idx}], Loss: {loss.item():.4f}")
        
        # 固定源域模型参数
        for param in self.source_model.parameters():
            param.requires_grad = False
        for param in self.classifier.parameters():
            param.requires_grad = False
        
        # 阶段2：对抗训练
        print("\n=== 阶段2: 对抗训练 ===")
        source_label = torch.ones(self.source_loader.batch_size, 1).cuda()
        target_label = torch.zeros(self.target_loader.batch_size, 1).cuda()
        
        for epoch in range(adversarial_epochs):
            self.target_model.train()
            self.discriminator.train()
            
            source_iter = iter(self.source_loader)
            target_iter = iter(self.target_loader)
            
            for batch_idx in range(min(len(self.source_loader), len(self.target_loader))):
                # 获取数据
                try:
                    source_data, _ = next(source_iter)
                    target_data, _ = next(target_iter)
                except StopIteration:
                    break
                
                source_data, target_data = source_data.cuda(), target_data.cuda()
                
                # 训练判别器
                with torch.no_grad():
                    source_features = self.source_model(source_data)
                target_features = self.target_model(target_data)
                
                source_pred = self.discriminator(source_features)
                target_pred = self.discriminator(target_features)
                
                loss_d_source = nn.BCELoss()(source_pred, source_label[:source_data.size(0)])
                loss_d_target = nn.BCELoss()(target_pred, target_label[:target_data.size(0)])
                loss_d = loss_d_source + loss_d_target
                
                self.optimizer_discriminator.zero_grad()
                loss_d.backward()
                self.optimizer_discriminator.step()
                
                # 训练目标域特征提取器
                target_features = self.target_model(target_data)
                target_pred = self.discriminator(target_features)
                loss_g = nn.BCELoss()(target_pred, source_label[:target_data.size(0)])
                
                self.optimizer_target.zero_grad()
                loss_g.backward()
                self.optimizer_target.step()
                
                # 记录损失
                self.history['d_loss'].append(loss_d.item())
                self.history['g_loss'].append(loss_g.item())
                
                if batch_idx % 50 == 0:
                    print(f"Adv Epoch [{epoch}/{adversarial_epochs}], "
                          f"Batch [{batch_idx}], D_Loss: {loss_d.item():.4f}, "
                          f"G_Loss: {loss_g.item():.4f}")
        
        return self.target_model, self.classifier

# 使用示例
# source_loader, target_loader = prepare_mnist_m_data()
# trainer = ADDATrainer(source_loader, target_loader)
# target_model, classifier = trainer.train(pretrain_epochs=5, adversarial_epochs=10)

4. 关键技术细节与调参技巧

4.1 学习率策略

# 使用不同的学习率
def create_optimizers(source_model, target_model, discriminator, lr_source=0.001, lr_adapt=0.0001):
    """
    为不同组件设置不同的学习率
    """
    # 源域模型预训练时使用较大的学习率
    optimizer_source = torch.optim.Adam(
        source_model.parameters(),
        lr=lr_source,
        betas=(0.9, 0.999)
    )
    
    # 对抗训练时，目标域模型和判别器使用较小的学习率
    optimizer_target = torch.optim.Adam(
        target_model.parameters(),
        lr=lr_adapt,
        betas=(0.5, 0.999)  # GAN训练常用设置
    )
    
    optimizer_discriminator = torch.optim.Adam(
        discriminator.parameters(),
        lr=lr_adapt,
        betas=(0.5, 0.999)
    )
    
    return optimizer_source, optimizer_target, optimizer_discriminator

# 学习率调度器
def create_lr_scheduler(optimizer, step_size=10, gamma=0.1):
    """
    学习率衰减调度器
    """
    return torch.optim.lr_scheduler.StepLR(optimizer, step_size=step_size, gamma=gamma)

4.2 梯度反转层（Gradient Reversal Layer）

虽然ADDA原论文未使用，但许多实现中会加入梯度反转层来简化训练：

class GradientReversalLayer(torch.autograd.Function):
    """
    梯度反转层：前向传播正常，反向传播时梯度乘以负常数
    """
    @staticmethod
    def forward(ctx, x, lambda_):
        ctx.lambda_ = lambda_
        return x.clone()
    
    @staticmethod
    def backward(ctx, grad_output):
        # 反向传播时梯度乘以 -lambda_
        return -ctx.lambda_ * grad_output, None

class GradientReversalModule(nn.Module):
    def __init__(self, lambda_=0.1):
        super(GradientReversalModule, self).__init__()
        self.lambda_ = lambda_
    
    def forward(self, x):
        return GradientReversalLayer.apply(x, self.lambda_)

4.3 特征可视化与监控

import matplotlib.pyplot as plt
from sklearn.manifold import TSNE

def visualize_features(source_model, target_model, source_loader, target_loader, epoch):
    """
    使用t-SNE可视化特征分布
    """
    source_model.eval()
    target_model.eval()
    
    # 收集特征
    source_features = []
    source_labels = []
    target_features = []
    target_labels = []
    
    with torch.no_grad():
        # 源域特征
        for data, labels in source_loader:
            data = data.cuda()
            feat = source_model(data)
            source_features.append(feat.cpu().numpy())
            source_labels.append(labels.numpy())
            if len(source_features) > 10:  # 限制样本数
                break
        
        # 目标域特征
        for data, labels in target_loader:
            data = data.cuda()
            feat = target_model(data)
            target_features.append(feat.cpu().numpy())
            target_labels.append(labels.numpy())
            if len(target_features) > 10:
                break
    
    # 合并数据
    all_features = np.vstack(source_features + target_features)
    all_labels = np.hstack(source_labels + target_labels)
    domain_labels = np.hstack([
        np.ones(sum(len(f) for f in source_features)),  # 源域标签1
        np.zeros(sum(len(f) for f in target_features))  # 目标域标签0
    ])
    
    # t-SNE降维
    tsne = TSNE(n_components=2, random_state=42)
    features_2d = tsne.fit_transform(all_features)
    
    # 绘图
    plt.figure(figsize=(12, 5))
    
    # 左图：按领域着色
    plt.subplot(1, 2, 1)
    scatter = plt.scatter(features_2d[:, 0], features_2d[:, 1], 
                         c=domain_labels, cmap='coolwarm', alpha=0.6)
    plt.colorbar(scatter, ticks=[0, 1])
    plt.title(f'Feature Distribution (Epoch {epoch})\nRed: Source, Blue: Target')
    plt.xlabel('t-SNE 1')
    plt.ylabel('t-SNE 2')
    
    # 右图：按类别着色
    plt.subplot(1, 2, 2)
    scatter = plt.scatter(features_2d[:, 0], features_2d[:, 1], 
                         c=all_labels, cmap='tab10', alpha=0.6)
    plt.colorbar(scatter)
    plt.title(f'Feature Distribution by Class (Epoch {epoch})')
    plt.xlabel('t-SNE 1')
    plt.ylabel('t-SNE 2')
    
    plt.tight_layout()
    plt.savefig(f'feature_viz_epoch_{epoch}.png')
    plt.close()

# 在训练过程中定期调用
# if epoch % 5 == 0:
#     visualize_features(source_model, target_model, source_loader, target_loader, epoch)

5. 实战应用案例：MNIST到MNIST-M的迁移

5.1 完整项目结构

adda_project/
├── data/
│   ├── __init__.py
│   ├── mnist.py          # 数据加载和预处理
│   └── mnist_m.py        # MNIST-M数据集生成
├── models/
│   ├── __init__.py
│   ├── feature_extractor.py
│   └── discriminator.py
├── utils/
│   ├── __init__.py
│   ├── logger.py         # 训练日志
│   └── visualizer.py     # 可视化工具
├── config.py             # 配置参数
├── train.py              # 训练脚本
└── eval.py               # 评估脚本

5.2 配置文件示例

# config.py
class Config:
    # 数据参数
    batch_size = 64
    num_workers = 4
    
    # 模型参数
    feature_dim = 512  # 特征维度
    num_classes = 10   # 分类类别
    
    # 训练参数
    pretrain_epochs = 20
    adapt_epochs = 50
    lr_source = 0.001
    lr_adapt = 0.0001
    
    # 路径
    source_data_path = './data/mnist'
    target_data_path = './data/mnist_m'
    save_dir = './checkpoints'
    
    # 设备
    device = 'cuda' if torch.cuda.is_available() else 'cpu'

5.3 实际训练命令

# 1. 预训练源域模型
python train.py --phase pretrain --epochs 20 --lr 0.001

# 2. 对抗训练
python train.py --phase adapt --epochs 50 --lr 0.0001

# 3. 评估
python eval.py --model_path ./checkpoints/target_model_best.pth

6. 常见问题与解决方案

6.1 训练不稳定

问题：判别器过强或过弱导致训练震荡。

解决方案：

# 1. 调整判别器学习率（通常比生成器小）
optimizer_d = torch.optim.Adam(discriminator.parameters(), lr=0.0001)
optimizer_t = torch.optim.Adam(target_model.parameters(), lr=0.0002)

# 2. 使用梯度裁剪
for p in discriminator.parameters():
    p.data.clamp_(-0.01, 0.01)

# 3. 调整损失权重
loss_total = loss_classification + lambda_adapt * loss_adversarial

6.2 特征坍塌

问题：目标域特征全部映射到同一个点。

解决方案：

  • 增加特征维度
  • 添加批次归一化（BatchNorm）
  • 使用更复杂的判别器结构
  • 调整对抗损失权重

6.3 模式崩溃

问题：目标域特征只覆盖源域特征空间的一部分。

解决方案：

# 使用多个判别器
class MultiDiscriminator(nn.Module):
    def __init__(self, input_dim, num_discriminators=3):
        super().__init__()
        self.discriminators = nn.ModuleList([
            DomainDiscriminator(input_dim) for _ in range(num_discriminators)
        ])
    
    def forward(self, x):
        # 返回所有判别器的平均预测
        preds = [d(x) for d in self.discriminators]
        return torch.mean(torch.stack(preds), dim=0)

7. 性能优化与工程实践

7.1 混合精度训练

from torch.cuda.amp import autocast, GradScaler

def train_mixed_precision():
    scaler = GradScaler()
    
    for data, target in dataloader:
        with autocast():
            features = model(data)
            loss = criterion(features, target)
        
        scaler.scale(loss).backward()
        scaler.step(optimizer)
        scaler.update()

7.2 分布式训练

import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP

def setup_distributed(rank, world_size):
    os.environ['MASTER_ADDR'] = 'localhost'
    os.environ['MASTER_PORT'] = '12355'
    dist.init_process_group("nccl", rank=rank, world_size=world_size)

def train_distributed():
    # 包装模型
    target_model = DDP(target_model, device_ids=[rank])
    discriminator = DDP(discriminator, device_ids=[rank])

7.3 模型保存与恢复

def save_checkpoint(state, filename='checkpoint.pth.tar'):
    torch.save(state, filename)
    print(f"Checkpoint saved to {filename}")

def load_checkpoint(filepath, model, optimizer=None):
    checkpoint = torch.load(filepath)
    model.load_state_dict(checkpoint['state_dict'])
    if optimizer and 'optimizer' in checkpoint:
        optimizer.load_state_dict(checkpoint['optimizer'])
    return checkpoint['epoch']

# 保存最佳模型
best_acc = 0
if target_acc > best_acc:
    best_acc = target_acc
    save_checkpoint({
        'epoch': epoch,
        'state_dict': target_model.state_dict(),
        'optimizer': optimizer_target.state_dict(),
        'accuracy': target_acc
    }, 'target_model_best.pth')

8. 扩展与变体

8.1 ADDA与其他方法的对比

方法 训练方式 是否需要源域模型 优势 劣势
DANN 端到端 否 训练简单 可能次优
ADDA 分阶段 是 收敛快，性能好 需要预训练
CDAN 条件对抗 否 考虑类别信息 实现复杂

8.2 扩展到半监督场景

# 结合伪标签
def generate_pseudo_labels(target_model, target_data, threshold=0.9):
    """
    为目标域数据生成伪标签
    """
    target_model.eval()
    with torch.no_grad():
        logits = target_model(target_data)
        probs = torch.softmax(logits, dim=1)
        max_probs, pseudo_labels = torch.max(probs, dim=1)
        
        # 只保留高置信度的伪标签
        mask = max_probs > threshold
        return pseudo_labels[mask], mask

# 在对抗训练中加入伪标签损失
def semi_supervised_loss(target_model, discriminator, target_data, target_labels=None):
    # 对抗损失
    target_features = target_model(target_data)
    target_pred = discriminator(target_features)
    loss_adv = nn.BCELoss()(target_pred, torch.ones_like(target_pred))
    
    # 伪标签分类损失（如果有）
    loss_cls = 0
    if target_labels is not None:
        loss_cls = nn.CrossEntropyLoss()(target_model(target_data), target_labels)
    
    return loss_adv + 0.1 * loss_cls

9. 总结与最佳实践

9.1 关键要点回顾

  1. 分阶段训练：ADDA的核心优势在于先预训练源域模型，再进行对抗适应
  2. 独立参数：源域和目标域特征提取器参数独立，避免负迁移
  3. 对抗平衡：判别器和生成器的学习率需要仔细调整
  4. 监控指标：定期可视化特征分布，监控训练稳定性

9.2 推荐配置

# 经过验证的最佳配置
OPTIMAL_CONFIG = {
    'pretrain': {
        'epochs': 20,
        'lr': 0.001,
        'batch_size': 64,
        'optimizer': 'Adam'
    },
    'adapt': {
        'epochs': 50,
        'lr_source': 0.0001,  # 源域模型固定，不更新
        'lr_target': 0.0002,
        'lr_discriminator': 0.0001,
        'batch_size': 64,
        'optimizer': 'Adam',
        'betas': (0.5, 0.999)
    }
}

9.3 实际应用建议

  1. 数据准备：确保源域和目标域数据预处理一致
  2. 模型选择：根据任务复杂度选择合适的特征提取器（ResNet、VGG等）
  3. 评估协议：使用多次随机种子运行，报告平均性能
  4. 错误分析：分析哪些类别迁移效果差，针对性改进

通过本文的深度解读，你应该已经掌握了ADDA的核心原理、代码实现细节以及实战技巧。ADDA虽然结构相对简单，但在领域自适应任务中表现出色，是理解对抗式迁移学习的绝佳起点。在实际应用中，建议从简单的任务开始，逐步调整参数，积累经验后再应用到复杂场景中。