Pytorch使用MNIST数据集实现基础GAN和DCGAN详解


Posted in Python onJanuary 10, 2020

原始生成对抗网络Generative Adversarial Networks GAN包含生成器Generator和判别器Discriminator,数据有真实数据groundtruth,还有需要网络生成的“fake”数据,目的是网络生成的fake数据可以“骗过”判别器,让判别器认不出来,就是让判别器分不清进入的数据是真实数据还是fake数据。总的来说是:判别器区分真实数据和fake数据的能力越强越好;生成器生成的数据骗过判别器的能力越强越好,这个是矛盾的,所以只能交替训练网络。

需要搭建生成器网络和判别器网络,训练的时候交替训练。

首先训练判别器的参数,固定生成器的参数,让判别器判断生成器生成的数据,让其和0接近,让判别器判断真实数据,让其和1接近;

接着训练生成器的参数,固定判别器的参数,让生成器生成的数据进入判别器,让判断结果和1接近。生成器生成数据需要给定随机初始值

线性版:

import torch
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torchvision import transforms
from torch import optim
import torch.nn as nn
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.gridspec as gridspec
 
def showimg(images,count):
 images=images.detach().numpy()[0:16,:]
 images=255*(0.5*images+0.5)
 images = images.astype(np.uint8)
 grid_length=int(np.ceil(np.sqrt(images.shape[0])))
 plt.figure(figsize=(4,4))
 width = int(np.sqrt((images.shape[1])))
 gs = gridspec.GridSpec(grid_length,grid_length,wspace=0,hspace=0)
 # gs.update(wspace=0, hspace=0)
 print('starting...')
 for i, img in enumerate(images):
 ax = plt.subplot(gs[i])
 ax.set_xticklabels([])
 ax.set_yticklabels([])
 ax.set_aspect('equal')
 plt.imshow(img.reshape([width,width]),cmap = plt.cm.gray)
 plt.axis('off')
 plt.tight_layout()
 print('showing...')
 plt.tight_layout()
 plt.savefig('./GAN_Image/%d.png'%count, bbox_inches='tight')
 
def loadMNIST(batch_size): #MNIST图片的大小是28*28
 trans_img=transforms.Compose([transforms.ToTensor()])
 trainset=MNIST('./data',train=True,transform=trans_img,download=True)
 testset=MNIST('./data',train=False,transform=trans_img,download=True)
 # device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 trainloader=DataLoader(trainset,batch_size=batch_size,shuffle=True,num_workers=10)
 testloader = DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=10)
 return trainset,testset,trainloader,testloader
 
class discriminator(nn.Module):
 def __init__(self):
 super(discriminator,self).__init__()
 self.dis=nn.Sequential(
  nn.Linear(784,300),
  nn.LeakyReLU(0.2),
  nn.Linear(300,150),
  nn.LeakyReLU(0.2),
  nn.Linear(150,1),
  nn.Sigmoid()
 )
 def forward(self, x):
 x=self.dis(x)
 return x
 
class generator(nn.Module):
 def __init__(self,input_size):
 super(generator,self).__init__()
 self.gen=nn.Sequential(
  nn.Linear(input_size,150),
  nn.ReLU(True),
  nn.Linear(150,300),
  nn.ReLU(True),
  nn.Linear(300,784),
  nn.Tanh()
 )
 def forward(self, x):
 x=self.gen(x)
 return x
 
