判别器输入为真实图像数据集和带掩膜的破损图像数据集，生成器输入为带掩膜的破损图像数据集，请定义生成器和判别器循环训练的代码，并计算生成器损失、判别器损失、重建损失

循环训练的代码如下：

# 定义生成器
generator = nn.Sequential(
    nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1),
    nn.ReLU(),
    nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=1),
    nn.ReLU(),
    nn.Conv2d(in_channels=64, out_channels=3, kernel_size=3, stride=1, padding=1),
    nn.Tanh()
)

# 定义判别器
discriminator = nn.Sequential(
    nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, stride=1, padding=1),
    nn.LeakyReLU(0.2),
    nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=2, padding=1),
    nn.BatchNorm2d(64),
    nn.LeakyReLU(0.2),
    nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1),
    nn.BatchNorm2d(128),
    nn.LeakyReLU(0.2),
    nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, stride=2, padding=1),
    nn.BatchNorm2d(128),
    nn.LeakyReLU(0.2),
    nn.Flatten(),
    nn.Linear(128 * 8 * 8, 1),
    nn.Sigmoid()
)

# 定义损失函数
criterion = nn.BCELoss()

# 定义优化器
generator_optimizer = optim.Adam(generator.parameters(), lr=0.0002, betas=(0.5, 0.999))
discriminator_optimizer = optim.Adam(discriminator.parameters(), lr=0.0002, betas=(0.5, 0.999))

# 开始循环训练
for epoch in range(num_epochs):
    for i, (real_image, masked_image, mask) in enumerate(dataloader):
        real_image = real_image.to(device)
        masked_image = masked_image.to(device)
        mask = mask.to(device)
        
        # 定义标签
        real_label = torch.ones(real_image.size(0), 1, device=device)
        fake_label = torch.zeros(real_image.size(0), 1, device=device)
        
        # 训练判别器
        discriminator_optimizer.zero_grad()
        output = discriminator(torch.cat((real_image, masked_image), dim=1))
        real_loss = criterion(output, real_label)
        
        fake_image = generator(masked_image)
        output = discriminator(torch.cat((fake_image, masked_image), dim=1))
        fake_loss = criterion(output, fake_label)
        
        d_loss = real_loss + fake_loss
        d_loss.backward()
        discriminator_optimizer.step()
        
        # 训练生成器
        generator_optimizer.zero_grad()
        fake_image = generator(masked_image)
        output = discriminator(torch.cat((fake_image, masked_image), dim=1))
        g_loss = criterion(output, real_label)
        
        reconstructed_image = fake_image * (1 - mask) + masked_image * mask
        r_loss = torch.mean(torch.abs(real_image - reconstructed_image))
        
        total_loss = g_loss + 0.01 * r_loss
        total_loss.backward()
        generator_optimizer.step()
        
        # 输出损失
        if (i+1) % 100 == 0:
            print('Epoch [{}/{}], Step [{}/{}], D Loss: {:.4f}, G Loss: {:.4f}, Reconstruct Loss: {:.4f}'
                  .format(epoch+1, num_epochs, i+1, len(dataloader), d_loss.item(), g_loss.item(), r_loss.item()))

其中，`real_image`为真实图像数据集，`masked_image`为带掩膜的破损图像数据集，`fake_image`为生成器生成的破损图像数据集。循环训练中，先训练判别器，再训练生成器。

生成器损失为 `g_loss`，判别器损失为 `d_loss`，重建损失为 `r_loss`。其中，`total_loss`为总损失，用于更新生成器。