使用PyTorch实现GAN（生成对抗网络）的详细步骤

于 2024-08-02 16:43:37 发布
阅读量760 收藏 14
点赞数 9
文章标签： pytorch 生成对抗网络 人工智能 pycharm python 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80396926/article/details/140874302
版权

使用PyTorch实现GAN（生成对抗网络）

在这篇博客中，我们将探讨如何使用PyTorch实现一个简单的生成对抗网络（GAN），用于生成手写数字图像（MNIST数据集）。我们将详细介绍代码的每一个部分，并确保所有注释信息都被保留。

1. 导入必要的库

以下是我们用到的主要库：

import torchvision
import torch
from matplotlib import pyplot as plt
from torch import nn, Tensor
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
import os

这些库将帮助我们处理数据、构建模型、训练网络以及可视化生成的图像。

2. 数据准备

我们需要首先对训练数据进行处理。下面是MNIST数据集的准备过程：

# 数据准备
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(0.5, 0.5)])
train_dataset = torchvision.datasets.MNIST("./dataset", train=True, transform=transform, download=True)
train_dataloader = DataLoader(train_dataset, batch_size=64, shuffle=True, drop_last=True)

我们使用了transforms.Compose将数据转换为张量并进行归一化，以便模型能够更好地进行学习。

3. 生成器和判别器的定义

接下来，我们定义生成器（Generator）和判别器（Discriminator）。

生成器：

# 生成器
class Generator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(100, 128),
            nn.Linear(128, 256),
            nn.Linear(256, 512),
            nn.Linear(512, 28 * 28),
            nn.Tanh()
        )

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

生成器将随机噪声输入转化为28x28的图像。

判别器：

# 判别器
class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Flatten(),
            nn.Linear(28 * 28, 512),
            nn.LeakyReLU(),
            nn.Linear(512, 256),
            nn.LeakyReLU(),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        x = x.view(-1, 28, 28)
        return self.model(x)

判别器负责区分生成的图像和真实图像。

4. 初始化模型，优化器及损失计算函数

接下来，我们初始化模型、优化器以及损失函数。

# 初始化模型，优化器及损失计算函数
writer = SummaryWriter("./p1log")
device = "cuda" if torch.cuda.is_available() else "cpu"
gen = Generator().to(device)
dis = Discriminator().to(device)
# 优化器
g_optim = torch.optim.Adam(gen.parameters(), lr=1e-3)
d_optim = torch.optim.Adam(dis.parameters(), lr=1e-3)
# 损失函数
loss_fn = nn.BCELoss()
epochs = 20

我们使用Adam优化器和二元交叉熵损失函数（BCELoss）来计算生成器和判别器的损失。

5. 训练过程

我们开始训练循环，并对生成器和判别器进行优化。

# 开始循环
for epoch in range(epochs):
    for step, (imgs, _) in enumerate(train_dataloader):
        imgs = imgs.to(device)
        size = imgs.size(0)  # 返回第0纬度的大小，也就是batch_size=64
        random_noise = torch.randn(size, 100, device=device)  # 生成64个，大小为100特征值的噪音

        # 鉴别器的优化
        d_optim.zero_grad()
        # 对真实的图片，希望判断为1
        real_output = dis(imgs)
        d_real_loss = loss_fn(real_output,
                               torch.ones_like(real_output))  # 达到鉴别器在真实图片上的损失

        # 对生成器生成的图片，希望对生成器生成的全部判断为0
        gen_img = gen(random_noise)
        fake_output = dis(gen_img).detach()  # 截断梯度，希望判断为0
        d_fake_loss = loss_fn(fake_output,
                               torch.zeros_like(fake_output))  # 得到鉴别器在生成图片上的损失
        # 鉴别器的损失等于鉴别真实图片和鉴别生成图片的损失和
        d_loss = d_fake_loss + d_real_loss
        d_loss.backward()
        d_optim.step()

        # 生成器的优化
        g_optim.zero_grad()
        gen_img = gen(random_noise)
        fake_output = dis(gen_img)
        g_loss = loss_fn(fake_output,
                         torch.ones_like(fake_output))
        g_loss.backward()
        g_optim.step()
        # 将损失记录到tensorboard
        writer.add_scalar('D_Loss_epoch:{}'.format(epoch + 1), d_loss.item(), epoch * len(train_dataloader) + step)
        writer.add_scalar('G_Loss_epoch:{}'.format(epoch + 1), g_loss.item(), epoch * len(train_dataloader) + step)
        # 每一百次进行一次打印
        if step % 100 == 0:
            print(f'Epoch [{epoch + 1}/{epochs}], Step [{step}], D Loss: {d_loss.item():.4f}, G Loss: {g_loss.item():.4f}')
            print("Epoch:{},生成器的损失：{}，鉴别器的损失：{}".format(epoch + 1, g_loss, d_loss))

