Tensorflow与深度学习编程——初级篇

Demo1:基于Tensorflow的深度神经网络:DNN

from tensorflow.examples.tutorials.mnist import input_data  
import tensorflow as tf  
from sklearn.metrics import accuracy_score 
import numpy as np  

if __name__ == '__main__':
	n_inputs = 28 * 28 
	n_hidden1 = 300
	n_hidden2 = 100
	n_outputs = 10

	mnist = input_data.read_data_sets("/tmp/data/") 

	X_train = mnist.train.images 
	X_test  = mnist.test.images
	y_train = mnist.train.labels.astype("int") 
	y_test  = mnist.test.labels.astype("int")

	X = tf.placeholder(tf.float32,shape = (None, n_inputs),name = 'X')
	y = tf.placeholder(tf.int64, shape = (None),name = 'y')
    
    #命名空间:dnn
	with tf.name_scope('dnn'):
		hidden1 = tf.layers.dense(X,n_hidden1,activation = tf.nn.relu, name = "hidden1")

		hidden2 = tf.layers.dense(hidden1,n_hidden2,activation = tf.nn.relu,name = "hidden2")

		logits  = tf.layers.dense(hidden2,n_outputs,name = "outputs")
    
    #命名空间:loss
	with tf.name_scope('loss'):
		x_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels = y,logits = logits)

		#所有值求平均
		loss = tf.reduce_mean(x_entropy,name = "loss")

 
	learning_rate = 0.01

	#命名空间:train
	with tf.name_scope('train'):
		optimizer = tf.train.GradientDescentOptimizer(learning_rate)
		training_op = optimizer.minimize(loss)

	#命名空间:eval
	with tf.name_scope('eval'):
		#是否与真值一致 返回布尔值
		correct = tf.nn.in_top_k(logits,y,1)
		accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))

	init = tf.global_variables_initializer()


	n_epochs = 20
	batch_size = 50

	with tf.Session() as sess:
		init.run()
		for epoch in range(n_epochs):
			for iteration in range(mnist.train.num_examples // batch_size):
				X_batch , y_batch = mnist.train.next_batch(batch_size)
				sess.run(training_op,feed_dict = {X:X_batch,y:y_batch})
				acc_train = accuracy.eval(feed_dict = {X:X_batch,y:y_batch})
				acc_test  = accuracy.eval(feed_dict = {X:mnist.test.images,y:mnist.test.labels})
				print (epoch,"Train accuracy:",acc_train,"Test accuracy",acc_test)

官方的温馨提示：

获取mnist的方式以后会变
Minist用起来一时爽，真正拿现实生活中的结构化数据跑深度学习模型时容易炸毛。

Demo1的问题：
1.层数比较浅，只有两个隐藏层
2.没有解决梯度消失或梯度爆炸问题

Demo2:
用批量标准化改进DNN，来避免梯度消失或爆炸问题

“TensorFlow
提供了一个batch_normalization()函数，它简单地对输入进行居中和标准化，但是您必须自己计算平均值和标准差（基于训练期间的小批量数据或测试过程中的完整数据集）
作为这个函数的参数，并且还必须处理缩放和偏移量参数的创建（并将它们传递给此函数）。 这是可行的，但不是最方便的方法。
相反，你应该使用batch_norm()函数，它为你处理所有这些。
您可以直接调用它。为了在每个隐藏层激活函数之前运行批量标准化，我们手动应用 RELU 激活函数”

import tensorflow as tf

n_inputs = 28 * 28
n_hidden1 = 300
n_hidden2 = 100
n_outputs = 10

X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")

training = tf.placeholder_with_default(False, shape=(), name='training')

hidden1 = tf.layers.dense(X, n_hidden1, name="hidden1")
bn1 = tf.layers.batch_normalization(hidden1, training=training, momentum=0.9)
bn1_act = tf.nn.elu(bn1)

hidden2 = tf.layers.dense(bn1_act, n_hidden2, name="hidden2")
bn2 = tf.layers.batch_normalization(hidden2, training=training, momentum=0.9)
bn2_act = tf.nn.elu(bn2)

logits_before_bn = tf.layers.dense(bn2_act, n_outputs, name="outputs")
logits = tf.layers.batch_normalization(logits_before_bn, training=training,
                                       momentum=0.9)
X = tf.placeholder(tf.float32, shape=(None, n_inputs), name="X")
training = tf.placeholder_with_default(False, shape=(), name='training')

为了避免一遍又一遍重复相同的参数，我们可以使用 Python 的partial()函数：

from functools import partial

my_batch_norm_layer = partial(tf.layers.batch_normalization,training=training, momentum=0.9)

hidden1 = tf.layers.dense(X, n_hidden1, name="hidden1")
bn1 = my_batch_norm_layer(hidden1)
bn1_act = tf.nn.elu(bn1)
hidden2 = tf.layers.dense(bn1_act, n_hidden2, name="hidden2")
bn2 = my_batch_norm_layer(hidden2)
bn2_act = tf.nn.elu(bn2)
logits_before_bn = tf.layers.dense(bn2_act, n_outputs, name="outputs")
logits = my_batch_norm_layer(logits_before_bn)

完整代码：

from functools import partial 
from tensorflow.examples.tutorials.mnist import input_data  
import tensorflow as tf  

if __name__ == '__main__':
	n_inputs = 28 * 28  
	n_hidden1 = 300
	n_hidden2 = 100
	n_outputs = 10 


	mnist = input_data.read_data_sets("/tmp/data") 

	batch_norm_momentum = 0.9 
	learning_rate = 0.01 

	X = tf.placeholder(tf.float32,shape = (None,n_inputs),name = "X")
	y = tf.placeholder(tf.int64,shape = None,name = 'y')
	#给Batch norm加一个placeholde
	training = tf.placeholder_with_default(False,shape = (),name = 'training')


	with tf.name_scope("dnn"):
		#权重初始化
		he_init = tf.contrib.layers.variance_scaling_initializer()

		my_batch_norm_layer = partial(
				tf.layers.batch_normalization,
				training = training,
				momentum = batch_norm_momentum
			)

		my_dense_layer = partial(
				tf.layers.dense,
				kernel_initializer = he_init
			)

		hidden1 = my_dense_layer(X,n_hidden1,name = "hidden1")
		bn1     = tf.nn.elu(my_batch_norm_layer(hidden1))
		hidden2 = my_dense_layer(bn1,n_hidden2,name = "hidden2")
		bn2     = tf.nn.elu(my_batch_norm_layer(hidden2))
		logists_before_bn = my_dense_layer(bn2,n_outputs,name = "outputs")
		logists = my_batch_norm_layer(logists_before_bn)

	with tf.name_scope('loss'):
		x_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels = y,logits = logists )
		loss = tf.reduce_mean(x_entropy, name = 'loss')

	with tf.name_scope("train"):
		optimizer = tf.train.GradientDescentOptimizer(learning_rate)
		training_op = optimizer.minimize(loss)

	with tf.name_scope("eval"):
		correct = tf.nn.in_top_k(logists,y,1)
		accuracy = tf.reduce_mean(tf.cast(correct,tf.float32))

	init = tf.global_variables_initializer()
	saver = tf.train.Saver()

	n_epoches = 20 
	batch_size = 200
