基于pytorch的GAN网络搭建

最新推荐文章于 2024-02-23 18:26:20 发布
最新推荐文章于 2024-02-23 18:26:20 发布
阅读量4k 收藏 43
点赞数 2
分类专栏： pytorch 文章标签： pytorch 网络 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37320084/article/details/122308741
版权

本次的主要任务是利用pytorch实现对GAN网络的搭建，并实现对手写数字的生成。GAN网络主要包含两部分网络，一部分是生成器，一部分是判别器。本次采用的数据库还是MNIST数据集，这里对数据的获取不在赘述。

1、生成器

生成器的主要功能是生成我们所需要的样本，这里是28*28的图片。首先生成长度为100的高斯噪声，并且将噪声通过线性模型升维到784维。激活函数采用Relu。

# 定义判别器  #####Generator######使用多层网络来作为判别器
# 输入一个100维的0～1之间的高斯分布，多层映射到784维

class generator(nn.Module):
    def __init__(self):
        super(generator, self).__init__()
        self.gen = nn.Sequential(
            nn.Linear(100, 256),  # 用线性变换将输入映射到256维
            nn.ReLU(True),  # relu激活
            nn.Linear(256, 512),  # 线性变换
            nn.ReLU(True),  # relu激活
            nn.Linear(512, 784),  # 线性变换
            nn.Tanh()  # Tanh激活使得生成数据分布在【-1,1】之间，因为输入的真实数据的经过transforms之后也是这个分布
        )

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

2、判别器

识别器的主要功能是分辨真实图片与构造的图片，实际上就是一个二分类问题，这里采用全连接网络提取特征并进行二分类，也可以利用CNN、LSTM等网络进行特征提取。

