生成对抗网络在商品合成中的应用

    import torch
    import torch.nn as nn
    import torchvision.datasets as datasets
    import torchvision.transforms as transforms
    from torch.utils.data import DataLoader
    
    # 定义生成器和判别器网络结构
    class Generator(nn.Module):
    def __init__(self, latent_dim, img_shape):
        super(Generator, self).__init__()
        self.img_shape = img_shape
    
        self.model = nn.Sequential(
            nn.Linear(latent_dim, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.BatchNorm1d(256),
            nn.Linear(256, 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.BatchNorm1d(512),
            nn.Linear(512, 1024),
            nn.LeakyReLU(0.2, inplace=True),
            nn.BatchNorm1d(1024),
            nn.Linear(1024, int(np.prod(img_shape))),
            nn.Tanh()
        )
    
    def forward(self, z):
        img = self.model(z)
        img = img.view(img.size(0), *self.img_shape)
        return img
    
    class Discriminator(nn.Module):
    def __init__(self, img_shape):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(int(np.prod(img_shape)), 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )
    
    def forward(self, img):
        img_flat = img.view(img.size(0), -1)
        validity = self.model(img_flat)
        return validity
    
    # 训练GAN模型
    def train_gan(epochs, batch_size, lr, latent_dim, img_shape, dataset):
    # 初始化生成器和判别器
    generator = Generator(latent_dim, img_shape)
    discriminator = Discriminator(img_shape)
    
    # 定义优化器和损失函数
    g_optimizer = torch.optim.Adam(generator.parameters(), lr=lr)
    d_optimizer = torch.optim.Adam(discriminator.parameters(), lr=lr)
    adversarial_loss = nn.BCELoss()
    
    for epoch in range(epochs):
        for i, (imgs, _) in enumerate(dataloader):
            batch_size = imgs.shape[0]
    
            # 训练判别器
            valid = torch.ones((batch_size, 1))
            fake = torch.zeros((batch_size, 1))
    
            real_imgs = imgs.to(device)
            z = torch.randn(batch_size, latent_dim).to(device)
            gen_imgs = generator(z)
    
            d_real_loss = adversarial_loss(discriminator(real_imgs), valid)
            d_fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
            d_loss = (d_real_loss + d_fake_loss) / 2
            d_optimizer.zero_grad()
            d_loss.backward()
            d_optimizer.step()
    
            # 训练生成器
            validity = discriminator(gen_imgs)
            g_loss = adversarial_loss(validity, valid)
            g_optimizer.zero_grad()
            g_loss.backward()
            g_optimizer.step()
    
            print(f"Epoch [{epoch+1}/{epochs}], Step [{i+1}/{len(dataloader)}], D_loss: {d_loss.item()}, G_loss: {g_loss.item()}")
    
    return generator, discriminator
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-07-12/ZlNy8RjDF7hPeUgcdt5QiLuqfmOA.png)