GAN代碼實現

GAN

生成式對抗網絡

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons

import torch
# 使用GPU訓練，可以在菜單 "代碼執行工具" -> "更改運行時類型" 里進行設置
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# 這是一個展示數據的函數
def plot_data(ax, X, Y, color = 'bone'):
    plt.axis('off')
    ax.scatter(X[:, 0], X[:, 1], s=1, c=Y, cmap=color)

借助於 sklearn.datasets.make_moons 庫，生成雙半月形的數據，同時把數據點畫出來。

可以看出，數據散點呈現兩個半月形狀。

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），我們希望生成器能夠由一組任意的 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)

顯示 loss 的變化情況：

利用生成器生成一組假樣本，觀察是否符合兩個半月形狀的數據分布：

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()

不知道為什么測試了很多次，都達不到老師示例里的效果。

現在把學習率修改為 0.001，batch_size改大到250，再試一次：

# 定義網絡的優化器
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)

下面我們生成更多的樣本觀察一下

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();