2. 程式人生 > 實用技巧 >第六週: 生成式對抗網路

第六週: 生成式對抗網路

阿新 • • 發佈：2020-09-12

視訊學習

1. GAN（生成式對抗網路）

GAN的框架

GAN的工作原理

  • 由判別器和生成器組成

  • 判別器（Discriminator)：區分真實(real)樣本和虛假(fake)樣本。對於真實樣本，儘可能給出高的評分1；對於虛假資料，儘可能給出低的評分0

  • 生成器（Generator)：欺騙判別器。生成虛假資料，使得判別器D能夠儘可能給出高的評分1

  • 生成器和判器存在著對抗的關係，通過不斷的對抗使最終結果無限接近我們想要的結果

  • 隨機噪聲z：從一個先驗分佈（人為定義，一般是均勻分佈或者正態分佈）中隨機取樣的向量

  • 真實樣本x：從資料庫中取樣的樣本；合成樣本G(z)：生成模型G輸出的樣本

GAN目標函式

GAN訓練演算法

  1. 隨機初始化生成器和判別器

  2. 交替訓練判別器D和生成器G，直到收斂

    （1）步驟1：固定生成器G，訓練判別器D區分真實影象與合成影象，賦予真實影象高分，賦予合成影象低分

    （2) 步驟2：固定判別器D，訓練生成器G欺騙判別器D，更新生成器的引數，使其合成的圖片被生成器D賦予高分

    重複執行以上兩步

GAN訓練策略

KL散度與JS散度

極大似然估計

GAN在做的事情

  • 最大化判別器損失，等價於計算合成數據分佈和真實資料分佈的JS散度

  • 最小化生成器損失，等價於最小化JS散度（也就是優化生成模型）

2. cGAN（條件生成式對抗網路）

網路結構

目標函式

3. DcGAN（深度卷積生成式對抗網路）

網路結構（判別器）

  • 使用滑動卷積（strided convolution）

  • 除了輸入層，全部使用批歸一化

  • 使用Leaky ReLu啟用函式

  • 除了最後一層，不使用全連線層

網路結構（生成器）

  • 使用滑動反捲積（fractional strided convolution）

  • 除了輸出層，全部使用批歸一化

  • 使用ReLu啟用函式，最後一層使用tanh啟用函式

滑動卷積、滑動反捲積：

使得判別器和生成器可以學習自己的上取樣和下采樣策略

批歸一化：

訓練更穩定

Tanh啟用函式：

更快的學習到真實資料的顏色空間

訓練策略

  • 資料預處理：所有輸入資料歸一化到[-1,1]

  • 啟用函式：Leaky ReLu的斜率設定為0.2

  • 初始化：使用均值為0，標準差為0.02的正態分佈初始化網路引數

  • 優化器：使用Adam優化器，學習率為0.0002，betal=0.5，beta2=0.999

程式碼練習

GAN

首先借助於 sklearn.datasets.make_moons 庫，生成雙半月形的資料，同時把資料點畫出來。可以看出，資料散點呈現兩個半月形狀。

  • 生成器： 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)

對抗訓練過程:

batch_size = 50
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)



可以看出訓練結果是十分不理想的，其中，白色的是原來的真實樣本，黑色的點是生成器生成的樣本。看起來，效果是不令人滿意的。現在把學習率修改為 0.001，batch_size改大到250：



loss明顯減小了，訓練結果比一開始好多了。

CGAN和DCGAN

Conditional Generative Adversarial Nets，簡單來說就是條件生成-對抗網路。在生成器以及判別器上它都多了一個標籤作為輸入。

所以，生成器的輸入是噪聲和標籤，輸出還是生成圖；判別器的輸入是生成圖，真實圖以及標籤，輸出還是真和假。

這裡epoch我設定為100

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

訓練過程：

# 開始訓練，一共訓練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()))



結果十分不理想

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



epoch為30結果還是可以的，但是epoch設為100結果很不理想。

相關推薦

第六週: 生成式對抗網路

視訊學習 1. GAN（生成式對抗網路） GAN的框架 GAN的工作原理 由判別器和生成器組成

第六週：生成式對抗網路

第六週：生成式對抗網路 目錄 視訊總結 問題總結 程式碼練習 3.1 GAN 3.2 CGAN 3.3 DCGAN