if __name__=="__main__":
 criterion=nn.BCELoss()
 num_img=100
 z_dimension=100
 D=discriminator()
 G=generator(z_dimension)
 trainset, testset, trainloader, testloader = loadMNIST(num_img) # data
 d_optimizer=optim.Adam(D.parameters(),lr=0.0003)
 g_optimizer=optim.Adam(G.parameters(),lr=0.0003)
 '''
 交替训练的方式训练网络
 先训练判别器网络D再训练生成器网络G
 不同网络的训练次数是超参数
 也可以两个网络训练相同的次数
 这样就可以不用分别训练两个网络
 '''
 count=0
 #鉴别器D的训练,固定G的参数
 epoch = 100
 gepoch = 1
 for i in range(epoch):
 for (img, label) in trainloader:
  # num_img=img.size()[0]
  real_img=img.view(num_img,-1)#展开为28*28=784
  real_label=torch.ones(num_img)#真实label为1
  fake_label=torch.zeros(num_img)#假的label为0
 
  #compute loss of real_img
  real_out=D(real_img) #真实图片送入判别器D输出0~1
  d_loss_real=criterion(real_out,real_label)#得到loss
  real_scores=real_out#真实图片放入判别器输出越接近1越好
 
  #compute loss of fake_img
  z=torch.randn(num_img,z_dimension)#随机生成向量
  fake_img=G(z)#将向量放入生成网络G生成一张图片
  fake_out=D(fake_img)#判别器判断假的图片
  d_loss_fake=criterion(fake_out,fake_label)#假的图片的loss
  fake_scores=fake_out#假的图片放入判别器输出越接近0越好
 
  #D bp and optimize
  d_loss=d_loss_real+d_loss_fake
  d_optimizer.zero_grad() #判别器D的梯度归零
  d_loss.backward() #反向传播
  d_optimizer.step() #更新判别器D参数
 
  #生成器G的训练compute loss of fake_img
  for j in range(gepoch):
  fake_label = torch.ones(num_img) # 真实label为1
  z = torch.randn(num_img, z_dimension) # 随机生成向量
  fake_img = G(z) # 将向量放入生成网络G生成一张图片
  output = D(fake_img) # 经过判别器得到结果
  g_loss = criterion(output, fake_label)#得到假的图片与真实标签的loss
  #bp and optimize
  g_optimizer.zero_grad() #生成器G的梯度归零
  g_loss.backward() #反向传播
  g_optimizer.step()#更新生成器G参数
 print('Epoch [{}/{}], d_loss: {:.6f}, g_loss: {:.6f} '
   'D real: {:.6f}, D fake: {:.6f}'.format(
  i, epoch, d_loss.data[0], g_loss.data[0],
  real_scores.data.mean(), fake_scores.data.mean()))
 showimg(fake_img,count)
 # plt.show()
 count += 1

这里的图分别是 epoch为0、50、100、150、190的运行结果,可以看到图片中的数字并不单一

Pytorch使用MNIST数据集实现基础GAN和DCGAN详解

卷积版 Deep Convolutional Generative Adversarial Networks:

import torch
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torchvision import transforms
from torch import optim
import torch.nn as nn
import matplotlib.pyplot as plt
import numpy as np
from torch.autograd import Variable
 
import matplotlib.gridspec as gridspec
import os
 
def showimg(images,count):
 images=images.to('cpu')
 images=images.detach().numpy()
 images=images[[6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]]
 images=255*(0.5*images+0.5)
 images = images.astype(np.uint8)
 grid_length=int(np.ceil(np.sqrt(images.shape[0])))
 plt.figure(figsize=(4,4))
 width = images.shape[2]
 gs = gridspec.GridSpec(grid_length,grid_length,wspace=0,hspace=0)
 print(images.shape)
 for i, img in enumerate(images):
 ax = plt.subplot(gs[i])
 ax.set_xticklabels([])
 ax.set_yticklabels([])
 ax.set_aspect('equal')
 plt.imshow(img.reshape(width,width),cmap = plt.cm.gray)
 plt.axis('off')
 plt.tight_layout()
# print('showing...')
 plt.tight_layout()
# plt.savefig('./GAN_Imaget/%d.png'%count, bbox_inches='tight')
 
def loadMNIST(batch_size): #MNIST图片的大小是28*28
 trans_img=transforms.Compose([transforms.ToTensor()])
 trainset=MNIST('./data',train=True,transform=trans_img,download=True)
 testset=MNIST('./data',train=False,transform=trans_img,download=True)
 # device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 trainloader=DataLoader(trainset,batch_size=batch_size,shuffle=True,num_workers=10)
 testloader = DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=10)
 return trainset,testset,trainloader,testloader
 
class discriminator(nn.Module):
 def __init__(self):
 super(discriminator,self).__init__()
 self.dis=nn.Sequential(
  nn.Conv2d(1,32,5,stride=1,padding=2),
  nn.LeakyReLU(0.2,True),
  nn.MaxPool2d((2,2)),
 
  nn.Conv2d(32,64,5,stride=1,padding=2),
  nn.LeakyReLU(0.2,True),
  nn.MaxPool2d((2,2))
 )
 self.fc=nn.Sequential(
  nn.Linear(7 * 7 * 64, 1024),
  nn.LeakyReLU(0.2, True),
  nn.Linear(1024, 1),
  nn.Sigmoid()
 )
 def forward(self, x):
 x=self.dis(x)
 x=x.view(x.size(0),-1)
 x=self.fc(x)
 return x
 
