图像生成：Pytorch实现一个简单的对抗生成网络模型

最新推荐文章于 2024-09-29 21:21:25 发布
最新推荐文章于 2024-09-29 21:21:25 发布
阅读量1.5k 收藏 32
点赞数 13
分类专栏： 人工智能应用 文章标签： pytorch 网络 人工智能 生成对抗网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/friendshiptang/article/details/137604437
版权
本文详细介绍了如何使用PyTorch实现一个简单的对抗生成网络，包括准备数据集、定义生成器和判别器结构，以及定义损失函数和优化器。通过训练过程展示了GAN在图像生成中的应用。
摘要由CSDN通过智能技术生成

图像生成：Pytorch实现一个简单的对抗生成网络模型

前言

相关介绍

对抗生成网络（Adversarial Generative Networks，简称GANs）是由伊恩·古德费洛（Ian Goodfellow）等人在2014年提出的深度学习框架，主要用于无监督学习中的数据生成任务。GAN的设计灵感来源于博弈论中的极小极大游戏，在机器学习领域开辟了一种全新的生成模型方法。

GAN包含两个主要组成部分：

  1. 生成器（Generator, G）：

    • 生成器G是一个神经网络，它的功能是从随机噪声向量（通常来自高斯分布或其他先验分布）出发，通过一系列变换来生成新的数据样本，这些样本应该尽可能接近于训练数据的真实分布。
    • G的目标是尽可能地“欺骗”判别器，使其无法区分生成的数据和真实数据。

  2. 判别器（Discriminator, D）：

    • 判别器D也是一个神经网络，它的作用是接收输入的样本，并将其分类为“真”（来自真实数据分布）或“假”（来自生成器产生的分布）。
    • D的目标是准确地区分真实数据和伪造数据，从而提高自身鉴别能力。

训练过程中，GAN采用了极小极大博弈策略，具体步骤如下：

  • 先固定判别器参数，更新生成器参数以使得生成的数据更有可能被判别器误认为真实数据；
  • 再固定生成器参数，更新判别器参数以更好地区分真实数据和生成器生成的伪数据。

这种交替优化的方式促使两个网络性能不断提升，直到达到纳什均衡，此时生成器能够生成非常逼真的新样本，而判别器再也无法有效区分真实数据和生成数据。

GAN在图像生成、图像到图像转换、视频生成、音频合成等多个领域都取得了显著成果，并且随着研究的深入，衍生出了许多改进版本和变体，比如条件GAN（Conditional GANs）、 Wasserstein GAN（WGAN）、CycleGAN等，进一步提高了生成效果并拓展了应用范围。
在这里插入图片描述

具体步骤

准备并读取数据集

以mnist数据集为例。

# Configure data loader
os.makedirs("./data/mnist", exist_ok=True)
dataloader = torch.utils.data.DataLoader(
    datasets.MNIST(
        "./data/mnist",
        train=True,
        download=True,
        transform=transforms.Compose(
            [transforms.Resize(opt.img_size), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]
        ),
    ),
    batch_size=opt.batch_size,
    shuffle=True,
)

定义生成器

class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()

        def block(in_feat, out_feat, normalize=True):
            layers = [nn.Linear(in_feat, out_feat)]
            if normalize:
                layers.append(nn.BatchNorm1d(out_feat, 0.8))
            layers.append(nn.LeakyReLU(0.2, inplace=True))
            return layers

        self.model = nn.Sequential(
            *block(opt.latent_dim, 128, normalize=False),
            *block(128, 256),
            *block(256, 512),
            *block(512, 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), *img_shape)
        return img

定义判别器

class Discriminator(nn.Module):
    def __init__(self):
        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

定义损失函数

# Loss function
adversarial_loss = torch.nn.BCELoss()

定义优化器

# Optimizers
optimizer_G = torch.optim.Adam(generator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))

开始训练

# ----------
#  Training
# ----------

