【生成式网络】入门篇(二)：GAN的 代码和结果记录

已于 2022-11-25 11:29:11 修改
阅读量1.4k 收藏 17
点赞数
分类专栏： Deep Learning Computer Vision 文章标签： 生成对抗网络 深度学习 pytorch
于 2022-11-24 17:28:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fangjin_kl/article/details/128017335
版权

GAN非常经典，我就不介绍具体原理了，直接上代码。
感兴趣的可以阅读，里面有更多变体。
https://github.com/rasbt/deeplearning-models/tree/master/pytorch_ipynb/gan

GAN 在 MINIST上的代码和效果

import os
# os.chdir(os.path.dirname(__file__))
import torch
import torch.nn as nn
import torch.functional as F

import torchvision
import torchvision.transforms as transforms
from torch.utils.tensorboard import SummaryWriter


device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
sample_dir = 'samples'
if not os.path.exists(sample_dir):
    os.makedirs(sample_dir, exist_ok=True)

writer = SummaryWriter(sample_dir)

# Hyper-parameters
image_size = 784
latent_size = 64
hidden_size = 256
num_epochs = 200
batch_size = 128
learning_rate = 0.0002

# MNIST
T = transforms.Compose([
                transforms.ToTensor(),
                transforms.Normalize(mean=[0.5],   # 1 for greyscale channels
                                     std=[0.5])])

dataset_train = torchvision.datasets.MNIST(root='../data',
                                    transform=T,
                                    train=True)
dataset_test = torchvision.datasets.MNIST(root='../data',
                                    transform=T,
                                    train=True)

dataloader_train = torch.utils.data.DataLoader(dataset=dataset_train,
                                    batch_size=batch_size,
                                    shuffle=True,
                                    drop_last=True)  
dataloader_test = torch.utils.data.DataLoader(dataset=dataset_test,
                                    batch_size=batch_size,
                                    shuffle=False)     

# GAN model

D = nn.Sequential(
    nn.Linear(image_size, hidden_size),
    nn.LeakyReLU(0.2),
    nn.Linear(hidden_size, hidden_size),
    nn.LeakyReLU(0.2),
    nn.Linear(hidden_size, 1),
    nn.Sigmoid()
)

G = nn.Sequential(
    nn.Linear(latent_size, hidden_size),
    nn.ReLU(),
    nn.Linear(hidden_size, hidden_size),
    nn.ReLU(),
    nn.Linear(hidden_size, image_size),
    nn.Tanh()
)



D = D.to(device)
G = G.to(device)

criterion = nn.BCELoss()
d_optimizer = torch.optim.Adam(D.parameters(), lr = learning_rate)
g_optimizer = torch.optim.Adam(G.parameters(), lr = learning_rate)

def reset_grad():
    d_optimizer.zero_grad()
    g_optimizer.zero_grad()

def denorm(x):
    out = (x+1)/2
    return out.clamp(0, 1)

ld = len(dataloader_train)

accumulated_iter = 0
for epoch in range(num_epochs):
    for i, (x, _) in enumerate(dataloader_train):
        # forward
        x = x.to(device).view(-1, image_size)

        real_label = torch.ones(batch_size, 1).to(device)
        fake_label = torch.zeros(batch_size, 1).to(device)

        # ================================================================== #
        #                      Train the discriminator                       #
        # ================================================================== #
        # discriminate real data
        real_output = D(x)
        d_loss_real = criterion(real_output, real_label)
        # generate fake data
        z = torch.randn(batch_size, latent_size).to(device)
        fake_data = G(z)
        # discriminate fake data
        fake_output = D(fake_data)
        d_loss_fake = criterion(fake_output, fake_label)

        # compute the loss
        d_loss = d_loss_fake + d_loss_real
        reset_grad()
        d_loss.backward()
        d_optimizer.step()

        # ================================================================== #
        #                        Train the generator                         #
        # ================================================================== #
        # compute the loss with fake image
        z = torch.randn(batch_size, latent_size).to(device)
        fake_data = G(z)
        fake_output = D(fake_data)

        # We train G to maximize log(D(G(z)) instead of minimizing log(1-D(G(z)))
        g_loss = criterion(fake_output, real_label)
        reset_grad()
        g_loss.backward()
        g_optimizer.step()

        accumulated_iter += 1

        writer.add_scalar('loss_d', d_loss.item(), global_step=accumulated_iter)
        writer.add_scalar('loss_g', g_loss.item(), global_step=accumulated_iter)

        if (i+1) % 10 == 0:
            print("Epoch[{}/{}], Step [{}/{}], D Loss: {:.4f}, G Loss: {:.4f}".format(epoch+1, num_epochs, i+1, ld, d_loss.item(), g_loss.item()))
    
    # 根据test数据集来看重建效果
    with torch.no_grad():
        writer.add_images('images_src', denorm(x).view(-1, 1, 28, 28), global_step=epoch)

    # 根据随机变量decode来看重建效果
    with torch.no_grad():
        writer.add_images('images_gen', denorm(fake_data).view(-1, 1, 28, 28), global_step=epoch)

    with torch.no_grad():
        x_all = torch.zeros(10, 10, 1, 28, 28).to(device)
        for a, da in enumerate(torch.linspace(-0.5, 0.5, 10)):
            for b, db in enumerate(torch.linspace(-0.5, 0.5, 10)):
                z = torch.zeros(1, latent_size).to(device)
                z[0, 0] = da
                z[0, 1] = db
                fake_data = G(z).view(-1, 1, 28, 28)
                x_all[a,b] = denorm(fake_data[0])
        
        x_all = x_all.view(10*10, 1, 28, 28)
        imgs = torchvision.utils.make_grid(x_all, pad_value=2,nrow=10)
        writer.add_image('images_uniform', imgs, epoch, dataformats='CHW')