# 定义判别器  #####Discriminator######使用多层网络来作为判别器
# 将图片利用LeNet网络进行二分类，判断图片是真实的还是生成的
class discriminator(nn.Module):
    def __init__(self):
        super(discriminator, self).__init__()
        self.f1 = nn.Sequential(
            nn.Linear(784, 512),
            nn.LeakyReLU(0.2)
        )
        self.f2 = nn.Sequential(
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2)
        )
        self.out = nn.Sequential(
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        x = self.f1(x)
        x = self.f2(x)
        x = self.out(x)
        return x

3、定义损失函数

（1）判别器损失

判别器主要实现对真假样本的分类，因此需要将真的图片判断为真，假的图片判断为假。因此需要分别计算两种情况的损失函数相加。

# ########判别器训练train#####################
# 分为两部分：1、真的图像判别为真；2、假的图像判别为假
# 计算真实图片的损失
real_out = self.D(real_img)  # 将真实图片放入判别器中
d_loss_real = self.criterion(real_out, real_label)  # 得到真实图片的loss
real_scores = real_out  # 得到真实图片的判别值，输出的值越接近1越好
# 计算假的图片的损失
z = Variable(torch.randn(num_img, Config.z_dim)).cuda()  # 随机生成一些噪声
fake_img = self.G(z).detach()  # 随机噪声放入生成网络中，生成一张假的图片。 # 避免梯度传到G，因为G不用更新, detach分离
fake_out = self.D(fake_img)  # 判别器判断假的图片，
d_loss_fake = self.criterion(fake_out, fake_label)  # 得到假的图片的loss
fake_scores = fake_out  # 得到假图片的判别值，对于判别器来说，假图片的损失越接近0越好
# 损失函数和优化
d_loss = d_loss_real + d_loss_fake  # 损失包括判真损失和判假损失
self.d_optimizer.zero_grad()  # 在反向传播之前，先将梯度归0
d_loss.backward()  # 将误差反向传播
self.d_optimizer.step()  # 更新参数

（2）生成器损失

# ==================训练生成器============================
# ###############################生成网络的训练
# 希望生成的图片被认为是真的照片，因此需要假图片对应真label的损失，并且更新生成器的参数

z = Variable(torch.randn(num_img, Config.z_dim)).cuda()  # 得到随机噪声
fake_img = self.G(z)  # 随机噪声输入到生成器中，得到一副假的图片
output = self.D(fake_img)  # 经过判别器得到的结果
g_loss = self.criterion(output, real_label)  # 得到的假的图片与真实的图片的label的loss
# bp and optimize
self.g_optimizer.zero_grad()  # 梯度归0
g_loss.backward()  # 进行反向传播
self.g_optimizer.step()  # .step()一般用在反向传播后面,用于更新生成网络的参数

4、训练模型

import torch
from torchvision import datasets, transforms
import torch.nn as nn
from torch.autograd import Variable
from torchvision.utils import save_image
import os


class Config:
    device = torch.device('cuda:0')
    batch_size = 128
    epoch = 100
    alpha = 3e-4
    print_per_step = 100  # 控制输出
    z_dim = 100


# 定义判别器  #####Discriminator######使用多层网络来作为判别器
# 将图片利用LeNet网络进行二分类，判断图片是真实的还是生成的
class discriminator(nn.Module):
    def __init__(self):
        super(discriminator, self).__init__()
        self.f1 = nn.Sequential(
            nn.Linear(784, 512),
            nn.LeakyReLU(0.2)
        )
        self.f2 = nn.Sequential(
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2)
        )
        self.out = nn.Sequential(
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        x = self.f1(x)
        x = self.f2(x)
        x = self.out(x)
        return x


# 定义判别器  #####Generator######使用多层网络来作为判别器
# 输入一个100维的0～1之间的高斯分布，多层映射到784维

class generator(nn.Module):
    def __init__(self):
        super(generator, self).__init__()
        self.gen = nn.Sequential(
            nn.Linear(100, 256),  # 用线性变换将输入映射到256维
            nn.ReLU(True),  # relu激活
            nn.Linear(256, 512),  # 线性变换
            nn.ReLU(True),  # relu激活
            nn.Linear(512, 784),  # 线性变换
            nn.Tanh()  # Tanh激活使得生成数据分布在【-1,1】之间，因为输入的真实数据的经过transforms之后也是这个分布
        )

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


class TrainProcess:
    def __init__(self):
        self.data = self.load_data()
        self.D = discriminator().to(Config.device)
        self.G = generator().to(Config.device)

        self.criterion = nn.BCELoss()  # 定义损失函数
        self.d_optimizer = torch.optim.Adam(self.D.parameters(), lr=Config.alpha)
        self.g_optimizer = torch.optim.Adam(self.G.parameters(), lr=Config.alpha)

    @staticmethod
    def load_data():
        transform = transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize((0.5,), (0.5,))  # (x-mean) / std
        ])

        data = datasets.MNIST(root='./data/',
                                    train=True,
                                    transform=transform,
                                    download=True)


        # 返回一个数据迭代器
        # shuffle：是否打乱顺序
        data_loader = torch.utils.data.DataLoader(dataset=data,
                                                   batch_size=Config.batch_size,
                                                   shuffle=True)

        return data_loader

    @staticmethod
    def to_img(x):
        out = 0.5 * (x + 1)
        out = out.clamp(0, 1)  # Clamp函数可以将随机变化的数值限制在一个给定的区间[min, max]内：
        out = out.view(-1, 1, 28, 28)  # view()函数作用是将一个多行的Tensor,拼接成一行
        return out

    def train_step(self):
        # ##########################进入训练##判别器的判断过程#####################
        for epoch in range(Config.epoch):  # 进行多个epoch的训练
            for i, (img, _) in enumerate(self.data):
                num_img = img.size(0)
                # view()函数作用是将一个多行的Tensor,拼接成一行
                # 第一个参数是要拼接的tensor,第二个参数是-1
                # =============================训练判别器==================
                img = img.view(num_img,-1)
                real_img = Variable(img).cuda()  # 将tensor变成Variable放入计算图中
                real_label = Variable(torch.ones(num_img)).cuda()  # 定义真实的图片label为1
                fake_label = Variable(torch.zeros(num_img)).cuda()  # 定义假的图片的label为0

                # ########判别器训练train#####################
                # 分为两部分：1、真的图像判别为真；2、假的图像判别为假
                # 计算真实图片的损失
                real_out = self.D(real_img)  # 将真实图片放入判别器中
                d_loss_real = self.criterion(real_out, real_label)  # 得到真实图片的loss
                real_scores = real_out  # 得到真实图片的判别值，输出的值越接近1越好
                # 计算假的图片的损失
                z = Variable(torch.randn(num_img, Config.z_dim)).cuda()  # 随机生成一些噪声
                fake_img = self.G(z).detach()  # 随机噪声放入生成网络中，生成一张假的图片。 # 避免梯度传到G，因为G不用更新, detach分离
                fake_out = self.D(fake_img)  # 判别器判断假的图片，
                d_loss_fake = self.criterion(fake_out, fake_label)  # 得到假的图片的loss
                fake_scores = fake_out  # 得到假图片的判别值，对于判别器来说，假图片的损失越接近0越好
                # 损失函数和优化
                d_loss = d_loss_real + d_loss_fake  # 损失包括判真损失和判假损失
                self.d_optimizer.zero_grad()  # 在反向传播之前，先将梯度归0
                d_loss.backward()  # 将误差反向传播
                self.d_optimizer.step()  # 更新参数

                # ==================训练生成器============================
                # ###############################生成网络的训练###############################
                # 原理：目的是希望生成的假的图片被判别器判断为真的图片，
                # 在此过程中，将判别器固定，将假的图片传入判别器的结果与真实的label对应，
                # 反向传播更新的参数是生成网络里面的参数，
                # 这样可以通过更新生成网络里面的参数，来训练网络，使得生成的图片让判别器以为是真的
                # 这样就达到了对抗的目的
                # 计算假的图片的损失
                z = Variable(torch.randn(num_img, Config.z_dim)).cuda()  # 得到随机噪声
                fake_img = self.G(z)  # 随机噪声输入到生成器中，得到一副假的图片
                output = self.D(fake_img)  # 经过判别器得到的结果
                g_loss = self.criterion(output, real_label)  # 得到的假的图片与真实的图片的label的loss
                # bp and optimize
                self.g_optimizer.zero_grad()  # 梯度归0
                g_loss.backward()  # 进行反向传播
                self.g_optimizer.step()  # .step()一般用在反向传播后面,用于更新生成网络的参数

                # 打印中间的损失
                if (i + 1) % 100 == 0:
                    print('Epoch[{}/{}],d_loss:{:.6f},g_loss:{:.6f} '
                          'D real: {:.6f},D fake: {:.6f}'.format(
                        epoch, Config.epoch, d_loss.data.item(), g_loss.data.item(),
                        real_scores.data.mean(), fake_scores.data.mean()  # 打印的是真实图片的损失均值
                    ))
                if epoch == 0:
                    real_images = self.to_img(real_img.cpu().data)
                    save_image(real_images, './img/real_images.png')
            fake_images = self.to_img(fake_img.cpu().data)
            save_image(fake_images, './img/fake_images-{}.png'.format(epoch + 1))


