# 权重初始化函数，为生成器和判别器模型初始化 def weights_init(m): classname = m.__class__.__name__ if classname.find('Conv') != -1: nn.init.normal_(m.weight.data, 0.0, 0.02) elif classname.find('BatchNorm') != -1: nn.init.normal_(m.weight.data, 1.0, 0.02) nn.init.constant_(m.bias.data, 0)# Generator Code class Generator(nn.Module): def __init__(self, ngpu): super(Generator, self).__init__() self.ngpu = ngpu self.main = nn.Sequential( # input is Z, going into a convolution nn.ConvTranspose2d( nz, ngf * 8, 4, 1, 0, bias=False), nn.BatchNorm2d(ngf * 8), nn.ReLU(True), # state size. (ngf*8) x 4 x 4 nn.ConvTranspose2d(ngf * 8, ngf * 4, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf * 4), nn.ReLU(True), # state size. (ngf*4) x 8 x 8 nn.ConvTranspose2d( ngf * 4, ngf * 2, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf * 2), nn.ReLU(True), # state size. (ngf*2) x 16 x 16 nn.ConvTranspose2d( ngf * 2, ngf, 4, 2, 1, bias=False), nn.BatchNorm2d(ngf), nn.ReLU(True), # state size. (ngf) x 32 x 32 nn.ConvTranspose2d( ngf, nc, 4, 2, 1, bias=False), nn.Tanh() # state size. (nc) x 64 x 64 )def forward(self, input): return self.main(input)class Discriminator(nn.Module): def __init__(self, ngpu): super(Discriminator, self).__init__() self.ngpu = ngpu self.main = nn.Sequential( # input is (nc) x 64 x 64 nn.Conv2d(nc, ndf, 4, 2, 1, bias=False), nn.LeakyReLU(0.2, inplace=True), # state size. (ndf) x 32 x 32 nn.Conv2d(ndf, ndf * 2, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf * 2), nn.LeakyReLU(0.2, inplace=True), # state size. (ndf*2) x 16 x 16 nn.Conv2d(ndf * 2, ndf * 4, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf * 4), nn.LeakyReLU(0.2, inplace=True), # state size. (ndf*4) x 8 x 8 nn.Conv2d(ndf * 4, ndf * 8, 4, 2, 1, bias=False), nn.BatchNorm2d(ndf * 8), nn.LeakyReLU(0.2, inplace=True), # state size. (ndf*8) x 4 x 4 nn.Conv2d(ndf * 8, 1, 4, 1, 0, bias=False), nn.Sigmoid() )def forward(self, input): return self.main(input)

# Create the generator netG = Generator(ngpu).to(device)# Handle multi-gpu if desired if (device.type == 'cuda') and (ngpu > 1): netG = nn.DataParallel(netG, list(range(ngpu)))# Apply the weights_init function to randomly initialize all weights # to mean=0, stdev=0.2. netG.apply(weights_init) # Print the model print(netG)# Create the Discriminator netD = Discriminator(ngpu).to(device)# Handle multi-gpu if desired if (device.type == 'cuda') and (ngpu > 1): netD = nn.DataParallel(netD, list(range(ngpu)))# Apply the weights_init function to randomly initialize all weights #to mean=0, stdev=0.2. netD.apply(weights_init)# Print the model print(netD)

# Initialize BCELoss function criterion = nn.BCELoss()

