pytorch 数据集大小不同的二元分类网络模型和多元分类网络模型联合训练代码

这里是一个 PyTorch 的二元分类和多元分类网络模型联合训练的代码示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

class BinaryDataset(Dataset):
    def __init__(self, data):
        self.data = data
        
    def __getitem__(self, index):
        x, y = self.data[index]
        return x, torch.tensor([y], dtype=torch.float32)
    
    def __len__(self):
        return len(self.data)

class MultiDataset(Dataset):
    def __init__(self, data):
        self.data = data
        
    def __getitem__(self, index):
        x, y = self.data[index]
        return x, torch.tensor(y, dtype=torch.float32)
    
    def __len__(self):
        return len(self.data)

class BinaryClassifier(nn.Module):
    def __init__(self, input_size):
        super(BinaryClassifier, self).__init__()
        self.fc1 = nn.Linear(input_size, 64)
        self.fc2 = nn.Linear(64, 32)
        self.fc3 = nn.Linear(32, 1)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()
        
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        out = self.relu(out)
        out = self.fc3(out)
        out = self.sigmoid(out)
        return out

class MultiClassifier(nn.Module):
    def __init__(self, input_size, num_classes):
        super(MultiClassifier, self).__init__()
        self.fc1 = nn.Linear(input_size, 64)
        self.fc2 = nn.Linear(64, 32)
        self.fc3 = nn.Linear(32, num_classes)
        self.relu = nn.ReLU()
        self.softmax = nn.Softmax(dim=1)
        
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        out = self.relu(out)
        out = self.fc3(out)
        out = self.softmax(out)
        return out

class JointModel(nn.Module):
    def __init__(self, binary_model, multi_model):
        super(JointModel, self).__init__()
        self.binary_model = binary_model
        self.multi_model = multi_model
        
    def forward(self, x):
        binary_out = self.binary_model(x)
        multi_out = self.multi_model(x)
        return binary_out, multi_out

def train_joint_model(joint_model, binary_dataset, multi_dataset, batch_size, num_epochs, learning_rate):
    binary_loader = DataLoader(dataset=binary_dataset, batch_size=batch_size, shuffle=True)
    multi_loader = DataLoader(dataset=multi_dataset, batch_size=batch_size, shuffle=True)
    criterion_binary = nn.BCELoss()
    criterion_multi = nn.CrossEntropyLoss()
    optimizer = optim.Adam(joint_model.parameters(), lr=learning_rate)
    
    for epoch in range(num_epochs):
        for i, (binary_data, multi_data) in enumerate(zip(binary_loader, multi_loader)):
            binary_x, binary_y = binary_data
            multi_x, multi_y = multi_data
            
            optimizer.zero_grad()
            binary_out, multi_out = joint_model(torch.cat([binary_x, multi_x], dim=0))
            loss_binary = criterion_binary(binary_out, binary_y)
            loss_multi = criterion_multi(multi_out, torch.argmax(multi_y, dim=1))
            loss = loss_binary + loss_multi
            loss.backward()
            optimizer.step()
            
            if (i+1) % 10 == 0:
                print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, i+1, len(binary_loader), loss.item()))

# Example usage
binary_data = [(torch.randn(10), 0) for _ in range(100)]
multi_data = [(torch.randn(10), torch.randint(0, 5, (1,))) for _ in range(100)]
binary_dataset = BinaryDataset(binary_data)
multi_dataset = MultiDataset(multi_data)
binary_model = BinaryClassifier(10)
multi_model = MultiClassifier(10, 5)
joint_model = JointModel(binary_model, multi_model)
train_joint_model(joint_model, binary_dataset, multi_dataset, batch_size=16, num_epochs=10, learning_rate=0.001)

这个代码示例包括了三个类：BinaryDataset、MultiDataset 和 JointModel。BinaryDataset 和 MultiDataset 分别用来加载二元分类和多元分类的数据集，JointModel 包含了两个子模型，分别是二元分类和多元分类的模型，通过 forward 方法将输入的数据同时传递给两个子模型，然后返回两个子模型的输出结果。在训练过程中，我们使用了 cross-entropy loss 和 binary cross-entropy loss 作为损失函数，同时使用 Adam 优化器对整个联合模型进行优化训练。