#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Aug 13 11:24:13 2017
@author: no1
"""
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data
import numpy as np
mnist = input_data.read_data_sets('MNIST_data/')
def input_placeholder(img_size,noise_size):
img=tf.placeholder(dtype=tf.float32,shape=(None,img_size[1],img_size[2],img_size[3]),name='input_image')
noise=tf.placeholder(dtype=tf.float32,shape=(None,noise_size),name='input_noise')
return img,noise
def generator(noise,output_dim,is_train=True,alpha=0.01):
#output_dim =1,means one channel
with tf.variable_scope('generator') as scope0:
if not is_train:
scope0.reuse_variables()
layer1=tf.layers.dense(noise,4*4*512)
layer1=tf.reshape(layer1,[-1,4,4,512])
#batch normalization
layer1=tf.layers.batch_normalization(layer1,training=is_train)
layer1=tf.maximum(alpha*layer1,layer1)
layer1=tf.layers.dropout(layer1,rate=0.8,training=is_train)
#deconv
layer2=tf.layers.conv2d_transpose(layer1,256,4,strides=1,padding='valid')
layer2=tf.layers.batch_normalization(layer2,training=is_train)
layer2=tf.maximum(alpha*layer2,layer2)
layer2=tf.layers.dropout(layer2,rate=0.8,training=is_train)
layer3=tf.layers.conv2d_transpose(layer2,128,3,strides=2,padding='same')
layer3=tf.layers.batch_normalization(layer3,training=is_train)
layer3=tf.maximum(alpha*layer3,layer3)
layer3=tf.layers.dropout(layer3,rate=0.8,training=is_train)
logits=tf.layers.conv2d_transpose(layer3,output_dim,3,strides=2,padding='same')
outputs=tf.tanh(logits)
tf.summary.image('input',outputs,10)
return outputs
def discriminator(img_or_noise,reuse=False,alpha=0.01):
#img_or_noise means batch image placeholder or noise's output
with tf.variable_scope('discriminator') as scope1:
if reuse:
scope1.reuse_variables()
#none*28*28*1 to none*14*14*128
layer1=tf.layers.conv2d(img_or_noise,128,3,strides=2,padding='same')
layer1=tf.maximum(alpha*layer1,layer1)
layer1=tf.nn.dropout(layer1,keep_prob=0.8)
#none*14*14*128 to none*7*7*256
layer2=tf.layers.conv2d(layer1,256,3,strides=2,padding='same')
layer2=tf.layers.batch_normalization(layer2,training=True)
layer2=tf.maximum(alpha*layer2,layer2)
layer2=tf.nn.dropout(layer2,keep_prob=0.8)
#none*7*7*256 to 4*4*512
layer3=tf.layers.conv2d(layer2,512,3,strides=1,padding='valid')
layer3=tf.layers.batch_normalization(layer3,training=True)
layer3=tf.maximum(alpha*layer3,layer3)
layer3=tf.nn.dropout(layer3,keep_prob=0.8)
flatten=tf.reshape(layer3,(-1,4*4*512))
logits=tf.layers.dense(flatten,1)
outputs=tf.sigmoid(logits)
return logits,outputs
def inference(real_img,fake_noise,image_depth=1,smooth=0.1):
g_outputs=generator(fake_noise,image_depth,is_train=True)
d_logits_real,d_outputs_real=discriminator(real_img)
d_logits_fake,d_outputs_fake=discriminator(g_outputs,reuse=True)
g_loss=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,
labels=tf.ones_like(d_outputs_fake)*(1-smooth)))
d_loss_real=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_real,
labels=tf.ones_like(d_outputs_real)*(1-smooth)))
d_loss_fake=tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=d_logits_fake,
labels=tf.zeros_like(d_outputs_fake)))
d_loss=tf.add(d_loss_real,d_loss_fake)
tf.summary.scalar('d_loss_real', d_loss_real)
tf.summary.scalar('d_loss_fake', d_loss_fake)
return g_loss,d_loss
def test(fake_placeholder,output_dim=1,num_images=25):
with tf.Session() as sess:
saver.restore(sess,tf.train.latest_checkpoint('checkpoints'))
fake_shape=fake_placeholder.shape.as_list()[-1]
fake_images=np.random.uniform(-1,1,size=[num_images,fake_shape])
samples=sess.run(generator(fake_placeholder,output_dim=1,is_train=False),
feed_dict={fake_placeholder:fake_images})
result=np.squeeze(samples,-1)
plot_image(result)
def plot_image(samples):
fig,axes=plt.subplots(nrows=5,ncols=5,figsize=(7,7))
for img,ax in zip(samples,axes.flatten()):
ax.imshow(img.reshape((28,28)),cmap='Greys_r')
ax.axis('off')
def get_optimizer(g_loss,d_loss,beta=0.4,learning_rate=0.001):
train_vars=tf.trainable_variables()
g_vars=[var for var in train_vars if var.name.startswith('generator')]
d_vars=[var for var in train_vars if var.name.startswith('discriminator')]
g_opt=tf.train.AdamOptimizer(learning_rate,beta1=beta).minimize(g_loss,var_list=g_vars)
d_opt=tf.train.AdamOptimizer(learning_rate,beta1=beta).minimize(d_loss,var_list=d_vars)
return g_opt,d_opt
def train(real_placeholder,fake_placeholder,g_train_opt,d_train_opt,epoches,noise_size=100,data_shape=[-1,28,28,1],batch_size=64,n_samples=25):
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
summary_writer = tf.summary.FileWriter('log/', sess.graph)
for e in range(1,epoches):
for step in range(mnist.train.num_examples//batch_size):
images,labels=mnist.train.next_batch(batch_size)
batch_image=images.reshape(data_shape)
batch_image=batch_image*2 -1
batch_noise=np.random.uniform(-1,1,size=(batch_size,noise_size))
sess.run(g_train_opt,feed_dict={real_placeholderhttp://116.255.235.199:6006:batch_image,fake_placeholder:batch_noise})
sess.run(d_train_opt,feed_dict={real_placeholder:batch_image,fake_placeholder:batch_noise})
summary_str=sess.run(summary,feed_dict={real_placeholder:batch_image,fake_placeholder:batch_noise})
summary_writer.add_summary(summary_str, step)
summary_writer.flush()
if step %101 ==0:
train_loss_d=d_loss.eval({real_placeholder:batch_image,fake_placeholder:batch_noise})
train_loss_g=g_loss.eval(feed_dict={fake_placeholder:batch_noise})
print('step:{}/Epoch:{}/total Epoch:{}'.format(step,e,epoches),
'Discriminator Loss:{:.4f}..'.format(train_loss_d),'Generator Loss:{:.4f}..'.format(train_loss_g))
saver.save(sess,'./checkpoints/generator.ckpt')
with tf.Graph().as_default():
real_img,fake_img=input_placeholder([-1,28,28,1],noise_size=100)
g_loss,d_loss=inference(real_img,fake_img)
summary = tf.summary.merge_all()
g_train_opt,d_train_opt=get_optimizer(g_loss,d_loss)
saver=tf.train.Saver()
train(real_img,fake_img,g_train_opt,d_train_opt,epoches=4)
test(fake_img,num_images=25)
DCGAN生成手写体数据
最新推荐文章于 2022-02-22 19:47:56 发布