文章目录
- 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 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")
保存的模型文件如下：
4. 什么是GAN（对抗生成网络）?
【详解1】
【详解2】
机器学习的模型大体分为两类：判别模型（Discriminative Model）和生成模型（Generative Model）。
- 判别模型：输入变量，使用模型进行预测
- 生成模型：给出目标的隐含信息，随机产生观测数据。比如：给出一系列猫的图片，来生成一张新的猫的图片。重要点在于“生成”二字。
GAN：适用于无监督学习，该网络的框架由（至少）两个模块构成，即判别模型（Discriminative Model）和生成模型（Generative Model），通过二者的互相博弈学习来产生相当好的输出。
