【Week-G1】调用官方GAN实现MNIST数字识别，Pytorch框架

m_Molly

已于 2024-06-27 10:08:30 修改

阅读量595

点赞数 20

分类专栏： 365天深度学习训练营学习打卡专栏文章标签：生成对抗网络深度学习

于 2024-06-27 10:04:54 首次发布

本文链接：https://blog.csdn.net/qq_40724911/article/details/139937943

版权

365天深度学习训练营学习打卡专栏专栏收录该内容

41 篇文章 4 订阅

订阅专栏

文章目录

1. 准备数据
2. 创建模型
- 2.1 定义鉴别器
- 2.2 定义生成器
3. 训练模型
4. 什么是GAN（对抗生成网络）?

🍨 本文为🔗365天深度学习训练营中的学习记录博客
🍖 原作者：K同学啊 | 接辅导、项目定制

说明：
（1）使用CPU时，屏蔽.cuda()，否则报错：

1. 准备数据

系统环境：
语言：Python3.7.8
编译器：VSCode
深度学习框架：torch 1.13.1

1.1 配置超参数

print("***********1.1 配置超参数*****************")
import argparse
import os
import numpy as np
import torchvision.transforms as transforms
from torchvision.utils import save_image
from torchvision import datasets
from torch.utils.data import DataLoader
from torch.autograd import Variable
import torch.nn as nn
import torch
## 创建文件夹
# 程序在路径 D:\jupyter notebook\DL-100-days\下运行，也就是下方的 ./
os.makedirs("./GAN/G1/images/", exist_ok=True)  # 记录训练过程的图片效果
os.makedirs("./GAN/G1/save/", exist_ok=True)    # 训练完成时，模型的保存位置
os.makedirs("./GAN/G1/mnist/", exist_ok=True)   # 下载数据集存放的位置
## 超参数配置
n_epochs  = 50
batch_size = 64
lr  = 0.0002
b1 = 0.5
b2 = 0.999
n_cpu = 2
latent_dim = 100
img_size = 28
channels = 1
sample_interval = 500
#图像的尺寸（1, 28, 28）,和图像的像素面积（784）
img_shape = (channels, img_size, img_size)
img_area = np.prod(img_shape)
#设置cuda: (cuda:0)
cuda = True if torch.cuda.is_available() else False
print("CUDA: ", cuda)
print("\n")

文件路径如下图：
在这里插入图片描述
使用CPU版本，所以打印的CUDA结果为FALSE；

1.2 下载数据

print("***********2. 下载数据*****************")
mnist = datasets.MNIST(
    root='./datasets/', train=True, download=True, 
    transform=transforms.Compose(
         [transforms.Resize(img_size), 
          transforms.ToTensor(), 
          transforms.Normalize([0.5], [0.5])]),
)
print("\n")

在这里插入图片描述

1.3 配置数据

print("***********1.3 配置数据*****************")
dataloader = DataLoader(
    mnist,
    batch_size=batch_size,
    shuffle=True
)
print("\n")

2. 创建模型

2.1 定义鉴别器

print("***********2. 创建模型********************")
print("***********2.1 定义鉴别器*****************")
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
print("\n")

2.2 定义生成器

print("***********2.2 定义生成器*****************")
class Generate(nn.Module):
    def __init__(self):
        super(Generate, 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):
        imgs = self.model(z)
        imgs = imgs.view(imgs.size(0), *img_shape)
        return imgs
print("\n")

3. 训练模型

3.1 创建实例

print("***********3. 训练模型*****************")
print("***********3.1 创建实例****************")
generator = Generate()
discriminator = Discriminator()
 
criterion = torch.nn.BCELoss()
 
optimizer_G = torch.optim.Adam(generator.parameters(), lr=lr, betas=(b1, b2))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=lr, betas=(b1, b2))
 
if torch.cuda.is_available():
    generator = generator.cuda()
    discriminator = discriminator#.cuda()
    criterion = criterion.cuda()
print("\n")

3.2 开始训练

