第六週：生成式對抗網路

yzm10發表於2020-09-12

視訊學習

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[j10+i, 0, :, :].detach().cpu().numpy()
img = img.reshape([28, 28])
plt.subplot(10, 10, j10+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[j10+i, 0, :, :].detach().cpu().numpy()
img = img.reshape([32, 32])
plt.subplot(10, 10, j10+i+1)
plt.imshow(img, 'gray')

這裡只用了30個 epoch，效果還可以，如果增大 epoch 的數量，效果可能會更好。

對抗樣本與生成式對抗網路
2017-05-31
【機器學習】李宏毅——生成式對抗網路GAN
2022-12-18
機器學習
GAN生成對抗網路-DCGAN原理與基本實現-深度卷積生成對抗網路03
2020-12-12
卷積
GAN實戰筆記——第六章漸進式增長生成對抗網路（PGGAN）
2022-03-06
筆記
實戰生成對抗網路[1]：簡介
2018-10-20
LSGAN：最小二乘生成對抗網路
2018-10-15
卷積生成對抗網路（DCGAN）---生成手寫數字
2020-06-06
卷積
實戰生成對抗網路[2]：生成手寫數字
2019-02-27
萬字綜述之生成對抗網路（GAN）
2019-03-19
轉：生成對抗網路GANs理解（附程式碼）
2017-06-05
解讀生成對抗網路（GAN）之U-GAN-IT
2020-08-05
生成對抗網路的進步多大，請看此文
2019-09-15
如何應用TFGAN快速實踐生成對抗網路？
2019-03-02
[深度學習]生成對抗網路的實踐例子
2020-10-26
深度學習
楊強教授漫談《西部世界》、生成式對抗網路及遷移學習
2017-05-05
遷移學習
【深度學習理論】通俗理解生成對抗網路GAN
2018-03-02
深度學習
生成對抗網路及其變體的論文彙總
2017-04-21
訓練生成對抗網路的一些技巧和陷阱
2019-11-04
生成對抗網路綜述：從架構到訓練技巧
2019-02-14
架構
0901-生成對抗網路GAN的原理簡介
2021-05-08
深度學習界明星：生成對抗網路與Improving GAN
2017-11-13
深度學習
谷歌開源TFGAN：輕量級生成對抗網路工具庫
2017-12-13
谷歌
海量案例！生成對抗網路（GAN）的18個絕妙應用
2019-07-31
生成對抗網路，AI將圖片轉成漫畫風格
2022-12-19
AI
生成對抗網路原理與應用：GAN如何使生活更美好
2017-08-23
對抗網路學習記錄
2020-10-25
生成對抗網路（GANs）最新家譜：為你揭秘GANs的前世今生
2018-01-30
理解生成對抗網路，一步一步推理得到GANs（二）
2019-08-15
理解生成對抗網路，一步一步推理得到GANs（一）
2019-08-15
生成對抗網路（GANs）最新家譜：為你揭祕GANs的前世今生
2018-01-30
用生成對抗網路給雪人上色，探索人工智慧時代的美學
2017-12-30
人工智慧
極端影象壓縮的生成對抗網路，可生成低位元速率的高質量影象
2018-04-17
極端影像壓縮的生成對抗網路，可生成低位元速率的高質量影像
2018-04-17
GAN實戰筆記——第七章半監督生成對抗網路（SGAN）
2022-03-13
筆記
帶自注意力機制的生成對抗網路，實現效果怎樣？
2018-06-06
送書 | AI插畫師：如何用基於PyTorch的生成對抗網路生成動漫頭像？
2019-03-04
AIPyTorch
一文入門人工智慧的掌上明珠：生成對抗網路（GAN）
2020-08-03
人工智慧
白話生成對抗網路 GAN，50 行程式碼玩轉 GAN 模型！【附原始碼】
2018-07-31
行程模型原始碼

第六週：生成式對抗網路

初始化構建判別器和生成器

初始化二值交叉熵損失

初始化優化器，使用Adam優化器

開始訓練，一共訓練total_epochs

用於生成效果圖

生成100個隨機噪聲向量

生成100個one_hot向量，每類10個

構建判別器和生成器

使用均值為0，方差為0.02的正態分佈初始化神經網路

初始化優化器，使用Adam優化器

載入MNIST資料集，和之前不同的是，DCGAN輸入的影像被 resize 成 32*32 畫素

開始訓練，一共訓練 total_epochs

用於生成效果圖

生成100個隨機噪聲向量

相關文章