視訊學習  - GAN應用：影象著色，影象超畫素，背景模糊，人臉生成，人臉定製，卡通頭像生成，文字生成圖片，字型變換，風格變換，影象修復，幀預測。 生成式對抗網路基礎   - 生成式對抗網路（GAN） - 框架和目標函式 - 從博弈角度解釋GAN - 零和博弈 - 對抗學習 - 從概率角度分析GAN - KL散度和JS散度 - 極大似然估計和最小化KL散度 - 數學分析 - 條件生成式對抗網路（Conditional GAN，cGAN） - 改進的生成式對抗網路（Improved GAN） - 卷積生成式對抗網路（Deep Convolutional GAN，DCGAN） - Wasserstein GAN - 原始GAN分析 - WGAN：權重截斷（Weight Clipping） - WGAN-GP：梯度懲罰（Gradient Penalty）  生成式對抗網路前沿 - 前沿方法 - 逐漸生成的生成式對抗網路（Progressive GAN） - 普歸一化生成式對抗網路（Spectral Normalization GAN，SNGAN） - 自注意力生成式對抗網路（Self-Attention GAN，SAGAN） - 前沿應用 - 行人再識別（Person Re-Identification，Re-ID） - 圖片生成解決資料缺乏難題 - 風格遷移解決訓練集內部偏差問題 - 風格遷移解決跨資料集學習問題 - 對抗訓練解決異構資料學習難題 生成式對抗網路實踐 - 概念介紹 - U型網路（U-Net） - 殘差生成器（ResGenerator） - 補丁GAN（PatchGAN） - 例項正則化（Instance Normalization） - Pixel2Pixel方法 - CycleGAN方法 - StarGAN方法 程式碼練習 生成式對抗網路(double moon) 一個簡單的 GAN 生成器和判別器的結構都非常簡單，具體如下： - 生成器： 32 ==> 128 ==> 2 - 判別器： 2 ==> 128 ==> 1 生成器生成的是樣本，即一組座標（x,y），我們希望生成器能夠由一組任意的 32組噪聲生成座標（x,y）處於兩個半月形狀上。 判別器輸入的是一組座標（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.0001) optimizer_D = torch.optim.Adam(net_D.parameters(),lr=0.0001) - 下面為對抗訓練的過程： 把學習率修改為 0.001，batch_size改大到250（loss降低，改善效果） # 定義網路的優化器 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 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) Epoch 950 , D loss: 11.052919387817383, G loss: 5.581031799316406 - 利用噪聲生成一組資料觀察一下： 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() 其中，白色的是原來的真實樣本，黑色的點是生成器生成的樣本。  CGAN 和 DCGAN CGAN 首先實現CGAN。下面分別是 判別器 和 生成器 的網路結構，可以看出網路結構非常簡單，具體如下： - 生成器：(784 + 10) ==> 512 ==> 256 ==> 1 - 判別器：(100 + 10) ==> 128 ==> 256 ==> 512 ==> 784 可以看出，去掉生成器和判別器那 10 維的標籤資訊，和普通的GAN是完全一樣的。下面是網路的具體實現程式碼： class Discriminator(nn.Module): '''全連線判別器，用於1x28x28的MNIST資料,輸出是資料和類別''' def __init__(self): super(Discriminator, self).__init__() self.model = nn.Sequential( nn.Linear(28*28+10, 512), nn.LeakyReLU(0.2, inplace=True), nn.Linear(512, 256), nn.LeakyReLU(0.2, inplace=True), nn.Linear(256, 1), nn.Sigmoid() ) def forward(self, x, c): x = x.view(x.size(0), -1) validity = self.model(torch.cat([x, c], -1)) return validity class Generator(nn.Module): '''全連線生成器，用於1x28x28的MNIST資料，輸入是噪聲和類別''' def __init__(self, z_dim): super(Generator, self).__init__() self.model = nn.Sequential( nn.Linear(z_dim+10, 128), nn.LeakyReLU(0.2, inplace=True), nn.Linear(128, 256), nn.BatchNorm1d(256, 0.8), nn.LeakyReLU(0.2, inplace=True), nn.Linear(256, 512), nn.BatchNorm1d(512, 0.8), nn.LeakyReLU(0.2, inplace=True), nn.Linear(in_features=512, out_features=28*28), nn.Tanh() ) def forward(self, z, c): x = self.model(torch.cat([z, c], dim=1)) x = x.view(-1, 1, 28, 28) return x - 下面定義相關的模型： # 初始化構建判別器和生成器 discriminator = Discriminator().to(device) generator = Generator(z_dim=z_dim).to(device) # 初始化二值交叉熵損失 bce = torch.nn.BCELoss().to(device) ones = torch.ones(batch_size).to(device) zeros = torch.zeros(batch_size).to(device) # 初始化優化器，使用Adam優化器 g_optimizer = optim.Adam(generator.parameters(), lr=learning_rate) d_optimizer = optim.Adam(discriminator.parameters(), lr=learning_rate) - 開始訓練： # 開始訓練，一共訓練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())) - 下面我們用隨機噪聲生成一組影象，看看CGAN的效果： #用於生成效果圖 # 生成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。兩者程式碼也非常類似，我們下面比較一下。 DCGAN 下面我們實現DCGAN。下面分別是 判別器 和 生成器 的網路結構，和之前類似，只是使用了卷積結構。 class D_dcgan(nn.Module): '''滑動卷積判別器''' def __init__(self): super(D_dcgan, self).__init__() self.conv = nn.Sequential( # 第一個滑動卷積層，不使用BN，LRelu啟用函式 nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3, stride=2, padding=1), nn.LeakyReLU(0.2, inplace=True), # 第二個滑動卷積層，包含BN，LRelu啟用函式 nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, stride=2, padding=1), nn.BatchNorm2d(32), nn.LeakyReLU(0.2, inplace=True), # 第三個滑動卷積層，包含BN，LRelu啟用函式 nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=2, padding=1), nn.BatchNorm2d(64), nn.LeakyReLU(0.2, inplace=True), # 第四個滑動卷積層，包含BN，LRelu啟用函式 nn.Conv2d(in_channels=64, out_channels=128, kernel_size=4, stride=1), nn.BatchNorm2d(128), nn.LeakyReLU(0.2, inplace=True) ) # 全連線層+Sigmoid啟用函式 self.linear = nn.Sequential(nn.Linear(in_features=128, out_features=1), nn.Sigmoid()) def forward(self, x): x = self.conv(x) x = x.view(x.size(0), -1) validity = self.linear(x) return validity class G_dcgan(nn.Module): '''反滑動卷積生成器''' def __init__(self, z_dim): super(G_dcgan, self).__init__() self.z_dim = z_dim # 第一層：把輸入線性變換成256x4x4的矩陣，並在這個基礎上做反捲機操作 self.linear = nn.Linear(self.z_dim, 4*4*256) self.model = nn.Sequential( # 第二層：bn+relu nn.ConvTranspose2d(in_channels=256, out_channels=128, kernel_size=3, stride=2, padding=0), nn.BatchNorm2d(128), nn.ReLU(inplace=True), # 第三層：bn+relu nn.ConvTranspose2d(in_channels=128, out_channels=64, kernel_size=3, stride=2, padding=1), nn.BatchNorm2d(64), nn.ReLU(inplace=True), # 第四層:不使用BN，使用tanh啟用函式 nn.ConvTranspose2d(in_channels=64, out_channels=1, kernel_size=4, stride=2, padding=2), nn.Tanh() ) def forward(self, z): # 把隨機噪聲經過線性變換，resize成256x4x4的大小 x = self.linear(z) x = x.view([x.size(0), 256, 4, 4]) # 生成圖片 x = self.model(x) return x - 定義相關的模型： # 構建判別器和生成器 d_dcgan = D_dcgan().to(device) g_dcgan = G_dcgan(z_dim=z_dim).to(device) def weights_init_normal(m): classname = m.__class__.__name__ if classname.find('Conv') != -1: torch.nn.init.normal_(m.weight.data, 0.0, 0.02) elif classname.find('BatchNorm2d') != -1: torch.nn.init.normal_(m.weight.data, 1.0, 0.02) torch.nn.init.constant_(m.bias.data, 0.0) # 使用均值為0，方差為0.02的正態分佈初始化神經網路 d_dcgan.apply(weights_init_normal) g_dcgan.apply(weights_init_normal) # 初始化優化器，使用Adam優化器 g_dcgan_optim = optim.Adam(g_dcgan.parameters(), lr=learning_rate) d_dcgan_optim = optim.Adam(d_dcgan.parameters(), lr=learning_rate) # 載入MNIST資料集，和之前不同的是，DCGAN輸入的影象被 resize 成 32*32 畫素 dcgan_dataloader = torch.utils.data.DataLoader( datasets.MNIST('./data', train=True, download=True, transform=transforms.Compose([transforms.Resize(32), transforms.ToTensor(),transforms.Normalize((0.5,), (0.5,))]) ), batch_size, shuffle=True, drop_last=True) - 開始訓練模型： # 開始訓練，一共訓練 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())) - 下面我們用一組隨機噪聲輸出影象，看看DCGAN的效果： #用於生成效果圖 # 生成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')  這裡只用了30個 epoch，效果還可以，如果增大 epoch 的數量，效果可能會