GAN——生成式對抗網路

GAN的定義 　　GAN是一個評估和學習生成模型的框架。生成模型的目標是學習到輸入樣本的分佈，用來生成樣本。GAN和傳統的生成模型不同，使用兩個內建模型以“對抗”的方式來使學習分佈不斷接近輸入樣本分佈

生成式對抗網路

如果說前面學習的CNN主要用於影象分類或語義分割，那麼GAN主要用於影象生成或影象轉換，更多有趣的應用可參照：https://blog.csdn.net/qq_25737169/article/details/80874717

生成式對抗網路（Generative Adversarial Networks, GANs）

1 原始的 GANs 1.1 GANs 的結構 GANs 的結果圖如下所示： 生成式對抗網路 GANs 最重要的兩個部分為：

【實踐】偽造名人的臉—做一個小示例瞭解生成式對抗網路

生成式對抗網路(GAN)的概念由Ian Goodfellow提出。Goodfellow使用了藝術評論家和藝術家的比喻來描述這兩個模型比喻發生器和鑑別，它們組成了GAN。一個藝術評論家(鑑別器)試圖判斷影象是不是偽造的。一個想愚弄藝術評

網路班第六週

重要知識點回顧一 1.軟體執行和編譯 1.1軟體相關概念 1.1.1ABI ABI即 Application Binary InterfaceWindows與Linux不相容

2019-2020-1學期20212419《網路空間安全專業》第六週學習總結

第十五章網路 聯網 通常是依靠電線，但也可通過無線連線 網路連結的裝置不只是計算機

2021-2022-1學期 20212307 《網路空間安全專業導論》第六週學習總結

收穫 第十五章 連網 計算機網路是為了通訊和共享資源而以各種方式連在一起的一組計算機裝置

2021-2022-1學期20212418《網路空間安全導論》第六週學習總結

第十五章網路 一、連網：1、計算機網路是為了通訊和共享資源而以種方式連在一起的一組計算機裝置。2、計算機之間聯接靠物理電線或電纜，亦或是使用無線電波或紅外訊號傳導資料。（網路不是由物理連線定義，而是由通

2019-2020-1學期 20212412 《網路空間安全專業導論》第六週學習總結

第十五章一.連網計算機網路：為了通訊和共享資源而連線在一起的一組計算裝置。無線連線：沒有物理電線的網路連線。節點（主機）：網路中任何可定址的裝置。資料傳輸率（頻寬）：資料從網路中的一個地點傳輸到另一個

2019-2020-1學期20212407《網路空間安全專業導論》第六週學習總結

第十五章“網路”思維導圖如下： 網路 15.1 連網 計算機網路(computer network):為了通訊和共享資源而連線在一起的一組計算裝置。

20211911 2021-2022-2 《網路攻防實踐》第六週實踐報告

1.實踐內容 Windows作業系統基本結構 （1） windows系統的核心基本模組 Windows執行體

python學習-第六週：高階函式

高階函式 遞迴函式 遞迴函式就是定義了一個函式，然後在函式內，自己呼叫了自己這個函式

8.16第六週學習記錄

8.16第六週學習記錄 這周電腦出了點問題，進度有點慢... 本週學習內容： 1.建立用於計算的屬性

學習java的第六週

面向物件程式設計 類與物件的建立 使用new關鍵字建立物件 使用new關鍵字建立的時候，除了分配記憶體空間之外，還會給建立好的物件進行預設的初始化以及對類中構造器的呼叫。

第六週學習報告

本週划水水的一週，就寫了一個例項，前面打基礎的時候覺得不是很難，但真正上手的時候才知道靈活應用這些理論有多難，一百多行程式碼憋了好幾天，還反覆回去看QAQ

第六週LeetCode記錄

10.19 27. 01矩陣 給定一個由 0 和 1 組成的矩陣，找出每個元素到最近的 0 的距離。

Android第六週

商城 MainActivity.java <?xml version=\"1.0\" encoding=\"utf-8\"?> <RelativeLayout xmlns:android=\"http://schemas.android.com/apk/res/android\"

第六週

<?xml version=\"1.0\" encoding=\"utf-8\"?> <manifest xmlns:android=\"http://schemas.android.com/apk/res/android\"