class generator(nn.Module):
 def __init__(self,input_size,num_feature):
 super(generator,self).__init__()
 self.fc=nn.Linear(input_size,num_feature) #1*56*56
 self.br=nn.Sequential(
  nn.BatchNorm2d(1),
  nn.ReLU(True)
 )
 self.gen=nn.Sequential(
  nn.Conv2d(1,50,3,stride=1,padding=1),
  nn.BatchNorm2d(50),
  nn.ReLU(True),
 
  nn.Conv2d(50,25,3,stride=1,padding=1),
  nn.BatchNorm2d(25),
  nn.ReLU(True),
 
  nn.Conv2d(25,1,2,stride=2),
  nn.Tanh()
 )
 def forward(self, x):
 x=self.fc(x)
 x=x.view(x.size(0),1,56,56)
 x=self.br(x)
 x=self.gen(x)
 return x
 
if __name__=="__main__":
 criterion=nn.BCELoss()
 num_img=100
 z_dimension=100
 D=discriminator()
 G=generator(z_dimension,3136) #1*56*56
 trainset, testset, trainloader, testloader = loadMNIST(num_img) # data
 D=D.cuda()
 G=G.cuda()
 d_optimizer=optim.Adam(D.parameters(),lr=0.0003)
 g_optimizer=optim.Adam(G.parameters(),lr=0.0003)
 '''
 交替训练的方式训练网络
 先训练判别器网络D再训练生成器网络G
 不同网络的训练次数是超参数
 也可以两个网络训练相同的次数,
 这样就可以不用分别训练两个网络
 '''
 count=0
 #鉴别器D的训练,固定G的参数
 epoch = 100
 gepoch = 1
 for i in range(epoch):
 for (img, label) in trainloader:
  # num_img=img.size()[0]
  img=Variable(img).cuda()
  real_label=Variable(torch.ones(num_img)).cuda()#真实label为1
  fake_label=Variable(torch.zeros(num_img)).cuda()#假的label为0
 
  #compute loss of real_img
  real_out=D(img) #真实图片送入判别器D输出0~1
  d_loss_real=criterion(real_out,real_label)#得到loss
  real_scores=real_out#真实图片放入判别器输出越接近1越好
 
  #compute loss of fake_img
  z=Variable(torch.randn(num_img,z_dimension)).cuda()#随机生成向量
  fake_img=G(z)#将向量放入生成网络G生成一张图片
  fake_out=D(fake_img)#判别器判断假的图片
  d_loss_fake=criterion(fake_out,fake_label)#假的图片的loss
  fake_scores=fake_out#假的图片放入判别器输出越接近0越好
 
  #D bp and optimize
  d_loss=d_loss_real+d_loss_fake
  d_optimizer.zero_grad() #判别器D的梯度归零
  d_loss.backward() #反向传播
  d_optimizer.step() #更新判别器D参数
 
  #生成器G的训练compute loss of fake_img
  for j in range(gepoch):
  fake_label = Variable(torch.ones(num_img)).cuda() # 真实label为1
  z = Variable(torch.randn(num_img, z_dimension)).cuda() # 随机生成向量
  fake_img = G(z) # 将向量放入生成网络G生成一张图片
  output = D(fake_img) # 经过判别器得到结果
  g_loss = criterion(output, fake_label)#得到假的图片与真实标签的loss
  #bp and optimize
  g_optimizer.zero_grad() #生成器G的梯度归零
  g_loss.backward() #反向传播
  g_optimizer.step()#更新生成器G参数
  # if ((i+1)%1000==0):
  # print("[%d/%d] GLoss: %.5f" % (i + 1, gepoch, g_loss.data[0]))
 print('Epoch [{}/{}], d_loss: {:.6f}, g_loss: {:.6f} '
   'D real: {:.6f}, D fake: {:.6f}'.format(
  i, epoch, d_loss.data[0], g_loss.data[0],
  real_scores.data.mean(), fake_scores.data.mean()))
 showimg(fake_img,count)
 plt.show()
 count += 1

这里的gepoch设置为1,运行39次的结果是:

Pytorch使用MNIST数据集实现基础GAN和DCGAN详解

gepoch设置为2,运行0、25、50、75、100次的结果是:

Pytorch使用MNIST数据集实现基础GAN和DCGAN详解

gepoch设置为3,运行25、50、75次的结果是:

Pytorch使用MNIST数据集实现基础GAN和DCGAN详解

gepoch设置为4,运行0、10、20、30、35次的结果是:

Pytorch使用MNIST数据集实现基础GAN和DCGAN详解

gepoch设置为5,运行0、10、20、25、29次的结果是:

Pytorch使用MNIST数据集实现基础GAN和DCGAN详解

