G1 GAN生成MNIST手写数字图像

🕗 发布于 2024-10-19 21:53 生成对抗网络 人工智能 神经网络

🍨 本文为🔗365天深度学习训练营中的学习记录博客
🍖 原作者：K同学啊

G1 GAN生成MNIST手写数字图像

1. 生成对抗网络 (GAN) 简介

生成对抗网络 (GAN) 是一种通过“对抗性”学习生成数据的深度学习模型，通常用于生成图像、视频等数据。GAN 由两个网络组成：

生成器 (Generator)：用于生成假的数据样本，试图让判别器无法分辨其为假的。
判别器 (Discriminator)：用于区分输入的数据是真实的还是生成器生成的。

GAN 的核心思想是，生成器和判别器通过相互对抗学习，生成器逐渐提高生成逼真数据的能力，而判别器逐渐提高区分真假数据的能力。最后，生成器生成的样本与真实样本之间的差异会越来越小。

GAN 的基本流程

判别器输入真实数据，判别器输出一个接近1的值，表示为真；
生成器生成假的数据，并试图欺骗判别器；
判别器输出接近0的值，表示为假；
生成器通过更新自身的参数，试图让判别器认为生成的数据是真实的。

GAN 的目标是使得生成器生成的假数据，能骗过判别器。

GAN 的损失函数

GAN 的训练目标是让生成器和判别器进行对抗训练，其损失函数分为两个部分：生成器损失和判别器损失。生成器的目标是最大化判别器判断生成数据为真的概率，判别器的目标是最大化正确判断真实数据和生成数据的概率。

判别器的损失函数定义为：

$\mathcal{L}_D = - \left[ \mathbb{E}_{x \sim p_{\text{data}}} \left[ \log D(x) \right] + \mathbb{E}_{z \sim p_z} \left[ \log (1 - D(G(z))) \right] \right]$

生成器的损失函数定义为：

$\mathcal{L}_G = - \mathbb{E}_{z \sim p_z} \left[ \log D(G(z)) \right]$

其中：

( D(x) ) 表示判别器对真实数据 ( x ) 判别为真的概率；
( G(z) ) 是生成器通过噪声 ( z ) 生成的假数据；
( D(G(z)) ) 表示判别器对生成器生成数据的输出（希望趋向于1）。

2. PyTorch 实现

下面使用 PyTorch 实现 GAN 生成 MNIST 手写数字图像。

2.1 导入库与超参数设置

import os
import numpy as np
import torch
import torch.nn as nn
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
from torchvision.utils import save_image

# 创建文件夹
os.makedirs('./output/images/', exist_ok=True)

# 超参数设置
n_epochs = 50
batch_size = 64
lr = 0.0002
latent_dim = 100
img_size = 28
channels = 1
img_shape = (channels, img_size, img_size)
img_area = np.prod(img_shape)

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

2.2 数据预处理

使用 torchvision.datasets.MNIST 下载并处理 MNIST 数据集。数据会被标准化到 [-1, 1] 区间，并通过 DataLoader 转化为可迭代数据集。

# 下载MNIST数据集并进行预处理
mnist = datasets.MNIST(root='./data', train=True, download=True,
                       transform=transforms.Compose([
                           transforms.Resize(img_size),
                           transforms.ToTensor(),
                           transforms.Normalize([0.5], [0.5])
                       ]))

dataloader = DataLoader(mnist, batch_size=batch_size, shuffle=True)

2.3 定义生成器模型

生成器接受一个随机噪声向量 ( z )，通过多层线性变换和激活函数逐步生成一个 28x28 的图像。

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(latent_dim, 128, normalize=False),
            *block(128, 256),
            *block(256, 512),
            *block(512, 1024),
            nn.Linear(1024, img_area),
            nn.Tanh()
        )

    def forward(self, z):
        img = self.model(z)
        return img.view(img.size(0), *img_shape)

2.4 定义判别器模型

判别器是一个二分类网络，输入一个 28x28 的图像，输出一个表示真假概率的值。

