当前位置： 首页 > article >正文

介绍如何使用生成对抗网络（GAN）和Cycle GAN设计用于水果识别的模型

article 2025/3/4 7:10:45

下面将详细介绍如何使用生成对抗网络（GAN）和Cycle GAN设计用于水果识别的模型，我们将使用Python和深度学习框架PyTorch来实现。

1. 生成对抗网络（GAN）用于水果识别

原理

GAN由生成器（Generator）和判别器（Discriminator）组成。生成器尝试生成逼真的水果图像，判别器则尝试区分生成的图像和真实的水果图像。通过两者的对抗训练，最终生成器能够生成高质量的水果图像，判别器可以用于水果识别。

代码实现
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

# 定义生成器
class Generator(nn.Module):
    def __init__(self, z_dim=100, img_dim=784):
        super(Generator, self).__init__()
        self.gen = nn.Sequential(
            nn.Linear(z_dim, 256),
            nn.LeakyReLU(0.1),
            nn.Linear(256, img_dim),
            nn.Tanh()
        )

    def forward(self, x):
        return self.gen(x)

# 定义判别器
class Discriminator(nn.Module):
    def __init__(self, img_dim=784):
        super(Discriminator, self).__init__()
        self.disc = nn.Sequential(
            nn.Linear(img_dim, 128),
            nn.LeakyReLU(0.1),
            nn.Linear(128, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.disc(x)

# 超参数设置
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
lr = 3e-4
z_dim = 100
img_dim = 28 * 28
batch_size = 32
num_epochs = 50

# 数据加载
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# 这里假设使用MNIST作为示例，实际中需要替换为水果数据集
dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

# 初始化模型
gen = Generator(z_dim, img_dim).to(device)
disc = Discriminator(img_dim).to(device)

# 定义优化器和损失函数
opt_gen = optim.Adam(gen.parameters(), lr=lr)
opt_disc = optim.Adam(disc.parameters(), lr=lr)
criterion = nn.BCELoss()

# 训练循环
for epoch in range(num_epochs):
    for batch_idx, (real, _) in enumerate(dataloader):
        real = real.view(-1, 784).to(device)
        batch_size = real.shape[0]

        ### 训练判别器
        noise = torch.randn(batch_size, z_dim).to(device)
        fake = gen(noise)
        disc_real = disc(real).view(-1)
        lossD_real = criterion(disc_real, torch.ones_like(disc_real))
        disc_fake = disc(fake.detach()).view(-1)
        lossD_fake = criterion(disc_fake, torch.zeros_like(disc_fake))
        lossD = (lossD_real + lossD_fake) / 2
        disc.zero_grad()
        lossD.backward()
        opt_disc.step()

        ### 训练生成器
        output = disc(fake).view(-1)
        lossG = criterion(output, torch.ones_like(output))
        gen.zero_grad()
        lossG.backward()
        opt_gen.step()

    print(f"Epoch [{epoch + 1}/{num_epochs}] Loss D: {lossD.item():.4f}, Loss G: {lossG.item():.4f}")

# 使用判别器进行水果识别
# 这里需要将测试数据加载进来，经过预处理后输入到判别器中
# 例如：
# test_data = ...
# test_data = test_data.view(-1, 784).to(device)
# predictions = disc(test_data)

2. Cycle GAN用于水果识别

原理

Cycle GAN用于在两个不同域之间进行图像转换，例如将苹果图像转换为橙子图像，反之亦然。在水果识别中，我们可以利用Cycle GAN的生成器学习不同水果的特征表示，然后使用这些特征进行分类。

代码实现
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
from torchvision.datasets import ImageFolder

# 定义生成器和判别器的基本块
class ResidualBlock(nn.Module):
    def __init__(self, in_channels):
        super(ResidualBlock, self).__init__()
        self.block = nn.Sequential(
            nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1, bias=False),
            nn.InstanceNorm2d(in_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1, bias=False),
            nn.InstanceNorm2d(in_channels)
        )

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

# 定义生成器
class Generator(nn.Module):
    def __init__(self, img_channels, num_residuals=9):
        super(Generator, self).__init__()
        self.initial = nn.Sequential(
            nn.Conv2d(img_channels, 64, kernel_size=7, stride=1, padding=3, bias=False),
            nn.InstanceNorm2d(64),
            nn.ReLU(inplace=True)
        )
        self.down_blocks = nn.ModuleList([
            nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1, bias=False),
            nn.InstanceNorm2d(128),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1, bias=False),
            nn.InstanceNorm2d(256),
            nn.ReLU(inplace=True)
        ])
        self.res_blocks = nn.Sequential(
            *[ResidualBlock(256) for _ in range(num_residuals)]
        )
        self.up_blocks = nn.ModuleList([
            nn.ConvTranspose2d(256, 128, kernel_size=3, stride=2, padding=1, output_padding=1, bias=False),
            nn.InstanceNorm2d(128),
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(128, 64, kernel_size=3, stride=2, padding=1, output_padding=1, bias=False),
            nn.InstanceNorm2d(64),
            nn.ReLU(inplace=True)
        ])
        self.final = nn.Conv2d(64, img_channels, kernel_size=7, stride=1, padding=3, bias=False)
        self.tanh = nn.Tanh()

    def forward(self, x):
        x = self.initial(x)
        for layer in self.down_blocks:
            x = layer(x)
        x = self.res_blocks(x)
        for layer in self.up_blocks:
            x = layer(x)
        x = self.final(x)
        return self.tanh(x)

