【GAN】基础原理讲解及代码实践

首先什么是ＧＡＮ：

 

 

 

 

 

 

 

 

ＧＡＮ的模型结构

 

设计ＧＡＮ模型的关键：

 

 

 GAN的算法原理：

 

 

 

这里输入噪声的随机性就可以带来生成图像的多样性

 

 

 

 

 GAN公式讲解：

 

 

 

 D（ｘ）表示判别器对真实图片的判别，取对数函数后我们希望其值趋于０，也就是D（ｘ）趋于１，也就是放大损失。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 GAN代码实践(基于jupyter,顺序执行即可):

导包

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt
import torchvision
from torchvision import transformstorch.__version__

数据准备

# 对数据做归一化 （-1， 1）对gan的输入数据全部规范化到（-1，1）之间
transform = transforms.Compose([   #transform做变形transforms.ToTensor(),         # ToTensor会将图像像素值转换为0-1; channel, high, witch,transforms.Normalize(0.5, 0.5) #然后我们通过均值为0.5，方差为0.5将数据规范化到（-1，1）
])train_ds = torchvision.datasets.MNIST('data',train=True,transform=transform,download=True)#定义MNIST数据集dataloader = torch.utils.data.DataLoader(train_ds, batch_size=64, shuffle=True)#加载数据集，打乱，batch_size设置为64
#%%
imgs, _ = next(iter(dataloader))#加载一个批次的图片（64张）
#%%
imgs.shape

 

定义生成器

# 输入是长度为 100 的 噪声（符合正态分布的随机数）
# 输出为（1， 28， 28）的图片
#linear 1 :   100----256
#linear 2:    256----512
#linear 2:    512----28*28
#reshape:     28*28----(1, 28, 28)class Generator(nn.Module):def __init__(self):super(Generator, self).__init__()self.main = nn.Sequential(nn.Linear(100, 256),nn.ReLU(),nn.Linear(256, 512),nn.ReLU(),nn.Linear(512, 28*28),nn.Tanh()                     # 对于-1, 1之间的数据分布，Tanh效果最好。输出的取值范围是-1，1之间)def forward(self, x):              # 前向传播，x 表示长度为100 的noise输入img = self.main(x)#将x输入到main模型中 得到imgimg = img.view(-1, 28, 28)#通过view函数reshape成（-1，28，28，1）return img

 

定义判别器

## 输入为（1， 28， 28）的图片  输出为二分类的概率值，输出使用sigmoid激活 0-1
# BCEloss计算交叉熵损失# nn.LeakyReLU   f(x) : x>0 输出 x， 如果x<0 ,输出 a*x  a表示一个很小的斜率，比如0.1
# 判别器中一般推荐使用 LeakyReLU，RELU激活函数在小于0没有任何梯度，会非常难以训练class Discriminator(nn.Module):def __init__(self):super(Discriminator, self).__init__()#继承父类的属性self.main = nn.Sequential(nn.Linear(28*28, 512),#输入一张图片28,8，然后展平成28*28，再卷积到256nn.LeakyReLU(),nn.Linear(512, 256),nn.LeakyReLU(),nn.Linear(256, 1),nn.Sigmoid())def forward(self, x):#x输入的是28，28的图片x = x.view(-1, 28*28)#展平x = self.main(x)return x

初始化模型、优化器及损失计算函数

device = 'cuda' if torch.cuda.is_available() else 'cpu'#默认使用cuda，否则cpu
#%%
gen = Generator().to(device)#初始化Generator模型
dis = Discriminator().to(device)#初始化Discriminator模型
#%%
d_optim = torch.optim.Adam(dis.parameters(), lr=0.0001)#定义优化器，学习率
g_optim = torch.optim.Adam(gen.parameters(), lr=0.0001)
#%%
loss_fn = torch.nn.BCELoss()#二分类判别模型

绘图函数

def gen_img_plot(model, test_input):#每次都给一个同样的test_input正态分布随机数prediction = np.squeeze(model(test_input).detach().cpu().numpy())#detach用来截断梯度，放到cpu上，转换为numpy，squeeze用于去掉维度为一的值，鲁棒性更高===>28*28的数组fig = plt.figure(figsize=(4, 4))#绘制16张图片for i in range(16):#循环plt.subplot(4, 4, i+1)#四行四列的第一张plt.imshow((prediction[i] + 1)/2)#转换成0，1之间的数值（预测的结果恢复到0，1之间plt.axis('off')#关闭plt.show()
#%%
test_input = torch.randn(16, 100, device=device)#生成长度为100的一个批次16张的随机噪声输入

 

GAN的训练

D_loss = []
G_loss = []#定义空列表用来放两个模型生成的loss
#%%
# 训练循环
for epoch in range(20):#训练20轮d_epoch_loss = 0g_epoch_loss = 0#初始化损失函数为0count = len(dataloader)#返回批次数，len（dataset）返回样本数for step, (img, _) in enumerate(dataloader):#_表示标签，这里生成模型用不到，enumerate用于对dataloader迭代img = img.to(device)#将照片上传到设备上size = img.size(0)#获批次大小根据这个大小来输入我们随机噪声的输入大小random_noise = torch.randn(size, 100, device=device)#生成噪声随机数，大小个数是sized_optim.zero_grad()#将梯度归0real_output = dis(img)      # 判别器输入真实的图片，real_output对真实图片的预测结果 真实图片为1，假图片为0d_real_loss = loss_fn(real_output, torch.ones_like(real_output))      # 得到判别器在真实图像上的损失  ones_like：全1数组d_real_loss.backward()#反向传播，计算梯度gen_img = gen(random_noise)# 判别器输入生成的图片，fake_output对生成图片的预测fake_output = dis(gen_img.detach()) #这里阶段梯度是因为，这里通过对判别器输入生成图片去计算损失是用来优化判别器的。对生成器的参数暂时不做优化。所以梯度不用再传递到生成器模型当中了，我们希望fake_output被判定为0d_fake_loss = loss_fn(fake_output,torch.zeros_like(fake_output))      # 得到判别器在生成图像上的损失，zeros_like：全0数组d_fake_loss.backward()#同样计算梯度#以上是用来优化判别器d_loss = d_real_loss + d_fake_loss#判别器的总损失（两部分）d_optim.step()#进行优化g_optim.zero_grad()#梯度归零fake_output = dis(gen_img)#将生成图片放到判别器当中--不要梯度截断g_loss = loss_fn(fake_output, #我们这里就希望fake_output被判定为1用来优化生成器torch.ones_like(fake_output))      # 生成器的损失g_loss.backward()#计算梯度g_optim.step()#权重优化with torch.no_grad():#两个模型的损失函数做累加（不需要计算梯度）---每个批次累加==一个epochd_epoch_loss += d_lossg_epoch_loss += g_losswith torch.no_grad():#得到平均lossd_epoch_loss /= countg_epoch_loss /= countD_loss.append(d_epoch_loss.item())G_loss.append(g_epoch_loss.item())#这样列表当中会保存每个epoch的平均lossprint('Epoch:', epoch)#打印当前epochgen_img_plot(gen, test_input)#绘图

运行效果