第六週：生成式對抗網絡
視頻學習網絡
- GAN應用：圖像着色，圖像超像素，背景模糊，人臉生成，人臉定製，卡通頭像生成，文本生成圖片，字體變換，風格變換，圖像修復，幀預測。
生成式對抗網絡基礎app
- 生成式對抗網絡（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）
- 圖片生成解決數據缺少難題
- 風格遷移解決訓練集內部誤差問題
- 風格遷移解決跨數據集學習問題
- 對抗訓練解決異構數據學習難題
生成式對抗網絡實踐dom
- 概念介紹
- U型網絡（U-Net）
- 殘差生成器（ResGenerator）
- 補丁GAN（PatchGAN）
- 實例正則化（Instance Normalization）
- Pixel2Pixel方法
- CycleGAN方法
- StarGAN方法
代碼練習ide
生成式對抗網絡(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 的數量，效果可能會更好。
- 1. 對抗式生成網絡學習筆記（第一週）
- 2. 生成對抗網絡(GAN)
- 3. GAN生成對抗網絡
- 4. 生成對抗網絡
- 5. 生成對抗網絡（二）
- 6. 生成對抗網絡（GAN）
- 7. GAN—生成對抗網絡
- 8. 圖生成對抗網絡
- 9. 生成對抗網絡（一）
- 10. 對抗生成網絡
- 更多相關文章...
- • Eclipse 生成jar包 - Eclipse 教程
- • Rust 生命週期 - RUST 教程
- • 使用Rxjava計算圓周率
- • RxJava操作符（六）Utility
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 對抗式生成網絡學習筆記（第一週）
- 2. 生成對抗網絡(GAN)
- 3. GAN生成對抗網絡
- 4. 生成對抗網絡
- 5. 生成對抗網絡（二）
- 6. 生成對抗網絡（GAN）
- 7. GAN—生成對抗網絡
- 8. 圖生成對抗網絡
- 9. 生成對抗網絡（一）
- 10. 對抗生成網絡