writer.close()

生成的图像如下，效果还行

在这里插入图片描述
简单的提一下这个loss，可以看出是由Discriminator和Generator两部分loss组成，对于前者来说，真样本label为1，经过G生成的fake样本label为0，这里就可以用BCELoss针对正负样本算loss了。对于Generator而言，虽然是一个变体，但是可以简单理解成，想用fake样本欺骗discriminatory，那就相当于希望G生成的样本label为1，那就把这个送进BCELoss进行计算。

DCGAN 在 Anime上的实验

这里，在二次元的头像任务上，我就使用DCGAN来做实验，DCGAN简单来说，就是用了deep CNN做backbone，网络比较简单
在这里插入图片描述
在这里插入图片描述
需要注意，在实际实现中，会把latent code比如128维，给写成128 * 1* 1的向量，这样就可以使用全卷积操作了。实际使用代码如下

import os
# os.chdir(os.path.dirname(__file__))
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.datasets as dset
from torchvision import transforms
from torchvision.utils import save_image
from torch.utils.tensorboard import SummaryWriter

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

sample_dir = 'samples'
if not os.path.exists(sample_dir):
    os.makedirs(sample_dir, exist_ok=True)

writer = SummaryWriter(sample_dir)

# Hyper-parameters
h_dim = 1024
z_dim = 128
num_epochs = 200
batch_size = 128
learning_rate = 0.0002
data_root = '../data/anime-faces'

# Anime dataset
def is_valid_file(fpath):
    fname = os.path.basename(fpath)
    return fname[0] != '.'

T = transforms.Compose([
            transforms.Scale(64),
            transforms.ToTensor(),
            transforms.Normalize((0.5,0.5,0.5), (0.5,0.5,0.5)), # bring images to (-1,1)
        ])
dataset = dset.ImageFolder(
    root=data_root,
    transform=T,
    is_valid_file=is_valid_file
)
data_loader = torch.utils.data.DataLoader(dataset, 
                                        batch_size=batch_size,
                                        shuffle=True, 
                                        num_workers=1,
                                        drop_last=True)

def reset_grad():
    d_optimizer.zero_grad()
    g_optimizer.zero_grad()

def denorm(x):
    out = (x+1)/2
    return out.clamp(0, 1)

# GAN model
NUM_MAPS_GEN = 64

