如何独立训练两个网络（分别在mnist和cifar上训练），最后进行特征融合，给出pytorch代码

你可以通过以下步骤独立训练两个网络（一个在MNIST上，一个在CIFAR上），最后进行特征融合：

1. 加载数据集

import torch
import torchvision
import torchvision.transforms as transforms

# MNIST dataset
train_dataset_mnist = torchvision.datasets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)

# CIFAR-10 dataset
train_dataset_cifar = torchvision.datasets.CIFAR10(root='./data', train=True, transform=transforms.ToTensor(), download=True)

# Data loaders
train_loader_mnist = torch.utils.data.DataLoader(dataset=train_dataset_mnist, batch_size=128, shuffle=True)
train_loader_cifar = torch.utils.data.DataLoader(dataset=train_dataset_cifar, batch_size=128, shuffle=True)

2. 定义模型

import torch.nn as nn
import torch.nn.functional as F

# MNIST model
class NetMNIST(nn.Module):
    def __init__(self):
        super(NetMNIST, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 5)
        self.conv2 = nn.Conv2d(32, 64, 5)
        self.fc1 = nn.Linear(4*4*64, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x, 2)
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x, 2)
        x = x.view(-1, 4*4*64)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# CIFAR model
class NetCIFAR(nn.Module):
    def __init__(self):
        super(NetCIFAR, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.conv3 = nn.Conv2d(64, 128, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(128 * 4 * 4, 512)
        self.fc2 = nn.Linear(512, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool(F.relu(self.conv2(x)))
        x = self.pool(F.relu(self.conv3(x)))
        x = x.view(-1, 128 * 4 * 4)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

3. 训练模型

import torch.optim as optim

# MNIST model training
net_mnist = NetMNIST()
criterion_mnist = nn.CrossEntropyLoss()
optimizer_mnist = optim.Adam(net_mnist.parameters(), lr=0.001)

for epoch in range(10):
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(train_loader_mnist, 0):
        optimizer_mnist.zero_grad()
        outputs = net_mnist(inputs)
        loss = criterion_mnist(outputs, labels)
        loss.backward()
        optimizer_mnist.step()

        running_loss += loss.item()
        if i % 100 == 99:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

print('MNIST model training finished')

# CIFAR model training
net_cifar = NetCIFAR()
criterion_cifar = nn.CrossEntropyLoss()
optimizer_cifar = optim.Adam(net_cifar.parameters(), lr=0.001)

for epoch in range(10):
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(train_loader_cifar, 0):
        optimizer_cifar.zero_grad()
        outputs = net_cifar(inputs)
        loss = criterion_cifar(outputs, labels)
        loss.backward()
        optimizer_cifar.step()

        running_loss += loss.item()
        if i % 100 == 99:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
            running_loss = 0.0

print('CIFAR model training finished')

4. 特征融合

# Feature extraction
net_mnist.eval()
net_cifar.eval()

features_mnist = torch.Tensor()
features_cifar = torch.Tensor()

with torch.no_grad():
    for inputs, labels in train_loader_mnist:
        features_mnist = torch.cat((features_mnist, net_mnist(inputs).data), 0)

    for inputs, labels in train_loader_cifar:
        features_cifar = torch.cat((features_cifar, net_cifar(inputs).data), 0)

# Feature fusion
features = torch.cat((features_mnist, features_cifar), 1)

print('Feature fusion finished')

这样就独立训练了两个网络，并且进行了特征融合。