在联邦学习中我每次挑选3个客户端进行聚合训练一个全局模型，重复10次这样的过程，这样得到10个全局模型，然后用这10个全局模型对测试集进行预测代码实现

下面是一个简单的代码实现示例，仅供参考：

import torch
from torch.utils.data import DataLoader, Dataset
from torchvision import datasets, transforms

# 定义客户端类
class Client():
    def __init__(self, data, index):
        self.index = index
        self.dataloader = DataLoader(data, batch_size=32, shuffle=True)

    def train(self, model):
        optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
        criterion = torch.nn.CrossEntropyLoss()

        for epoch in range(10):
            for x, y in self.dataloader:
                optimizer.zero_grad()
                output = model(x)
                loss = criterion(output, y)
                loss.backward()
                optimizer.step()

        return model.state_dict()

# 定义数据集类
class MyDataset(Dataset):
    def __init__(self, data):
        self.data = data

    def __getitem__(self, index):
        x, y = self.data[index]
        return transforms.ToTensor()(x), torch.LongTensor([y])

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

# 加载数据集
train_data = datasets.MNIST('./data', train=True, download=True)
test_data = datasets.MNIST('./data', train=False, download=True)

# 创建客户端列表
clients = [Client(MyDataset(train_data), i) for i in range(10)]

# 初始化全局模型
global_model = torch.nn.Sequential(
    torch.nn.Conv2d(1, 32, 3),
    torch.nn.ReLU(),
    torch.nn.MaxPool2d(2),
    torch.nn.Conv2d(32, 64, 3),
    torch.nn.ReLU(),
    torch.nn.MaxPool2d(2),
    torch.nn.Flatten(),
    torch.nn.Linear(1600, 10),
    torch.nn.LogSoftmax(dim=1)
)

# 聚合训练10次
for i in range(10):
    selected_clients = clients[i:i+3]  # 每次选择3个客户端
    models = [global_model] + [torch.nn.Sequential(global_model[i]) for i in range(1, 3)]
    state_dicts = [client.train(model) for client, model in zip(selected_clients, models)]
    global_model.load_state_dict({k: sum(sd[k] for sd in state_dicts) / 3 for k in state_dicts[0]})

# 用10个全局模型对测试集进行预测
for i in range(10):
    model = torch.nn.Sequential(global_model[i])
    model.eval()
    test_loader = DataLoader(test_data, batch_size=32, shuffle=False)
    correct = 0
    total = 0
    with torch.no_grad():
        for x, y in test_loader:
            output = model(x)
            _, predicted = torch.max(output.data, 1)
            total += y.size(0)
            correct += (predicted == y).sum().item()

    print('模型{}的准确率为：{:.2f}%'.format(i+1, 100 * correct / total))

这个示例中，我们通过 `Client` 类来表示每个客户端，其中包含一个数据集和一个 `train` 方法，用于训练模型并返回其状态字典。我们还定义了一个 `MyDataset` 类来封装数据集，使其能够被 `DataLoader` 加载。在主函数中，我们首先加载数据集并创建客户端列表，然后初始化全局模型。接下来，我们通过循环10次，每次选择3个客户端进行训练，并将它们训练出的模型状态字典加权平均得到一个新的全局模型。最后，我们用10个全局模型对测试集进行预测，并计算准确率。