1. tf.layers.conv2d(input, filter, kernel_size, stride, padding) # 进行卷积操作

参数说明:input输入数据, filter特征图的个数,kernel_size卷积核的大小,stride步长,padding是否补零

2. tf.layers.conv2d_transpose(input, filter, kernel_size, stride, padding) # 进行反卷积操作

参数说明:input输入数据, filter特征图的个数,kernel_size卷积核的大小,stride步长, padding是否补零

3. tf.layers.batch_normalize(input, training=False) 进行归一化操作

参数说明:input表示输入数据, training 表示是否是在进行训练

4.tf,maximum(alpha*layer1, layer1) 返回较大的值,这里进行的lrelu操作

参数说明: 输入数据为两个比较大小的数

5. tf.train_variable() 获得训练过程中的所有参数

6. np.random.uniform(-1, 1, shape) 生成随机的正态分布的数

参数说明, -1和1表示这个范围内的正态分布

情景说明:这里演示的代码使用的mnist数据集,使用[batch_size, noise_size], 即[None, 100]的数据集经过反卷积生成[None, 28, 28, 1]的mnist图片,范围为-1, 1

模型的结构说明:

对于生成网络:[None, 100] - > [None, 4*4*512](全连接) -> [None, 7, 7, 256](反卷积) -> [None, 14, 14, 128](反卷积) -> [None, 28, 28, 3](反卷积) -> tf.tanh(-1, 1的变化)

对于判别网络:[None, 28, 28, 1] -> [None, 14, 14, 128](卷积) -> [None, 7, 7, 256](卷积) -> [None, 4, 4, 512](卷积) ->[None, 512*4*4](维度变化) ->[None, 1] (全连接) -> tf.sigmoid(0, 1的变化)

生成网络参数说明: 第一层全连接,使用的w为 [100, 4*4*512], 使用的b为[4*4*512]

第二层反卷积,使用的w为[4, 4, 512, 256], 使用的b为[256]

第三层反卷积,使用的w为[3, 3, 256, 128], 使用的b为[128]

第四层反卷积,使用的w为[3, 3, 128, 1], 使用的b为[1]

判别网络参数说明:第一层卷积,使用的w为[3, 3, 1, 128] 使用的b是[128]

第二层卷积, 使用的w为[3, 3, 128, 256], 使用的b是[256]

第三层卷积,使用的w为[3, 3, 256, 512], 使用的b是[512]

第四层全连接,使用的w为[4*4*512, 1] 使用的b是[1]

代码说明:由于上述代码建立了多个函数,因此我们先进行主函数的说明

建立函数train()进行代码的训练操作

第一步:首先是定义参数, 包括input_size(输入图片的维度), noise_size(噪声图片的维度), output_dim(生成图片的维度),batch_size(一个batch的大小)

第二步:使用get_inputs(input_size, noise_size) 获得生成的初始化的real_image 和 noise_image, 对生成的real_image进行维度的变化,将其变化为[-1, 28, 28, 1], 以用于判别网络进行判断

第三步:将生成的real_image_reshape 和 noise_image 输入到get_loss里面 获得 d_loss 和 g_loss

get_loss函数说明:输入的数据为real_image_reshape, noise_image, output_dim

第一步: 调用get_generator(noise_image, output_dim, True)生成g_outputs

第二步:调用get_discrimator(real_image, reuse=False, ) 判别真实样本的输入

第三步: 调用get_discrimator(g_outputs, reuse=True) 判别生成样本的输入

第四步: 构造判别网络d_loss的损失值

第一步:构造判别网络的真实样本的损失值, tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=, label=tf.ones_like(real_logits)))

第二步:构造判别网络的生成样本的损失值

第三步:将两种损失值进行加和操作

第五步:构造生成网络g_loss的损失值, tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=, label=tf.ones_like))

第六步:返回d_loss 和 g_loss

第四步: 调用get_opt, 输入为d_loss, g_loss, learning_rate=0.001, 进行优化操作, 获得g_opt, 和d_opt

第一步:获得g_var 和 d_var 进行训练时生成网络的参数和判别网络的参数

第一步:使用varias = tf.train_variable() 获得训练时的参数

第二步:使用g_var = [v for v in varias if v.name.startswith('generator')] 来获得训练过程中的生成网络的参数

第三步:d_var = [v for v in varias if v.name.startswith('discrimator')] 来获得训练过程中的判别网络的参数

第二步:构造优化的操作g_opt, d_opt