# 定义判别器
class Discriminator(nn.Module):
    def __init__(self, img_channels):
        super(Discriminator, self).__init__()
        self.disc = nn.Sequential(
            nn.Conv2d(img_channels, 64, kernel_size=4, stride=2, padding=1),
            nn.LeakyReLU(0.2),
            self._block(64, 128, 4, 2, 1),
            self._block(128, 256, 4, 2, 1),
            self._block(256, 512, 4, 1, 1),
            nn.Conv2d(512, 1, kernel_size=4, stride=1, padding=1)
        )

    def _block(self, in_channels, out_channels, kernel_size, stride, padding):
        return nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=False),
            nn.InstanceNorm2d(out_channels),
            nn.LeakyReLU(0.2)
        )

    def forward(self, x):
        return self.disc(x)

# 超参数设置
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
lr = 2e-4
batch_size = 1
img_size = 256
img_channels = 3
num_epochs = 50

# 数据加载
transform = transforms.Compose([
    transforms.Resize((img_size, img_size)),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# 这里需要替换为实际的水果数据集
dataset_A = ImageFolder(root='./data/fruits_A', transform=transform)
dataset_B = ImageFolder(root='./data/fruits_B', transform=transform)
dataloader_A = DataLoader(dataset_A, batch_size=batch_size, shuffle=True)
dataloader_B = DataLoader(dataset_B, batch_size=batch_size, shuffle=True)

# 初始化模型
gen_AB = Generator(img_channels).to(device)
gen_BA = Generator(img_channels).to(device)
disc_A = Discriminator(img_channels).to(device)
disc_B = Discriminator(img_channels).to(device)

# 定义优化器和损失函数
opt_gen = optim.Adam(list(gen_AB.parameters()) + list(gen_BA.parameters()), lr=lr, betas=(0.5, 0.999))
opt_disc = optim.Adam(list(disc_A.parameters()) + list(disc_B.parameters()), lr=lr, betas=(0.5, 0.999))
criterion_GAN = nn.MSELoss()
criterion_cycle = nn.L1Loss()
criterion_identity = nn.L1Loss()

# 训练循环
for epoch in range(num_epochs):
    for idx, (real_A, real_B) in enumerate(zip(dataloader_A, dataloader_B)):
        real_A = real_A[0].to(device)
        real_B = real_B[0].to(device)

        ### 训练生成器
        opt_gen.zero_grad()

        # 身份损失
        same_B = gen_AB(real_B)
        loss_identity_B = criterion_identity(same_B, real_B) * 5
        same_A = gen_BA(real_A)
        loss_identity_A = criterion_identity(same_A, real_A) * 5

        # GAN损失
        fake_B = gen_AB(real_A)
        disc_B_fake = disc_B(fake_B)
        loss_GAN_AB = criterion_GAN(disc_B_fake, torch.ones_like(disc_B_fake))
        fake_A = gen_BA(real_B)
        disc_A_fake = disc_A(fake_A)
        loss_GAN_BA = criterion_GAN(disc_A_fake, torch.ones_like(disc_A_fake))

        # 循环一致性损失
        recov_A = gen_BA(fake_B)
        loss_cycle_A = criterion_cycle(recov_A, real_A) * 10
        recov_B = gen_AB(fake_A)
        loss_cycle_B = criterion_cycle(recov_B, real_B) * 10

        # 总生成器损失
        loss_G = (
            loss_identity_A + loss_identity_B +
            loss_GAN_AB + loss_GAN_BA +
            loss_cycle_A + loss_cycle_B
        )

        loss_G.backward()
        opt_gen.step()

        ### 训练判别器
        opt_disc.zero_grad()

        # 判别器A损失
        disc_A_real = disc_A(real_A)
        loss_D_A_real = criterion_GAN(disc_A_real, torch.ones_like(disc_A_real))
        disc_A_fake = disc_A(fake_A.detach())
        loss_D_A_fake = criterion_GAN(disc_A_fake, torch.zeros_like(disc_A_fake))
        loss_D_A = (loss_D_A_real + loss_D_A_fake) / 2

        # 判别器B损失
        disc_B_real = disc_B(real_B)
        loss_D_B_real = criterion_GAN(disc_B_real, torch.ones_like(disc_B_real))
        disc_B_fake = disc_B(fake_B.detach())
        loss_D_B_fake = criterion_GAN(disc_B_fake, torch.zeros_like(disc_B_fake))
        loss_D_B = (loss_D_B_real + loss_D_B_fake) / 2

        # 总判别器损失
        loss_D = loss_D_A + loss_D_B

        loss_D.backward()
        opt_disc.step()

    print(f"Epoch [{epoch + 1}/{num_epochs}] Loss G: {loss_G.item():.4f}, Loss D: {loss_D.item():.4f}")

# 使用生成器的特征进行水果识别
# 可以将生成器的中间层特征提取出来，用于训练一个分类器

注意事项

  • 数据准备：上述代码中使用了MNIST和示例的水果数据集路径，实际应用中需要准备真实的水果图像数据集，并进行适当的预处理。
  • 模型调优：可以根据实际情况调整超参数，如学习率、批量大小、训练轮数等，以获得更好的性能。
  • 硬件要求：GAN和Cycle GAN的训练计算量较大，建议使用GPU进行训练。

http://www.kler.cn/a/569817.html

相关文章：

  • ES 删除index 的curl
  • Vue.js 组件开发指南：实现、传值与优缺点分析
  • 性能优化——cache与cacheline
  • 如何远程访问svn中的URL
  • 数据结构（初阶）（六）----队列
  • ctfshow刷题笔记—栈溢出—pwn61~pwn64
  • C++类和对象：匿名对象及连续构造拷贝编译器的优化
  • Vscode通过Roo Cline接入Deepseek
  • 授权与认证之jwt（三）刷新令牌该如何设计
  • 计算机网络学习————(五)TCP/IP学习
  • ubuntu Linux 正确设置中文环境的方法
  • Python常见面试题的详解24
  • 实现用户特征自动识别和动态圈子创建，需构建一套完整的自动化流程
  • 本地搭建Ollama运行各种平台的大模型（deepseek），配合AnythingLLM-UI界面使用
  • 2025-02-28 学习记录--C/C++-PTA 7-34 通讯录的录入与显示
  • 基于消息事件实现结合状态机实现事件触发通用单片机逻裸机框架处理
  • 《机器学习数学基础》补充资料：线性变换和最小二乘
  • 【Go语言快速上手】第一部分：数据类型（数组、切片、映射）与控制语句
  • 【JAVA-数据结构】枚举
  • Storm实时流式计算系统（全解）——中