if __name__ == "__main__":
    # 创建文件夹
    if not os.path.exists('./img'):
        os.mkdir('./img')
    p = TrainProcess()
    p.train_step()

结果展示：

                 

                   真实样本                                                       训练1个epoch生成的样本

                

         训练50个epoch生成的样本                                        训练100个epoch生成的样本

AI小蜗牛
关注
  • 2
    点赞
  • 踩
  • 43
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
【深入了解pytorch】PyTorch生成对抗网络（GAN）详解
Science prince的博客
07-25 403
本文详细介绍了生成对抗网络（GAN）的基本原理、生成器和判别器的训练过程，并提供了一个基于PyTorch的简单实现。GAN作为一种强大的生成模型，已经在图像生成、风格转换等多个领域取得了显著的成功。然而，GAN的训练也面临着一些挑战，如训练不稳定、模式崩溃等问题，需要通过更多的技巧和改进来解决。希望本文对于你理解和应用GAN有所帮助！
GAN生成对抗网络实战(PyTorch版)
04-18
分享视频教程——《GAN生成对抗网络实战(PyTorch版)》，2022最新升级版！本课程讲解GAN的基本原理和常见的各种GAN，提供数据集、代码和课件。 适用人群： 1、对GAN生成对抗网络感兴趣的 2、对PyTorch感兴趣的 3、希望研究深度学习模型的
GAN-生成对抗网络-生成手写数字(基于pytorch)
qq_45882032的博客
03-12 7935
GAN(Generative Adversarial Network)，网络也如他的名字一样，有生成，有对抗，两个网络相互博弈。我们两个网络起个名字，第一个网络用来生成数据命名为生成器（generator），另一个网络用来鉴别生成器生成的数据我们命名为鉴别器（discriminator）。
第G1周：生成对抗网络（GAN）入门
geo436872的博客
02-23 1033
GAN（生成对抗网络）是一种神经网络架构，它的设计灵感来自于博弈论的思想。这种网络由两个关键组件组成：生成器（Generator）和判别器（Discriminator）。生成器的任务是从随机噪声中生成与真实数据相似的合成样本，而判别器则负责辨别给定的样本是真实数据还是生成器产生的人工样本。这两个组件通过反复对抗性的训练相互影响和提升。在训练过程中，生成器努力生成越来越逼真的样本，而判别器则不断提高辨别真实与生成样本的能力。
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)
qq_42233059的博客
08-29 7384
深度学习（PyTorch）——生成对抗网络（GAN)
使用PyTorch构建GAN生成对抗网络源码（详细步骤讲解+注释版）01 手写字体识别
Hello Word
01-05 1万+
构建一个生成对抗网络，生成对抗网络可以模拟出新的手写数字数据集。附逐句代码讲解
深度学习（四）：pytorch搭建GAN（对抗网络）
m0_68926749的博客
12-02 1754
生成对抗网络（GAN）是一种深度学习模型，由两个网络组成：生成器（Generator）和判别器（Discriminator）。生成器负责生成假数据，而判别器则负责判断数据是真实的还是 fake的。这两个网络互相竞争，生成器试图生成更真实的数据以欺骗判别器，而判别器则试图更好地识别生成的数据。GAN 的基本思想是：通过训练生成器和判别器，使得生成器能够生成与真实数据非常相似的数据，同时使得判别器能够更有效地识别这些数据。
简单实现基于pytorch的gan网络
qq_43710103的博客
03-07 1042
简单实现基于pytorch的gan网络
pytorch GAN生成对抗网络实例
01-20
我就废话不多说了，直接上代码吧！ import torch import torch.nn as nn from torch.autograd import Variable import numpy as np import matplotlib.pyplot as plt torch.manual_seed(1) np.random.seed(1) ...
基于pytorch实现原版GAN
12-08
基于pytorch实现原版GAN，一个是原本GAN，另一个是使用BCELoss的GAN
基于Pytorch的线性分类网络模型搭建功能实现
最新发布
05-04
本程序实现了对二维数据的创建，以及搭建二维线性分类模型，基于Pytorch，进行网络模型的训练测试，实现了模型的评估测试，并进行分类结果显示,适合Pytorch编程的同学学习。
基于pytorch的分类网络
06-22
包含多种常见的分类网络以及训练测试脚本 analyze_weights_featuremap ConfusionMatrix custom_dataset mini_imagenet model_complexity tensorboard_test 包含网络official_demo alexnet vgg...
用PyTorch代码生成对抗网络（GAN）
gongdiwudu的专栏
07-12 3944
​ 2014年，蒙特利尔大学的伊恩·古德费罗（Ian Goodfellow）和他的同事发表了一篇令人惊叹的论文，向世界介绍了GANs或生成对抗网络。通过计算图和博弈论的创新组合，他们表明，如果有足够的建模能力，相互竞争的两个模型将能够通过普通的旧反向传播进行共同训练。
pytorch中WGAN的实战以及代码注释
tjjyqing的博客
05-15 1984
WGAN 这里是学习过程中WGAN判别八个点高斯分布的实战，代码是照着教学视频抄的，中文注释是自己写的，希望对大家理解有帮助。 import torch from torch import nn, optim, autograd import numpy as np import visdom from torch.nn import functional as F from matplotlib import pyplot as plt import random h_dim = 400 batchsz
【Pytorch深度学习实战】（10）生成对抗网络（GAN）
sikh_0529的博客
09-20 1万+
第一步我们训练D，D是希望V(G, D)越大越好，所以是加上梯度(ascending)。第二步训练G时，V(G, D)越小越好，所以是减去梯度(descending)。假设我们有两个网络，G（Generator）和D（Discriminator）。G可以生成足以“以假乱真”的图片G(z)。对于D来说，它难以判定G生成的图片究竟是不是真实的，因此D(G(z)) = 0.5。这样我们的目的就达成了：我们得到了一个生成式的模型G，它可以用来生成图片。这样，G和D构成了一个动态的“博弈过程”。
GAN实战：以高斯混合模型为例
weixin_62637793的博客
01-19 839
import torch from torch import nn, optim, autograd # autograd 是一个自动求导的包 import numpy as np import visdom import random h_dim = 400 batchsz = 512 viz = visdom.Visdom() # 新建两个网络结构 Generator and Discriminator class Generator(nn.Module): def __init.
机器学习——从0开始构建自己的GAN网络
qq_52222102的博客
06-04 4226
机器学习——从0开始构建自己的GAN网络
从零实现Transformer的简易版与强大版：从300多行到3000多行
结构之法 算法之道
04-12 3万+
transformer强大到什么程度呢，基本是17年之后绝大部分有影响力模型的基础架构都基于的transformer(比如，有200来个，包括且不限于基于decode的GPT、基于encode的BERT、基于encode-decode的T5等等)通过博客内的这篇文章《》，我们已经详细了解了transformer的原理(如果忘了，建议先务必复习下再看本文)
pytorch gan
02-09
PyTorch是一个基于Python的开源机器学习库，它提供了丰富的工具和函数，用于构建和训练深度学习模型。PyTorch的设计理念是简洁、灵活和易于使用，它广泛应用于学术界和工业界。 GAN（生成对抗网络）是一种深度学习...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值