第一步: 使用tf.train.Adaoptimer(learning_rate).minimize(d_loss, var_list=d_var), 构造d_opt

第二步: 使用tf.train.Adaoptimer(learning_rate).minimize(g_loss, var_list=g_var)  构造g_opt

第五步:进入循环操作,迭代30次,进行训练操作,一个epoch迭代的次数为range(mnist.train.num_examples // batch_size)

第一步:读取一个batch_size的数据image_batch,并将其转换为-1, 1的范围

第一步:使用mnist.train.next_batch(batch_size)获得一个batch的数据

第二步:使用batch_image = batch[0]获得其中的图片

第三步: batch_image = batch_image * 2 - 1将image的范围从0, 1变化为-1, 1

第二步:使用np.random.uniform(-1, 1, (batch_size, noise_size)) 生成一个batch的噪音数据,大小为batch_size, noise_size

第三步:使用sess.run(g_opt, feed_dict) 和 d_opt更新参数

第四步:在一个epoch结束后,执行sess.run(d_loss) 和 sess,run(g_loss)

第五步:调用show_sample_image获得生成后的图片, 输入为sess, n_sample, input_image, output_dim, reuse , 这里的input_image表示real_image

第一步:使用input_image.get_shape().as_list()[-1]获得noise的维度,这里是100

第二步:使用np.random.uniform(-1, 1, (n_sample, input_shape)) 生成50,100的噪音数据

第三步:使用sess.run(get_generator(input_image, output_dim, reuse), feed_dict={input_image, sample_noise})

第四步:返回生成的图片sample

第六步:调用plot_show()进行图片的展示

第七步:打印结果

import numpy as np
import tensorflow as tf
import pickle
from tensorflow.examples.tutorials.mnist import input_data
import matplotlib.pyplot as plt # 读入mnist输入
mnist = input_data.read_data_sets('/data') # 构造输入样本的数据,real_size 和 noise_size, 生成初始化的real_image 和 noise_image
def get_inputs(real_size, noise_size):
# 真实图片的维度为[None, 784]
real_img = tf.placeholder('float32', [None, real_size])
# 噪音数据的维度为[None , 100]
noise_img = tf.placeholder('float32', [None, noise_size]) return real_img, noise_img # 构造generator网络,将[None, 100]的噪音数据, 生成[None, 28, 28, 1]的图片数据
def get_generator(noise_img, output_dim, is_train, alpha=0.01): with tf.variable_scope('generator', reuse=not is_train): # 100 -> 4*4*512 - > 4, 4, 512
# 进行全连接操作,将100的数据通过全连接,转换为[None ,4*4*512]
layer1 = tf.layers.dense(noise_img, 4*4*512)
# 进行维度变化,将其转换为[-1, 4, 4, 512]
layer1 = tf.reshape(layer1, [-1, 4, 4, 512])
# 使用tf.layers.batch_normalization进行归一化操作
layer1 = tf.layers.batch_normalization(layer1, training=is_train)
# 使用tf.maximum进行lrelu操作
layer1 = tf.maximum(alpha*layer1, layer1)
# 使用tf.nn.dropout进行dropout操作
layer1 = tf.nn.dropout(layer1, keep_prob=0.8) # 4*4*512 -> 7*7*256
# 进行反卷积操作,将4*4*256 -> 7*7*256
layer2 = tf.layers.conv2d_transpose(layer1, 256, 4, 1, padding='valid')
# 进行归一化操作
layer2 = tf.layers.batch_normalization(layer2, training=is_train)
# 进行lrelu操作
layer2 = tf.maximum(alpha*layer2, layer2)
# 进行dropout操作
layer2 = tf.nn.dropout(layer2, keep_prob=0.8) # 7*7*256 - 14*14*128
# 进行反卷积操作,stride=2,维度扩大为原来的2倍
layer3 = tf.layers.conv2d_transpose(layer2, 128, 3, 2, padding='SAME')
# 归一化操作
layer3 = tf.layers.batch_normalization(layer3, training=is_train)
# 进行lrelu操作
layer3 = tf.maximum(alpha*layer3, layer3)
# 进行dropout的操作
layer3 = tf.nn.dropout(layer3, keep_prob=0.8)
# 进行反卷积操作将 14*14*128 -> 28*28*1
logits = tf.layers.conv2d_transpose(layer3, output_dim, 3, 2, padding='SAME')
# 将输出结果转换为-1, 1之间
outputs = tf.tanh(logits) return outputs # 生成判别网络,输入样本的大小为[28, 28, 1], reuse表示是否进行参数复用
def get_discrimator(input_image, reuse, alpha=0.01):
# 指定参数范围
with tf.variable_scope('discrimator', reuse=reuse): # 28*28*1 -> 14*14*128
# 进行卷积操作,将28*28*1变化为14*14*128,步长为2
layer1 = tf.layers.conv2d(input_image, 128, 2, padding='SAME')
# 进行lrelu操作
layer1 = tf.maximum(layer1*alpha, layer1)
# 进行dropout操作
layer1 = tf.nn.dropout(layer1, keep_prob=0.8)
# 14*14*128 -> 7*7*256
# 进行卷积操作,将14*14*128变换为7*7*256, 步长为2
layer2 = tf.layers.conv2d(layer1, 256, 2, padding='SAME')
# 使用tf.layers.batch_normalization进行归一化操作
layer2 = tf.layers.batch_normalization(layer2, training=True)
# 进行lrelu操作
layer2 = tf.maximum(layer2*alpha, layer2)
# 进行dropout操作
layer2 = tf.nn.dropout(layer2, keep_prob=0.8)
# 7*7*64 -> 4*4*512
# 进行卷积操作
layer3 = tf.layers.conv2d(layer2, 512, 2, padding='SAME')
# 进行归一化操作
layer3 = tf.layers.batch_normalization(layer3, training=True)
# 进行lrelu操作
layer3 = tf.maximum(layer3*alpha, layer3)
# 进行dropout操作
layer3 = tf.nn.dropout(layer3, keep_prob=0.8)\
# 进行维度变换
flatten_fc = tf.reshape(layer3, [-1, 4*4*512])
# 进行全连接操作,将4*4*512 变为1
logits = tf.layers.dense(flatten_fc, 1)
# 将结果变化为0, 1之间,输出的是概率值
outputs = tf.sigmoid(logits) return logits, outputs # 用于生成损失值,输入为真实图片,噪音图片, 生成图片的维度, smooth
def get_loss(real_image, noise_image, output_dim, smooth=0.1): # 生成图片和判别网络
# 使用生成网络,输入噪音图片,生成图片
g_outputs = get_generator(noise_image, output_dim, True)
# 使用判别网络,对真实图片进行判别,返回Logits和inputs
d_real_logits, d_real_outputs = get_discrimator(real_image, False)
# 使用判别网络,对生成图片进行判别,返回为logits和inputs
d_fake_logits, d_real_outputs = get_discrimator(g_outputs, True) # 生成loss函数, 使用tf.reduce_mean构成d_loss
d_loss_1 = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_real_logits, labels=tf.ones_like(d_real_logits) * (1-smooth)))
d_loss_2 = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_fake_logits, labels=tf.zeros_like(d_fake_logits)))
d_loss = d_loss_1 + d_loss_2
# 使用tf.reduce_mean 构成g_loss, labels=tf.ones_like(d_fake_logits)
g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_fake_logits, labels=tf.ones_like(d_fake_logits) * (1-smooth))) # 返回判别和生成的损失值
return d_loss, g_loss # 获得用于降低损失的g_opt 和 d_opt
def get_opt(d_loss, g_loss, learning_rate=0.001):
# 获得训练过程中的所有训练参数
varies = tf.trainable_variables()
# 循环训练参数,根据参数名字的开头获得生成网络的参数
g_var = [var for var in varies if var.name.startswith('generator')]
# 根据参数名字的开头获得判别网络的参数
d_var = [var for var in varies if var.name.startswith('discrimator')]
# 对于d_loss的损失值,只训练d_var参数
d_opt = tf.train.AdamOptimizer(learning_rate).minimize(d_loss, var_list=d_var)
# 对于g_loss的损失值,只训练g_var参数
g_opt = tf.train.AdamOptimizer(learning_rate).minimize(g_loss, var_list=g_var) return d_opt, g_opt
# 调用get_generator生成图片
def show_sample_image(sess, n_sample, input_noise, output_dim):
# 获得输入图片的维度,这里值噪声图片,维度为100
input_size = input_noise.get_shape().as_list()[-1]
# 生成-1,1的[50, 100]的噪音数据
noise_sample = np.random.uniform(-1, 1, (n_sample, input_size))
# 执行生成函数,将噪音数据传入
samples = sess.run(get_generator(input_noise, output_dim, False), feed_dict={input_noise:noise_sample}) return samples
# 进行画图操作
def plot_samples(samples):
# 表示图片以及图片的维度
fig, axes = plt.subplots(nrows=1, ncols=25)
# 循环每一个subplots进行画图操作
for img, ax in zip(samples, axes):
# 在每个subplot上进行画图
ax.imshow(img, cmap='Greys_r')
# 去除ax的边界
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
# 图片没有边界
fig.tight_layer(pad=0)
# 图片展示
plt.show() # 主函数进行训练
def train():
# 第一步:设置基本的参数
# 图片的大小,这里是784
input_size = mnist.train.images[0].shape[0]
# 噪声数据的大小,100
noise_size = 100
# 每一个batch值
batch_size = 64
# 生成图片的维度
output_dim = 1
# 迭代的epoch值
epoch = 30
# 用于展示的图片大小
n_sample = 25
# 第二步:调用get_inputs,生成初始化的输入数据,[None, 784], [None, 100]
real_img, noise_img = get_inputs(input_size, noise_size)
# 对输入数据的真实数据进行维度变化,用来输入到判别网络进行判别
real_img_reshape = tf.reshape(real_img, [-1, 28, 28, 1])
# 第三步: 将真实数据和噪音数据输入到loss函数中,生成判别损失值d_loss和生成损失值g_loss
d_loss, g_loss = get_loss(real_img_reshape, noise_img, output_dim)
# 第四步:嗲用get_op根据损失值获得操作步骤opt
d_opt, g_opt = get_opt(d_loss, g_loss)
# 第五步:实际传入数据,进行模型的训练
with tf.Session() as sess:
# 参数初始化
sess.run(tf.global_variables_initializer())
# 循环epoch
for i in range(epoch):
# 迭代每一个batch_size
for batch_i in range(mnist.train.num_examples // batch_size):
# 获得一个batch_size的数据
batch = mnist.train.next_batch(batch_size)
# 获得一个batch_size的图片
batch_img = batch[0]
# 将其范围变为-1, 1
batch_img = batch_img * 2 - 1
# 获得一个batch_size的噪音数据
batch_noise = np.random.uniform(-1, 1, (batch_size, noise_size))
# 实际传入参数,执行g_opt 和 d_opt
_ = sess.run(g_opt, feed_dict={real_img:batch_img, noise_img:batch_noise})
_ = sess.run(d_opt, feed_dict={real_img:batch_img, noise_img:batch_noise})
# 一个epoch后获的损失值
train_d_loss = sess.run(d_loss, feed_dict={real_img:batch_img, noise_img:batch_noise})
train_g_loss = sess.run(g_loss, feed_dict={real_img: batch_img, noise_img: batch_noise})
# 迭代10次以后
if i % 10 == 0:
# 根据噪音数据生成samples数据
samples = show_sample_image(sess, n_sample, noise_img, output_dim)
# 对生成的samples数据进行图像展示
plot_samples(samples) train()

对抗生成网络-图像卷积-mnist数据生成(代码) 1.tf.layers.conv2d(卷积操作) 2.tf.layers.conv2d_transpose(反卷积操作) 3.tf.layers.batch_normalize(归一化操作) 4.tf.maximum(用于lrelu) 5.tf.train_variable(训练中所有参数) 6.np.random.uniform(生成正态数据的更多相关文章

  1. 深度学习原理与框架-图像补全(原理与代码) 1.tf.nn.moments(求平均值和标准差) 2.tf.control_dependencies(先执行内部操作) 3.tf.cond(判别执行前或后函数) 4.tf.nn.atrous_conv2d 5.tf.nn.conv2d_transpose(反卷积) 7.tf.train.get_checkpoint_state(判断sess是否存在

    1. tf.nn.moments(x, axes=[0, 1, 2])  # 对前三个维度求平均值和标准差,结果为最后一个维度,即对每个feature_map求平均值和标准差 参数说明:x为输入的fe ...

  2. 深度学习原理与框架- tf.nn.conv2d_transpose(反卷积操作) tf.nn.conv2d_transpose(进行反卷积操作) 对于stride的理解存在问题?

    反卷积操作: 首先对需要进行维度扩张的feature_map 进行补零操作,然后使用3*3的卷积核,进行卷积操作,使得其维度进行扩张,图中可以看出,2*2的feature经过卷积变成了4*4.    ...

  3. 2019-3-10——生成对抗网络GAN---生成mnist手写数字图像

    """ 生成对抗网络(GAN,Generative Adversarial Networks)的基本原理很简单: 假设有两个网络,生成网络G和判别网络D.生成网络G接受一 ...

  4. 高并发分布式系统中生成全局唯一(订单号)Id js返回上一页并刷新、返回上一页、自动刷新页面 父页面操作嵌套iframe子页面的HTML标签元素 .net判断System.Data.DataRow中是否包含某列 .Net使用system.Security.Cryptography.RNGCryptoServiceProvider类与System.Random类生成随机数

    高并发分布式系统中生成全局唯一(订单号)Id   1.GUID数据因毫无规律可言造成索引效率低下,影响了系统的性能,那么通过组合的方式,保留GUID的10个字节,用另6个字节表示GUID生成的时间(D ...

  5. 第十四节,TensorFlow中的反卷积,反池化操作以及gradients的使用

    反卷积是指,通过测量输出和已知输入重构未知输入的过程.在神经网络中,反卷积过程并不具备学习的能力,仅仅是用于可视化一个已经训练好的卷积神经网络,没有学习训练的过程.反卷积有着许多特别的应用,一般可以用 ...

  6. tf.nn.conv2d。卷积函数

    tf.nn.conv2d是TensorFlow里面实现卷积的函数,参考文档对它的介绍并不是很详细,实际上这是搭建卷积神经网络比较核心的一个方法,非常重要 tf.nn.conv2d(input, fil ...

  7. tf.nn.conv2d 参数介绍

    tf.nn.conv2d是TensorFlow里面实现卷积的函数,参考文档对它的介绍并不是很详细,实际上这是搭建卷积神经网络比较核心的一个方法,非常重要 tf.nn.conv2d(input, fil ...

  8. 【TensorFlow】tf.nn.conv2d是怎样实现卷积的?

    tf.nn.conv2d是TensorFlow里面实现卷积的函数,参考文档对它的介绍并不是很详细,实际上这是搭建卷积神经网络比较核心的一个方法,非常重要 tf.nn.conv2d(input, fil ...

  9. spring boot拦截器中获取request post请求中的参数

    最近有一个需要从拦截器中获取post请求的参数的需求,这里记录一下处理过程中出现的问题. 首先想到的就是request.getParameter(String )方法,但是这个方法只能在get请求中取 ...

随机推荐

  1. EBS查询在线用户

    转自:https://www.cnblogs.com/benio/archive/2011/03/10/1979417.html SELECT u.user_name, app.application ...

  2. C++中的内部类

    1.内部类的概念 如果一个类定义在另一个类的内部,这个内部类就叫做内部类.注意此时这个内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去调用内部类.外部类对内部类没有任何优越的访问权限. ...

  3. Vue --- :is

    1.1 基本示例 <div id="app"> <!-- template slot transition --> <input type=" ...

  4. el-popover 的显示或隐藏,要在拿到真实dom之后再做控制

    el-popover 的显示或隐藏,要在拿到真实dom之后再做控制

  5. laravel的ORM模型的find(),findOrFail(),first(),firstOrFail(),get(),list(),toArray()之间的区别

    find($id)需要一个id并返回一个模型.如果不存在匹配的模型,则返回null. findOrFail($id)需要一个id并返回一个模型.如果不存在匹配的模型,则会引发错误, 它会抛出一个err ...

  6. Ant将Jmeter的jtl文件转为html文件报“前言中不允许有内容”

    ant执行jmeter的脚本的时候提示“Fatal Error! 前言中不允许有内容” 解决办法: 在jmeter的bin目录中找到jmeter.properties: 将文件中#jmeter.sav ...

  7. logback root level logger level 日志级别覆盖?继承?

    1. logback-spring.xml 配置 <appender name="STDOUT" class="ch.qos.logback.core.Consol ...

  8. py-day3-6 python map函数

    map函数 :处理序列中的每个元素,得到的结果是一个列表,该列表元素个数及位置与原来一样 ## 求列表里元素的平方 (原始方法) num_1=[1,2,13,5,8,9] res =[] for i ...

  9. kill -9 ,kill -12,kill -15

    https://www.cnblogs.com/liuhouhou/p/5400540.html Linux kill -9 和 kill -15 的区别 大家对kill -9 肯定非常熟悉,在工作中 ...

  10. python判断平台

    网上找到的判断平台的方法,特此记录 # -*- coding: utf-8 -*- import platform osName = platform.system() if(osName == 'W ...