原始生成对抗网络生成甘敌对的网络包含生成器生成器和判别器鉴频器,数据有真实数据groundtruth,还有需要网络生成的“假”数据,目的是网络生成的假数据可以“骗过”判别器,让判别器认不出来,就是让判别器分不清进入的数据是真实数据还是假的数据。总的来说是:判别器区分真实数据和假数据的能力越强越好,生成器生成的数据骗过判别器的能力越强越好,这个是矛盾的,所以只能交替训练网络。
需要搭建生成器网络和判别器网络,训练的时候交替训练。
首先训练判别器的参数,固定生成器的参数,让判别器判断生成器生成的数据,让其和0接近,让判别器判断真实数据,让其和1接近;
接着训练生成器的参数,固定判别器的参数,让生成器生成的数据进入判别器,让判断结果和1接近。生成器生成数据需要给定随机初始值
<强>线性版:
进口火炬
从torch.utils。数据导入DataLoader
从torchvision。数据导入MNIST
从torchvision导入转换
从火炬进口optim
进口火炬。神经网络是神经网络
进口matplotlib。pyplot作为plt
进口numpy np
进口matplotlib。gridspec作为gridspec
def showimg(图片、数量):
图像=images.detach () .numpy () [0:16:]
图像=255 *(0.5 + 0.5)*图像
图像=images.astype (np.uint8)
grid_length=int (np.ceil (np.sqrt (images.shape [0])))
plt.figure (figsize=(4, 4))
宽度=int (np.sqrt (images.shape [1])))
gs=gridspec.GridSpec (grid_length、grid_length wspace=0,水平间距=0)
# gs。更新(wspace=0,水平间距=0)
打印(“开始…”)
因为我,img在列举(图片):
ax=plt.subplot (gs[我])
ax.set_xticklabels ([])
ax.set_yticklabels ([])
ax.set_aspect(“平等”)
plt.imshow (img.reshape((宽度、宽度)),提出=plt.cm.gray)
plt.axis(“了”)
plt.tight_layout ()
打印(“显示…”)
plt.tight_layout ()
plt.savefig (’。/GAN_Image/% d。png ' %计算,bbox_inches=敖簟?
def loadMNIST (batch_size): # MNIST图片的大小是28 * 28
trans_img=transforms.Compose ([transforms.ToTensor ()))
小火车=MNIST (=True”。/数据”,火车,变换=trans_img下载=True)
testset=MNIST(“。/数据”,火车=False,变换=trans_img下载=True)
#设备=torch.device(如果torch.cuda.is_available cuda: 0()其他cpu)
装载量=DataLoader(小火车,batch_size=batch_size洗牌=True, num_workers=10)
试验载荷=DataLoader (testset batch_size=batch_size洗牌=False, num_workers=10)
返回小火车,testset,装载量、试验载荷
类鉴别器(nn.Module):
def __init__(自我):
超级(鉴别器,自我). __init__ ()
self.dis=nn.Sequential (
nn.Linear (784300),
nn.LeakyReLU (0.2),
nn.Linear (300150),
nn.LeakyReLU (0.2),
nn.Linear (150 1),
nn.Sigmoid ()
)
def向前(自我,x):
x=self.dis (x)
返回x
类发生器(nn.Module):
def __init__(自我,input_size):
超级(发电机,自我). __init__ ()
self.gen=nn.Sequential (
nn.Linear (input_size, 150),
nn.ReLU(真正的),
nn.Linear (150300),
nn.ReLU(真正的),
nn.Linear (300784),
nn.Tanh ()
)
def向前(自我,x):
x=self.gen (x)
返回x
if __name__==癬_main__”:
标准=nn.BCELoss ()
num_img=100
z_dimension=100
D=鉴别器()
G=发生器(z_dimension)
小火车,testset、装载量、试验载荷=loadMNIST (num_img) #数据
d_optimizer=optim.Adam (D.parameters (), lr=0.0003)
g_optimizer=optim.Adam (G.parameters (), lr=0.0003)
“‘
交替训练的方式训练网络
先训练判别器网络D再训练生成器网络G
不同网络的训练次数是超参数
也可以两个网络训练相同的次数
这样就可以不用分别训练两个网络
“‘
数=0
#鉴别器D的训练,固定G的参数
时代=100
gepoch=1
因为我在范围(时代):
在装载量(img标签):
# num_img=img.size () [0]
real_img=img.view (num_img, 1) #展开为28 * 28=784
real_label=torch.ones (num_img) #真实标签为1
fake_label=torch.zeros (num_img) #假的标签为0
#计算real_img的损失
real_out=D (real_img) #真实图片送入判别器D输出0 ~ 1
d_loss_real=标准(real_out real_label) #得到的损失
real_scores=real_out #真实图片放入判别器输出越接近1越好
#计算fake_img的损失
z=torch.randn (num_img z_dimension) #随机生成向量
fake_img=G (z) #将向量放入生成网络克生成一张图片
fake_out=D (fake_img) #判别器判断假的图片
d_loss_fake=标准(fake_out fake_label) #假的图片的损失
fake_scores=fake_out #假的图片放入判别器输出越接近0越好
# D bp和优化
d_loss=d_loss_real + d_loss_fake
d_optimizer.zero_grad() #判别器D的梯度归零
d_loss.backward() #反向传播
d_optimizer.step() #更新判别器D参数
#生成器G的训练计算fake_img的损失
j的范围(gepoch):
fake_label=torch.ones (num_img) #真实标签为1
z=火炬。randn (num_img z_dimension) #随机生成向量
fake_img=G (z) #将向量放入生成网络克生成一张图片
输出=D (fake_img) #经过判别器得到结果
fake_label g_loss=标准(输出)#得到假的图片与真实标签的损失
#英国石油(bp)和优化
g_optimizer.zero_grad() #生成器G的梯度归零
g_loss.backward() #反向传播
g_optimizer.step() #更新生成器G参数
打印(“时代[{}/{}],d_loss: {:。6 f}, g_loss: {:。6 f}’
' D真实:{:。D假6 f}: {: .6f} .format (
时代,我d_loss。数据[0],g_loss.data [0],
real_scores.data.mean (), fake_scores.data.mean ()))
showimg (fake_img,计算)
# plt.show ()
数+=1
