第六周:生成式对抗网络
生成式对抗网络 (Generative Adversarial Networks)
生成式对抗网络的应用:
图像着色、图像超像素、背景模糊、人脸生成、人脸定制、卡通图像生成、文本生成图片、字体变换、分格变换、图像修复、帧预测
生成式对抗网络及其衍生网络:
GAN
生成式对抗网络由判别器和生成器组成:
- 判别器(Discriminator):区分真实(real)样本和虚假(fake)样本。对于真实样本,尽可能给出高的评分1;对于虚假数据,尽可能给出低个评分0。
- 生成器(Generator):欺骗判别器。生成虚假数据,使得判别器D能够尽可能给出高的评分1。
CGAN模型
DCGAN
DCGAN,使用卷积神经网络作为判别器和生成器,通过大量的工程实践,经验性地提出一系列的网络结构和优化策略,来有效的建模图。
代码演示
X, y = make_moons(n_samples=2000, noise=0.05) n_samples = X.shape[0] Y = np.ones(n_samples) fig, ax = plt.subplots(1, 1, facecolor='#4B6EA9') plot_data(ax, X, Y) plt.show()
一个简单的 GAN
生成器和判别器的结构都非常简单,具体如下:
- 生成器: 32 ==> 128 ==> 2
- 判别器: 2 ==> 128 ==> 1
判别器输入的是一组座标(x,y),最后一层是sigmoid函数,是一个范围在(0,1)间的数,即样本为真或者假的置信度。如果输入的是真样本,得到的结果尽量接近1;如果输入的是假样本,得到的结果尽量接近0。
import torch.nn as nn z_dim = 32 hidden_dim = 128 # 定义生成器 net_G = nn.Sequential( nn.Linear(z_dim,hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, 2)) # 定义判别器 net_D = nn.Sequential( nn.Linear(2,hidden_dim), nn.ReLU(), nn.Linear(hidden_dim,1), nn.Sigmoid()) # 网络放到 GPU 上 net_G = net_G.to(device) net_D = net_D.to(device)
# 定义网络的优化器 optimizer_G = torch.optim.Adam(net_G.parameters(),lr=0.001) optimizer_D = torch.optim.Adam(net_D.parameters(),lr=0.001) batch_size = 250
nb_epochs = 1000
loss_D_epoch = [] loss_G_epoch = [] for e in range(nb_epochs): np.random.shuffle(X) real_samples = torch.from_numpy(X).type(torch.FloatTensor) loss_G = 0 loss_D = 0 for t, real_batch in enumerate(real_samples.split(batch_size)): # 固定生成器G,改进判别器D # 使用normal_()函数生成一组随机噪声,输入G得到一组样本 z = torch.empty(batch_size,z_dim).normal_().to(device) fake_batch = net_G(z) # 将真、假样本分别输入判别器,得到结果 D_scores_on_real = net_D(real_batch.to(device)) D_scores_on_fake = net_D(fake_batch) # 优化过程中,假样本的score会越来越小,真样本的score会越来越大,下面 loss 的定义刚好符合这一规律, # 要保证loss越来越小,真样本的score前面要加负号 # 要保证loss越来越小,假样本的score前面是正号(负负得正) loss = -torch.mean(torch.log(1-D_scores_on_fake) + torch.log(D_scores_on_real)) # 梯度清零 optimizer_D.zero_grad() # 反向传播优化 loss.backward() # 更新全部参数 optimizer_D.step() loss_D += loss # 固定判别器,改进生成器 # 生成一组随机噪声,输入生成器得到一组假样本 z = torch.empty(batch_size,z_dim).normal_().to(device) fake_batch = net_G(z) # 假样本输入判别器得到 score D_scores_on_fake = net_D(fake_batch) # 我们希望假样本能够骗过生成器,得到较高的分数,下面的 loss 定义也符合这一规律 # 要保证 loss 越来越小,假样本的前面要加负号 loss = -torch.mean(torch.log(D_scores_on_fake)) optimizer_G.zero_grad() loss.backward() optimizer_G.step() loss_G += loss if e % 50 ==0: print(f'\n Epoch {e} , D loss: {loss_D}, G loss: {loss_G}') loss_D_epoch.append(loss_D) loss_G_epoch.append(loss_G)
z = torch.empty(n_samples,z_dim).normal_().to(device) fake_samples = net_G(z) fake_data = fake_samples.cpu().data.numpy() fig, ax = plt.subplots(1, 1, facecolor='#4B6EA9') all_data = np.concatenate((X,fake_data),axis=0) Y2 = np.concatenate((np.ones(n_samples),np.zeros(n_samples))) plot_data(ax, all_data, Y2) plt.show()
z = torch.empty(10*n_samples,z_dim).normal_().to(device) fake_samples = net_G(z) fake_data = fake_samples.cpu().data.numpy() fig, ax = plt.subplots(1, 1, facecolor='#4B6EA9') all_data = np.concatenate((X,fake_data),axis=0) Y2 = np.concatenate((np.ones(n_samples),np.zeros(10*n_samples))) plot_data(ax, all_data, Y2) plt.show();
CGAN
首先实现CGAN。下面分别是 判别器 和 生成器 的网络结构,可以看出网络结构非常简单,具体如下:
- 生成器:(784 + 10) ==> 512 ==> 256 ==> 1
- 判别器:(100 + 10) ==> 128 ==> 256 ==> 512 ==> 784
# 开始训练,一共训练total_epochs for epoch in range(total_epochs): # torch.nn.Module.train() 指的是模型启用 BatchNormalization 和 Dropout # torch.nn.Module.eval() 指的是模型不启用 BatchNormalization 和 Dropout # 因此,train()一般在训练时用到, eval() 一般在测试时用到 generator = generator.train() # 训练一个epoch for i, data in enumerate(dataloader): # 加载真实数据 real_images, real_labels = data real_images = real_images.to(device) # 把对应的标签转化成 one-hot 类型 tmp = torch.FloatTensor(real_labels.size(0), 10).zero_() real_labels = tmp.scatter_(dim=1, index=torch.LongTensor(real_labels.view(-1, 1)), value=1) real_labels = real_labels.to(device) # 生成数据 # 用正态分布中采样batch_size个随机噪声 z = torch.randn([batch_size, z_dim]).to(device) # 生成 batch_size 个 ont-hot 标签 c = torch.FloatTensor(batch_size, 10).zero_() c = c.scatter_(dim=1, index=torch.LongTensor(np.random.choice(10, batch_size).reshape([batch_size, 1])), value=1) c = c.to(device) # 生成数据 fake_images = generator(z,c) # 计算判别器损失,并优化判别器 real_loss = bce(discriminator(real_images, real_labels), ones) fake_loss = bce(discriminator(fake_images.detach(), c), zeros) d_loss = real_loss + fake_loss d_optimizer.zero_grad() d_loss.backward() d_optimizer.step() # 计算生成器损失,并优化生成器 g_loss = bce(discriminator(fake_images, c), ones) g_optimizer.zero_grad() g_loss.backward() g_optimizer.step() # 输出损失 print("[Epoch %d/%d] [D loss: %f] [G loss: %f]" % (epoch, total_epochs, d_loss.item(), g_loss.item()))
#用于生成效果图 # 生成100个随机噪声向量 fixed_z = torch.randn([100, z_dim]).to(device) # 生成100个one_hot向量,每类10个 fixed_c = torch.FloatTensor(100, 10).zero_() fixed_c = fixed_c.scatter_(dim=1, index=torch.LongTensor(np.array(np.arange(0, 10).tolist()*10).reshape([100, 1])), value=1) fixed_c = fixed_c.to(device) generator = generator.eval() fixed_fake_images = generator(fixed_z, fixed_c) plt.figure(figsize=(8, 8)) for j in range(10): for i in range(10): img = fixed_fake_images[j*10+i, 0, :, :].detach().cpu().numpy() img = img.reshape([28, 28]) plt.subplot(10, 10, j*10+i+1) plt.imshow(img, 'gray')
DCGAN
# 开始训练,一共训练 total_epochs for e in range(total_epochs): # 给generator启用 BatchNormalization g_dcgan = g_dcgan.train() # 训练一个epoch for i, data in enumerate(dcgan_dataloader): # 加载真实数据,不加载标签 real_images, _ = data real_images = real_images.to(device) # 用正态分布中采样batch_size个噪声,然后生成对应的图片 z = torch.randn([batch_size, z_dim]).to(device) fake_images = g_dcgan(z) # 计算判别器损失,并优化判别器 real_loss = bce(d_dcgan(real_images), ones) fake_loss = bce(d_dcgan(fake_images.detach()), zeros) d_loss = real_loss + fake_loss d_dcgan_optim.zero_grad() d_loss.backward() d_dcgan_optim.step() # 计算生成器损失,并优化生成器 g_loss = bce(d_dcgan(fake_images), ones) g_dcgan_optim.zero_grad() g_loss.backward() g_dcgan_optim.step() # 输出损失 print ("[Epoch %d/%d] [D loss: %f] [G loss: %f]" % (e, total_epochs, d_loss.item(), g_loss.item()))
#用于生成效果图 # 生成100个随机噪声向量 fixed_z = torch.randn([100, z_dim]).to(device) g_dcgan = g_dcgan.eval() fixed_fake_images = g_dcgan(fixed_z) plt.figure(figsize=(8, 8)) for j in range(10): for i in range(10): img = fixed_fake_images[j*10+i, 0, :, :].detach().cpu().numpy() img = img.reshape([32, 32]) plt.subplot(10, 10, j*10+i+1) plt.imshow(img, 'gray')