class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.model = nn.Sequential(
            nn.Linear(img_area, 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

2.5 定义优化器与损失函数

generator = Generator()
discriminator = Discriminator()

# 定义损失函数
criterion = nn.BCELoss()

# 定义生成器和判别器的优化器
optimizer_G = torch.optim.Adam(generator.parameters(), lr=lr, betas=(0.5, 0.999))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=lr, betas=(0.5, 0.999))

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

2.6 训练过程

2.6.1 训练判别器

判别器需要区分真实图像和生成的假图像，通过两个损失值相加，更新判别器的参数。

real_img = Variable(imgs.type(torch.cuda.FloatTensor))
real_label = Variable(torch.ones(imgs.size(0), 1).cuda())
fake_label = Variable(torch.zeros(imgs.size(0), 1).cuda())

real_out = discriminator(real_img)
loss_real = criterion(real_out, real_label)

z = Variable(torch.randn(imgs.size(0), latent_dim).cuda())
fake_img = generator(z).detach()
fake_out = discriminator(fake_img)
loss_fake = criterion(fake_out, fake_label)

loss_D = loss_real + loss_fake
optimizer_D.zero_grad()
loss_D.backward()
optimizer_D.step()

2.6.2 训练生成器

生成器的目标是让判别器认为生成的数据是真实的，因此生成器的损失是判别器对假图像的输出。

z = Variable(torch.randn(imgs.size(0), latent_dim).cuda())
fake_img = generator(z)
output = discriminator(fake_img)

loss_G = criterion(output, real_label)
optimizer_G.zero_grad()
loss_G.backward()
optimizer_G.step()

在这里插入图片描述

2.7 保存与可视化生成图像

if batches_done % sample_interval == 0:
    save_image(fake_img.data[:25], "./output/images/%d.png" % batches_done, nrow=5, normalize=True)

在这里插入图片描述

4. 总结

这周学习了如何使用 PyTorch 实现生成对抗网络 (GAN) 来生成 MNIST 手写数字图像。GAN 通过生成器与判别器之间的对抗学习，不断提升生成图像的质量，是一种非常强大的生成模型。可以在论文中将其作为数据增强的一种方式。

原文地址：https://blog.csdn.net/tjl521314_21/article/details/142961358

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Android OpenGL高度图
下一篇：centos 安装达梦数据库

【python3】函数注解
函数注解是 Python 的一种特性，用于为函数的参数和返回值添加元数据。注解通常和类型提示（type hinting）相关联，但它们本质上不会影响程序的实际执行，只是作为一种信息记录。从Python
阅读更多2024-10-19
linux和端口相关的命令总结
在Linux中，端口管理和网络相关操作是非常常见的任务。
阅读更多2024-10-19
【服务器部署】Docker部署小程序
我是虚拟机装的Centos7，linux 3.10 内核，docker官方说至少3.8以上，建议3.10以上（ubuntu下要linux内核3.8以上， RHEL/Centos 的内核修补过， cen
阅读更多2024-10-19
基于Java实现（PC）大学班级事务管理系统
本次设计要求利用 Java 实现 C/S 模式的大学班级内日常事务管理系统（PC 版，应用于校内网有线网络访问，暂不开发移动端），不得依赖现有的建模框架，使用 swings 技术完成如下基本功能需求：
阅读更多2024-10-19
JMeter如何设置HTTP代理服务器？
JMeter如何设置HTTP代理服务器？
阅读更多2024-10-19
多级缓存-案例导入说明
为了演示多级缓存，我们先导入一个商品管理的案例，其中包含商品的CRUD功能。我们将来会给查询商品添加多级缓存。
阅读更多2024-10-19
python爬虫之使用 Beautiful Soup
是一个非常强大的工具，可以方便地解析和提取网页中的数据。通过结合requests库，你可以构建功能强大的爬虫。希望这个教程对你有所帮助，祝你顺利完成爬虫任务！
阅读更多2024-10-19
.NET 6 API + Middleware + Audit rail
.NET 6 API 利用中间件Middleware记录操作日志
阅读更多2024-10-19
[Linux#67][IP] 报头详解 | 网络划分 | CIDR无类别 | DHCP动态分配 | NAT转发 | 路由器
本文深入浅出地介绍了IP协议头格式、网络通信原理以及全球网络架构，帮助读者建立起对互联网工作方式的全面认识。从基本的IP地址划分到复杂的运营商网络角色，逐步揭开网络世界的神秘面纱。
阅读更多2024-10-19
spring jpa代码生成器
【代码】spring jpa代码生成器。
阅读更多2024-10-19

G1 GAN生成MNIST手写数字图像