在每个训练步骤中，我们首先优化判别器，之后再优化生成器。我们记录损失值以用于后期分析和可视化。

6. 生成和保存图像

在每个epoch结束时，我们将生成的图像保存到文件中。

# 每个 epoch 保存生成的图片
with torch.no_grad():
    gen.eval()
    test_noise = torch.randn(64, 100, device=device)
    i = 0
    generated_images = gen(test_noise).view(-1, 1, 28, 28)
    generated_images = (generated_images + 1) / 2  # 将[-1, 1]转换到[0, 1]
    # 绘图
    grid = torchvision.utils.make_grid(generated_images, nrow=8)  # 将多个生成的图像组合成一个网格图像
    plt.figure(figsize=(8, 8))  # 创建一个新的图形对象，并设置图形的大小为8x8英寸
    plt.imshow(grid.cpu().numpy().transpose((1, 2, 0)))  # 转换为Matplotlib所需的格式
    plt.axis('off')  # 关闭坐标轴和刻度
    if not os.path.exists(f'./images/epoch_{epoch + 1}'):
        os.makedirs(f'./images/epoch_{epoch + 1}')
    plt.savefig(f"./images/epoch_{epoch + 1}/{i}.png")  # 保存生成的图片
    i += 1
    plt.close()

这个部分的代码生成了一些假图片，并将结果保存到指定的目录中，以便后续查看。

总代码

import torchvision
import torch
from matplotlib import pyplot as plt
from torch import nn, Tensor
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from torchvision import transforms
import os

#数据准备
transform=transforms.Compose([transforms.ToTensor(),transforms.Normalize(0.5, 0.5)])
train_dataset=torchvision.datasets.MNIST("./dataset",train=True,transform=transform,download=True)
train_dataloader=DataLoader(train_dataset,batch_size=64,shuffle=True,drop_last=True)

#生成器
class Generator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model=nn.Sequential(
            nn.Linear(100,128),
            nn.Linear(128,256),
            nn.Linear(256,512),
            nn.Linear(512,28*28),
            nn.Tanh()
        )

    def forward(self,x):
        return self.model(x)
#判别器
class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.model=nn.Sequential(
            nn.Flatten(),
            nn.Linear(28*28,512),
            nn.LeakyReLU(),
            nn.Linear(512,256),
            nn.LeakyReLU(),
            nn.Linear(256,1),
            nn.Sigmoid()
        )

    def forward(self,x):
        x=x.view(-1,28,28)
        return self.model(x)

#初始化模型，优化器及损失计算函数
#用BCEloss计算交叉熵损失
writer=SummaryWriter("./p1log")
device="cuda" if torch.cuda.is_available() else "cpu"
gen=Generator().to(device)
dis=Discriminator().to(device)
#优化器
g_optim=torch.optim.Adam(gen.parameters(),lr=1e-3)
d_optim=torch.optim.Adam(dis.parameters(),lr=1e-3)
#损失函数
loss_fn=nn.BCELoss()
epochs=20

