精华内容
下载资源
问答
  • DCGAN

    2020-03-03 03:17:33
    DCGAN

    DCGAN

    Tensorflow2.0实现DCGAN

    《unsupervised representation learning with deep convolutional generative adversarial networks》
    —深度卷积生成对抗网络(DCGAN)
    作者:Alec Radford & Luke Metz
    发表会议及时间:ICLR 2016

    一 论文导读

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    如果判别大图像,比如1024*1024,则输入神经元会过多,对于判别器,参数量过于巨大。

    为了减少参数量,自然就会想到卷积神经网络。
    在这里插入图片描述

    2012: Alexnet

    在这里插入图片描述
    在这里插入图片描述

    • 怎么做呢?

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    效果结果很差!!!!

    所以DCGAN产生了


    主要贡献

    • 提出了一系列策略,成功的将GAN和CNN进行结合
    • 能够训练卷积生成对抗网络,使得生成效果大大提升
    • 通过充分的实验,对原理做了直观全面的解释

    DCGAN作为2016年GAN的代表之作起到了明显的划分作用
    在这里插入图片描述


    MLP与CNN

    • MLP

    在这里插入图片描述
    ●网络有多个隐层组成
    ●每一个神经元都和上一层中的所有节点连接
    ●参数量大,训练难度大
    ●会丢失像素间的空间信息


    • CNN

    在这里插入图片描述

    ●稀疏连接,参数少
    ●可以处理更复杂的图像
    ●可以利用像素间的空间信息
    ●可以引入池化、空洞卷积等操作


    Decoder中常用的3种上采样

    ●upsampling 插值上采样
    ●unpooling 反池化
    ●deconvolution 转置卷积


    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    双立方插值和双线性插值一样,只不过是把周围4个值,变成周围16个值

    最常用的就是双线性插值

    在这里插入图片描述


    在这里插入图片描述
    反池化,因为位置的关系,保留住了特征,特别是位置信息特征


    在这里插入图片描述
    转置卷积,要先进行扩充,再进行卷积

    转置卷积,相比于插值和uppooling的最大优点,就是有着可学习参数的卷积核,典型应用U-NET


    GAN网络结构

    ●由判别模型和生成模型两部分组成
    ●生成模型负责生成假样本,欺骗判别器
    ●判别模性来分辨真样本和假样本
    ●两个模型交替训练,类似对抗博弈的过程

    在这里插入图片描述


    过程


    一 训练判别器,固定生成器,使用反向传播

    在这里插入图片描述


    二 固定判别器,训练生成器,使用反向传播

    在这里插入图片描述


    GAN网络训练过程示意图

    在这里插入图片描述

    并不是说,一开始判别器就很厉害,即警察很厉害,判别器和生成器是一起进步的(因为一起训练),判别器每次都要比生成器强一点才行,这样一直一起变强。
    在这里插入图片描述


    二 论文精读

    一 去掉判别器中所有的池化,用卷积代替

    在这里插入图片描述

    为什么用卷积代替池化

    因为,卷积带有可学习参数,在GAN网络中,判别器D主要目的是辅助生成器G达到最优,如果用池化,则其梯度会稀疏,会导致判别器学习困难,如果判别器学习困难,他就不能很好的辅助指导生成器学习。

    同时,卷积也要有下采样的作用

    在这里插入图片描述


    二 生成器使用反卷积

    在这里插入图片描述
    在这里插入图片描述

    三 去掉判别网络的全连接层

    因为FC层其巨大的参数量计算提高了网络的训练难度,改用了卷积

    四 改用batch normalization

    在这里插入图片描述

    五 激活函数改用tanh 和 Leaky RelLu

    其目的和去池化等同,因为避免梯度稀疏,特别是Leaky RelLu

    在这里插入图片描述
    在这里插入图片描述

    训练参数设置

    在这里插入图片描述


    训练GAN要了解

    在这里插入图片描述


    在这里插入图片描述

    在这里插入图片描述

    突变就是没有学到分布,只是进行了记忆

    下图是没有突变,是学到了分布

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述



    三 代码实现

    四 问题思索

    恍然大悟!是解码,解码,解码(decode),以前一直把上采样,看作解码了,解码就是解码,是总称。

    补充小知识:深度学习三巨头之一的Bengio Y的数学功底非常强,GAN网络的作者就是Bengio的学生,作为Bengio组出来的文章,数学论证一般都是非常充分的

    展开全文
  • dcgan

    2019-04-25 16:04:56
    来源:...""" Deep Convolutional Generative Adversarial Network (DCGAN). Using deep convolutional generative adversarial networks (DCGAN) to ge...

    来源:https://github.com/aymericdamien/TensorFlow-Examples#tutorials

    """ Deep Convolutional Generative Adversarial Network (DCGAN).
    
    Using deep convolutional generative adversarial networks (DCGAN) to generate
    digit images from a noise distribution.
    
    References:
        - Unsupervised representation learning with deep convolutional generative
        adversarial networks. A Radford, L Metz, S Chintala. arXiv:1511.06434.
    
    Links:
        - [DCGAN Paper](https://arxiv.org/abs/1511.06434).
        - [MNIST Dataset](http://yann.lecun.com/exdb/mnist/).
    
    Author: Aymeric Damien
    Project: https://github.com/aymericdamien/TensorFlow-Examples/
    """
    
    from __future__ import division, print_function, absolute_import
    
    import matplotlib.pyplot as plt
    import numpy as np
    import tensorflow as tf
    
    # Import MNIST data
    from tensorflow.examples.tutorials.mnist import input_data
    mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)
    
    # Training Params
    num_steps = 20000
    batch_size = 32
    
    # Network Params
    image_dim = 784 # 28*28 pixels * 1 channel
    gen_hidden_dim = 256
    disc_hidden_dim = 256
    noise_dim = 200 # Noise data points
    
    
    # Generator Network
    # Input: Noise, Output: Image
    def generator(x, reuse=False):
        with tf.variable_scope('Generator', reuse=reuse):
            # TensorFlow Layers automatically create variables and calculate their
            # shape, based on the input.
            x = tf.layers.dense(x, units=6 * 6 * 128)
            x = tf.nn.tanh(x)
            # Reshape to a 4-D array of images: (batch, height, width, channels)
            # New shape: (batch, 6, 6, 128)
            x = tf.reshape(x, shape=[-1, 6, 6, 128])
            # Deconvolution, image shape: (batch, 14, 14, 64)
            x = tf.layers.conv2d_transpose(x, 64, 4, strides=2)
            # Deconvolution, image shape: (batch, 28, 28, 1)
            x = tf.layers.conv2d_transpose(x, 1, 2, strides=2)
            # Apply sigmoid to clip values between 0 and 1
            x = tf.nn.sigmoid(x)
            return x
    
    
    # Discriminator Network
    # Input: Image, Output: Prediction Real/Fake Image
    def discriminator(x, reuse=False):
        with tf.variable_scope('Discriminator', reuse=reuse):
            # Typical convolutional neural network to classify images.
            x = tf.layers.conv2d(x, 64, 5)
            x = tf.nn.tanh(x)
            x = tf.layers.average_pooling2d(x, 2, 2)
            x = tf.layers.conv2d(x, 128, 5)
            x = tf.nn.tanh(x)
            x = tf.layers.average_pooling2d(x, 2, 2)
            x = tf.contrib.layers.flatten(x)
            x = tf.layers.dense(x, 1024)
            x = tf.nn.tanh(x)
            # Output 2 classes: Real and Fake images
            x = tf.layers.dense(x, 2)
        return x
    
    # Build Networks
    # Network Inputs
    noise_input = tf.placeholder(tf.float32, shape=[None, noise_dim])
    real_image_input = tf.placeholder(tf.float32, shape=[None, 28, 28, 1])
    
    # Build Generator Network
    gen_sample = generator(noise_input)
    
    # Build 2 Discriminator Networks (one from noise input, one from generated samples)
    disc_real = discriminator(real_image_input)
    disc_fake = discriminator(gen_sample, reuse=True)
    disc_concat = tf.concat([disc_real, disc_fake], axis=0)
    
    # Build the stacked generator/discriminator
    stacked_gan = discriminator(gen_sample, reuse=True)
    
    # Build Targets (real or fake images)
    disc_target = tf.placeholder(tf.int32, shape=[None])
    gen_target = tf.placeholder(tf.int32, shape=[None])
    
    # Build Loss
    disc_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
        logits=disc_concat, labels=disc_target))
    gen_loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
        logits=stacked_gan, labels=gen_target))
    
    # Build Optimizers
    optimizer_gen = tf.train.AdamOptimizer(learning_rate=0.001)
    optimizer_disc = tf.train.AdamOptimizer(learning_rate=0.001)
    
    # Training Variables for each optimizer
    # By default in TensorFlow, all variables are updated by each optimizer, so we
    # need to precise for each one of them the specific variables to update.
    # Generator Network Variables
    gen_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Generator')
    # Discriminator Network Variables
    disc_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Discriminator')
    
    # Create training operations
    train_gen = optimizer_gen.minimize(gen_loss, var_list=gen_vars)
    train_disc = optimizer_disc.minimize(disc_loss, var_list=disc_vars)
    
    # Initialize the variables (i.e. assign their default value)
    init = tf.global_variables_initializer()
    
    # Start training
    with tf.Session() as sess:
    
        # Run the initializer
        sess.run(init)
    
        for i in range(1, num_steps+1):
    
            # Prepare Input Data
            # Get the next batch of MNIST data (only images are needed, not labels)
            batch_x, _ = mnist.train.next_batch(batch_size)
            batch_x = np.reshape(batch_x, newshape=[-1, 28, 28, 1])
            # Generate noise to feed to the generator
            z = np.random.uniform(-1., 1., size=[batch_size, noise_dim])
    
            # Prepare Targets (Real image: 1, Fake image: 0)
            # The first half of data fed to the generator are real images,
            # the other half are fake images (coming from the generator).
            batch_disc_y = np.concatenate(
                [np.ones([batch_size]), np.zeros([batch_size])], axis=0)
            # Generator tries to fool the discriminator, thus targets are 1.
            batch_gen_y = np.ones([batch_size])
    
            # Training
            feed_dict = {real_image_input: batch_x, noise_input: z,
                         disc_target: batch_disc_y, gen_target: batch_gen_y}
            _, _, gl, dl = sess.run([train_gen, train_disc, gen_loss, disc_loss],
                                    feed_dict=feed_dict)
            if i % 100 == 0 or i == 1:
                print('Step %i: Generator Loss: %f, Discriminator Loss: %f' % (i, gl, dl))
    
        # Generate images from noise, using the generator network.
        f, a = plt.subplots(4, 10, figsize=(10, 4))
        for i in range(10):
            # Noise input.
            z = np.random.uniform(-1., 1., size=[4, noise_dim])
            g = sess.run(gen_sample, feed_dict={noise_input: z})
            for j in range(4):
                # Generate image from noise. Extend to 3 channels for matplot figure.
                img = np.reshape(np.repeat(g[j][:, :, np.newaxis], 3, axis=2),
                                 newshape=(28, 28, 3))
                a[j][i].imshow(img)
    
        f.show()
        plt.draw()
        plt.waitforbuttonpress()
    
    
    展开全文

空空如也

空空如也

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

dcgan