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

文章目录

1. 准备数据
- 1.1 配置超参数
- 1.2 下载数据
- 1.3 配置数据
2. 创建模型
- 2.1 定义鉴别器
- 2.2 定义生成器
3. 训练模型
- 3.1 创建实例
- 3.2 开始训练
- 3.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 layersself.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:50for 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为1fake_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)  # 得到真实图片的lossreal_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)  ## 得到假的图片的lossfake_scores = fake_out  ## 得到假图片的判别值，对于判别器来说，假图片的损失越接近0越好## 损失函数和优化loss_D = loss_real_D + loss_fake_D  # 损失包括判真损失和判假损失optimizer_D.zero_grad()  # 在反向传播之前，先将梯度归0loss_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的lossoptimizer_G.zero_grad()  ## 梯度归0loss_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) + iif 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")