[深度学习]半监督学习、无监督学习之DCGAN深度卷积生成对抗网络(附代码)

 import os

    
  
    
 import torch
    
 import torch.nn as nn
    
 import torch.nn.functional as F
    
  
    
 latent_dims = 10
    
 num_epochs = 20
    
 batch_size = 128
    
 learning_rate = 2e-4
    
 use_gpu = True

 import torchvision.transforms as transforms

    
 from torch.utils.data import DataLoader
    
 from torchvision.datasets import MNIST
    
  
    
 img_transform = transforms.Compose([
    
     transforms.Resize(64),
    
     transforms.ToTensor(),
    
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    
 ])
    
  
    
 train_dataset = MNIST(root='./data/MNIST', download=True, train=True, transform=img_transform)
    
 train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
    
  
    
 test_dataset = MNIST(root='./data/MNIST', download=True, train=False, transform=img_transform)
    
 test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True)

 class Generator(nn.Module):

    
     def __init__(self, d=128):
    
     super(Generator, self).__init__()
    
     self.deconv1 = nn.ConvTranspose2d(100, d*8, 4, 1, 0)
    
     self.deconv1_bn = nn.BatchNorm2d(d*8)
    
     self.deconv2 = nn.ConvTranspose2d(d*8, d*4, 4, 2, 1)
    
     self.deconv2_bn = nn.BatchNorm2d(d*4)
    
     self.deconv3 = nn.ConvTranspose2d(d*4, d*2, 4, 2, 1)
    
     self.deconv3_bn = nn.BatchNorm2d(d*2)
    
     self.deconv4 = nn.ConvTranspose2d(d*2, d, 4, 2, 1)
    
     self.deconv4_bn = nn.BatchNorm2d(d)
    
     self.deconv5 = nn.ConvTranspose2d(d, 1, 4, 2, 1)
    
  
    
     def forward(self, input):
    
     # x = F.relu(self.deconv1(input))
    
     x = F.relu(self.deconv1_bn(self.deconv1(input)))
    
     x = F.relu(self.deconv2_bn(self.deconv2(x)))
    
     x = F.relu(self.deconv3_bn(self.deconv3(x)))
    
     x = F.relu(self.deconv4_bn(self.deconv4(x)))
    
     x = torch.tanh(self.deconv5(x))
    
  
    
     return x

 class Discriminator(nn.Module):

    
     def __init__(self, d=128):
    
     super(Discriminator, self).__init__()
    
     self.conv1 = nn.Conv2d(1, d, 4, 2, 1)
    
     self.conv2 = nn.Conv2d(d, d*2, 4, 2, 1)
    
     self.conv2_bn = nn.BatchNorm2d(d*2)
    
     self.conv3 = nn.Conv2d(d*2, d*4, 4, 2, 1)
    
     self.conv3_bn = nn.BatchNorm2d(d*4)
    
     self.conv4 = nn.Conv2d(d*4, d*8, 4, 2, 1)
    
     self.conv4_bn = nn.BatchNorm2d(d*8)
    
     self.conv5 = nn.Conv2d(d*8, 1, 4, 1, 0)
    
  
    
     def forward(self, input):
    
     x = F.leaky_relu(self.conv1(input), 0.2)
    
     x = F.leaky_relu(self.conv2_bn(self.conv2(x)), 0.2)
    
     x = F.leaky_relu(self.conv3_bn(self.conv3(x)), 0.2)
    
     x = F.leaky_relu(self.conv4_bn(self.conv4(x)), 0.2)
    
     x = torch.sigmoid(self.conv5(x))
    
  
    
     return x

 generator = Generator()

    
 discriminator = Discriminator()
    
  
    
 device = torch.device("cuda:0" if use_gpu and torch.cuda.is_available() else "cpu")
    
 generator = generator.to(device)
    
 discriminator = discriminator.to(device)
    
  
    
 num_params_gen = sum(p.numel() for p in generator.parameters() if p.requires_grad)
    
 num_params_disc = sum(p.numel() for p in discriminator.parameters() if p.requires_grad)
    
 print('Number of parameters for generator: %d and discriminator: %d' % (num_params_gen, num_params_disc))

 # Train GAN

    
 # 分别定义两个优化器，作为生成器和判别器的优化器
    
 gen_optimizer = torch.optim.Adam(params=generator.parameters(), lr=learning_rate, betas=(0.5, 0.999))
    
 disc_optimizer = torch.optim.Adam(params=discriminator.parameters(), lr=learning_rate, betas=(0.5, 0.999))
    
  
    
 # 设置为训练模式
    
 generator.train()
    
 discriminator.train()
    
  
    
 gen_loss_avg = []
    
 disc_loss_avg = []
    
  
    
 print("Training...")
    
 for epoch in range(num_epochs):
    
     gen_loss_avg.append(0)
    
     disc_loss_avg.append(0)
    
     num_batches = 0
    
  
    
     for image_batch, _ in train_dataloader:
    
     image_batch = image_batch.to(device)
    
     label_real = torch.ones(image_batch.size(0), device=device)
    
     label_fake = torch.zeros(image_batch.size(0), device=device)
    
  
    
     # 随机生成，作为生成器的输入
    
     latent = torch.randn(image_batch.size(0), 100, 1, 1, device=device)
    
     fake_image_batch = generator(latent)
    
  
    
     # 生成判别器的label，1为真，0为假
    
     pred_real = discriminator(image_batch).squeeze()  # squeeze()是去除张量里维度为一
    
     pred_fake = discriminator(fake_image_batch.detach()).squeeze()  # detach是分离生成器和判别器
    
  
    
     # 定义判别器的loss，使他能区分真假
    
     disc_loss = 0.5 * (
    
             F.binary_cross_entropy(pred_fake, label_fake) + F.binary_cross_entropy(pred_real, label_real))
    
  
    
     # 判别器的反向传播和权重更新
    
     disc_optimizer.zero_grad()
    
     disc_loss.backward()
    
     disc_optimizer.step()
    
  
    
     # 用权重依旧得到更新的判别器再次判别生成器生成的图像，这时候predict的结果应该比上面更能区分真假
    
     pred_fake = discriminator(fake_image_batch).squeeze()
    
  
    
     # 定义生成器的loss 使他更接近真实值
    
     gen_loss = F.binary_cross_entropy(pred_fake, label_real)
    
  
    
     # 生成器的反向传播和权重更新
    
     gen_optimizer.zero_grad()
    
     gen_loss.backward()
    
     gen_optimizer.step()
    
  
    
     # 累加loss
    
     gen_loss_avg[-1] += gen_loss.item()
    
     disc_loss_avg[-1] += disc_loss.item()
    
     num_batches += 1
    
  
    
     # 输出loss
    
     gen_loss_avg[-1] /= num_batches
    
     disc_loss_avg[-1] /= num_batches
    
     print('Epoch [%d / %d] average loss generator vs. discrim.: %f vs. %f' %
    
       (epoch+1, num_epochs, gen_loss_avg[-1], disc_loss_avg[-1]))

 import matplotlib.pyplot as plt

    
 plt.ion()
    
  
    
 fig = plt.figure()
    
 plt.plot(gen_loss_avg, label='generator')
    
 plt.plot(disc_loss_avg, label='discriminator')
    
 plt.xlabel('Epochs')
    
 plt.ylabel('Loss')
    
 plt.legend()
    
 plt.show()

 import numpy as np

    
 import matplotlib.pyplot as plt
    
 plt.ion()
    
  
    
 import torchvision.utils
    
  
    
 generator.eval()
    
  
    
 def interpolation(lambda1, model, latent_1, latent_2):
    
  
    
     with torch.no_grad():
    
  
    
     # interpolation of the two latent vectors
    
     inter_latent = lambda1* latent_1 + (1- lambda1) * latent_2
    
  
    
     # reconstruct interpolated image
    
     inter_latent = inter_latent.to(device)
    
     inter_image = model(inter_latent)
    
     inter_image = inter_image.cpu()
    
  
    
     return inter_image
    
     
    
 # sample two latent vectors from the standard normal distribution
    
 latent_1 = torch.randn(1, 100, 1, 1, device=device)
    
 latent_2 = torch.randn(1, 100, 1, 1, device=device)
    
  
    
 # interpolation lambdas
    
 lambda_range=np.linspace(0,1,10)
    
  
    
 fig, axs = plt.subplots(2,5, figsize=(15, 6))
    
 fig.subplots_adjust(hspace = .5, wspace=.001)
    
 axs = axs.ravel()
    
  
    
 for ind,l in enumerate(lambda_range):
    
     inter_image=interpolation(float(l), generator, latent_1, latent_2)
    
    
    
     inter_image = to_img(inter_image)
    
     
    
     image = inter_image.numpy()
    
    
    
     axs[ind].imshow(image[0,0,:,:], cmap='gray')
    
     axs[ind].set_title('lambda_val='+str(round(l,1)))
    
 plt.show()

 import numpy as np

    
 import matplotlib.pyplot as plt
    
 plt.ion()
    
  
    
 import torchvision.utils
    
  
    
 generator.eval()
    
  
    
 def to_img(x):
    
     x = 0.5 * (x + 1)
    
     x = x.clamp(0, 1)
    
     return x
    
  
    
 def show_image(img):
    
     img = to_img(img)
    
     npimg = img.numpy()
    
     plt.imshow(np.transpose(npimg, (1, 2, 0)))
    
  
    
 with torch.no_grad():
    
  
    
     # sample latent vectors from the standard normal distribution
    
     latent = torch.randn(image_batch.size(0), 100, 1, 1, device=device)
    
     fake_image_batch = generator(latent)
    
     fake_image_batch = fake_image_batch.cpu()
    
  
    
     fig, ax = plt.subplots(figsize=(8, 8))
    
     show_image(torchvision.utils.make_grid(fake_image_batch.data[:100],10,5))
    
     plt.show()