#开始循环
for epoch in range(epochs):
    for step,(imgs,_) in enumerate(train_dataloader):
        imgs = imgs.to(device)
        size = imgs.size(0)#返回第0纬度的大小，也就是batch_size=64
        random_noise = torch.randn(size, 100, device=device)#生成64个，大小为100特征值的噪音

        # 鉴别器的优化
        d_optim.zero_grad()
        # 对真实的图片，希望判断为1
        real_output = dis(imgs)
        d_real_loss = loss_fn(real_output,
                              torch.ones_like(real_output))  # 达到鉴别器在真实图片上的损失

        # 对gen生成图片，希望对gen生成的全部判断为0
        gen_img = gen(random_noise)
        fake_output = dis(gen_img).detach()  # 截断梯度，希望判断为0
        d_fake_loss = loss_fn(fake_output,
                              torch.zeros_like(fake_output))  # 得到鉴别器在生成图片上的损失
        # 鉴别器的损失等于鉴别真实图片和鉴别生成图片的损失和
        d_loss = d_fake_loss + d_real_loss
        d_loss.backward()
        d_optim.step()

        # 生成器的优化
        g_optim.zero_grad()
        gen_img=gen(random_noise)
        fake_output = dis(gen_img)
        g_loss = loss_fn(fake_output,
                         torch.ones_like(fake_output))
        g_loss.backward()
        g_optim.step()
        #将损失记录到tensorboard
        writer.add_scalar('D_Loss_epoch:{}'.format(epoch+1), d_loss.item(), epoch * len(train_dataloader) + step)
        writer.add_scalar('G_Loss_epoch:{}'.format(epoch+1), g_loss.item(), epoch * len(train_dataloader) + step)
        #每一百次进行一次打印
        if step % 100 == 0:
            print(f'Epoch [{epoch+1}/{epochs}], Step [{step}], D Loss: {d_loss.item():.4f}, G Loss: {g_loss.item():.4f}')
            print("Epoch:{},生成器的损失：{}，鉴别器的损失：{}".format(epoch+1,g_loss,d_loss))
 # 每个 epoch 保存生成的图片
    with torch.no_grad():
        gen.eval()
        test_noise = torch.randn(64, 100, device=device)
        i=0
        generated_images = gen(test_noise).view(-1, 1, 28, 28)
        generated_images = (generated_images + 1) / 2  # 将 [-1, 1] 转换到 [0, 1]
        #绘图
        grid = torchvision.utils.make_grid(generated_images, nrow=8)#torchvision.utils.make_grid 将多个生成的图像（generated_images）组合成一个网格图像，nrow=8 表示每一行显示 8 张图像。
        plt.figure(figsize=(8, 8))#创建一个新的图形对象，并设置图形的大小为 8x8 英寸。
        plt.imshow(grid.cpu().numpy().transpose((1, 2, 0))) #作用是将图像的数据格式从 PyTorch 的默认格式 (C, H, W) 转换为 Matplotlib 所需的格式 (H, W, C)，以便正确显示图像。
        plt.axis('off')#关闭坐标轴和刻度
        if not os.path.exists(f'./images/epoch_{epoch+1}'):
            os.makedirs(f'./images/epoch_{epoch+1}')
        plt.savefig(f"./images/epoch_{epoch+1}/{i}.png")  # 保存生成的图片
        i+=1
        plt.close()