gepoch设置为3,z_dimension设置为190,epoch运行0、10、15、20、25、35的结果是:

Pytorch使用MNIST数据集实现基础GAN和DCGAN详解

可以看到生成的数字基本没有太多的规律,可能最终都是同个数字,不能生成指定的数字,CGAN就很好的解决这个问题,可以生成指定的数字 Pytorch使用MNIST数据集实现CGAN和生成指定的数字方式

以上这篇Pytorch使用MNIST数据集实现基础GAN和DCGAN详解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持三水点靠木。

Python 相关文章推荐
Python  __getattr__与__setattr__使用方法
Sep 06 Python
python模块之StringIO使用示例
Apr 08 Python
Python3中的json模块使用详解
May 05 Python
python 查找文件名包含指定字符串的方法
Jun 05 Python
python导入模块交叉引用的方法
Jan 19 Python
Python字典的基本用法实例分析【创建、增加、获取、修改、删除】
Mar 05 Python
python GUI库图形界面开发之PyQt5动态加载QSS样式文件
Feb 25 Python
PIL.Image.open和cv2.imread的比较与相互转换的方法
Jun 03 Python
Python创建临时文件和文件夹
Aug 05 Python
Python爬虫入门教程02之笔趣阁小说爬取
Jan 24 Python
python munch库的使用解析
May 25 Python
Python3的进程和线程你了解吗
Mar 16 Python
Pytorch使用MNIST数据集实现CGAN和生成指定的数字方式
Jan 10 #Python
pytorch实现mnist分类的示例讲解
Jan 10 #Python
pytorch 准备、训练和测试自己的图片数据的方法
Jan 10 #Python
pytorch GAN伪造手写体mnist数据集方式
Jan 10 #Python
MNIST数据集转化为二维图片的实现示例
Jan 10 #Python
pytorch:实现简单的GAN示例(MNIST数据集)
Jan 10 #Python
pytorch GAN生成对抗网络实例
Jan 10 #Python
You might like
php获取当前网址url并替换参数或网址的方法
2010/06/06 PHP
PHP学习之输出字符串(echo,print,printf,print_r和var_dump)
2011/04/17 PHP
redis 队列操作的例子(php)
2012/04/12 PHP
CSS常用网站布局实例
2008/04/03 Javascript
网页中的图片的处理方法与代码
2009/11/26 Javascript
JS去除数组重复值的五种不同方法
2013/09/06 Javascript
多种方法实现load加载完成后把图片一次性显示出来
2014/02/19 Javascript
php实例分享之实现显示网站运行时间
2014/05/20 Javascript
利用javascript实现全部删或清空所选的操作
2014/05/27 Javascript
yepnope.js使用详解及示例分享
2014/06/23 Javascript
原生js结合html5制作简易的双色子游戏
2015/03/30 Javascript
Bootstrap Table使用方法详解
2016/08/01 Javascript
基于Javascript实现的不重复ID的生成器
2016/12/25 Javascript
vue2.0构建单页应用最佳实战
2017/04/01 Javascript
微信小程序实现的一键拨号功能示例
2019/04/24 Javascript
layerui代码控制tab选项卡,添加,关闭的实例
2019/09/04 Javascript
javascript设计模式 ? 职责链模式原理与用法实例分析
2020/04/16 Javascript
Python 条件判断的缩写方法
2008/09/06 Python
把项目从Python2.x移植到Python3.x的经验总结
2015/04/20 Python
python使用pyqt写带界面工具的示例代码
2017/10/23 Python
详解利用Python scipy.signal.filtfilt() 实现信号滤波
2019/06/05 Python
关于Tensorflow 模型持久化详解
2020/02/12 Python
Python对Tornado请求与响应的数据处理
2020/02/12 Python
Python pandas对excel的操作实现示例
2020/07/21 Python
python 服务器运行代码报错ModuleNotFoundError的解决办法
2020/09/16 Python
python 带时区的日期格式化操作
2020/10/23 Python
玩具反斗城天猫官方旗舰店:享誉全球的玩具店
2017/10/10 全球购物
Yahoo-PHP面试题4
2012/05/05 面试题
海量信息软件测试笔试题
2015/08/08 面试题
EJB的角色和三个对象
2015/12/31 面试题
新三好学生主要事迹
2014/01/23 职场文书
授权委托书格式模板
2014/04/03 职场文书
旅游与酒店管理专业求职信
2014/07/21 职场文书
教师四风自我剖析材料
2014/09/30 职场文书
优秀团员自我评价
2015/03/10 职场文书
小学教学工作总结2015
2015/05/13 职场文书