迁移学习中DAN的代码

以下是使用PyTorch实现的DAN（Domain-Adversarial Neural Networks）的代码示例：

首先，我们需要导入相关的库和模块：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.autograd import Function
from torch.utils.data import DataLoader, Dataset
import numpy as np

接下来，我们定义一个数据集类，用于加载我们的数据：

class DAN_Dataset(Dataset):
    def __init__(self, X, y, domain):
        self.X = torch.from_numpy(X).float()
        self.y = torch.from_numpy(y).long()
        self.domain = torch.from_numpy(domain).long()
        
    def __len__(self):
        return len(self.X)
    
    def __getitem__(self, index):
        return self.X[index], self.y[index], self.domain[index]

然后，我们定义一个多层感知机（MLP）作为我们的特征提取器：

class MLP(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, output_dim)
        self.relu = nn.ReLU()
        
    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

接下来，我们定义一个域分类器（domain classifier）：

class Domain_Classifier(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(Domain_Classifier, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, output_dim)
        self.relu = nn.ReLU()
        
    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

接下来，我们定义一个DAN模型：

class DAN(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(DAN, self).__init__()
        self.feature_extractor = MLP(input_dim, hidden_dim, output_dim)
        self.domain_classifier = Domain_Classifier(output_dim, hidden_dim, 2)
        
    def forward(self, x, alpha):
        features = self.feature_extractor(x)
        reverse_features = ReverseLayerF.apply(features, alpha)
        domain_output = self.domain_classifier(reverse_features)
        return features, domain_output

最后，我们定义一个反向层（Reverse Layer）的类，用于域自适应：

class ReverseLayerF(Function):
    @staticmethod
    def forward(ctx, x, alpha):
        ctx.alpha = alpha
        return x.view_as(x)
    
    @staticmethod
    def backward(ctx, grad_output):
        output = grad_output.neg() * ctx.alpha
        return output, None

现在，我们可以使用上述定义的类和模型来训练我们的DAN模型。