for epoch in range(opt.n_epochs):
    for i, (imgs, _) in enumerate(dataloader):

        # Adversarial ground truths
        valid = Variable(Tensor(imgs.size(0), 1).fill_(1.0), requires_grad=False)
        fake = Variable(Tensor(imgs.size(0), 1).fill_(0.0), requires_grad=False)

        # Configure input
        real_imgs = Variable(imgs.type(Tensor))

        # -----------------
        #  Train Generator
        # -----------------

        optimizer_G.zero_grad()

        # Sample noise as generator input
        z = Variable(Tensor(np.random.normal(0, 1, (imgs.shape[0], opt.latent_dim))))

        # Generate a batch of images
        gen_imgs = generator(z)

        # Loss measures generator's ability to fool the discriminator
        # 生成器损失，目的是生成的图像，逼近真是图像，是判别器认为是真
        g_loss = adversarial_loss(discriminator(gen_imgs), valid)

        g_loss.backward()
        optimizer_G.step()

        # ---------------------
        #  Train Discriminator
        # ---------------------

        optimizer_D.zero_grad()

        # Measure discriminator's ability to classify real from generated samples
        # 真实图像在判别器的目标函数损失，即判别器应该判为真
        real_loss = adversarial_loss(discriminator(real_imgs), valid)
        # 生成器生成出来的图像在判别器的目标函数损失，即判别器应该判为假
        fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
        # 判别器损失，目的是判别生成的图像是假
        d_loss = (real_loss + fake_loss) / 2

        d_loss.backward()
        optimizer_D.step()

        print(
            "[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]"
            % (epoch, opt.n_epochs, i, len(dataloader), d_loss.item(), g_loss.item())
        )

完整代码

import argparse
import os
import numpy as np
import math

import torchvision.transforms as transforms
from torchvision.utils import save_image

from torch.utils.data import DataLoader
from torchvision import datasets
from torch.autograd import Variable

import torch.nn as nn
import torch.nn.functional as F
import torch

os.makedirs("images", exist_ok=True)

parser = argparse.ArgumentParser()
parser.add_argument("--n_epochs", type=int, default=100, help="number of epochs of training")
parser.add_argument("--batch_size", type=int, default=128, help="size of the batches")
parser.add_argument("--lr", type=float, default=0.0002, help="adam: learning rate")
parser.add_argument("--b1", type=float, default=0.5, help="adam: decay of first order momentum of gradient")
parser.add_argument("--b2", type=float, default=0.999, help="adam: decay of first order momentum of gradient")
parser.add_argument("--n_cpu", type=int, default=8, help="number of cpu threads to use during batch generation")
parser.add_argument("--latent_dim", type=int, default=100, help="dimensionality of the latent space")
parser.add_argument("--img_size", type=int, default=28, help="size of each image dimension")
parser.add_argument("--channels", type=int, default=1, help="number of image channels")
parser.add_argument("--sample_interval", type=int, default=400, help="interval betwen image samples")
opt = parser.parse_args()
print(opt)

img_shape = (opt.channels, opt.img_size, opt.img_size)

cuda = True if torch.cuda.is_available() else False


class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()

        def block(in_feat, out_feat, normalize=True):
            layers = [nn.Linear(in_feat, out_feat)]
            if normalize:
                layers.append(nn.BatchNorm1d(out_feat, 0.8))
            layers.append(nn.LeakyReLU(0.2, inplace=True))
            return layers

        self.model = nn.Sequential(
            *block(opt.latent_dim, 128, normalize=False),
            *block(128, 256),
            *block(256, 512),
            *block(512, 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), *img_shape)
        return img


class Discriminator(nn.Module):
    def __init__(self):
        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


# Loss function
adversarial_loss = torch.nn.BCELoss()

# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()

if cuda:
    generator.cuda()
    discriminator.cuda()
    adversarial_loss.cuda()

# Configure data loader
os.makedirs("./data/mnist", exist_ok=True)
dataloader = torch.utils.data.DataLoader(
    datasets.MNIST(
        "./data/mnist",
        train=True,
        download=True,
        transform=transforms.Compose(
            [transforms.Resize(opt.img_size), transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]
        ),
    ),
    batch_size=opt.batch_size,
    shuffle=True,
)

# Optimizers
optimizer_G = torch.optim.Adam(generator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))


Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor

# ----------
#  Training
# ----------

