生成对抗网络 订阅
生成式对抗网络(GAN, Generative Adversarial Networks )是一种深度学习模型,是近年来复杂分布上无监督学习最具前景的方法之一。模型通过框架中(至少)两个模块:生成模型(Generative Model)和判别模型(Discriminative Model)的互相博弈学习产生相当好的输出。原始 GAN 理论中,并不要求 G 和 D 都是神经网络,只需要是能拟合相应生成和判别的函数即可。但实用中一般均使用深度神经网络作为 G 和 D 。一个优秀的GAN应用需要有良好的训练方法,否则可能由于神经网络模型的自由性而导致输出不理想。 展开全文
生成式对抗网络(GAN, Generative Adversarial Networks )是一种深度学习模型,是近年来复杂分布上无监督学习最具前景的方法之一。模型通过框架中(至少)两个模块:生成模型(Generative Model)和判别模型(Discriminative Model)的互相博弈学习产生相当好的输出。原始 GAN 理论中,并不要求 G 和 D 都是神经网络,只需要是能拟合相应生成和判别的函数即可。但实用中一般均使用深度神经网络作为 G 和 D 。一个优秀的GAN应用需要有良好的训练方法,否则可能由于神经网络模型的自由性而导致输出不理想。
信息
属    于
无监督学习方法
简    称
GAN
构    成
生成模型和判别模型
中文名
生成式对抗网络
外文名
Generative Adversarial Networks
领    域
机器学习 / 深度学习
Gan发展历史
Ian J. Goodfellow等人于2014年10月在Generative Adversarial Networks中提出了一个通过对抗过程估计生成模型的新框架。框架中同时训练两个模型:捕获数据分布的生成模型G,和估计样本来自训练数据的概率的判别模型D。G的训练程序是将D错误的概率最大化。这个框架对应一个最大值集下限的双方对抗游戏。可以证明在任意函数G和D的空间中,存在唯一的解决方案,使得G重现训练数据分布,而D=0.5。在G和D由多层感知器定义的情况下,整个系统可以用反向传播进行训练。在训练或生成样本期间,不需要任何马尔科夫链或展开的近似推理网络。实验通过对生成的样品的定性和定量评估证明了本框架的潜力 [1]  。
收起全文
精华内容
下载资源
问答
  • 生成对抗网络

    2019-03-14 15:26:21
    1. 什么是生成对抗网络 2 生成对抗网络的英文 3 生成对抗网络和编码器的区别 4 生成对抗网络的简单结构 5. 生成对抗网络的各种变体 6. 生成对抗网络的应用 1 什么是生成对抗网络 生成式对抗网络(GAN, ...

    1. 什么是生成对抗网络

    2 生成对抗网络的英文

    3 生成对抗网络和编码器的区别

    4 生成对抗网络的简单结构

    5. 生成对抗网络的各种变体

    6. 生成对抗网络的应用

     

    1 什么是生成对抗网络

    生成式对抗网络(GAN, Generative Adversarial Networks )是一种深度学习模型,是近年来复杂分布上无监督学习最具前景的方法之一。模型通过框架中(至少)两个模块:生成模型(Generative Model)和判别模型(Discriminative Model)的互相博弈学习产生相当好的输出。原始 GAN 理论中,并不要求 G 和 D 都是神经网络,只需要是能拟合相应生成和判别的函数即可。但实用中一般均使用深度神经网络作为 G 和 D 。一个优秀的GAN应用需要有良好的训练方法,否则可能由于神经网络模型的自由性而导致输出不理想。

    下面我们来简单介绍一下生成式对抗网络,主要介绍三篇论文:1)Generative Adversarial Networks;2)Conditional Generative Adversarial Nets;3)Unsupervised Representation Learning with Deep Convolutional Generative Adversarial Networks。

    2 英文

    Generative Adversarial Networks

    3 生成对抗网络和编码器的区别

    一句话就可以说清楚,自编码器就是Gan网络的生成器。

    AE,DAE只是单纯的从单个样例中学习,目标是重构出输入样例,说白了网络的输出就是尽可能重构出网络的输入,这样其实并不能说数据生成,充其量也就是数据复原罢了。

    4 生成对抗网络的简单结构

    稍微解释以下上图,z是随机噪声(就是随机生成的一些数,也就是GAN生成图像的源头)。D通过真图和假图的数据(相当于天然label),进行一个二分类神经网络训练(想各位必再熟悉不过了)。G根据一串随机数就可以捏造一个“假图像”出来,用这些假图去欺骗D,D负责辨别这是真图还是假图,会给出一个score。比如,G生成了一张图,在D这里得分很高,那证明G是很成功的;如果D能有效区分真假图,则G的效果还不太好,需要调整参数。GAN就是这么一个博弈的过程。

    5. 生成对抗网络的各种变体

    深度卷积 GAN(DCGAN)

    条件性 GAN(CGAN)

    StackGAN

    InfoGANs

    Wasserstein GAN

    6 生成对抗网络的应用

    https://blog.csdn.net/jkbhbgy/article/details/80168048

    6.1 图像生成 目前GAN最常使用的地方就是图像生成,如超分辨率任务,语义分割等等。

    6.2 数据增强,用GAN生成的图像来做数据增强

     

    展开全文
  • 生成对抗网络训练深度学习(Deep Learning) 什么是生成对抗网络(GAN)?(What are Generative Adversarial Networks (GANs)?) Designed by Ian Goodfellow and his colleagues in 2014, GANs consist of two neural ...

    生成对抗网络训练

    深度学习(Deep Learning)

    什么是生成对抗网络(GAN)?(What are Generative Adversarial Networks (GANs)?)

    Designed by Ian Goodfellow and his colleagues in 2014, GANs consist of two neural networks that are trained together in a zero-sum game where one player’s loss is the gain of another.

    GAN由Ian Goodfellow和他的同事在2014年设计,由两个神经网络组成,它们在零和游戏中一起训练,其中一个玩家的损失是另一个玩家的损失。

    To understand GANs we need to be familiar with generative models and discriminative models.

    要了解GAN,我们需要熟悉生成模型和判别模型。

    Generative models try to output new data points using the distribution from the training set. These models generate new data instances. These models capture joint probability p(X, Y)

    生成模型尝试使用训练集中的分布来输出新的数据点。 这些模型生成新的数据实例。 这些模型捕获联合概率p(X,Y)

    Types of Generative models1. Explicit density models2. Implicit density models

    生成模型的类型1.显式密度模型2。 隐式密度模型

    Explicit density models define an explicit density function while implicit density models define a stochastic procedure that can directly generate data.

    显式密度模型定义了显式密度函数,而隐式密度模型定义了可以直接生成数据的随机过程。

    If you are interested in reading more about generative models, check out this popular GitHub repository below.

    如果您有兴趣阅读有关生成模型的更多信息,请在下面查看此流行的GitHub存储库。

    On the other hand, Discriminative models capture conditional probabilities p(X/Y) and they differentiate different data instances.

    另一方面,判别模型捕获条件概率p(X / Y),并区分不同的数据实例。

    Image for post
    Image from Source: Google Developers. Licensed under the Creative Commons Attribution 4.0 License.图片来源:Google Developers。 根据知识共享署名4.0许可获得许可。

    Generative models solve difficult tasks. The level of attention detail is more compared to that in discriminative models. Simply speaking generative models do more work. Generative models try to approximate the real data distribution as closely as possible.

    生成模型可以解决难题。 与区分模型相比,关注细节的级别更高。 简而言之,生成模型可以做更多的工作。 生成模型试图尽可能接近实际数据的分布。

    In the figure above we can see that the discriminative model tries to separate 0’s and 1’s data space. Whereas the generative models closely approximate the 0’s and 1’s data space.

    在上图中,我们可以看到判别模型试图将0和1的数据空间分开。 生成模型非常接近0和1的数据空间。

    Now that you know the basic definitions of generative and discriminative models, let us learn about GANs.

    既然您已经知道了生成模型和判别模型的基本定义,那么让我们了解GAN。

    鉴别器和生成器网络-GAN游戏 (The Discriminator & Generator networks — The GAN Game)

    Image for post
    Photo by JESHOOTS.COM on Unsplash
    JESHOOTS.COMUnsplash上的照片

    Generative Adversarial Networks (GANs) are generative models. They generate whole images in parallel. GANs consist of 2 networks: Discriminator & Generator networks

    生成对抗网络(GAN)是生成模型。 它们并行生成整个图像。 GAN包含2个网络:鉴别器和生成器网络

    Image for post
    Image from Source: Google Developers. Licensed under the Creative Commons Attribution 4.0 License.图片来源:Google Developers。 根据知识共享署名4.0许可获得许可。

    GANs use a differentiable function. This is usually a neural network. We call it the generator network. This generator network takes random inputs. These inputs are noise. This noise is given to a differentiable function that transforms and reshapes the same into a recognizable structure. This could be an image and the same is highly dependent on the noise at the input of the differentiable function.

    GAN使用可微函数。 这通常是一个神经网络。 我们称其为发电机网络。 该发电机网络采用随机输入。 这些输入是噪声。 将此噪声提供给微分函数,该函数将其转换并重塑为可识别的结构。 这可能是图像,并且高度依赖于微分函数输入端的噪声。

    For various noise inputs, we can generate many images. However, the generator network immediately doesn't start giving out realistic images. We need to train it.

    对于各种噪声输入,我们可以生成许多图像。 但是,生成器网络不会立即开始发出逼真的图像。 我们需要训练它。

    How do we train this generator network? Probably the same way as any other network? Actually no!

    我们如何训练发电机网络? 可能与其他任何网络相同? 其实不行!

    Generator networks see many images and try to output something similar to the same probability distribution. How is that done? 👀

    生成器网络看到许多图像,并尝试输出类似于相同概率分布的图像。 怎么做? 👀

    Here comes the Discriminator, a regular neural network classifier. The discriminator guides our generator network.

    这是鉴别器,一个常规的神经网络分类器。 鉴别器指导我们的发电机网络。

    For the sake of simplicity let us call the output images of the generator network as fake images. The output of the generator, the fake images, are given to the discriminator as the input. The Discriminator also sees so-called real images from the training data. The discriminator then outputs the probability that the input is a real image. So a 1 for real images, and 0 for fake images. Meanwhile, the generator also tries to output images that could be assigned a probability of 1 by the discriminator.

    为了简单起见,让我们将生成器网络输出图像称为伪图像。 生成器的输出(伪图像)作为输入提供给鉴别器。 鉴别器还从训练数据中看到所谓的真实图像。 然后,鉴别器输出输入为真实图像的概率。 因此对于真实图像为1,对于伪图像为0。 同时,生成器还尝试输出可能由鉴别器分配为1的概率的图像。

    Most machine learning models try to minimize some cost function by optimizing the parameters. If we were to assign cost functions to GANs, we can say the cost for the discriminator is negative of the cost of the generator and vice versa.

    大多数机器学习模型都试图通过优化参数来最小化某些成本函数。 如果我们要为GAN分配成本函数,那么可以说,鉴别器的成本是生成器成本的负数,反之亦然。

    So let us try to understand how GANs work by assuming discriminator and generators as 2 players and a say a function f.

    因此,让我们通过将鉴别器和生成器假设为2个参与者并说一个函数f来尝试了解GAN的工作原理。

    The generator tries to decrease the output value of the function f, while the discriminator tries to increase it. Let us assume this is done until we reach an equilibrium where neither the generator can decrease the output value of the function f, nor the discriminator can increase it. Since we use 2 optimization algorithms simultaneously, one for the generator and the other for the discriminator, we may never reach an equilibrium. Adam optimizer is a good choice.

    生成器试图减小函数f的输出值,而鉴别器试图增大函数f的输出值。 让我们假设这样做一直到达到平衡为止,在该平衡下,生成器既不能减小函数f的输出值,也不能使鉴别器增大它的值。 由于我们同时使用两种优化算法,一种用于生成器,另一种用于鉴别器,因此我们可能永远无法达到平衡。 Adam优化器是一个不错的选择。

    Briefly speaking, the generator and discriminator compete, where the generator gives fake data to the discriminator. The discriminator which also sees training data, predicts if the received image is real or fake.

    简而言之,生成器和鉴别器竞争,其中生成器将虚假数据提供给鉴别器。 鉴别器还可以查看训练数据,预测接收到的图像是真实的还是伪造的。

    Look at this example below from google developers' machine learning crash course.

    在Google开发人员的机器学习速成课程中查看以下示例。

    The generator begins with unrealistic images and quickly learns to fool the discriminator.

    生成器从不真实的图像开始,并Swift学会欺骗鉴别器。

    Image for post
    Image from Source: Google Developers. Licensed under the Creative Commons Attribution 4.0 License.图片来源:Google Developers。 根据知识共享署名4.0许可获得许可。

    Thus, the generator is trained over time to fool the discriminator to make it look like the fake images are much like the real ones that the discriminator sees.

    因此,随着时间的流逝训练生成器以欺骗鉴别器,以使其看起来像伪造图像非常类似于鉴别器看到的真实图像。

    那么培训过程如何? (So how does the training process look like?)

    During the training process of the discriminator, it is shown real images and uses computes the discriminator loss. It classifies both real and fake images from the generator and discriminator loss penalizes the discriminator if any image is incorrectly classified. Through backpropagation, the discriminator updates its weights.

    在鉴别器的训练过程中,它显示为真实图像,并用于计算鉴别器损耗。 它对来自生成器的真实和伪造图像进行分类,如果对任何图像进行了不正确分类,则鉴别器损失将对鉴别器进行惩罚。 通过反向传播,鉴别器更新其权重。

    Similarly, the generator is given noisy inputs to generate fake images. These images are given to the discriminator and the generator loss penalizes the generator for producing a sample that the discriminator network classifies as fake. Weights are updated through backpropagation right from the discriminator into the generator.

    类似地,为生成器提供了噪声输入以生成伪图像。 这些图像被提供给鉴别器,并且发生器损失惩罚了发生器以产生鉴别器网络分类为伪造的样本。 权重通过从鉴别器到生成器的反向传播进行更新。

    It is important to note that the generator must be constant during the discriminator training phase. Similarly, the discriminator remains constant during the generator training phase. Thus GAN training proceeds in an alternating fashion.

    重要的是要注意,在鉴别器训练阶段,发生器必须是恒定的。 同样,鉴别器在发电机训练阶段保持不变。 因此,GAN训练以交替方式进行。

    甘妮丝 (MNIST GAN)

    In this section, we will learn to design a GAN that can generate new images of handwritten digits. We will use the famous MNIST dataset. Get it here.

    在本节中,我们将学习设计可以生成手写数字新图像的GAN。 我们将使用著名的MNIST数据集。 在这里获取。

    鉴别器架构 (The Discriminator architecture)

    The discriminator is going to be a typical linear classifier.

    鉴别器将是典型的线性分类器。

    The activation function we will be using is Leaky ReLu.

    我们将使用的激活功能是Leaky ReLu

    Image for post
    Image from PyTorch documentation. (Open Source)图片来自PyTorch文档。 (开源)

    Why leaky ReLu?We should use a leaky ReLU to allow gradients to flow backward through the layer unhindered. A leaky ReLU is like a normal ReLU, except that there is a small non-zero output for negative input values.

    为什么泄漏ReLu? 我们应该使用泄漏的ReLU,以使渐变不受阻碍地流回图层。 泄漏的ReLU与正常的ReLU相似,只是负输入值有一个小的非零输出。

    class Discriminator(nn.Module):
    
    
        def __init__(self, input_size, hidden_dim, output_size):
            super(Discriminator, self).__init__()
            
            # define hidden linear layers
            self.fc1 = nn.Linear(input_size, hidden_dim*4)
            self.fc2 = nn.Linear(hidden_dim*4, hidden_dim*2)
            self.fc3 = nn.Linear(hidden_dim*2, hidden_dim)
            
            # final fully-connected layer
            self.fc4 = nn.Linear(hidden_dim, output_size)
            
            # dropout layer 
            self.dropout = nn.Dropout(0.3)
            
            
        def forward(self, x):
            # flatten image
            x = x.view(-1, 28*28)
            # all hidden layers
            x = F.leaky_relu(self.fc1(x), 0.2) # (input, negative_slope=0.2)
            x = self.dropout(x)
            x = F.leaky_relu(self.fc2(x), 0.2)
            x = self.dropout(x)
            x = F.leaky_relu(self.fc3(x), 0.2)
            x = self.dropout(x)
            # final layer
            out = self.fc4(x)
    
    
            return out

    发电机架构(The Generator architecture)

    The generator uses latent samples to make fake images. These latent samples are vectors which are mapped to the fake images. A latent vector is just a compressed, feature-level representation of an image!

    生成器使用潜在样本制作伪造图像。 这些潜在样本是映射到伪图像的向量。 一种 潜矢量只是图像的压缩特征级表示!

    To understand what is a latent sample, consider an autoencoder. The outputs that connect the encoder and decoder portion of a network are made up of a compressed representation that could also be referred to as a latent vector.

    要了解什么是潜在样本,请考虑使用自动编码器。 连接网络的编码器和解码器部分的输出由压缩表示形式组成,该压缩表示形式也可以称为潜在矢量。

    The activation function for all the layers remains the same except we will be using Tanh at the output.

    除了将在输出中使用Tanh之外,所有层的激活功能均保持不变。

    Image for post
    Image from PyTorch documentation. (Open Source)图片来自PyTorch文档。 (开源)

    Why Tanh at the output?The generator has been found to perform the best with 𝑡𝑎𝑛ℎtanh for the generator output, which scales the output to be between -1 and 1, instead of 0 and 1.

    为什么在输出中使用Tanh? 已经发现,对于发电机输出,发电机以tanh表现最佳,它将输出缩放到-1和1之间,而不是0和1之间。

    class Generator(nn.Module):
    
    
        def __init__(self, input_size, hidden_dim, output_size):
            super(Generator, self).__init__()
            
            # define hidden linear layers
            self.fc1 = nn.Linear(input_size, hidden_dim)
            self.fc2 = nn.Linear(hidden_dim, hidden_dim*2)
            self.fc3 = nn.Linear(hidden_dim*2, hidden_dim*4)
            
            # final fully-connected layer
            self.fc4 = nn.Linear(hidden_dim*4, output_size)
            
            # dropout layer 
            self.dropout = nn.Dropout(0.3)
    
    
        def forward(self, x):
            # all hidden layers
            x = F.leaky_relu(self.fc1(x), 0.2) # (input, negative_slope=0.2)
            x = self.dropout(x)
            x = F.leaky_relu(self.fc2(x), 0.2)
            x = self.dropout(x)
            x = F.leaky_relu(self.fc3(x), 0.2)
            x = self.dropout(x)
            # final layer with tanh applied
            out = F.tanh(self.fc4(x))
    
    
            return out

    缩放图像(Scaling images)

    We want the output of the generator to be comparable to the real images pixel values, which are normalized values between 0 and 1. Thus, we’ll also have to scale our real input images to have pixel values between -1 and 1 when we train the discriminator. This will be done during the training phase.

    我们希望生成器的输出与真实图像的像素值相当,后者是介于0和1之间的归一化值。因此,当我们输入真实图像时,我们还必须缩放真实输入图像的像素值,使其介于-1和1之间训练鉴别器。 这将在培训阶段完成。

    概括 (Generalization)

    To help the discriminator generalize better, the labels are reduced a bit from 1.0 to 0.9. For this, we’ll use the parameter smooth; if True, then we should smooth our labels. In PyTorch, this looks like:labels = torch.ones(size) * 0.9

    为了帮助区分器更好地泛化,将标签从1.0减少到0.9 。 为此,我们将使用参数smooth。 如果为True,则应使标签平滑。 在PyTorch中,这看起来像: labels = torch.ones(size) * 0.9

    We also made use of dropout layers to avoid overfitting.

    我们还利用辍学层来避免过度拟合。

    损失计算 (Loss calculation)

    The discriminator’s goal is to output a 1 for real and 0 for fake images. On the other hand, the generator wants to make fake images that closely resemble the real ones.

    判别器的目标是为真实图像输出1,为伪图像输出0。 另一方面,生成器想要制作与真实图像非常相似的伪图像。

    Thus we can say if “D” represents the loss for the discriminator, then the following can be stated:The goal of discriminator : D(real_images)=1 & D(fake_images)=0The goal of generator: D(real_images)=0 & D(fake_images)=1

    因此,我们可以说,如果“ D”代表鉴别器的损失,则可以说明以下内容: 鉴别目标: D(real_images)= 1&D(fake_images)= 0 生成器的目标: D(real_images)= 0和D(fake_images)= 1

    # Calculate losses
    def real_loss(D_out, smooth=False):
        batch_size = D_out.size(0)
        # label smoothing
        if smooth:
            # smooth, real labels = 0.9
            labels = torch.ones(batch_size)*0.9
        else:
            labels = torch.ones(batch_size) # real labels = 1
            
        # numerically stable loss
        criterion = nn.BCEWithLogitsLoss()
        # calculate loss
        loss = criterion(D_out.squeeze(), labels)
        return loss
    
    
    def fake_loss(D_out):
        batch_size = D_out.size(0)
        labels = torch.zeros(batch_size) # fake labels = 0
        criterion = nn.BCEWithLogitsLoss()
        # calculate loss
        loss = criterion(D_out.squeeze(), labels)
        return loss

    We will use BCEWithLogitsLoss, which combines a sigmoid activation function (we want the discriminator to output a value 0–1 indicating whether an image is real or fake) and binary cross-entropy loss.

    我们将使用BCEWithLogitsLoss ,它结合了S型激活函数(我们希望鉴别器输出值0–1指示图像是真实的还是伪造的)和二进制交叉熵损失。

    Image for post
    Equation of Binar Cross-Entropy Loss. Image by the author.
    二进制交叉熵损失方程。 图片由作者提供。

    训练 (Training)

    As mentioned earlier, Adam is a suitable optimizer.

    如前所述,Adam是合适的优化器。

    The generator takes in a vector z and outputs fake images. The discriminator alternates between training on the real images and that of the fakes images produced by the generator.

    生成器接收向量z并输出伪图像。 鉴别器在对真实图像的训练与由生成器产生的伪造图像的训练之间交替。

    鉴别器培训涉及的步骤: (Steps involved in discriminator training:)

    1. We first compute the loss on real images

      我们首先计算真实图像上的损失
    2. Generate fake images

      生成假图片
    3. Compute loss on fake images

      计算假图片损失
    4. Add the loss of the real and fake images

      添加真实和伪造图像的损失
    5. Perform backpropagation and update weights of the discriminator

      执行反向传播并更新鉴别器的权重

    发电机培训涉及的步骤:(Steps involved in generator training:)

    1. Generate fake images

      生成假图片
    2. Compute loss on fake images with inversed labels

      计算带有反标签的假图片的损失
    3. Perform backpropagation and update the weights of the generator.

      执行反向传播并更新发生器的权重。
    import torch.optim as optim
    
    
    # Optimizers
    lr = 0.002
    
    
    # Create optimizers for the discriminator and generator
    d_optimizer = optim.Adam(D.parameters(), lr)
    g_optimizer = optim.Adam(G.parameters(), lr)
    
    
    
    
    import pickle as pkl
    
    
    # training hyperparams
    num_epochs = 100
    
    
    # keep track of loss and generated, "fake" samples
    samples = []
    losses = []
    
    
    print_every = 400
    
    
    # Get some fixed data for sampling. These are images that are held
    # constant throughout training, and allow us to inspect the model's performance
    sample_size=16
    fixed_z = np.random.uniform(-1, 1, size=(sample_size, z_size))
    fixed_z = torch.from_numpy(fixed_z).float()
    
    
    # train the network
    D.train()
    G.train()
    for epoch in range(num_epochs):
        
        for batch_i, (real_images, _) in enumerate(train_loader):
                    
            batch_size = real_images.size(0)
            
            ## Important rescaling step ## 
            real_images = real_images*2 - 1  # rescale input images from [0,1) to [-1, 1)
            
            # ============================================
            #            TRAIN THE DISCRIMINATOR
            # ============================================
            
            d_optimizer.zero_grad()
            
            # 1. Train with real images
    
    
            # Compute the discriminator losses on real images 
            # smooth the real labels
            D_real = D(real_images)
            d_real_loss = real_loss(D_real, smooth=True)
            
            # 2. Train with fake images
            
            # Generate fake images
            z = np.random.uniform(-1, 1, size=(batch_size, z_size))
            z = torch.from_numpy(z).float()
            fake_images = G(z)
            
            # Compute the discriminator losses on fake images        
            D_fake = D(fake_images)
            d_fake_loss = fake_loss(D_fake)
            
            # add up loss and perform backprop
            d_loss = d_real_loss + d_fake_loss
            d_loss.backward()
            d_optimizer.step()
            
            
            # =========================================
            #            TRAIN THE GENERATOR
            # =========================================
            g_optimizer.zero_grad()
            
            # 1. Train with fake images and flipped labels
            
            # Generate fake images
            z = np.random.uniform(-1, 1, size=(batch_size, z_size))
            z = torch.from_numpy(z).float()
            fake_images = G(z)
            
            # Compute the discriminator losses on fake images 
            # using flipped labels!
            D_fake = D(fake_images)
            g_loss = real_loss(D_fake) # use real loss to flip labels
            
            # perform backprop
            g_loss.backward()
            g_optimizer.step()
    
    
            # Print some loss stats
            if batch_i % print_every == 0:
                # print discriminator and generator loss
                print('Epoch [{:5d}/{:5d}] | d_loss: {:6.4f} | g_loss: {:6.4f}'.format(
                        epoch+1, num_epochs, d_loss.item(), g_loss.item()))
    
    
        
        ## AFTER EACH EPOCH##
        # append discriminator loss and generator loss
        losses.append((d_loss.item(), g_loss.item()))
        
        # generate and save sample, fake images
        G.eval() # eval mode for generating samples
        samples_z = G(fixed_z)
        samples.append(samples_z)
        G.train() # back to train mode
    
    
    
    
    # Save training generator samples
    with open('train_samples.pkl', 'wb') as f:
        pkl.dump(samples, f)

    训练损失(Training loss)

    We shall plot generator and discriminator losses against the number of epochs.

    我们将生成器和鉴别器的损耗与历时数作图。

    fig, ax = plt.subplots()
    losses = np.array(losses)
    plt.plot(losses.T[0], label='Discriminator')
    plt.plot(losses.T[1], label='Generator')
    plt.title("Training Losses")
    plt.legend()
    plt.show()
    Image for post
    Training losses. Image by the author.
    培训损失。 图片由作者提供。

    发生器产生的样品 (Samples generated by the generator)

    At the start

    在开始时

    # helper function for viewing a list of passed in sample images
    def view_samples(epoch, samples):
        fig, axes = plt.subplots(figsize=(7,7), nrows=4, ncols=4, sharey=True, sharex=True)
        for ax, img in zip(axes.flatten(), samples[epoch]):
            img = img.detach()
            ax.xaxis.set_visible(False)
            ax.yaxis.set_visible(False)
            im = ax.imshow(img.reshape((28,28)), cmap='Greys_r')
            
    # Load samples from generator, taken while training
    with open('train_samples.pkl', 'rb') as f:
        samples = pkl.load(f)
    # -1 indicates final epoch's samples (the last in the list)
    view_samples(-1, samples)
    Image for post
    Image by the author.
    图片由作者提供。

    Overtime

    随着时间的推移

    rows = 10 # split epochs into 10, so 100/10 = every 10 epochs
    cols = 6
    fig, axes = plt.subplots(figsize=(7,12), nrows=rows, ncols=cols, sharex=True, sharey=True)
    
    
    for sample, ax_row in zip(samples[::int(len(samples)/rows)], axes):
        for img, ax in zip(sample[::int(len(sample)/cols)], ax_row):
            img = img.detach()
            ax.imshow(img.reshape((28,28)), cmap='Greys_r')
            ax.xaxis.set_visible(False)
            ax.yaxis.set_visible(False)
    Image for post
    Image by the author.
    图片由作者提供。

    This way the generator starts out with noisy images and learns over time.

    这样,生成器便从嘈杂的图像开始,并随着时间的推移而学习。

    You can check out the code and readme file on my GitHub profile as well.

    您也可以在我的GitHub个人资料上签出代码和自述文件。

    结论 (Conclusions)

    Since the time Ian Goodfellow and his colleagues at the University of Montreal designed GANs, they exploded with popularity. The number of applications is remarkable. GANs were further improved by many variations some of which are CycleGAN, Conditional GAN, Progressive GAN, etc. To read more about these check out this link. Now open a Jupyter notebook and try to implement whatever you learned.

    自从Ian Goodfellow和他的蒙特利尔大学同事设计GAN以来,它们便受到了欢迎。 申请数量惊人。 通过许多变体进一步改进了GAN,其中包括CycleGAN,条件GAN,渐进GAN等。要了解更多有关这些的信息,请查看此链接。 现在打开Jupyter笔记本,并尝试实施所学知识。

    谢谢。 下一个见。 (Thank you. See you at the next one.)

    翻译自: https://towardsdatascience.com/generative-adversarial-networks-6a17673db367

    生成对抗网络训练

    展开全文
  • 本文章为生成式对抗网络学习笔记Evolutionary Generative Adversarial Networks生成对抗网络(GAN)是从复杂的真实数据中学习相关特征的一种重要的生成模型。生成对抗模型主要包含生成器与判别器两个深度神经网络。...

    本文章为生成式对抗网络学习笔记

    Evolutionary Generative Adversarial Networks

    生成对抗网络(GAN)是从复杂的真实数据中学习相关特征的一种重要的生成模型。生成对抗模型主要包含生成器与判别器两个深度神经网络。生成器的输入为合成图像,其目标是尽可能的学习真实数据中学习相关知识。判别器的输入为生成器的输出和真实图像这两类,其作用使最大可能的识别真实图像与生成图像之间的差距。于是,在模型的每次迭代中,生成器尽可能的想生成与真实图像的相似图像,从而骗过判别器。而判别器尽可能的想对真实图像与合成图像进行区分。两个网络相互博弈,即为生成对抗模型。

    而在当前的GAN模型中,存在着很多问题。GAN在训练中,存在着不稳定的问题,往往需要平衡生成器和判别器的训练步数,不让判别器很快的收敛。此外,还存在模式坍塌的问题,即生成多种相似特征的数据。GAN的网络结构对应的超参数的调整往往也需要耗费大量的精力。因此,如何解决GAN对抗网络的以上三个主要缺陷成为当前的研究热点之一。

    近年来,进化算法与深度学习结合的模型,取得的较好的结果。我们以(2018, Wang)的Evolutionary Generative Adversarial Networks一文为例,分析遗传算法运用在生成对抗网络中的性能提升。

    在原始的GAN,如图1(a),生成器G和判别器D均为神经网络。而在E-GAN中,如图1(b),生成器变成以遗传算法为基础的模型。生成模型包含三个步骤:首先由噪声生成基础的种群;初始种群经过变异操作后产生不同的k个个体

    ;根据判别网络的返回结果,评估当前种群的适应度值
    ;根据适应度值,挑选合适的个体进入下一次迭代。

    c36b2c8fdf1de7778fd47a93ac82ef9e.png

    图1 原始GAN与E-GAN模型结构对比

    模型细节

    原始的GAN:

    对于GAN,其解决的问题是如何使得生成图像的分布

    尽可能的逼近真实图像的分布
    。设生成器的输出为
    ,判别器的输出为
    。将真实图像的标签设为正例,生成图像的标签设为负例。模型优化的目标为使判别器D尽可能的分离
    的同时,生成器G保持和的JS散度尽可能的小。对抗网络的目标函数如下:

    对于

    ,最小化其JS散度:

    其中:

    E-GAN的生成器模型:

    在E-GAN中,生成器被遗传算法模型所代替,即期望通过遗传算法的改进,使得

    尽可能接近。每步的遗传过程包含三个步骤:
    • 进化:通过一个个体
      变异操作后产生不同的k个子代个体
    • 评估:对于每一个产生的子代通过适应度函数对其进行评估,适应度函数即为鉴别器的loss。
    • 选择:根据适应度值挑选下一子代

    在群落进化的过程中,主要选取了三种变异方法,分别为极大极小值变异,启发式变异,最小二乘变异,这三种变异方法直接体现在GAN网络loss函数的变化中。进化过程种三种变异算子的损失函数如图2所示。

    4ef7a80a618c2cfe6c7ca526d6204bfc.png

    图2 三种变异方式的损失函数

    极大极小值变异即为原始的GAN的loss函数。通过最小化

    分布的JS散度,实现生成模型。若
    存在重叠部分,判别器不能完全区分真实样本和生成样本,极小极大值loss可以提供梯度,并不断缩小数据分布和生成的分布之间的差距。但这种loss存在一个缺陷,即当
    没有重叠部分,或存在其重叠的比例很小,则会出现loss恒为常数
    ,产生梯度均为0(梯度消失),网络无法训练的问题。极大极小值loss函数如下:

    启发式变异希望最大化判别器出错时的对数概率。启发式loss函数如下:

    通过等式的变换,我们可以将最小化

    等价为
    。这种惩罚方法有效的避免了梯度消失的问题。而在这个损失函数中,优化目标是矛盾的,即通过KL散度期望
    尽可能接近,而减去JS散度则期望
    拉远。这会导致训练过程中出现不稳定的错误。

    最小二乘变异的损失函数为:

    对于最小二乘变异的目标函数,判别器在有效识别生成数据时同样是不饱和的。随着判别器不断的训练,目标函数输出趋于0,逐渐饱和。相比启发式变异,最小二乘变异在生成器产生虚假图像时不会产生较大的惩罚,因此可以避免模式坍塌的问题。

    对于群落适应度函数的评估,模型着重关注于生成器的两个性质:生成图片的质量与生成数据的多样性。模型的适应度函数为:

    其中:

    为图像质量评估分数,用于评估遗传算法每次迭代后,当前生成的种群图像的质量。图像质量得分越高,则说明生成器有效的学到了真实图像中的特征。
    为图像多样性的评估分数。
    为梯度正则化项。如果多样性分数高,则说明判别器的梯度
    较小,避免了判别器训练的过好,从而使得生成器可以产生丰富的样本。

    算法总结

    对于E-GAN,生成器为一个种群的进化算法,生成器为种群当前所在的环境。在每一次的进化中,生成器根据几种不同的损失函数去适应当前的环境(判别器),挪去适应度较低的个体。相比单一的损失函数,采用多种损失函数(极大极小值变异,启发式变异,最小二乘变异)进行优化,可以相互取长补短,从而有效的避免模式崩溃的问题,实现生成数据与真实数据的逼近。

    参考文献:

    [1] C. Wang, C. Xu, X. Yao and D. Tao, "Evolutionary Generative Adversarial Networks," IEEE Transactions on Evolutionary Computation, vol. 23, no. 6, pp. 921-934, Dec. 2019.
    [2] Martin, Arjovsky, and B. Lon. "Towards principled methods for training generative adversarial networks." NIPS 2016 Workshop on Adversarial Training. In review for ICLR. Vol. 2016. 2017.
    [3] Arjovsky, Martin, Soumith Chintala, and Léon Bottou. "Wasserstein Generative Adversarial Networks." International Conference on Machine Learning. 2017.
    展开全文
  • 生成对抗网络和对抗神经网络 如果您最近一直在关注人工智能(AI)新闻媒体,则可能听说过Google的顶级AI人物之一Ian Goodfellow于三月份移居了Apple 。 Goodfellow在2017年被麻省理工学院评为35岁以下创新者之一,在...

    生成对抗网络和对抗神经网络

    如果您最近一直在关注人工智能(AI)新闻媒体,则可能听说过Google的顶级AI人物之一Ian Goodfellow于三月份移居了Apple Goodfellow在2017年被麻省理工学院评为35岁以下创新者之一,在2019年被外交政策杂志评为100位全球思想家之一。他还被称为机器学习概念之父,称为生成对抗网络(GAN) Facebook AI主管Yann LeCun表示,GAN是“过去10年机器学习中最有趣的想法”。

    几乎每个人都知道机器学习领域现在有多热。 Google正在做机器学习。 亚马逊正在进行机器学习。 Facebook正在进行机器学习。 星球上的每个公司都想对机器学习有所作为。 美国商人,投资者(包括在《 鲨鱼坦克》真人秀中)和达拉斯小牛NBA球队的老板马克·库班(Mark Cuban)最近表示, 每个人都应该学习机器学习

    如果机器学习是我们应该学习的东西,而GAN是机器学习中最热门的想法,那么可以肯定的是,更多地了解GAN是个好主意。

    互联网上有很多有趣的文章,视频和其他学习材料可以解释GAN。 本文是GAN和一些开源项目和资源的非常入门的指南,您可以在其中扩展您对GAN和机器学习的知识。

    如果您想快速入门,我强烈建议您从斯坦福大学在YouTube上有关生成模型的讲座开始。 同样,Ian Goodfellow的原始论文“ Generative Adversarial Networks ”也可以PDF格式下载。 否则,请继续阅读一些背景信息以及其他对您有帮助的工具和资源。

    统计分类模型

    在学习GAN之前,重要的是要了解广泛用于机器学习和统计的统计分类模型之间的差异。 在统计分类中,这是一个研究领域,旨在确定一组类别中新观察结果的位置,其中有两个主要模型: 判别模型和生成模型。 判别模型属于监督学习 ,生成模型属于非监督学习。 斯坦福大学演讲的这张幻灯片解释了两者的区别:

    Difference between Supervised and Unsupervised Learning

    判别模型

    区分模型尝试根据从新项目中发现的特征识别特定新项目在类别中的位置。 例如,假设我们要创建一个非常简单的区分模型系统,该系统将给定的对话分配给特定的电影类别,在这种情况下,是否来自电影《复仇者联盟》。 这是一行示例对话:

    “他是复仇者联盟的一员,该组织将尽一切力量确保世界安全。Loki最好提防。”

    我们预先定义的“复仇者联盟”关键字组可以包括“复仇者联盟”和“ Loki”。 我们的判别模型算法将尝试匹配给定文本中与“复仇者联盟”相关的关键字,并报告在0.0到1.0之间的概率,其中接近1的数字表示最有可能来自“复仇者联盟”的对话, 接近0的数字表明事实并非如此。

    这是判别模型的一个非常简单的示例,但是您可能会明白。 您可以看到,区分模型在很大程度上取决于预定义类别的质量,但是仅作了一些假设。

    生成模型

    生成模型不是通过标记数据而是通过尝试从特定数据集中获取一些见识来工作。 如果您还记得高中时可能学过的高斯分布,则可能马上就想到了。

    Example of Gaussian Distribution

    例如,假设这是一班100名学生的期末考试成绩列表。

    • 10名学生达到80%或以上
    • 80名学生获得70%至80%
    • 10名学生的分数达到或低于70%

    根据这些数据,我们可以推断出大多数学生在70年代得分。 此洞察力基于特定数据集的统计分布。 如果我们看到其他模式,也可以收集该数据并进行其他推断。

    您可能听说过的生成模型包括高斯混合模型,贝叶斯模型,隐马尔可夫模型和变异编码器模型。 GAN也属于生成模型,但有所不同。

    GAN的模型

    GAN试图通过生成模型随机生成数据,然后使判别模型对数据进行评估并使用结果来改善下一个输出,从而将区分模型和生成模型进行组合

    这是GAN的简化视图:

    Simplified GAN model

    GAN的实际实现要比这复杂得多,但这是一个总的想法。

    理解GAN的最简单方法是考虑一个场景,其中侦探和伪造者正在玩重复性的猜谜游戏,其中伪造者试图制造100美元的钞票的伪造品,而侦探则判断每个物品是真品还是假品。 这是这种情况的假设对话:

    造假者: “这100美元看起来像真钱吗?”
    侦探: “不!那看上去根本不是一张真正的100美元钞票。”
    伪造者 (持有一种新设计):“这张100美元的钞票看起来像真钱吗?”
    侦探: “那更好,但仍不如真实。”
    伪造者 (持有设计的变体):“现在呢?”
    侦探: “那很接近,但仍然不像真实。”
    伪造者 (持有另一个变种):“这应该像真实的,对吧?”
    侦探: “是的!那非常接近!”

    好。 因此,侦探实际上是犯罪分子。 在这个例子中,伪造者是产生者,而侦探是鉴别者。 随着游戏的反复进行,伪造货币与真实货币相似的可能性可能会越来越高。

    假冒伪劣侦探示例与GAN之间的主要区别在于GAN的主要目的不是创建一个只有一个答案的100%实际输出。 相反,您可以将GAN视为某种超级创意引擎 ,它可以生成许多意外的输出,这些输出既可以使您感到惊讶,又可以满足您的好奇心和期望。

    机器学习

    在开始使用GAN之前,您需要一些有关机器学习及其背后的数学知识的背景知识。

    如果您不熟悉机器学习,则可以免费使用Goodfellow的Deep Learning教科书 ,也可以根据需要通过其网站上的Amazon链接购买印刷版。

    您还可以在YouTube上观看斯坦福大学有关用于视觉识别的卷积神经网络的讲座。

    但是,开始进行机器学习的最佳方法可能是通过大规模开放式在线课程(MOOC)上免费课程,例如:

    既然数据科学对机器学习有所帮助,请了解Kaggle ,这是最著名的数据科学家和机器学习者在线社区

    您还将希望熟悉最受欢迎的机器学习工具:

    另外,请务必查看有关机器学习的其他Opensource.com文章:

    GAN入门

    现在,我们了解了有关机器学习和GAN的一些基础知识,您可能已经准备好开始使用GAN。 首先,根据BSD 3-条款“ New”或“ Revised”许可在GitHub上访问Goodwell的原始GAN代码

    GAN也有几种变体:

    您可以使用GAN的方式

    GAN有无限可能的用例,但以下是人们尝试过的一些方法:

    您使用过GAN吗? 您还有其他资源要分享吗? 如果是这样,请在评论中留下注释。

    翻译自: https://opensource.com/article/19/4/introduction-generative-adversarial-networks

    生成对抗网络和对抗神经网络

    展开全文
  • 生成对抗网络和对抗神经网络A generative adversarial network (GAN) is a powerful approach to machine learning (ML). At a high level, a GAN is simply two neural networks that feed into each other. One ...
  • 生成对抗网络用于分类 GANS系列 (GANS SERIES) This article is a part of the Gans-Series published by me on TowardsDataScience Publication on Medium. If you do not know what GANs are or if you have an ...
  • 生成对抗网络gans 介绍 (Introduction) Generative Adversarial Networks (GANs) were first introduced in a paper by Goodfellow and other researchers at the University of Montreal in 2014. Since then we ...
  • 生成对抗网络 图像生成Machines are generating perfect images these days and it’s becoming more and more difficult to distinguish the machine-generated images from the originals.如今,机器正在生成完美...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,691
精华内容 2,276
关键字:

生成对抗网络