初學tensorflow，參考了以下幾篇博客：
tensorflow構建CNN[待學習]
BN層[待學習]
先解釋以下MNIST數據集，訓練數據集有55,000 條，即X為55,000 * 784的矩陣，那么Y為55,000 * 10的矩陣，每個圖片是28像素*28像素，帶有標簽，Y為該圖片的真實數字，即標簽，每個圖片10個數字，1所在位置代表圖片類別。
Softmax模型
准確率92.3，讀入時候將圖片拉成一個向量。使用Adam梯度下降求答案。
-
-
import tensorflow
as tf
-
import numpy
as np
-
from tensorflow.examples.tutorials.mnist
import input_data
-
#訓練數據集有55,000 條，即X為55,000 * 784的矩陣，那么Y為55,000 * 10的矩陣
-
#讀數據，one_hot表示將矩陣處理為行向量，即28*28 => 1*784
-
mnist = input_data.read_data_sets(
"MNIST_data/", one_hot=
True)
-
learning_rate =
0.01
-
batch_size =
128
-
n_epochs =
1000
-
x = tf.placeholder(tf.float32, [
None,
784])
#因為訓練時跟測試時樣本數量不一樣，所以直接None
-
#只是一個softmax分類器，初始化0就好了,默認訓練variable.trainable=True的參數
-
W = tf.Variable(tf.zeros([
784,
10]))
-
b = tf.Variable(tf.zeros([
10]))
-
#softmax 輸出一個10*1的矩陣，代表每個值的概率分布
-
y_hat = tf.nn.softmax(tf.matmul(x, W) + b)
-
y = tf.placeholder(tf.float32, [
None,
10])
-
#交叉熵損失函數
-
loss = tf.reduce_mean(-tf.reduce_sum(y * tf.log(y_hat)))
-
#也可以調用內置函數
-
#entropy = tf.nn.softmax_cross_entropy_with_logits(logits, Y) #第一個是測試輸出的函數，第二個是樣本類別真實值
-
#loss = tf.reduce_mean(entropy) # computes the mean over examples in the batch
-
#學習率為0.01 使用Adam梯度下降
-
train = tf.train.AdamOptimizer(learning_rate).minimize(loss)
-
correct_prediction = tf.equal(tf.argmax(y,
1), tf.argmax(y_hat,
1))
# 測試樣本只有一個1，看這個1的位置和預測的概率最大值是否一樣
-
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# 通過cast將布爾類型轉化成float類型，每個值要么0要么1，求他的均值就是准確率
-
with tf.Session()
as sess:
-
sess.run(tf.global_variables_initializer())
-
for i
in range(n_epochs):
-
batch_x, batch_y = mnist.train.next_batch(batch_size)
#獲取批量樣本
-
sess.run(train, feed_dict={x: batch_x, y: batch_y})
#運行計算圖
-
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y: mnist.test.labels}))
全連接神經網絡模型
2層隱藏層，激活函數為relu函數，分類函數為softmax函數，學習率采用指數下降法，基本初始學習率0.01，如果太大會只有9.8%的准確率，學習率衰減速度如果太快也會准確率下降（過擬合），dropout正則化不是很管用，會讓准確率下降，只有keep_prob = 0.99才勉強准確率高點。如果一個隱藏層，准確率為93.45%，無論是學習率大了，過度正則化都會導致9.8%。學習率太低則90左右的准確率
-
import tensorflow
as tf
-
import numpy
as np
-
from tensorflow.examples.tutorials.mnist
import input_data
-
# 訓練數據集有55,000 條，即X為55,000 * 784的矩陣，那么Y為55,000 * 10的矩陣
-
# 讀數據，one_hot表示將矩陣處理為行向量，即28*28 => 1*784
-
mnist = input_data.read_data_sets(
"MNIST_data/", one_hot=
True)
-
-
base_learning_rate =
0.01
-
batch_size =
128
-
n_epochs =
1000
-
keep_prob =
1
-
decay_steps =
2
-
decay_rate =
0.99
-
-
-
def add_layer(inputs, input_size, output_size, activation_function=None):
-
W = tf.Variable(tf.random_normal([input_size, output_size]) * np.sqrt(
1/input_size))
-
b = tf.Variable(tf.zeros([
1, output_size]) +
0.1)
-
y_hat = tf.matmul(inputs, W) + b
-
y_hat = tf.nn.dropout(y_hat, keep_prob=keep_prob)
#dropout 自動除以了keep_prob
-
-
if activation_function
is
None:
-
outputs = y_hats
-
else:
-
outputs = activation_function(y_hat)
-
return outputs
-
-
-
x = tf.placeholder(tf.float32, [
None,
784])
-
y = tf.placeholder(tf.float32, [
None,
10])
-
-
layer1 = add_layer(x,
784,
100, activation_function=tf.nn.relu)
-
layer2 = add_layer(layer1,
100,
10, activation_function=tf.nn.relu)
-
y_hat = add_layer(layer2,
10,
10, tf.nn.softmax)
-
#定義存儲訓練輪數的變量，這個變量不需要被訓練
-
global_step = tf.Variable(
0, trainable=
False)
-
-
learning_rate = tf.train.exponential_decay(base_learning_rate, global_step, decay_steps, decay_rate)
-
#base_learning_rate為基礎學習率，global_step為當前迭代的次數
-
#decay_steps為幾步一下降
-
#decay_rate為學習率衰減速度
-
loss = tf.reduce_mean(-tf.reduce_sum(y*tf.log(y_hat)))
-
train = tf.train.AdamOptimizer(learning_rate).minimize(loss, global_step=global_step)
#會自增
-
-
correct_prediction = tf.equal(tf.argmax(y,
1), tf.argmax(y_hat,
1))
# 測試樣本只有一個1，看這個1的位置和預測的概率最大值是否一樣
-
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# 通過cast將布爾類型轉化成float類型，每個值要么0要么1，求他的均值就是准確率
-
-
with tf.Session()
as sess:
-
sess.run(tf.global_variables_initializer())
-
for i
in range(n_epochs):
-
batch_x, batch_y = mnist.train.next_batch(batch_size)
-
sess.run(train, feed_dict={x: batch_x, y: batch_y})
-
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y: mnist.test.labels}))
卷積網絡模型（LENET）
思路
使用一個簡單的CNN網絡結構如下，括號里邊表示tensor經過本層后的輸出shape：
- 輸入層（28 * 28 * 1）
- 卷積層1（28 * 28 * 32）
- pooling層1（14 * 14 * 32）
- 卷積層2（14 * 14 * 64）
- pooling層2（7 * 7 * 64）
- 全連接層（1 * 1024）
- softmax層（10）
主要的函數說明：
卷積層：
tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, data_format=None, name=None)
參數說明：
data_format：表示輸入的格式，有兩種分別為：“NHWC”和“NCHW”，默認為“NHWC”
input：輸入是一個4維格式的（圖像）數據，數據的 shape 由 data_format 決定：當 data_format 為“NHWC”輸入數據的shape表示為[batch, in_height, in_width, in_channels]，分別表示訓練時一個batch的圖片數量、圖片高度、 圖片寬度、 圖像通道數。當 data_format 為“NHWC”輸入數據的shape表示為[batch, in_channels， in_height, in_width]
filter：卷積核是一個4維格式的數據：shape表示為：[height,width,in_channels, out_channels]，分別表示卷積核的高、寬、深度（與輸入的in_channels應相同）、輸出 feature map的個數（即卷積核的個數）。
strides：表示步長：一個長度為4的一維列表，每個元素跟data_format互相對應，表示在data_format每一維上的移動步長。當輸入的默認格式為：“NHWC”，則 strides = [batch , in_height , in_width, in_channels]。其中 batch 和 in_channels 要求一定為1，即只能在一個樣本的一個通道上的特征圖上進行移動，in_height , in_width表示卷積核在特征圖的高度和寬度上移動的布長，即 和 。
padding：表示填充方式：“SAME”表示采用填充的方式，簡單地理解為以0填充邊緣，當stride為1時，輸入和輸出的維度相同；“VALID”表示采用不填充的方式，多余地進行丟棄。具體公式：
“SAME”:
“VALID”:
池化層：
tf.nn.max_pool( value, ksize,strides,padding,data_format=’NHWC’,name=None)
或者
tf.nn.avg_pool(…)
參數說明：
value：表示池化的輸入：一個4維格式的數據，數據的 shape 由 data_format 決定，默認情況下shape 為[batch, height, width, channels]
其他參數與 tf.nn.cov2d 類型
ksize：表示池化窗口的大小：一個長度為4的一維列表，一般為[1, height, width, 1]，因不想在batch和channels上做池化，則將其值設為1。
Batch Nomalization層：
batch_normalization( x,mean,variance,offset,scale, variance_epsilon,name=None)
mean 和 variance 通過 tf.nn.moments 來進行計算：
batch_mean, batch_var = tf.nn.moments(x, axes = [0, 1, 2], keep_dims=True)，注意axes的輸入。對於以feature map 為維度的全局歸一化，若feature map 的shape 為[batch, height, width, depth]，則將axes賦值為[0, 1, 2]x 為輸入的feature map 四維數據，offset、scale為一維Tensor數據，shape 等於 feature map 的深度depth。
注意，計算准確率的時候，一定讓keep_prob等於1
-
import tensorflow
as tf
-
import numpy
as np
-
-
#導入input_data用於自動下載和安裝MNIST數據集
-
from tensorflow.examples.tutorials.mnist
import input_data
-
mnist = input_data.read_data_sets(
"MNIST_data/", one_hot=
True)
-
-
-
#創建兩個占位符，x為輸入網絡的圖像，y_為輸入網絡的圖像類別
-
x = tf.placeholder(
"float", shape=[
None,
784])
-
y = tf.placeholder(
"float", shape=[
None,
10])
-
-
#權重初始化函數
-
def weight_variable(shape):
-
#輸出服從截尾正態分布的隨機值
-
initial = tf.truncated_normal(shape, stddev=
0.1)
-
return tf.Variable(initial)
-
-
#偏置初始化函數
-
def bias_variable(shape):
-
initial = tf.constant(
0.1, shape=shape)
-
return tf.Variable(initial)
-
-
#創建卷積op
-
#x 是一個4維張量，shape為[batch,height,width,channels]
-
#卷積核移動步長為1。填充類型為SAME,可以不丟棄任何像素點
-
def conv2d(x, W):
-
return tf.nn.conv2d(x, W, strides=[
1,
1,
1,
1], padding=
"SAME")
-
-
#創建池化op
-
#采用最大池化，也就是取窗口中的最大值作為結果
-
#x 是一個4維張量，shape為[batch,height,width,channels]
-
#ksize表示pool窗口大小為2x2,也就是高2，寬2
-
#strides，表示在height和width維度上的步長都為2
-
def max_pool_2x2(x):
-
return tf.nn.max_pool(x, ksize=[
1,
2,
2,
1],
-
strides=[
1,
2,
2,
1], padding=
"SAME")
-
-
-
#第1層，卷積層
-
#初始化W為[5,5,1,32]的張量，表示卷積核大小為5*5，第一層網絡的輸入和輸出神經元個數分別為1和32
-
W_conv1 = weight_variable([
5,
5,
1,
32])
-
#初始化b為[32],即輸出大小
-
b_conv1 = bias_variable([
32])
-
-
#把輸入x(二維張量,shape為[batch, 784])變成4d的x_image，x_image的shape應該是[batch,28,28,1]
-
#-1表示自動推測這個維度的size
-
x_image = tf.reshape(x, [
-1,
28,
28,
1])
-
-
#把x_image和權重進行卷積，加上偏置項，然后應用ReLU激活函數，最后進行max_pooling
-
#h_pool1的輸出即為第一層網絡輸出，shape為[batch,14,14,1]
-
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
-
h_pool1 = max_pool_2x2(h_conv1)
-
-
#第2層，卷積層
-
#卷積核大小依然是5*5，這層的輸入和輸出神經元個數為32和64
-
W_conv2 = weight_variable([
5,
5,
32,
64])
-
b_conv2 = weight_variable([
64])
-
-
#h_pool2即為第二層網絡輸出，shape為[batch,7,7,1]
-
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
-
h_pool2 = max_pool_2x2(h_conv2)
-
-
#第3層, 全連接層
-
#這層是擁有1024個神經元的全連接層
-
#W的第1維size為7*7*64，7*7是h_pool2輸出的size，64是第2層輸出神經元個數
-
W_fc1 = weight_variable([
7*
7*
64,
1024])
-
b_fc1 = bias_variable([
1024])
-
-
#計算前需要把第2層的輸出reshape成[batch, 7*7*64]的張量
-
h_pool2_flat = tf.reshape(h_pool2, [
-1,
7*
7*
64])
-
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
-
-
#Dropout層
-
#為了減少過擬合，在輸出層前加入dropout
-
keep_prob = tf.placeholder(
"float")
-
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
-
-
#輸出層
-
#最后，添加一個softmax層
-
#可以理解為另一個全連接層，只不過輸出時使用softmax將網絡輸出值轉換成了概率
-
W_fc2 = weight_variable([
1024,
10])
-
b_fc2 = bias_variable([
10])
-
-
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
-
-
#預測值和真實值之間的交叉墒
-
cross_entropy = -tf.reduce_sum(y * tf.log(y_conv))
-
-
#train op, 使用ADAM優化器來做梯度下降。學習率為0.0001
-
train_step = tf.train.AdamOptimizer(
1e-4).minimize(cross_entropy)
-
-
#評估模型，tf.argmax能給出某個tensor對象在某一維上數據最大值的索引。
-
#因為標簽是由0,1組成了one-hot vector，返回的索引就是數值為1的位置
-
correct_predict = tf.equal(tf.argmax(y_conv,
1), tf.argmax(y,
1))
-
-
#計算正確預測項的比例，因為tf.equal返回的是布爾值，
-
#使用tf.cast把布爾值轉換成浮點數，然后用tf.reduce_mean求平均值
-
accuracy = tf.reduce_mean(tf.cast(correct_predict,
"float"))
-
with tf.Session()
as sess:
-
# 初始化變量
-
sess.run(tf.global_variables_initializer())
-
-
# 開始訓練模型，循環20000次，每次隨機從訓練集中抓取50幅圖像
-
for i
in range(
1000):
-
batch = mnist.train.next_batch(
50)
-
if i %
100 ==
0:
-
# 每100次輸出一次日志
-
train_accuracy = accuracy.eval(feed_dict={
-
x: batch[
0], y: batch[
1], keep_prob:
1.0})
#計算准確率時候一定讓keep_prob等於1
-
print(
"step %d, training accuracy %g" % (i, train_accuracy))
-
-
train_step.run(feed_dict={x: batch[
0], y: batch[
1], keep_prob:
0.5})
-
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y: mnist.test.labels}))