for epoch in range(opt.n_epochs):
    for i, (imgs, _) in enumerate(dataloader):

        # Adversarial ground truths
        valid = Variable(Tensor(imgs.size(0), 1).fill_(1.0), requires_grad=False)
        fake = Variable(Tensor(imgs.size(0), 1).fill_(0.0), requires_grad=False)

        # Configure input
        real_imgs = Variable(imgs.type(Tensor))

        # -----------------
        #  Train Generator
        # -----------------

        optimizer_G.zero_grad()

        # Sample noise as generator input
        z = Variable(Tensor(np.random.normal(0, 1, (imgs.shape[0], opt.latent_dim))))

        # Generate a batch of images
        gen_imgs = generator(z)

        # Loss measures generator's ability to fool the discriminator
        g_loss = adversarial_loss(discriminator(gen_imgs), valid)

        g_loss.backward()
        optimizer_G.step()

        # ---------------------
        #  Train Discriminator
        # ---------------------

        optimizer_D.zero_grad()

        # Measure discriminator's ability to classify real from generated samples
        real_loss = adversarial_loss(discriminator(real_imgs), valid)
        fake_loss = adversarial_loss(discriminator(gen_imgs.detach()), fake)
        d_loss = (real_loss + fake_loss) / 2

        d_loss.backward()
        optimizer_D.step()

        print(
            "[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]"
            % (epoch, opt.n_epochs, i, len(dataloader), d_loss.item(), g_loss.item())
        )

        batches_done = epoch * len(dataloader) + i
        if batches_done % opt.sample_interval == 0:
            save_image(gen_imgs.data[:25], "images/%d.png" % batches_done, nrow=5, normalize=True)

在这里插入图片描述

训练生成的图片

在这里插入图片描述

