cyclegan马和斑马代码

### CycleGAN 马 斑马 图像转换 实现代码

为了实现从马到斑马以及从斑马到马的图像转换，可以采用CycleGAN框架。该模型能够无监督地学习不同域之间的映射关系，在不需要配对训练样本的情况下完成跨领域图像翻译。

以下是使用PyTorch实现的一个简化版CycleGAN架构：

import torch
from torchvision import transforms, datasets
from torch.utils.data import DataLoader
import itertools
import os

class ResidualBlock(torch.nn.Module):
    """残差块"""
    def __init__(self, in_features):
        super(ResidualBlock, self).__init__()
        conv_block = [
            torch.nn.ReflectionPad2d(1),
            torch.nn.Conv2d(in_features, in_features, 3),
            torch.nn.InstanceNorm2d(in_features),
            torch.nn.ReLU(inplace=True),
            torch.nn.ReflectionPad2d(1),
            torch.nn.Conv2d(in_features, in_features, 3),
            torch.nn.InstanceNorm2d(in_features)
        ]
        self.conv_block = torch.nn.Sequential(*conv_block)

    def forward(self, x):
        return x + self.conv_block(x)


class Generator(torch.nn.Module):
    """生成器定义"""
    def __init__(self, input_nc=3, output_nc=3, n_residual_blocks=9):
        super(Generator, self).__init__()

        model = [torch.nn.ReflectionPad2d(3),
                 torch.nn.Conv2d(input_nc, 64, 7),
                 torch.nn.InstanceNorm2d(64),
                 torch.nn.ReLU(inplace=True)]

        # 下采样
        in_features = 64
        out_features = in_features * 2
        for _ in range(2):
            model += [torch.nn.Conv2d(in_features, out_features, 3, stride=2, padding=1),
                      torch.nn.InstanceNorm2d(out_features),
                      torch.nn.ReLU(inplace=True)]
            in_features = out_features
            out_features = in_features * 2

        # 残差块
        for _ in range(n_residual_blocks):
            model += [ResidualBlock(in_features)]

        # 上采样
        out_features = in_features // 2
        for _ in range(2):
            model += [torch.nn.ConvTranspose2d(in_features, out_features, 3, stride=2, padding=1, output_padding=1),
                      torch.nn.InstanceNorm2d(out_features),
                      torch.nn.ReLU(inplace=True)]
            in_features = out_features
            out_features = in_features // 2

        # 输出层
        model += [torch.nn.ReflectionPad2d(3), torch.nn.Conv2d(64, output_nc, 7), torch.nn.Tanh()]

        net_g = torch.nn.Sequential(*model)

    def forward(self, x):
        return net_g(x)


def weights_init_normal(m):
    classname = m.__class__.__name__
    if classname.find('Conv') != -1:
        torch.nn.init.normal_(m.weight.data, 0.0, 0.02)
    elif classname.find('BatchNorm2d') != -1:
        torch.nn.init.normal_(m.weight.data, 1.0, 0.02)
        torch.nn.init.constant_(m.bias.data, 0.0)


# 初始化生成器和判别器并加载预训练权重
netG_A2B = Generator().cuda()
netG_B2A = Generator().cuda()

if not os.path.exists('./output'):
    os.makedirs('./output')

transform = transforms.Compose([
    transforms.Resize((256, 256)),
    transforms.ToTensor(),
])

dataset = datasets.ImageFolder(root='./datasets/horse2zebra', transform=transform)
dataloader = DataLoader(dataset, batch_size=1, shuffle=False)

for i, (real_A, _) in enumerate(dataloader):

    real_A = real_A.cuda()  # 原始马图
    fake_B = netG_A2B(real_A)  # 转换成斑马图
    rec_A = netG_B2A(fake_B)  # 再次转回马图验证一致性损失
    
    # 存储结果以便查看效果
    save_image(rec_A, f'./output/rec_{i}.png')
    

上述代码展示了如何构建一个简单的CycleGAN结构来执行马与斑马间的相互转换[^1]。这里仅提供了生成部分的核心逻辑；完整的项目通常还需要加入对抗性损失函数、循环一致性和身份映射机制等组件以优化最终的效果[^4]。