print("***********3.2 开始训练*****************")
for epoch in range(n_epochs):  # epoch:50
    for i, (imgs, _) in enumerate(dataloader):
 
        ## =============================训练判别器==================
        ## view(): 相当于numpy中的reshape，重新定义矩阵的形状, 相当于reshape(128，784)  原来是(128, 1, 28, 28)
        imgs = imgs.view(imgs.size(0), -1)  # 将图片展开为28*28=784  imgs:(64, 784)
        real_img = Variable(imgs).cuda()  # 将tensor变成Variable放入计算图中，tensor变成variable之后才能进行反向传播求梯度
        real_label = Variable(torch.ones(imgs.size(0), 1))#.cuda()  ## 定义真实的图片label为1
        fake_label = Variable(torch.zeros(imgs.size(0), 1))#.cuda()  ## 定义假的图片的label为0
 
        ## ---------------------
        ##  Train Discriminator
        ## 分为两部分：1、真的图像判别为真；2、假的图像判别为假
        ## ---------------------
        ## 计算真实图片的损失
        real_out = discriminator(real_img)  # 将真实图片放入判别器中
        loss_real_D = criterion(real_out, real_label)  # 得到真实图片的loss
        real_scores = real_out  # 得到真实图片的判别值，输出的值越接近1越好
        ## 计算假的图片的损失
        ## detach(): 从当前计算图中分离下来避免梯度传到G，因为G不用更新
        z = Variable(torch.randn(imgs.size(0), latent_dim))#.cuda()  ## 随机生成一些噪声, 大小为(128, 100)
        fake_img = generator(z).detach()  ## 随机噪声放入生成网络中，生成一张假的图片。
        fake_out = discriminator(fake_img)  ## 判别器判断假的图片
        loss_fake_D = criterion(fake_out, fake_label)  ## 得到假的图片的loss
        fake_scores = fake_out  ## 得到假图片的判别值，对于判别器来说，假图片的损失越接近0越好
        ## 损失函数和优化
        loss_D = loss_real_D + loss_fake_D  # 损失包括判真损失和判假损失
        optimizer_D.zero_grad()  # 在反向传播之前，先将梯度归0
        loss_D.backward()  # 将误差反向传播
        optimizer_D.step()  # 更新参数
 
        ## -----------------
        ##  Train Generator
        ## 原理：目的是希望生成的假的图片被判别器判断为真的图片，
        ## 在此过程中，将判别器固定，将假的图片传入判别器的结果与真实的label对应，
        ## 反向传播更新的参数是生成网络里面的参数，
        ## 这样可以通过更新生成网络里面的参数，来训练网络，使得生成的图片让判别器以为是真的, 这样就达到了对抗的目的
        ## -----------------
        z = Variable(torch.randn(imgs.size(0), latent_dim))#.cuda()  ## 得到随机噪声
        fake_img = generator(z)  ## 随机噪声输入到生成器中，得到一副假的图片
        output = discriminator(fake_img)  ## 经过判别器得到的结果
        ## 损失函数和优化
        loss_G = criterion(output, real_label)  ## 得到的假的图片与真实的图片的label的loss
        optimizer_G.zero_grad()  ## 梯度归0
        loss_G.backward()  ## 进行反向传播
        optimizer_G.step()  ## step()一般用在反向传播后面,用于更新生成网络的参数
 
        ## 打印训练过程中的日志
        ## item():取出单元素张量的元素值并返回该值，保持原元素类型不变
        if (i + 1) % 300 == 0:
            print(
                "[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f] [D real: %f] [D fake: %f]"
                % (epoch, n_epochs, i, len(dataloader), loss_D.item(), loss_G.item(), real_scores.data.mean(),
                   fake_scores.data.mean())
            )
        ## 保存训练过程中的图像
        batches_done = epoch * len(dataloader) + i
        if batches_done % sample_interval == 0:
            save_image(fake_img.data[:25], "./GAN/G1/images/%d.png" % batches_done, nrow=5, normalize=True)
print("\n")

训练结果：

***********3.2 开始训练*****************
[Epoch 0/50] [Batch 299/938] [D loss: 1.363185] [G loss: 1.811396] [D real: 0.922554] [D fake: 0.692913]
[Epoch 0/50] [Batch 599/938] [D loss: 0.753042] [G loss: 2.229975] [D real: 0.815112] [D fake: 0.410212]
[Epoch 0/50] [Batch 899/938] [D loss: 1.049122] [G loss: 1.940738] [D real: 0.789812] [D fake: 0.548839]
... ... ...
[Epoch 48/50] [Batch 299/938] [D loss: 0.956054] [G loss: 1.398938] [D real: 0.661061] [D fake: 0.327662]
[Epoch 48/50] [Batch 599/938] [D loss: 1.070262] [G loss: 0.950201] [D real: 0.538358] [D fake: 0.234096]
[Epoch 48/50] [Batch 899/938] [D loss: 1.012980] [G loss: 1.247620] [D real: 0.650552] [D fake: 0.319423]
[Epoch 49/50] [Batch 299/938] [D loss: 1.254801] [G loss: 1.048441] [D real: 0.522079] [D fake: 0.313869]
[Epoch 49/50] [Batch 599/938] [D loss: 0.884523] [G loss: 1.709880] [D real: 0.767361] [D fake: 0.402201]
[Epoch 49/50] [Batch 899/938] [D loss: 1.019181] [G loss: 1.608823] [D real: 0.739194] [D fake: 0.421154]

./GAN/G1/images/下的缩略图如下：
在这里插入图片描述
部分详细图如下：

3.3 保存模型

print("***********3.3 保存模型*****************")
torch.save(generator.state_dict(), "./GAN/G1/save/generator.pth")
torch.save(discriminator.state_dict(). "./GAN/G1/save/discriminator.pth")
print("\n")