PyTorch深度学习实战（33）——生成对抗网络(Generative Adversarial Network, GAN)
盼小辉丶的博客
01-22 3986
生成对抗网络 (Generative Adversarial Networks, GAN) 是一种由两个相互竞争的神经网络组成的深度学习模型，它由一个生成网络和一个判别网络组成，通过彼此之间的博弈来提高生成网络的性能。生成对抗网络使用神经网络生成与原始图像集非常相似的新图像，它在图像生成中应用广泛，且 GAN 的相关研究正在迅速发展，以生成与真实图像难以区分的逼真图像。在本节中，我们将学习 GAN 网络的原理并使用 PyTorch 实现 GAN。
Python-一个简单的PyTorch实现生成式对抗网络专注于动画脸部绘图
08-10
一个简单的PyTorch实现生成式对抗网络，专注于动画脸部绘图。A simple PyTorch Implementation of Generative Adversarial Networks, focusing on anime face drawing。
【PyTorch】生成对抗网络
最新发布
Glass_Gun的博客
09-29 980
Generative Adversarial Nets，简称GANGAN：生成对抗网络 —— 一种可以生成的模型。
PyTorch--生成对抗网络（GAN）
weixin_43384504的博客
11-25 324
在没了解它之前，我大概的印象就是它可以为我们创造更多的数据。 用数学方式阐述训练算法： 1.初始化生成器的参数+鉴别器的参数 2.每次迭代执行下面的参数： 前4步是升级鉴别器，后面两步是升级生成器； 不想知道这个其中的原理，我只是使用，如有需要，再来仔细探究。 ...
【PyTorch】生成对抗网络/GAN(generative adversarial network)
积流成河
04-22 784
模型介绍
【Pytorch】生成对抗网络实战
Frost_Descent的博客
08-26 2501
GAN框架是基于两个模型的竞争，generator生成器和discriminator鉴别器。生成器生成假图像，鉴别器尝试从假图像中识别真实的图像。作为这种竞争的结果，生成器将生成更好看的假图像，而鉴别器将更好地识别它们。定义生成器模型# 获取参数# 定义反卷积层1# 定义批归一化层1# 定义反卷积层2# 定义批归一化层2# 定义反卷积层3# 定义批归一化层3# 定义反卷积层4# 定义批归一化层4# 定义反卷积层5# 前向传播# 反卷积层1# 反卷积层2# 反卷积层3。
探索对抗之美：PyTorch中生成对抗网络（GAN）的实现
07-19
通过以上步骤，我们可以在PyTorch中成功实现并训练一个简单的GAN模型。需要注意的是，在实际应用中，还需要考虑更多的细节，比如数据预处理、更复杂的网络结构、超参数调优等，以获得更好的生成效果。
基于Pytorch实现对偶生成对抗网络来实现图像去雾python源码+文档说明+模型.zip
03-24
基于Pytorch实现对偶生成对抗网络来实现图像去雾python源码+文档说明+模型.zip使用说明 DualGan含有两个生成器和辨别器 本项目中为同样结构，生成器为U-Net，辨别器为PatchGan的辨别器 G_A：有雾生成无雾 G_B: 无雾...
使用Pytorch实现对偶生成对抗网络来实现图像去雾
06-05
【作品名称】：使用Pytorch实现对偶生成对抗网络来实现图像去雾 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： 使用...
PyTorch生成对抗网络编程
07-14
PyTorch生成对抗网络编程（畅销书《Python神经网络编程》作者最新力作！用PyTorch构建自己的生成对抗网络） by 塔里克·拉希德
基于Pytorch实现对偶生成对抗网络来实现图像去雾python源码+项目说明+代码注释.zip
05-16
基于Pytorch实现对偶生成对抗网络来实现图像去雾python源码+项目说明+代码注释.zip 【资源介绍】 DualGan含有两个生成器和辨别器 本项目中为同样结构，生成器为U-Net，辨别器为PatchGan的辨别器 G_A：有雾生成无雾 G...
深度学习（PyTorch）——生成对抗网络（GAN)
qq_42233059的博客
08-29 7570
深度学习（PyTorch）——生成对抗网络（GAN)
pytorch基础（十一）- 生成对抗网络
sherryhwang的博客
05-25 1929
目录生成对抗网络原理纳什均衡JS散度的缺陷EM距离 生成对抗网络原理 我们无法知道数据的真实分布是什么，如何用数学公式表达； 纳什均衡 JS散度的缺陷 EM距离
用PyTorch代码生成对抗网络（GAN）
gongdiwudu的专栏
07-12 6821
​ 2014年，蒙特利尔大学的伊恩·古德费罗（Ian Goodfellow）和他的同事发表了一篇令人惊叹的论文，向世界介绍了GANs或生成对抗网络。通过计算图和博弈论的创新组合，他们表明，如果有足够的建模能力，相互竞争的两个模型将能够通过普通的旧反向传播进行共同训练。
基于PyTorch的生成对抗网络入门（1）——利用PyTorch搭建入门生成对抗网络（GAN）超详解
Wendy的博客
11-18 1393
目录一、案例描述二、代码详解2.1 构建真是数据集2.2 构建判别器 一、案例描述 我们首先从一个简单的GAN开始实现，利用生成器学习创建符合1010格式规律的值，这个任务比生成图像更简单。通过这个基础任务，我们可以了解GAN的基本框架和PyTorch编程的基本思路。 二、代码详解 2.1 构建真是数据集 真实数据集是一个一直返回1010格式规律的数据的函数： # 真实数据集 def generate_real(): real_data=torch.FloatTensor([1,0,1,0])
Pytorch | 基于Pytorch的生成对抗网络
若北辰
07-27 404
y.backward() 是用于计算梯度的，也就是y对x的导数，dy/dx，计算当x=3.5时的值。但实际上requires_grad=True告诉了pytorch我们需要得到一个关于x的梯度。pytorch将这些张量连成一幅图，以展示这些张量是如何连接的，这幅图就叫做。这行代码除了计算出梯度外，并将梯度与x的实际值一同存储在x中。希望知道z随y的变化情况，就需要知道梯度： dz/dx。输出只多了一些东西，但是仍然是我们想要的结果。当x=3.5时，z=14。
使用 Pytorch 生成对抗性网络(GANs) | 附完整代码链接
Warmer_Sweeter
02-19 3354
欢迎关注“小白玩转Python”，发现更多 “有趣”2014年，Ian Goodfellow 和他在蒙特利尔大学的同事们发表了一篇令人惊叹的论文，向世界介绍了 GANs)，即生成对抗性网...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FriendshipT

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值