class G(nn.Module):
    def __init__(self, h_dim=h_dim, z_dim=z_dim):
        super(G, self).__init__()

        self.generator = nn.Sequential(
            #
            # input size: vector z of size LATENT_DIM
            #
            nn.ConvTranspose2d(z_dim, NUM_MAPS_GEN*8, 
                               kernel_size=4, stride=1, padding=0,
                               bias=False), # bias is redundant when using BatchNorm
            nn.BatchNorm2d(NUM_MAPS_GEN*8),
            nn.ReLU(True),
            #
            # size: NUM_MAPS_GEN*8 x 4 x 4
            #
            nn.ConvTranspose2d(NUM_MAPS_GEN*8, NUM_MAPS_GEN*4, 
                               kernel_size=4, stride=2, padding=1,
                               bias=False),
            nn.BatchNorm2d(NUM_MAPS_GEN*4),
            nn.ReLU(True),
            #
            # size: NUM_MAPS_GEN*4 x 8 x 8
            #
            nn.ConvTranspose2d(NUM_MAPS_GEN*4, NUM_MAPS_GEN*2, 
                               kernel_size=4, stride=2, padding=1,
                               bias=False),
            nn.BatchNorm2d(NUM_MAPS_GEN*2),
            nn.ReLU(True),
            #
            # size: NUM_MAPS_GEN*2 x 16 x 16
            #
            nn.ConvTranspose2d(NUM_MAPS_GEN*2, NUM_MAPS_GEN, 
                               kernel_size=4, stride=2, padding=1,
                               bias=False),
            nn.BatchNorm2d(NUM_MAPS_GEN),
            nn.ReLU(True),   
            #
            # size: NUM_MAPS_GEN x 32 x 32
            #
            nn.ConvTranspose2d(NUM_MAPS_GEN, 3, 
                               kernel_size=4, stride=2, padding=1,
                               bias=False),
            #
            # size: IMAGE_SIZE[2] x 64 x 64
            #  
            nn.Tanh()
        )

    def forward(self, z):
        return self.generator(z)

# GAN model
NUM_MAPS_DIS = 64

class D(nn.Module):
    def __init__(self, h_dim=h_dim, z_dim=z_dim):
        super(D, self).__init__()

        self.discriminator = nn.Sequential(
            #
            # input size IMAGE_SIZE[2] x IMAGE_SIZE[0] x IMAGE_SIZE[1]
            #
            nn.Conv2d(3, NUM_MAPS_DIS, kernel_size=4, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),
            #
            # size: NUM_MAPS_DIS x 32 x 32
            #              
            nn.Conv2d(NUM_MAPS_DIS, NUM_MAPS_DIS*2,
                      kernel_size=4, stride=2, padding=1,
                      bias=False),        
            nn.BatchNorm2d(NUM_MAPS_DIS*2),
            nn.LeakyReLU(0.2, inplace=True),
            #
            # size: NUM_MAPS_DIS*2 x 16 x 16
            #   
            nn.Conv2d(NUM_MAPS_DIS*2, NUM_MAPS_DIS*4,
                      kernel_size=4, stride=2, padding=1,
                      bias=False),        
            nn.BatchNorm2d(NUM_MAPS_DIS*4),
            nn.LeakyReLU(0.2, inplace=True),
            #
            # size: NUM_MAPS_DIS*4 x 8 x 8
            #   
            nn.Conv2d(NUM_MAPS_DIS*4, NUM_MAPS_DIS*8,
                      kernel_size=4, stride=2, padding=1,
                      bias=False),        
            nn.BatchNorm2d(NUM_MAPS_DIS*8),
            nn.LeakyReLU(0.2, inplace=True),
            #
            # size: NUM_MAPS_DIS*8 x 4 x 4
            #   
            nn.Conv2d(NUM_MAPS_DIS*8, 1,
                      kernel_size=4, stride=1, padding=0),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.discriminator(x)

def reconstruct_loss_binaray(x, y):
    return F.binary_cross_entropy(x, y, size_average=False)

def reconstruct_loss_real(x, y):
    return F.mse_loss(x, y, size_average=False)

def kl_loss(mu, log_var):
    return -0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())


D = D().to(device)
G = G().to(device)
criterion = nn.BCELoss()
d_optimizer = torch.optim.Adam(D.parameters(), lr = learning_rate)
g_optimizer = torch.optim.Adam(G.parameters(), lr = learning_rate)

ld = len(data_loader)
accumulated_iter = 0
for epoch in range(num_epochs):
    for i, (x, _) in enumerate(data_loader):
        # forward
        x = x.to(device)

        real_label = torch.ones(batch_size, 1).to(device)
        fake_label = torch.zeros(batch_size, 1).to(device)

        # ================================================================== #
        #                      Train the discriminator                       #
        # ================================================================== #
        # discriminate real data
        real_output = D(x)
        d_loss_real = criterion(real_output, real_label)
        # generate fake data
        z = torch.randn(batch_size, z_dim, 1, 1,).to(device)
        fake_data = G(z)
        # discriminate fake data
        fake_output = D(fake_data)
        d_loss_fake = criterion(fake_output, fake_label)

        # compute the loss
        d_loss = 0.5*(d_loss_fake + d_loss_real)
        reset_grad()
        d_loss.backward()
        d_optimizer.step()

        # ================================================================== #
        #                        Train the generator                         #
        # ================================================================== #
        # compute the loss with fake image
        z = torch.randn(batch_size, z_dim, 1, 1,).to(device)
        fake_data = G(z)
        fake_output = D(fake_data)

        # We train G to maximize log(D(G(z)) instead of minimizing log(1-D(G(z)))
        g_loss = criterion(fake_output, real_label)
        reset_grad()
        g_loss.backward()
        g_optimizer.step()

        accumulated_iter += 1

        writer.add_scalar('loss_d', d_loss.item(), global_step=accumulated_iter)
        writer.add_scalar('loss_g', g_loss.item(), global_step=accumulated_iter)

        if (i+1) % 10 == 0:
            print("Epoch[{}/{}], Step [{}/{}], D Loss: {:.4f}, G Loss: {:.4f}".format(epoch+1, num_epochs, i+1, ld, d_loss.item(), g_loss.item()))
    

    with torch.no_grad():
        writer.add_images('images_src', denorm(x), global_step=epoch)
        writer.add_images('images_gen', denorm(fake_data), global_step=epoch)

    with torch.no_grad():
        x_all = torch.zeros(20, 20, 3, 64, 64).to(device)
        for a, da in enumerate(torch.linspace(-1, 1, 20)):
            for b, db in enumerate(torch.linspace(-1, 1, 20)):
                z = torch.zeros(1, z_dim, 1, 1).to(device)
                z[0, 0] = da
                z[0, 1] = db
                fake_data = G(z)
                x_all[a,b] = denorm(fake_data[0])
        
        x_all = x_all.view(-1, 3, 64, 64)
        imgs = torchvision.utils.make_grid(x_all, pad_value=2, nrow=20, normalize=True)
        writer.add_image('images_uniform', imgs, epoch, dataformats='CHW')

writer.close()

生成的数据如下，中间曾经似乎在往好发展，后面却越训练约差，说明这个训练过程确实不容易掌控，也不稳定
在这里插入图片描述

Improved techniques for training GANs.

这里介绍一个小trick，来自 Improved techniques for training GANs 这篇论文
label smoothing， 把 real image labels 1改成 0.9。
可以简单的这么操作

real_label= torch.ones(targets.size(0)).float().to(device) * 0.9

WGAN

Wasserstein GAN，一种经典的变体，核心思想是一种新的loss，能比较好的提升训练的稳定性。GAN网络训练的重点在于均衡生成器与判别器，若判别器太 强，loss没有再下降，生成器学习不到东西，生成图像的质量 便不会再有提升。原始GAN定义的生成器loss 等价变换为最小化真实分布与生成分布之间的JS散度。我们通过 优化JS散度就能将生成分布拉向真实分布，最终以假乱真。 这个希望在两个分布有所重叠的时候是成立的，但是如果两 个分布完全没有重叠的部分，或者它们重叠的部分可忽略， 那它们的JS散度就一直是 log2，这样在距离远的时候，很难优化。

Wasserstein距离 衡量两个分布之间的距离 Wasserstein距离 优越性在于： 即使两个分布没有任何重叠，也可以反应他们之间的距离。

核心区别是：

  • 判别器最后一层去掉sigmoid
  • 生成器和判别器的loss不取log
  • 每次更新判别器的参数之后把它们的值截断到不超过一个 固定常数c
  • 不要用基于动量的优化算法（包括momentum和 Adam），推荐RMSProp
  • 生成器每更新一次，评论者都需要训练多次
  • WGAN的训练使用1表示真实，-1表示伪造

别人总结的如下

  • Not using a sigmoid activation function and just using a linear output layer for the critic (i.e., discriminator).
  • Using label -1 instead of 1 for the real images; using label 1 instead of 0 for fake images.
  • Using Wasserstein distance (loss) for training both the critic and the generator.
  • After each weight update, clip the weights to be in range [-0.1, 0.1].
  • Train the critic 5 times for each generator training update.

注意，不同说法里，1和-1到底谁是真实谁是伪造，其实都行，保持一致就ok，我们这里用-1表示真实，1表示伪造。

代码如下

import os
os.chdir(os.path.dirname(__file__))
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import torchvision.datasets as dset
from torchvision import transforms
from torchvision.utils import save_image
from torch.utils.tensorboard import SummaryWriter

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

sample_dir = 'samples'
if not os.path.exists(sample_dir):
    os.makedirs(sample_dir, exist_ok=True)

writer = SummaryWriter(sample_dir)

# Hyper-parameters
h_dim = 1024
z_dim = 128
num_epochs = 200
batch_size = 128
learning_rate = 0.00005
## WGAN-specific settings
num_iter_critic = 5
weight_clip_value = 0.01

data_root = '../data/anime-faces'

# Anime dataset
def is_valid_file(fpath):
    fname = os.path.basename(fpath)
    return fname[0] != '.'

T = transforms.Compose([
            transforms.Scale(64),
            transforms.ToTensor(),
            transforms.Normalize((0.5,0.5,0.5), (0.5,0.5,0.5)), # bring images to (-1,1)
        ])
dataset = dset.ImageFolder(
    root=data_root,
    transform=T,
    is_valid_file=is_valid_file
)
data_loader = torch.utils.data.DataLoader(dataset, 
                                        batch_size=batch_size,
                                        shuffle=True, 
                                        num_workers=16,
                                        drop_last=True)

def reset_grad():
    d_optimizer.zero_grad()
    g_optimizer.zero_grad()

def denorm(x):
    out = (x+1)/2
    return out.clamp(0, 1)

# WGAN model
NUM_MAPS_GEN = 64

class G(nn.Module):
    def __init__(self, h_dim=h_dim, z_dim=z_dim):
        super(G, self).__init__()

        self.generator = nn.Sequential(
            #
            # input size: vector z of size LATENT_DIM
            #
            nn.ConvTranspose2d(z_dim, NUM_MAPS_GEN*8, 
                               kernel_size=4, stride=1, padding=0,
                               bias=False), # bias is redundant when using BatchNorm
            nn.BatchNorm2d(NUM_MAPS_GEN*8),
            nn.ReLU(True),
            #
            # size: NUM_MAPS_GEN*8 x 4 x 4
            #
            nn.ConvTranspose2d(NUM_MAPS_GEN*8, NUM_MAPS_GEN*4, 
                               kernel_size=4, stride=2, padding=1,
                               bias=False),
            nn.BatchNorm2d(NUM_MAPS_GEN*4),
            nn.ReLU(True),
            #
            # size: NUM_MAPS_GEN*4 x 8 x 8
            #
            nn.ConvTranspose2d(NUM_MAPS_GEN*4, NUM_MAPS_GEN*2, 
                               kernel_size=4, stride=2, padding=1,
                               bias=False),
            nn.BatchNorm2d(NUM_MAPS_GEN*2),
            nn.ReLU(True),
            #
            # size: NUM_MAPS_GEN*2 x 16 x 16
            #
            nn.ConvTranspose2d(NUM_MAPS_GEN*2, NUM_MAPS_GEN, 
                               kernel_size=4, stride=2, padding=1,
                               bias=False),
            nn.BatchNorm2d(NUM_MAPS_GEN),
            nn.ReLU(True),   
            #
            # size: NUM_MAPS_GEN x 32 x 32
            #
            nn.ConvTranspose2d(NUM_MAPS_GEN, 3, 
                               kernel_size=4, stride=2, padding=1,
                               bias=False),
            #
            # size: IMAGE_SIZE[2] x 64 x 64
            #  
            nn.Tanh()
        )

    def forward(self, z):
        return self.generator(z)

# GAN model
NUM_MAPS_DIS = 64


class Flatten(nn.Module):
    def forward(self, input):
        return input.view(input.size(0), -1)

class D(nn.Module):
    def __init__(self, h_dim=h_dim, z_dim=z_dim):
        super(D, self).__init__()

        self.discriminator = nn.Sequential(
            #
            # input size IMAGE_SIZE[2] x IMAGE_SIZE[0] x IMAGE_SIZE[1]
            #
            nn.Conv2d(3, NUM_MAPS_DIS, kernel_size=4, stride=2, padding=1),
            nn.LeakyReLU(0.2, inplace=True),
            #
            # size: NUM_MAPS_DIS x 32 x 32
            #              
            nn.Conv2d(NUM_MAPS_DIS, NUM_MAPS_DIS*2,
                      kernel_size=4, stride=2, padding=1,
                      bias=False),        
            nn.BatchNorm2d(NUM_MAPS_DIS*2),
            nn.LeakyReLU(0.2, inplace=True),
            #
            # size: NUM_MAPS_DIS*2 x 16 x 16
            #   
            nn.Conv2d(NUM_MAPS_DIS*2, NUM_MAPS_DIS*4,
                      kernel_size=4, stride=2, padding=1,
                      bias=False),        
            nn.BatchNorm2d(NUM_MAPS_DIS*4),
            nn.LeakyReLU(0.2, inplace=True),
            #
            # size: NUM_MAPS_DIS*4 x 8 x 8
            #   
            nn.Conv2d(NUM_MAPS_DIS*4, NUM_MAPS_DIS*8,
                      kernel_size=4, stride=2, padding=1,
                      bias=False),        
            nn.BatchNorm2d(NUM_MAPS_DIS*8),
            nn.LeakyReLU(0.2, inplace=True),
            #
            # size: NUM_MAPS_DIS*8 x 4 x 4
            #   
            nn.Conv2d(NUM_MAPS_DIS*8, 1,
                      kernel_size=4, stride=1, padding=0),
            
            Flatten(),
            # nn.Linear(512, 1),
            # nn.Sigmoid() # # WGAN should have linear activation
        )

    def forward(self, x):
        return self.discriminator(x)

def reconstruct_loss_binaray(x, y):
    return F.binary_cross_entropy(x, y, size_average=False)

def reconstruct_loss_real(x, y):
    return F.mse_loss(x, y, size_average=False)

def kl_loss(mu, log_var):
    return -0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())

def wasserstein_loss(y_true, y_pred):
    return torch.mean(y_true * y_pred)

D = D().to(device)
G = G().to(device)
criterion = nn.BCELoss()
d_optimizer = torch.optim.RMSprop(D.parameters(), lr = learning_rate)
g_optimizer = torch.optim.RMSprop(G.parameters(), lr = learning_rate)


ld = len(data_loader)
accumulated_iter = 0
for epoch in range(num_epochs):
    for i, (x, _) in enumerate(data_loader):
        # forward
        x = x.to(device)

        real_label = -torch.ones(batch_size, 1).to(device)
        fake_label = torch.ones(batch_size, 1).to(device)

        # ================================================================== #
        #                      Train the discriminator                       #
        # ================================================================== #
        # WGAN: Multiple loops for the discriminator
        for _ in range(num_iter_critic):
            # discriminate real data
            real_output = D(x)
            d_loss_real = wasserstein_loss(real_output, real_label)
            # generate fake data
            z = torch.randn(batch_size, z_dim, 1, 1,).to(device)
            fake_data = G(z)
            # discriminate fake data
            fake_output = D(fake_data)
            d_loss_fake = wasserstein_loss(fake_output, fake_label)

            # compute the loss
            d_loss = 0.5*(d_loss_fake + d_loss_real)
            reset_grad()
            d_loss.backward()
            d_optimizer.step()

            # WGAN:
            for p in D.parameters():
                p.data.clamp_(-weight_clip_value, weight_clip_value)

        # ================================================================== #
        #                        Train the generator                         #
        # ================================================================== #
        # compute the loss with fake image
        z = torch.randn(batch_size, z_dim, 1, 1,).to(device)
        fake_data = G(z)
        fake_output = D(fake_data)

        # We train G to maximize log(D(G(z)) instead of minimizing log(1-D(G(z)))
        g_loss = wasserstein_loss(fake_output, real_label)
        reset_grad()
        g_loss.backward()
        g_optimizer.step()

        accumulated_iter += 1

        writer.add_scalar('loss_d', d_loss.item(), global_step=accumulated_iter)
        writer.add_scalar('loss_g', g_loss.item(), global_step=accumulated_iter)

        if (i+1) % 10 == 0:
            print("Epoch[{}/{}], Step [{}/{}], D Loss: {:.4f}, G Loss: {:.4f}".format(epoch+1, num_epochs, i+1, ld, d_loss.item(), g_loss.item()))
    

    with torch.no_grad():
        writer.add_images('images_src', denorm(x), global_step=epoch)
        writer.add_images('images_gen', denorm(fake_data), global_step=epoch)

    with torch.no_grad():
        x_all = torch.zeros(20, 20, 3, 64, 64).to(device)
        for a, da in enumerate(torch.linspace(-1, 1, 20)):
            for b, db in enumerate(torch.linspace(-1, 1, 20)):
                z = torch.zeros(1, z_dim, 1, 1).to(device)
                z[0, 0] = da
                z[0, 1] = db
                fake_data = G(z)
                x_all[a,b] = denorm(fake_data[0])
        
        x_all = x_all.view(-1, 3, 64, 64)
        imgs = torchvision.utils.make_grid(x_all, pad_value=2, nrow=20, normalize=True)
        writer.add_image('images_uniform', imgs, epoch, dataformats='CHW')

writer.close()

生成的数据效果如下，能够看到明显的质量提升，并且训练的时候也更加稳定了。

在这里插入图片描述

# WGAN-GP

这是一个针对WGAN的改进工作，生成器与WGAN完全相同，只有一下几个针对discriminator的修改

  • 在discriminatory的损失函数中加入一个梯度惩罚项
  • 不要裁剪discriminatory的权重，这样会造成不稳定，我们通过梯度惩罚项来惩罚那些范数偏离1的梯度
  • 不要在discriminatory中使用BN层，因为BN会在同一批次的图像之间创建相关性，导致梯度惩罚损失有效性降低。
  • 使用Adam优化器，该优化器是公认最佳的WGAN-GP的优化器

在实际梯度惩罚过程中，每一处都计算梯度非常麻烦，因此只评估少数几个点上的梯度，我们把真实图像批次与伪造图像批次之间的随机位置逐像素进行插值，以生成一些图像。
可以参考

def compute_gradient_penalty(D, real_samples, fake_samples):
    """Calculates the gradient penalty loss for WGAN GP"""
    # Random weight term for interpolation between real and fake samples
    alpha = Tensor(np.random.random((real_samples.size(0), 1, 1, 1)))
    # Get random interpolation between real and fake samples
    interpolates = (alpha * real_samples + ((1 - alpha) * fake_samples)).requires_grad_(True)
    d_interpolates = D(interpolates)
    fake = Variable(Tensor(real_samples.shape[0], 1).fill_(1.0), requires_grad=False)
    # Get gradient w.r.t. interpolates
    gradients = autograd.grad(
        outputs=d_interpolates,
        inputs=interpolates,
        grad_outputs=fake,
        create_graph=True,
        retain_graph=True,
        only_inputs=True,
    )[0]
    gradients = gradients.view(gradients.size(0), -1)
    gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean()
    return gradient_penalty

其他

最后推荐一个github
库，https://github.com/eriklindernoren/PyTorch-GAN，
里面实现了很多的GAN，且代码非常简洁易读，感兴趣的可以深入研究一下。

