生成式對抗網路 （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

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