GAN：生成对抗网络，首先是一个生成模型，区别与之前的辨别模型，对抗体现在生成器与辨别器之间的对抗。
生成器输入的是噪音，通过多层的MLP可以产生图片，将产生的图片和真实图片输入到辨别器，辨别器进行分辨生成的图片是否是真实的图片，如果是输出1，不是输出0。
GAN主要的优化公式:
1:固定G，训练D，真实数据x希望被D分为1，生成数据z希望被D分为0。根据log函数性质，如果x被错分为0的话，那么logD(x)就会变为负无穷小。如果生成数据G(z)被错分为1的话，那个log(1-1)也是负无穷小。所以要最大化D。
2：固定D，训练G，第一项没有G，跳过，第二项生成数据G(z)目的是，最理想状态是骗过分辨器D，所以他希望D(G(z))为1，则log0为负无穷小，所以要最大化G。
看一下算法步骤，即如何进行梯度传播。我们可以看到分别对生成器和辨别器进行更新，更新辨别器时同时将真实图片和生成图片输入到辨别器，更新生成器时，将生成的图片输入进去。
1：也就是生成器输入的是噪音，经过多层感知机即linear层后，输入和真实图片大小一样的图片。
2：将真实图片和生成图片共同输入到辨别器进行损失计算。
3：生成器和辨别器各自更新，互不影响。
如何将GAN和CNN结合起来。DCGAN应运而生。
DCGAN将GAN的生成器和辨别器替换为CNN。模型生成器结构：噪声首先经过一个线性层，然后在review为图片，再经过转置卷积进行上采样。
辨别器结构：因为输出的是一个概率，所以最后大小为(Batchsize,1)。生成器产生的图片输入到辨别器然后经过步长为2的卷积进行下采样，不使用池化是因为卷积可以学习如何进行下采样。最后review为2维，经过一个linear层后紧接一个sigmoid获得最终的概率。
且包括一些细节部分：
代码：参考添加链接描述
# -*- coding: utf-8 -*-
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '2'
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import torchvision
from torchvision import transforms
# 加载数据
transform = transforms.Compose([transforms.ToTensor(),
transforms.Normalize(mean=0.5, std=0.5)])
train_ds = torchvision.datasets.MNIST('/home/Projects/ZQB/a/dataset',
train=True,
transform=transform,
download=False)
dataloader = torch.utils.data.DataLoader(train_ds, batch_size=64, shuffle=True)
# 定义生成器
class Generator(nn.Module):
def __init__(self):
super(Generator, self).__init__()
self.linear1 = nn.Linear(100, 256 * 7 * 7)
self.bn1 = nn.BatchNorm1d(256 * 7 * 7)
self.deconv1 = nn.ConvTranspose2d(256, 128,
kernel_size=(3, 3),
stride=1,
padding=1
) # 得到128*7*7的图像
self.bn2 = nn.BatchNorm2d(128)
self.deconv2 = nn.ConvTranspose2d(128, 64,
kernel_size=(4, 4),
stride=2,
padding=1 # 64*14*14
)
self.bn3 = nn.BatchNorm2d(64)
self.deconv3 = nn.ConvTranspose2d(64, 1,
kernel_size=(4, 4),
stride=2,
padding=1 # 1*28*28
)
def forward(self, x):
x = F.relu(self.linear1(x))
x = self.bn1(x)
x = x.view(-1, 256, 7, 7)
x = F.relu(self.deconv1(x))
x = self.bn2(x)
x = F.relu(self.deconv2(x))
x = self.bn3(x)
x = torch.tanh(self.deconv3(x))
return x
# 定义判别器
# input:1，28，28
class Discriminator(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.conv1 = nn.Conv2d(1, 64, kernel_size=3, stride=2) # 第一层不适用bn 64，13，13
self.conv2 = nn.Conv2d(64, 128, kernel_size=3, stride=2) # 128，6，6
self.bn = nn.BatchNorm2d(128)
self.fc = nn.Linear(128 * 6 * 6, 1) # 输出一个概率值
def forward(self, x):
x = F.dropout2d(F.leaky_relu(self.conv1(x)))
x = F.dropout2d(F.leaky_relu(self.conv2(x))) # (batch, 128,6,6)
x = self.bn(x)
x = x.view(-1, 128 * 6 * 6) # (batch, 128,6,6)---> (batch, 128*6*6)
x = torch.sigmoid(self.fc(x))
return x
# 初始化模型
device = 'cuda' if torch.cuda.is_available() else 'cpu'
gen = Generator().to(device)
dis = Discriminator().to(device)
# 损失计算函数
loss_function = torch.nn.BCELoss()
# 定义优化器
d_optim = torch.optim.Adam(dis.parameters(), lr=1e-5)
g_optim = torch.optim.Adam(gen.parameters(), lr=1e-4)
test_input = torch.randn(16, 100, device=device)
# 开始训练
D_loss = []
G_loss = []
# 训练循环
for epoch in range(30):
d_epoch_loss = 0
g_epoch_loss = 0
count = len(dataloader)
# 对全部的数据集做一次迭代
for i, (img, _) in enumerate(dataloader):
img = img.to(device)
size = img.shape[0] # 返回img的第一维的大小
random_noise = torch.randn(size, 100, device=device)
d_optim.zero_grad() # 将上述步骤的梯度归零
real_output = dis(img) # 对判别器输入真实的图片，real_output是对真实图片的预测结果
d_real_loss = loss_function(real_output,torch.ones_like(real_output, device=device))
d_real_loss.backward() # 求解梯度
# 得到判别器在生成图像上的损失
gen_img = gen(random_noise)
fake_output = dis(gen_img.detach())
d_fake_loss = loss_function(fake_output,torch.zeros_like(fake_output, device=device))
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_function(fake_output,torch.ones_like(fake_output, device=device))
g_loss.backward()
g_optim.step()
torchvision.utils.save_image(gen_img,fp='/home/Projects/ZQB/a/DCGAN/DCGAN/result/result'+f"image_{
epoch}.png")
print('Epoch:', epoch)
1：最主要看一下三个损失计算：
判别器两个：真实输出，希望判别器判为1，用torch.ones_like，生成的输出即fake输出，希望判别器输出为0，用torch.zeros_like。
d_real_loss = loss_function(real_output,torch.ones_like(real_output, device=device))
d_fake_loss = loss_function(fake_output,torch.zeros_like(fake_output, device=device))
生成器一个：我们希望生成器输出的图片骗过判别器即希望判别器输出为1，torch.ones_like。
g_loss = loss_function(fake_output,torch.ones_like(fake_output, device=device))
2：生成器和判别器采用各自的优化器和各自的反向传播。
3：训练30代后将生成的结果用grid格式保存下来看一下：:
epoch1：
epoch15:
epoch30:
