一、原始GAN网络存在问题

原始GAN网络判别器(D)损失函数为： $E_{x-P_r}[logD(x)]-E_{x-P_g}[log(1-D(x))]$
原始GAN网络生成器(G)损失函数为： $E_{x-P_g}[log(1-D(x))]$
此处 $P_r$ 为真实样本分布， $P_g$ 为生成样本分布。对于一个具体的样本x，其可能来自真实数据分布，也有可能来自生成数据分布，将样本x带入至判别器损失函数中，然后对 $D (x)$ 求导，可以解出最优判别器的形式： $D^*=\frac{P_r(x)}{P_g(x)+P_r(x)}$ 。此时，判别器作为最优判别器，可以给出样本来自真实数据和生成数据的概率。当 $P_r(x)=P_g(x)$ 时，最优判别器给出样本概率为0.5。
在生成器的损失函数中，加入一项不依赖于生成器的项 $E_{x-P_r}[logD(x)]$ ，此时最小化生成器的损失函数相当于优化此式 $E_{x-P_g}[log(1-D(x))]+E_{x-P_r}[logD(x)]$ 。而将D(x)替换为最优判别器形式可以化简得到最终结果为 $2JS(P_r(x)||P_g(x))-2log2$ 。而当两组数据不重合时，JS散度值恒为log2。如下图所示，下图为两个几乎不重合的正态数据分布。
Alt
可以看出，当x≥3时， $2JS(P_r(x)||P_g(x))-2log2=P_g(x)log\frac{P_r(x)}{P_g(x)+P_r(x)}+P_r(x)log\frac{P_r(x)}{P_g(x)+P_r(x)}$ ，可以很容易的得出此式为0。同理，当x<3时，生成器损失函数值为0。所以，我们可以得到一个结论：判别器达到最优判别器状态时，生成器没有任何的梯度信息，无法完成学习任务。

二、Wasserstain距离

在WGAN一文中引入Wasserstain距离来代替JS散度来表示两组数据之间的距离。 $W(P_r(x),P_g(x))=\displaystyle \inf_{r\in\prod(P_r(x)，P_g(x))}E_{(x,y)-r}[||x-y||]$ 。其中， $\prod(P_r(x)，P_g(x))$ 代表 $P_r(x)$ 和 $P_g(x)$ 组合起来的所有可能的联合分布的集合； $∣∣ x - y ∣∣$ 代表生成样本和真实样本之间的距离； $in f$ 为这对样本的距离期望取下界。Wasserstain距离直观上理解为将生成数据分布移动至真实数据分布的最短平均距离。假设两组数据没有重叠，比如两组数据分布为均匀分布，如下图所示。
Alt
其中 $\theta$ 为两组数据之间的距离，即Wasserstain距离，此时，两者之间的Wasserstain随着生成器的学习而变化，所以不会出现梯度为零的情况，反观JS散度则在 $\theta=0$ 时为0，在 $\theta$ $\not=a$ 时为log2。

三、WGAN

因为 $W(P_r(x),P_g(x))=\displaystyle \inf_{r\in\prod(P_r(x)，P_g(x))}E_{(x,y)-r}[||x-y||]$ 在实际情况下无法直接对下界进行求取，所以将上式等价为 $W(P_r(x),P_g(x))=\displaystyle \sup_{||f||_l≤1}E_{x-P_r}[f(x)]-E_{x-P_θ}[f(x)]$ 。此处需要对x加以限制，要存在K≥0使得定义域中的任何两元素 $X_1$ 、 $X_2$ 满足 $f(x_1)-f(x_2)|≤K|x_1-x_2|$ ，即函数f(x)的导数值不超过K，然后对满足此条件下的 $E_{x-P_r}[f(x)]-E_{x-P_θ}[f(x)]$ 取上界。我们限制判别器神经网络 $f_w$ 中的参数不超过某个范围[-c,c]，即使得关于输入样本x的导数也不会超过某个范围，所以存在常数K使得上式成立。
在满足上述条件的情况下，损失函数可以写为 $L=E_{x-P_r}[f(x)]-E_{x-P_θ}[f(x)]$ ，因为损失函数中第一项与生成器无关，所以生成器的损失函数去掉第一项。
判别器损失函数为： $E_{x-P_g}[f_w(x)]$
生成器损失函数为： $E_{x-P_θ}[f(x)]-E_{x-P_r}[f(x)]$
WGAN的伪代码如下图所示在这里插入图片描述

四、WGAN代码

原始代码（原始代码中所使用的数据集为MNIST手写数字数据集）

import argparse
import os
import numpy as np
import math
import sys

import torchvision.transforms as transforms
from torchvision.utils import save_image

from torch.utils.data import DataLoader
from torchvision import datasets
from torch.autograd import Variable

import torch.nn as nn
import torch.nn.functional as F
import torch

os.makedirs("images", exist_ok=True)

parser = argparse.ArgumentParser()
parser.add_argument("--n_epochs", type=int, default=200, help="number of epochs of training")
parser.add_argument("--batch_size", type=int, default=64, help="size of the batches")
parser.add_argument("--lr", type=float, default=0.00005, help="learning rate")
parser.add_argument("--n_cpu", type=int, default=8, help="number of cpu threads to use during batch generation")
parser.add_argument("--latent_dim", type=int, default=100, help="dimensionality of the latent space")
parser.add_argument("--img_size", type=int, default=28, help="size of each image dimension")
parser.add_argument("--channels", type=int, default=1, help="number of image channels")
parser.add_argument("--n_critic", type=int, default=5, help="number of training steps for discriminator per iter")
parser.add_argument("--clip_value", type=float, default=0.01, help="lower and upper clip value for disc. weights")
parser.add_argument("--sample_interval", type=int, default=400, help="interval betwen image samples")
opt = parser.parse_args()
print(opt)

img_shape = (opt.channels, opt.img_size, opt.img_size)

cuda = True if torch.cuda.is_available() else False


class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()

        def block(in_feat, out_feat, normalize=True):
            layers = [nn.Linear(in_feat, out_feat)]
            if normalize:
                layers.append(nn.BatchNorm1d(out_feat, 0.8))
            layers.append(nn.LeakyReLU(0.2, inplace=True))
            return layers

        self.model = nn.Sequential(
            *block(opt.latent_dim, 128, normalize=False),
            *block(128, 256),
            *block(256, 512),
            *block(512, 1024),
            nn.Linear(1024, int(np.prod(img_shape))),
            nn.Tanh()
        )

    def forward(self, z):
        img = self.model(z)
        img = img.view(img.shape[0], *img_shape)
        return img


class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()

        self.model = nn.Sequential(
            nn.Linear(int(np.prod(img_shape)), 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
        )

    def forward(self, img):
        img_flat = img.view(img.shape[0], -1)
        validity = self.model(img_flat)
        return validity


# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()

if cuda:
    generator.cuda()
    discriminator.cuda()

# Configure data loader
os.makedirs("../../data/mnist", exist_ok=True)
dataloader = torch.utils.data.DataLoader(
    datasets.MNIST(
        "../../data/mnist",
        train=True,
        download=True,
        transform=transforms.Compose([transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]),
    ),
    batch_size=opt.batch_size,
    shuffle=True,
)

# Optimizers
optimizer_G = torch.optim.RMSprop(generator.parameters(), lr=opt.lr)
optimizer_D = torch.optim.RMSprop(discriminator.parameters(), lr=opt.lr)

Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor

# ----------
#  Training
# ----------

batches_done = 0
for epoch in range(opt.n_epochs):

    for i, (imgs, _) in enumerate(dataloader):

        # Configure input
        real_imgs = Variable(imgs.type(Tensor))

        # ---------------------
        #  Train Discriminator
        # ---------------------

        optimizer_D.zero_grad()

        # Sample noise as generator input
        z = Variable(Tensor(np.random.normal(0, 1, (imgs.shape[0], opt.latent_dim))))

        # Generate a batch of images
        fake_imgs = generator(z).detach()
        # Adversarial loss
        loss_D = -torch.mean(discriminator(real_imgs)) + torch.mean(discriminator(fake_imgs))

        loss_D.backward()
        optimizer_D.step()

        # Clip weights of discriminator
        for p in discriminator.parameters():
            p.data.clamp_(-opt.clip_value, opt.clip_value)

        # Train the generator every n_critic iterations
        if i % opt.n_critic == 0:

            # -----------------
            #  Train Generator
            # -----------------

            optimizer_G.zero_grad()

            # Generate a batch of images
            gen_imgs = generator(z)
            # Adversarial loss
            loss_G = -torch.mean(discriminator(gen_imgs))

            loss_G.backward()
            optimizer_G.step()

            print(
                "[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]"
                % (epoch, opt.n_epochs, batches_done % len(dataloader), len(dataloader), loss_D.item(), loss_G.item())
            )

        if batches_done % opt.sample_interval == 0:
            save_image(gen_imgs.data[:25], "images/%d.png" % batches_done, nrow=5, normalize=True)
        batches_done += 1

自定义数据集代码（自定义数据集代码中使用的本地自己做的数据集，在路径中进行改动即可运行）

import argparse
import os
import numpy as np
import math
import sys

import torchvision.transforms as transforms
from torchvision.utils import save_image

from torch.utils.data import DataLoader,Dataset#此处加入dataset
from torchvision import datasets
from torch.autograd import Variable
from PIL import Image

import torch.nn as nn
import torch.nn.functional as F
import torch

os.makedirs("images", exist_ok=True)#输出图片保存路径

parser = argparse.ArgumentParser()#设置超参数
parser.add_argument("--n_epochs", type=int, default=10000, help="number of epochs of training")
parser.add_argument("--batch_size", type=int, default=64, help="size of the batches")
parser.add_argument("--lr", type=float, default=0.00005, help="learning rate")
parser.add_argument("--n_cpu", type=int, default=8, help="number of cpu threads to use during batch generation")
parser.add_argument("--latent_dim", type=int, default=100, help="dimensionality of the latent space")#噪声向量的维度
parser.add_argument("--img_size", type=int, default=64, help="size of each image dimension")#输入图片的尺寸
parser.add_argument("--channels", type=int, default=3, help="number of image channels")#输入图片的通道数
parser.add_argument("--n_critic", type=int, default=5, help="number of training steps for discriminator per iter")
parser.add_argument("--clip_value", type=float, default=0.01, help="lower and upper clip value for disc. weights")
parser.add_argument("--sample_interval", type=int, default=400, help="interval betwen image samples")
opt = parser.parse_args()
print(opt)

img_shape = (opt.channels, opt.img_size, opt.img_size)#图片格式

cuda = True if torch.cuda.is_available() else False


class Generator(nn.Module):#生成器网络模型
    def __init__(self):
        super(Generator, self).__init__()

        def block(in_feat, out_feat, normalize=True):
            layers = [nn.Linear(in_feat, out_feat)]#设置全连接层
            if normalize:
                layers.append(nn.BatchNorm1d(out_feat, 0.8))#归一化处理，加快训练速度
            layers.append(nn.LeakyReLU(0.2, inplace=True))#加入LeakyReLU激活函数
            return layers

        self.model = nn.Sequential(
            *block(opt.latent_dim, 128, normalize=False),
            *block(128, 256),
            *block(256, 512),
            *block(512, 1024),
            nn.Linear(1024, int(np.prod(img_shape))),
            nn.Tanh()
        )

    def forward(self, z):
        img = self.model(z)
        img = img.view(img.shape[0], *img_shape)
        return img


class Discriminator(nn.Module):#判别器网络模型
    def __init__(self):
        super(Discriminator, self).__init__()

        self.model = nn.Sequential(
            nn.Linear(int(np.prod(img_shape)), 512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(512, 256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Linear(256, 1),
        )

    def forward(self, img):
        img_flat = img.view(img.shape[0], -1)
        validity = self.model(img_flat)
        return validity


# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()

if cuda:
    generator.cuda()
    discriminator.cuda()

img_transform=transforms.Compose([
    transforms.Resize((64, 64)),#图片进行裁剪
    transforms.ToTensor(),#图片转换为tensor格式
    transforms.Normalize((0.5,),(0.5,))#图片进行标准化处理
])
class MyData(Dataset):#设置数据集
    def __init__(self,root_dir,transform=None):
        self.root_dir=root_dir#文件目录
        self.transform=transform#图像变换
        self.images=os.listdir(self.root_dir)#遍历目录下的图片文件

    def __len__(self):
        return len(self.images)#返回数据集中所有图片的个数

    def __getitem__(self, index):
        image_index=self.images[index]
        image_path=os.path.join(self.root_dir,image_index)
        image=Image.open(image_path).convert('RGB')
        if self.transform:
            image=self.transform(image)
        return image
mydataset=MyData(
    root_dir='D:\Sonar Dataset',transform=img_transform
)

dataloader=DataLoader(
    dataset=mydataset,batch_size=opt.batch_size,shuffle=True
)


# Configure data loader
#os.makedirs("D:\Sonar Dataset", exist_ok=True)#此处进行改动，改变文件夹位置
#dataloader = torch.utils.data.DataLoader(
#   datasets.SONAR(#需要改动，改动为自定义的数据集
#        "D:\Sonar Dataset",#数据集位置
#        train=True,
#        download=True,
#        transform=transforms.Compose([transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]),
#    ),
#    batch_size=opt.batch_size,
#    shuffle=True,
#)



# Optimizers
optimizer_G = torch.optim.RMSprop(generator.parameters(), lr=opt.lr)
optimizer_D = torch.optim.RMSprop(discriminator.parameters(), lr=opt.lr)

Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor

# ----------
#  Training
# ----------

batches_done = 0
for epoch in range(opt.n_epochs):

    for i,imgs in enumerate(dataloader):
    #for i, (imgs, _) in enumerate(dataloader):

        # Configure input
        real_imgs = Variable(imgs.type(Tensor))

        # ---------------------
        #  Train Discriminator
        # ---------------------

        optimizer_D.zero_grad()

        # Sample noise as generator input
        z = Variable(Tensor(np.random.normal(0, 1, (imgs.shape[0], opt.latent_dim))))

        # Generate a batch of images
        fake_imgs = generator(z).detach()
        # Adversarial loss
        loss_D = -torch.mean(discriminator(real_imgs)) + torch.mean(discriminator(fake_imgs))#判别器损失函数

        loss_D.backward()
        optimizer_D.step()

        # Clip weights of discriminator
        for p in discriminator.parameters():
            p.data.clamp_(-opt.clip_value, opt.clip_value)

        # Train the generator every n_critic iterations
        if i % opt.n_critic == 0:

            # -----------------
            #  Train Generator
            # -----------------

            optimizer_G.zero_grad()

            # Generate a batch of images
            gen_imgs = generator(z)
            # Adversarial loss
            loss_G = -torch.mean(discriminator(gen_imgs))#生成器损失函数

            loss_G.backward()
            optimizer_G.step()

            print(
                "[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]"
                % (epoch, opt.n_epochs, batches_done % len(dataloader), len(dataloader), loss_D.item(), loss_G.item())
            )

        if batches_done % opt.sample_interval == 0:
            save_image(gen_imgs.data[:25], "images/%d.png" % batches_done, nrow=5, normalize=True)
        batches_done += 1

五、实验结果

MNIST数据集运行结果
Alt
自定义侧扫声呐数据集运行结果

Alt
模模糊糊可以看出是个声呐图像中的飞机形状(捂脸.jpg)

令人拍案叫绝的Wasserstein GAN；https://zhuanlan.zhihu.com/p/25071913
pytorch实现GAN网络及训练自己的数据集；https://blog.csdn.net/weixin_50113231/article/details/122959899?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166202179316782390594954%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=166202179316782390594954&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_positive~default-1-122959899-null-null.142^v44pc_ran_alice&utm_term=GAN%E8%AE%AD%E7%BB%83%E8%87%AA%E5%B7%B1%E7%9A%84%E6%95%B0%E6%8D%AE%E9%9B%86&spm=1018.2226.3001.4187
WGAN论文；https://arxiv.org/abs/1701.07875
WGAN的GitHub源代码；https://github.com/eriklindernoren/PyTorch-GAN/blob/master/implementations/wgan/wgan.py

如果对你有帮助的话，麻烦点赞，收藏，敲公式实在太麻烦啦！！！

本文含有隐藏内容，请开通VIP 后查看

WGAN+代码分析+自定义数据集训练

文章目录

一、原始GAN网络存在问题

二、Wasserstain距离

三、WGAN

四、WGAN代码

五、实验结果

网站公告

今日签到

热门文章

最新发布