FrankJingle
关注
  • 0
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
GAN数学原理及代码实现
weixin_44909476的博客
05-30 997
生成式对抗网络(Generative Adversarial Networks, GAN)，包括生成器 generator 和判别器 discriminator。
GAN生成对抗网络入门与实战（新增Tensorflow2.0代码实现）
08-23
给大家分享一套课程——GAN生成对抗网络入门与实战（新增Tensorflow2.0代码实现）
【图像生成】(二) GAN 原理 & pytorch代码实例
Lizhi_Tech的博客
08-07 3629
上一篇文章里我们介绍了【图像生成】的几种模型以及最直观的DNN的代码和效果，当然可以看出来不足的地方。这篇文章里主要介绍GAN模型的原理，以及它是怎么解决以上问题的。
生成对抗网络GAN论文总结+复现代码(已完成28篇，未完待续。。。)
热门推荐
iiiiiiimp的博客
01-06 4万+
GAN论文总结
生成对抗网络——GAN（代码+理解）
最新发布
CXDNW的博客
06-17 2099
一、GAN模型介绍GAN，全称 Generative Adversarial Network，即生成对抗网络，是一种基于 对抗学习的深度生成模型。该模型由Ian Goodfellow在 2014年 首次提出，并迅速成为 学术界研究的热点，推动了生成模型领域的发展。GAN模型主要由两部分组成：生成器（Generator）和判别器（Discriminator）。，其 输入是 随机噪声，输出则是 生成的样本。。2. 判别器：判别器模型同样。
GAN | 代码简单实现生成对抗网络（GAN）（PyTorch）
weixin_44649780的博客
02-28 5144
GAN从编程的角度来看（纯个人理解，不对可指正）利用numpy的random方法，随机生成多维的噪音向量创建一个G网络用来生成创建一个D网络用来判断俩个网络在训练时分别进行优化先训练D网络去判断真假：如果训练D为真时，进行传播；如果训练D为假时，进行传播，投入优化器（1为真，0为假）在D的基础上训练G。*因为是随机生成，所以每次生成结果不同。
GAN基础代码
Crystalxxtt的博客
09-18 656
对抗生成网络生成器：生成假的数据，骗过判别器判别器：将假数据判别为假，真实数据判别为真。流程：1.导入数据待生成图像（噪音）和真实数据：将噪音图像进行生成：（1）判断真实图像输出结果 1（2）判断生成图像输出结果 03.目标函数：(1)：对于生成网络，要使得 生成结果 通过判别网络为真（2）：对于判别网络，要使得输入为真实图像时判别为真，输入为生成图像时判别为假判别模型：log(D1(x)) + log(1-D2(G(z)))生成网络:log(D2(G(z)))
生成对抗网络（GAN）实例 代码+数据集
04-18
在这个实例中，我们将探讨如何使用GAN来生成手写数字图像，基于提供的vanilla_gan代码和MNIST_data数据集。 首先，MNIST数据集是机器学习领域常用的基准数据集，包含60000个训练样本和10000个测试样本，都是28x28...
八种最常用的GAN生成式对抗网络代码框架
04-13
包括多种GAN生成试对抗网络代码框架 ACGAN.py BEGAN.py CGAN.py CVAE.py DRAGAN.py EBGAN.py GAN.py LSGAN.py VAE.py WGAN.py WGAN_GP.py infoGAN.py
GAN对抗式生成网络的应用：从图片上生成诗歌
11-18
Automatic generation of natural language from images has attracted extensive attention. In this paper, we take one step further to investigate generation of poetic language (with multiple lines) to an...
生成对抗网络GAN正则化方法: 近期研究综述
05-21
尽管生成式对抗网络(GAN)的历史并不长，但它已被广泛地研究和用于各种任务，包括其最初的目的，即合成样品的生成。然而，将GAN用于具有不同神经网络结构的不同数据类型，由于其在训练方面的局限性，使得模型很容易...
circleGAN训练代码
02-23
circleGAN训练代码
从零使用GAN（生成对抗网络）进行图像生成
hyk的博客
07-30 1万+
基于Pytorch使用生成对抗网络完成笑脸图片生成任务
GAN损失函数公式详细推导（含完整代码）
学姐带你玩AI的博客
03-14 7136
GAN是由生成器G和判别器D组成，通过大量样本数据训练使得生成器的生成能力和判别器的判别能力在对抗中逐步提高，最终目的是让生成器G输入到生成器中生成假的样本。
从零开始 - 在Python中构建和训练生成对抗网络（GAN）模型
Warmer_Sweeter
12-31 1494
生成对抗网络（GANs）是一种强大的生成模型，可以合成新的逼真图像。通过完整的实现过程，读者将对GANs在幕后的工作原理有深刻的理解。本教程首先导入必要的库并加载将用于训练GAN的Fashion-MNIST数据集。然后，提供了构建GAN核心组件（生成器和判别器模型）的代码示例。接下来的部分解释了如何构建一个组合模型，该模型训练生成器以欺骗判别器，以及如何设计一个训练函数来优化对抗过程。目录：1. ...
第G1周：生成对抗网络（GAN）入门
geo436872的博客
02-23 1144
GAN（生成对抗网络）是一种神经网络架构，它的设计灵感来自于博弈论的思想。这种网络由两个关键组件组成：生成器（Generator）和判别器（Discriminator）。生成器的任务是从随机噪声中生成与真实数据相似的合成样本，而判别器则负责辨别给定的样本是真实数据还是生成器产生的人工样本。这两个组件通过反复对抗性的训练相互影响和提升。在训练过程中，生成器努力生成越来越逼真的样本，而判别器则不断提高辨别真实与生成样本的能力。
GAN论文分析与代码实现
gaowencheng01的博客
05-06 630
GAN介绍，简单理论推导，代码实现，生成MNIST
简单实现基于pytorch的gan网络
qq_43710103的博客
03-07 1054
简单实现基于pytorch的gan网络
GAN 对抗生成网络代码实现
gdtop的个人笔记
05-25 3154
作报告写了ppt，这里po上  更完整的介绍关注专栏生成对抗网络Generative Adversarial Network 本篇的同名博客[生成对抗网络GAN入门指南]（3）GAN的工程实践及基础代码 In [1]: import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data i...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值