# Create batch of latent vectors that we will use to visualize #the progression of the generator fixed_noise = torch.randn(64, nz, 1, 1, device=device)# Establish convention for real and fake labels during training real_label = 1.0 fake_label = 0.0# Setup Adam optimizers for both G and D optimizerD = optim.Adam(netD.parameters(), lr=lr, betas=(beta1, 0.999)) optimizerG = optim.Adam(netG.parameters(), lr=lr, betas=(beta1, 0.999))# Training Loop# Lists to keep track of progress img_list = [] G_losses = [] D_losses = [] iters = 0print("Starting Training Loop...") # For each epoch for epoch in range(num_epochs): import time start = time.time() # For each batch in the dataloader for i, data in enumerate(dataloader, 0):############################ # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z))) ########################### ## Train with all-real batch netD.zero_grad() # Format batch real_cpu = data[0].to(device) b_size = real_cpu.size(0) label = torch.full((b_size,), real_label, device=device) # Forward pass real batch through D output = netD(real_cpu).view(-1) # Calculate loss on all-real batch errD_real = criterion(output, label) # Calculate gradients for D in backward pass errD_real.backward() D_x = output.mean().item()## Train with all-fake batch # Generate batch of latent vectors noise = torch.randn(b_size, nz, 1, 1, device=device) # Generate fake image batch with G fake = netG(noise) label.fill_(fake_label) # Classify all fake batch with D output = netD(fake.detach()).view(-1) # Calculate D's loss on the all-fake batch errD_fake = criterion(output, label) # Calculate the gradients for this batch errD_fake.backward() D_G_z1 = output.mean().item() # Add the gradients from the all-real and all-fake batches errD = errD_real + errD_fake # Update D optimizerD.step()############################ # (2) Update G network: maximize log(D(G(z))) ########################### netG.zero_grad() label.fill_(real_label)# fake labels are real for generator cost # Since we just updated D, perform another forward pass of all-fake batch through D output = netD(fake).view(-1) # Calculate G's loss based on this output errG = criterion(output, label) # Calculate gradients for G errG.backward() D_G_z2 = output.mean().item() # Update G optimizerG.step()# Output training stats if i % 50 == 0: print('[%d/%d][%d/%d]\tLoss_D: %.4f\tLoss_G: %.4f\tD(x): %.4f\tD(G(z)): %.4f / %.4f' % (epoch, num_epochs, i, len(dataloader), errD.item(), errG.item(), D_x, D_G_z1, D_G_z2))# Save Losses for plotting later G_losses.append(errG.item()) D_losses.append(errD.item())# Check how the generator is doing by saving G's output on fixed_noise if (iters % 20 == 0) or ((epoch == num_epochs-1) and (i == len(dataloader)-1)):with torch.no_grad(): fake = netG(fixed_noise).detach().cpu()img_list.append(vutils.make_grid(fake, padding=2, normalize=True)) i = vutils.make_grid(fake, padding=2, normalize=True) fig = plt.figure(figsize=(8, 8)) plt.imshow(np.transpose(i, (1, 2, 0))) plt.axis('off')# 关闭坐标轴 plt.savefig("out/%d_%d.png" % (epoch, iters)) plt.close(fig) iters += 1 print('time:', time.time() - start)

plt.figure(figsize=(10,5)) plt.title("Generator and Discriminator Loss During Training") plt.plot(G_losses,label="G") plt.plot(D_losses,label="D") plt.xlabel("iterations") plt.ylabel("Loss") plt.legend() plt.show()

# Grab a batch of real images from the dataloader # real_batch = next(iter(dataloader))# Plot the real images plt.figure(figsize=(15,15)) plt.subplot(1,2,1) plt.axis("off") plt.title("Real Images") plt.imshow(np.transpose(vutils.make_grid(real_batch[0].to(device)[:64], padding=5, normalize=True).cpu(),(1,2,0)))# Plot the fake images from the last epoch plt.subplot(1,2,2) plt.axis("off") plt.title("Fake Images") plt.imshow(np.transpose(img_list[-1],(1,2,0))) plt.show()

推荐阅读

• 

  揭秘太监阉割全过程 太监净身过程
• 

  弥猴桃怎么催熟
• 

  中国四大盐场分布图 中国盐场
• 

  深圳求水山庄好玩
• 

  奇怪近义词 词语奇怪近义词
• 

  500大卡需要走多少步
• 

  威能壁挂炉f20排除方法是什么故障,这个就要看的功率了
• 

  新生儿吃多少奶粉 新生儿奶粉喝多少毫升
• 

  g27方向盘g27方向盘安装
• 

  火影水门大战九尾是第几集
• 

  asp.net mvc验证
• 

  软考时间几个小时，软考答案一般要多久才出
• 

  描写天空的诗句有哪些
• 

  马桶里堵了硬物取不出
• 

  手机怎么连接腾达无线网卡，腾达无线网卡无法连接到这个网络
• 

  阴香根的功效与作用
• 

  生产工艺记录做错分析报告
• 

  巴黎世家鸭舌帽洗了掉色严重正常吗 巴黎世家鸭舌帽洗了掉色严重
• 

  winform可行性分析
• 

  新手如何养好锦鲤，新手养锦鲤入门基础教程

• 机器学习|从零完成深度学习手写图片分类任务
• #|算法理论——快速幂思想（附例题）
• #|Python基础——强制类型转换及字符串
• python|Jupyter/IPython笔记本集合 !（附大量资源链接）-上篇
• 神经网络|文献阅读（03）Computing Graph Neural Networks: A Survey from Algorithms to Accelerators
• 数据分析系列|数据分析系列之matplotlib库的使用
• 机器学习|吴恩达机器学习（五）神经网络 2/2 —— 反向传播算法（BP-神经网络）
• 人工智能|PyTorch视频理解利器！数行代码训练视频模型
• 数据分析师|【机器学习】决策树案例三（利用决策树进行泰坦尼克号事故人员存活分类预测）