king-xxz
关注
用PyTorch代码生成对抗网络（GAN）
gongdiwudu的专栏
07-12 6688
​ 2014年，蒙特利尔大学的伊恩·古德费罗（Ian Goodfellow）和他的同事发表了一篇令人惊叹的论文，向世界介绍了GANs或生成对抗网络。通过计算图和博弈论的创新组合，他们表明，如果有足够的建模能力，相互竞争的两个模型将能够通过普通的旧反向传播进行共同训练。
使用 Pytorch 实现 GAN
qq_39215715的博客
11-09 2990
使用 Pytorch 实现 GAN 文章目录使用 Pytorch 实现 GAN前言一、什么是GAN？二、代码讲解1.生成器(Generator)2.判别器(Discriminator)3.全部代码总结 前言 自 2014 年 Ian Goodfellow 提出了 GAN（Generative Adversarial Network）以来，对 GAN 的研究可谓如火如荼，各种 GAN 的变体不断涌现。 下图是 GAN 相关论文的发表情况： Yann LeCun 评价 GAN 为 “adversaria
Python-各种GAN的PyTorch实现集合
08-11
各种GAN的PyTorch实现集合
GAN | 代码简单实现生成对抗网络（GAN）（PyTorch）
weixin_44649780的博客
02-28 5351
GAN从编程的角度来看（纯个人理解，不对可指正）利用numpy的random方法，随机生成多维的噪音向量创建一个G网络用来生成创建一个D网络用来判断俩个网络在训练时分别进行优化先训练D网络去判断真假：如果训练D为真时，进行传播；如果训练D为假时，进行传播，投入优化器（1为真，0为假）在D的基础上训练G。*因为是随机生成，所以每次生成结果不同。
Pytorch 实现 GAN 对抗网络
最新发布
hawk2014bj的博客
05-05 1320
下面的例子是生成图片的对抗网络，一个网络用于生成图片，另一个网络用于验证。G 网络用于生成图片，不断的学习并生成更接近于训练数据的图像，D 网络用于鉴别图片，通过学习更准确的识别出图片的真假，最终通过学习让 G 网络能够生成高质量的目标图片。首先，通过 1x1 卷积进行逐点卷积，当数据进行压缩，之后再通过频谱归一化，对网络层的权重进行归一化操作吗，更有助于模型的收敛。GAN 对抗网络可以通过两个网络互相对抗，最终让生成网络更加有效的生成目标图片，由于两个网络都是在不断学习中互相促进，可以完善学习的效果。
pytorch实现GAN
热门推荐
一千零一夜的博客
07-19 4万+
本文转自： https://www.pytorchtutorial.com/50-lines-of-codes-for-gan/ https://blog.csdn.net/qinglingLS/article/details/91480550 一、什么是 GAN？ 在进入技术层面之前，为照顾新入门的开发者，先来介绍下什么是 GAN。 2014 年，Ian Goodfellow 和...
pytorch实现GAN——代码和原理详解
QinZheng7575的博客
07-31 7360
文章目录小知识点np.vstack()和np.hstack()[:,np.newaxis]np.random.seed(n)函数用于生成指定随机数。查看tensor的shape细讲代码理想数据生成器G网络和D网络开始训练优化器与损失函数（极重要）损失函数优化器 本人主页 首先根据这个看一看，试着做一次https://zhuanlan.zhihu.com/p/117529144 然后是书上的生成动漫头像 最后是使用数据集的这个 https://pytorch.apachecn.org/docs/1.4/13.
pytorch实现GAN（附代码）
OpenSceneGraph的博客
02-02 5020
GAN定义的生成器和判别器网络结构： GAN训练：首先训练D，每迭代训练5次D再迭代训练一次G，总训练5000次，批次为512。数据集为8个高斯混合模型，使得GAN去拟合一个圆上的8个分布点。 根据GAN的loss函数，使得D尽可能的大，G尽可能的小，所以D取负数。 过程中用到了visdom可视化工具。 import visdom viz = visdom.Visdo...
pytorch-使用Pytorch实现的GAN生成对抗网络.zip
03-02
在"pytorch_使用Pytorch实现的GAN生成对抗网络"这个项目中，你可以找到一个完整的例子，包括代码实现、数据处理和模型训练，这对于理解和应用GAN模型非常有帮助。通过深入研究这个项目，你可以进一步掌握PyTorch在...
pytorch GAN生成对抗网络实例
09-18
在本文中，我们将深入探讨如何使用PyTorch实现生成对抗网络（GAN）的实例。GAN是一种深度学习模型，由两部分组成：生成器（Generator）和判别器（Discriminator）。生成器尝试创建与训练数据相似的新样本，而判别器...
pytorch:实现简单的GAN示例(MNIST数据集)
12-23
我就废话不多说了，直接上代码吧！ # -*- coding: utf-8 -*- """ Created on Sat Oct 13 10:22:45 2018 @author: www """ import torch from torch import nn from torch.autograd import Variable import torchvision.transforms as tfs from torch.utils.data import DataLoader, sampler from torchvision.datasets import MNIST import
生成对抗网络demo源码gan_pytorch.py
05-28
代码使用两个对抗网络生成一个数据的分布，是一个非常好的生成对抗网络模型，Python直接运行，使用的pytorch作为深度学习引擎。对于入门深度学习的人很容易懂和了解生成对抗网络。本人控制不了下载所需积分 ，所以实在没积分的可以私信我。
Pytorch实现数字对抗样本生成全套代码（GAN）
05-06
利用GAN的思想，进行数字对抗样本生成，以LeNet作为图像分类模型，LeNet是一个小型的神经网络结构，仅包含两层卷积层、两个池化层以及三层全连接。该轻量级网络能快速、占内存小、高精确度的解决复杂度比较低的问题...
利用PyTorch搭建基础生成对抗网络（GAN）
11-18
在本教程中，我们将深入探讨如何使用Python的深度学习库PyTorch来构建一个基本的生成对抗网络（GAN）。GAN是一种强大的机器学习模型，由两个神经网络组成：生成器（Generator）和判别器（Discriminator）。生成器...
pytorch：实现简单的GAN（MNIST数据集）
xckkcxxck的博客
10-13 2289
# -*- coding: utf-8 -*- """ Created on Sat Oct 13 10:22:45 2018 @author: www """ import torch from torch import nn from torch.autograd import Variable import torchvision.transforms as tfs from tor...
GAN的Pytorch实现
qq_43118572的博客
03-12 443
import numpy as np import torch import torch.nn as nn import torch.optim as optim from matplotlib import pyplot as plt #torch.autograd提供了类和函数用来对任意标量函数进行求导。要想使用自动求导， # 只需要对已有的代码进行微小的改变。只需要将所有的tensor包含进Variable对象中即可。 from torch.autograd import Variable #Da
GAN模型——pytorch实现
Peach_____的博客
01-02 347
【代码】GAN模型——pytorch实现。
pytorch实现生成对抗网络（GAN）
06-09
好的，下面是pytorch实现GAN的步骤： 1.导入必要的库 ```python import torch import torch.nn as nn import torch.optim as optim import torchvision.datasets as dset import torchvision.transforms as transforms from torch.utils.data import DataLoader import os import numpy as np import torchvision.utils as vutils ``` 2.定义生成器和鉴别器 ```python class Generator(nn.Module): def __init__(self, ngf, nz, nc): super(Generator, self).__init__() self.main = nn.Sequential( nn.ConvTranspose2d(nz, ngf * 8, 4, 1, 0, bias=False), nn.BatchNorm2d(ngf * 8), nn.ReLU(True), nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf * 4), nn.ReLU(True), nn.ConvTranspose2d(ngf * 4, ngf * 2, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf * 2), nn.ReLU(True), nn.ConvTranspose2d(ngf * 2, ngf, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf), nn.ReLU(True), nn.ConvTranspose2d(ngf, nc, 4, 2, 1, bias=False), nn.Tanh() ) def forward(self, input): return self.main(input) class Discriminator(nn.Module): def __init__(self, ndf, nc): super(Discriminator, self).__init__() self.main = nn.Sequential( nn.Conv2d(nc, ndf, 4, 2, 1, bias=False), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf * 2), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf * 4), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf * 8), nn.LeakyReLU(0.2, inplace=True), nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False), nn.Sigmoid() ) def forward(self, input): return self.main(input).view(-1, 1).squeeze(1) ``` 3.定义超参数 ```python # 超参数 batch_size = 64 image_size = 64 nz = 100 ngf = 64 ndf = 64 num_epochs = 50 lr = 0.0002 beta1 = 0.5 ngpu = 1 ``` 4.准备数据集 ```python # 图像处理 transform = transforms.Compose([ transforms.Resize(image_size), transforms.CenterCrop(image_size), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # 数据集 dataset = dset.ImageFolder(root='./data', transform=transform) dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=2) ``` 5.定义优化器和损失函数 ```python # 设备 device = torch.device("cuda:0" if (torch.cuda.is_available() and ngpu > 0) else "cpu") # 初始化生成器和鉴别器 netG = Generator(ngf, nz, 3).to(device) netD = Discriminator(ndf, 3).to(device) # 初始化权重 netG.apply(weights_init) netD.apply(weights_init) # 定义损失函数和优化器 criterion = nn.BCELoss() optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999)) optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999)) ``` 6.训练模型 ```python # 真实标签 real_label = 1. # 假标签 fake_label = 0. # 训练 for epoch in range(num_epochs): for i, data in enumerate(dataloader, 0): # 判别器的训练 netD.zero_grad() real_cpu = data[0].to(device) b_size = real_cpu.size(0) label = torch.full((b_size,), real_label, device=device) output = netD(real_cpu) errD_real = criterion(output, label) errD_real.backward() D_x = output.mean().item() noise = torch.randn(b_size, nz, 1, 1, device=device) fake = netG(noise) label.fill_(fake_label) output = netD(fake.detach()) errD_fake = criterion(output, label) errD_fake.backward() D_G_z1 = output.mean().item() errD = errD_real + errD_fake optimizerD.step() # 生成器的训练 netG.zero_grad() label.fill_(real_label) output = netD(fake) errG = criterion(output, label) errG.backward() D_G_z2 = output.mean().item() optimizerG.step() # 输出训练状态 if i % 50 == 0: print('[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f' % (epoch, num_epochs, i, len(dataloader), errD.item(), errG.item(), D_x, D_G_z1, D_G_z2)) # 保存生成器的输出 if (epoch == 0) and (i == 0): vutils.save_image(real_cpu, '%s/real_samples.png' % "./results", normalize=True) if i % 100 == 0: with torch.no_grad(): fake = netG(fixed_noise).detach().cpu() vutils.save_image(fake, '%s/fake_samples_epoch_%03d.png' % ("./results", epoch), normalize=True) ``` 以上就是pytorch实现GAN的步骤，其中还包括了权重的初始化、训练状态的输出、保存生成器的输出等。这里只是一个简单的示例，实际使用时还需要根据具体问题进行相应的调整和优化。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值