刚好看到了论文，里面提到了VAE（变分自编码机）然后读相关材料，看到VAE和GAN有点像
于是阅读了解GAN

原理

GAN的目标只有一个：从给定的一个分布里，生成目标分布
已有材料

  1. 现有的一个分布
  2. 目标分布的若干样本

从已有材料和训练目的可以显然得到我们需要一个生成器，生成所谓的目标分布数据。
显然我们需要一个标准评定生成的质量，并作为生成器训练的损失。
但是人工构造的存在一定的问题。

于是用一个生成器，从给定分布计算出“虚构样本”，和目标分布的样本分别为正例和负例，让判别器学习。

原理：

示例

原理里讲的还是很理论化的，同时讲的是WGAN-GP，和简单的GAN也不大一样。于是找到例子：
写的灰常好，很简洁，还有很多注释

不过有一个点：看到很多实现在训练判别器的时候，生成伪造数据的时候用了Detach，其实应该是没有必要的，唯一的优点就是可能跑的比较快。因为两个参数是分开用两个不同的Optimizer优化的，在训练生成器的时候，伪造数据和错误标签的时候，也是不希望更新判别器的，但是没有单独的detach。

  1. # coding=utf-8
  2. import torch.autograd
  3. import torch.nn as nn
  4. from torch.autograd import Variable
  5. from torchvision import transforms
  6. from torchvision import datasets
  7. from torchvision.utils import save_image
  8. import os
  10. # 创建文件夹
  11. if not os.path.exists('./img'):
  12.     os.mkdir('./img')
  15. def to_img(x):
  16.     out = 0.5 * (x + 1)
  17.     out = out.clamp(0, 1)  # Clamp函数可以将随机变化的数值限制在一个给定的区间[min, max]内：
  18.     out = out.view(-1, 1, 28, 28)  # view()函数作用是将一个多行的Tensor,拼接成一行
  19.     return out
  22. batch_size = 128
  23. num_epoch = 100
  24. z_dimension = 100
  25. # 图像预处理
  26. img_transform = transforms.Compose([
  27.     transforms.ToTensor(),
  28.     transforms.Normalize((0.5,), (0.5,))  # (x-mean) / std
  29. ])
  31. # mnist dataset mnist数据集下载
  32. mnist = datasets.MNIST(
  33.     root='./data/', train=True, transform=img_transform, download=True
  34. )
  36. # data loader 数据载入
  37. dataloader = torch.utils.data.DataLoader(
  38.     dataset=mnist, batch_size=batch_size, shuffle=True
  39. )
  42. # 定义判别器  #####Discriminator######使用多层网络来作为判别器
  43. # 将图片28x28展开成784，然后通过多层感知器，中间经过斜率设置为0.2的LeakyReLU激活函数，
  44. # 最后接sigmoid激活函数得到一个0到1之间的概率进行二分类。
  45. class discriminator(nn.Module):
  46.     def __init__(self):
  47.         super(discriminator, self).__init__()
  48.         self.dis = nn.Sequential(
  49.             nn.Linear(784, 256),  # 输入特征数为784，输出为256
  50.             nn.LeakyReLU(0.2),  # 进行非线性映射
  51.             nn.Linear(256, 256),  # 进行一个线性映射
  52.             nn.LeakyReLU(0.2),
  53.             nn.Linear(256, 1),
  54.             nn.Sigmoid()  # 也是一个激活函数，二分类问题中，
  55.             # sigmoid可以班实数映射到【0,1】，作为概率值，
  56.             # 多分类用softmax函数
  57.         )
  59.     def forward(self, x):
  60.         x = self.dis(x)
  61.         return x
  64. # ###### 定义生成器 Generator #####
  65. # 输入一个100维的0～1之间的高斯分布，然后通过第一层线性变换将其映射到256维,
  66. # 然后通过LeakyReLU激活函数，接着进行一个线性变换，再经过一个LeakyReLU激活函数，
  67. # 然后经过线性变换将其变成784维，最后经过Tanh激活函数是希望生成的假的图片数据分布
  68. # 能够在-1～1之间。
  69. class generator(nn.Module):
  70.     def __init__(self):
  71.         super(generator, self).__init__()
  72.         self.gen = nn.Sequential(
  73.             nn.Linear(100, 256),  # 用线性变换将输入映射到256维
  74.             nn.ReLU(True),  # relu激活
  75.             nn.Linear(256, 256),  # 线性变换
  76.             nn.ReLU(True),  # relu激活
  77.             nn.Linear(256, 784),  # 线性变换
  78.             nn.Tanh()  # Tanh激活使得生成数据分布在【-1,1】之间，因为输入的真实数据的经过transforms之后也是这个分布
  79.         )
  81.     def forward(self, x):
  82.         x = self.gen(x)
  83.         return x
  86. # 创建对象
  87. D = discriminator()
  88. G = generator()
  89. if torch.cuda.is_available():
  90.     D = D.cuda()
  91.     G = G.cuda()
  94. # 首先需要定义loss的度量方式  （二分类的交叉熵）
  95. # 其次定义 优化函数,优化函数的学习率为0.0003
  96. criterion = nn.BCELoss()  # 是单目标二分类交叉熵函数
  97. d_optimizer = torch.optim.Adam(D.parameters(), lr=0.0003)
  98. g_optimizer = torch.optim.Adam(G.parameters(), lr=0.0003)
  100. # ##########################进入训练##判别器的判断过程#####################
  101. for epoch in range(num_epoch):  # 进行多个epoch的训练
  102.     for i, (img, _) in enumerate(dataloader):
  103.         num_img = img.size(0)
  104.         # view()函数作用是将一个多行的Tensor,拼接成一行
  105.         # 第一个参数是要拼接的tensor,第二个参数是-1
  106.         # =============================训练判别器==================
  107.         img = img.view(num_img, -1)  # 将图片展开为28*28=784
  108.         real_img = Variable(img).cuda()  # 将tensor变成Variable放入计算图中
  109.         real_label = Variable(torch.ones(num_img)).cuda()  # 定义真实的图片label为1
  110.         fake_label = Variable(torch.zeros(num_img)).cuda()  # 定义假的图片的label为0
  112.         # ########判别器训练train#####################
  113.         # 分为两部分：1、真的图像判别为真；2、假的图像判别为假
  114.         # 计算真实图片的损失
  115.         real_out = D(real_img)  # 将真实图片放入判别器中
  116.         real_label = real_label.reshape(-1,1)
  117.         #print(real_out.shape,real_label.shape)
  119.         d_loss_real = criterion(real_out, real_label)  # 得到真实图片的loss
  120.         real_scores = real_out  # 得到真实图片的判别值，输出的值越接近1越好
  121.         # 计算假的图片的损失
  122.         z = Variable(torch.randn(num_img, z_dimension)).cuda()  # 随机生成一些噪声
  123.         fake_img = G(z).detach()  # 随机噪声放入生成网络中，生成一张假的图片。 # 避免梯度传到G，因为G不用更新, detach分离
  124.         fake_out = D(fake_img)  # 判别器判断假的图片，
  125.         fake_label = fake_label.reshape(-1,1)
  126.         d_loss_fake = criterion(fake_out, fake_label)  # 得到假的图片的loss
  127.         fake_scores = fake_out  # 得到假图片的判别值，对于判别器来说，假图片的损失越接近0越好
  128.         # 损失函数和优化
  129.         d_loss = d_loss_real + d_loss_fake  # 损失包括判真损失和判假损失
  130.         d_optimizer.zero_grad()  # 在反向传播之前，先将梯度归0
  131.         d_loss.backward()  # 将误差反向传播
  132.         d_optimizer.step()  # 更新参数
  134.         # ==================训练生成器============================
  135.         # ###############################生成网络的训练###############################
  136.         # 原理：目的是希望生成的假的图片被判别器判断为真的图片，
  137.         # 在此过程中，将判别器固定，将假的图片传入判别器的结果与真实的label对应，
  138.         # 反向传播更新的参数是生成网络里面的参数，
  139.         # 这样可以通过更新生成网络里面的参数，来训练网络，使得生成的图片让判别器以为是真的
  140.         # 这样就达到了对抗的目的
  141.         # 计算假的图片的损失
  142.         z = Variable(torch.randn(num_img, z_dimension)).cuda()  # 得到随机噪声
  143.         fake_img = G(z)  # 随机噪声输入到生成器中，得到一副假的图片
  144.         output = D(fake_img)  # 经过判别器得到的结果
  145.         g_loss = criterion(output, real_label)  # 得到的假的图片与真实的图片的label的loss
  146.         # bp and optimize
  147.         g_optimizer.zero_grad()  # 梯度归0
  148.         g_loss.backward()  # 进行反向传播
  149.         g_optimizer.step()  # .step()一般用在反向传播后面,用于更新生成网络的参数
  151.         # 打印中间的损失
  152.         if (i + 1) % 100 == 0:
  153.             print('Epoch[{}/{}],d_loss:{:.6f},g_loss:{:.6f} '
  154.                   'D real: {:.6f},D fake: {:.6f}'.format(
  155.                 epoch, num_epoch, d_loss.data.item(), g_loss.data.item(),
  156.                 real_scores.data.mean(), fake_scores.data.mean()  # 打印的是真实图片的损失均值
  157.             ))
  158.         if epoch == 0:
  159.             real_images = to_img(real_img.cpu().data)
  160.             save_image(real_images, './img/real_images.png')
  161.     fake_images = to_img(fake_img.cpu().data)
  162.     save_image(fake_images, './img/fake_images-{}.png'.format(epoch + 1))
  164. # 保存模型
  165. torch.save(G.state_dict(), './generator.pth')
  166. torch.save(D.state_dict(), './discriminator.pth')

结果

epoch 1，40，100：
image.pngimage.pngimage.png