# 注意：由于我们使用的是 tf.layers.batch_normalization() 而不是 tf.contrib.layers.batch_norm()（如本书所述），
# 所以我们需要明确运行批量规范化所需的额外更新操作（sess.run([ training_op，extra_update_ops], ...)。

	extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)

	with tf.Session() as sess:
		init.run()
		for epoch in range(n_epoches):
			for iteration in range(mnist.train.num_examples // batch_size):
				X_batch,y_batch = mnist.train.next_batch(batch_size)
				sess.run([training_op,extra_update_ops],feed_dict = {training:True,X:X_batch,y:y_batch})
				accuracy_val = accuracy.eval(feed_dict = {X:mnist.test.images, y:mnist.test.labels})

				print (epoch, 'Test accuracy',accuracy_val)

Demo3:CNN的卷积层实现

from sklearn.datasets import load_sample_image 
import matplotlib.pyplot as plt  
import numpy as np 
import tensorflow as tf  

if __name__ == '__main__':
	#Load sample images 
	china = load_sample_image("china.jpg")
	flower = load_sample_image("flower.jpg")

	datasets = np.array([china,flower],dtype = np.float32)
	batch_size,height,width,channels = datasets.shape 

	#Create 2 filters 
	filters = np.zeros(shape = (7,7,channels,2), dtype = np.float32)
	filters[:,3,:,0] = 2 #vertical line 
	filters[3,:,:,1] = 2#horizontal line
	# Create a graph with input X plus a convolutional layer applying the 2 filters
	X = tf.placeholder(tf.float32, shape = (None,height,width,channels))
	convolution = tf.nn.conv2d(X,filters,strides = [1,2,2,1],padding = "SAME")

	with tf.Session() as sess:
		output = sess.run(convolution,feed_dict = {X:datasets})

	plt.imshow(output[1, :, :, 1], cmap="gray") # plot 1st image's 2nd feature map
	#plt.imshow(output[0, :, :, 1], cmap="gray")
	plt.show()

Demo4:CNN的池化层实现

import numpy as np
from sklearn.datasets import load_sample_image
import tensorflow as tf
import matplotlib.pyplot as plt

china = load_sample_image("china.jpg")
flower = load_sample_image("flower.jpg")

dataset = np.array([china, flower], dtype=np.float32)
batch_size, height, width, channels = dataset.shape

# Create 2 filters
filters = np.zeros(shape=(7, 7, channels, 2), dtype=np.float32)
filters[:, 3, :, 0] = 1  # vertical line
filters[3, :, :, 1] = 1  # horizontal line

X = tf.placeholder(tf.float32, shape=(None, height, width, channels))
max_pool = tf.nn.max_pool(X, ksize=[1,3,3,1], strides=[1,3,3,1],padding="VALID")

with tf.Session() as sess:
    output = sess.run(max_pool, feed_dict={X: dataset})

plt.imshow(output[0].astype(np.uint8))  # plot the output for the 1st image
#plt.imshow(output[1].astype(np.uint8)) 
plt.show()

Demo5.RNN实现：
最基本的RNN，相当于两个前馈神经网络：

import numpy as np  
import tensorflow as tf  

if __name__ == '__main__':
	n_inputs = 3 
	n_neurons = 5 
	X0 = tf.placeholder(tf.float32,[None,n_inputs])
	X1 = tf.placeholder(tf.float32,[None,n_inputs])
	Wx = tf.Variable(tf.random_normal(shape = [n_inputs,n_neurons],dtype = tf.float32))
	Wy = tf.Variable(tf.random_normal(shape = [n_neurons,n_neurons],dtype = tf.float32))
	b  = tf.Variable(tf.zeros([1,n_neurons],dtype = tf.float32))
	Y0 = tf.tanh(tf.matmul(X0,Wx) + b)
	Y1 = tf.tanh(tf.matmul(Y0,Wy) + tf.matmul(X1,Wx) + b)
	init = tf.global_variables_initializer() 

	#Mini-batch: instance 0,instance 1,instance 2,instance 3 
	X0_batch = np.array([[0,1,2],[3,4,5],[6,7,8],[9,0,1]])  #t = 0 
	X1_batch = np.array([[9,8,7],[0,0,0],[6,5,4],[3,2,1]])  #t = 1
	with tf.Session() as sess:
		init.run()
		Y0_val,Y1_val = sess.run([Y0,Y1],feed_dict = {X0:X0_batch,X1:X1_batch})

	print(Y0_val)
	print('\n')
	print(Y1_val)

参考教程：https://www.jianshu.com/p/fe0bf7a49a9f