Tensor Flow 是一个采用数据流图（data flow graphs），用于数值计算的开源软件库。节点（Nodes）在图中表示数学操作，图中的线（edges）则表示在节点间相互联系的多维数据数组，即张量（tensor）。
这是谷歌开源的一个强大的做深度学习的软件库，提供了C++ 和 Python 接口，下面给出用Tensor Flow 建立CNN 网络做笑脸识别的一个简单用例。
我们用到的数据库是GENKI4K，这个数据库有4000张图像，首先做人脸检测与剪切，将图像resize到 64×64 的大小，然后用一个 CNN 网络做识别。
网络的基本结构如下：
input -> conv 1 -> pool 1 -> conv 2 -> pool 2 -> conv 3 -> pool 3 -> fc 1 -> out
input -> 64×64
conv 1 -> filter size: 5×5, output: 60×60
pool 1 -> filter size: 2×2, output: 30×30
conv 2 -> filter size: 7×7, output: 24×24
pool 2 -> filter size: 2×2, output: 12×12
conv 3 -> filter size: 5×5, output: 8×8
pool 3 -> filter size: 2×2, output: 4×4
fc 1 -> hidden nodes: 100, output: 1×100
out -> 1×2
import string, os, sys
import numpy as np
import matplotlib.pyplot as plt
import scipy.io
import random
import tensorflow as tf
# set the folder path
dir_name = 'GENKI4K/Feature_Data'
# set the file path
files = os.listdir(dir_name)
for f in files:
print (dir_name + os.sep + f)
file_path = dir_name + os.sep + files[10]
# get the data
dic_mat = scipy.io.loadmat(file_path)
data_mat = dic_mat['Face_64']
file_path2 = dir_name + os.sep + files[15]
dic_label = scipy.io.loadmat(file_path2)
label_mat = dic_label['Label']
file_path3 = dir_name + os.sep+files[16]
# get the label
label = label_mat.ravel()
label_y = np.zeros((4000, 2))
label_y[:, 0] = label
label_y[:, 1] = 1-label
T_ind=random.sample(range(0, 4000), 4000)
# Parameters
learning_rate = 0.001
batch_size = 40
batch_num=4000/batch_size
train_epoch=100
# Network Parameters
n_input = 4096 # data input (img shape: 64*64)
n_classes = 2 # total classes (smile & non-smile)
dropout = 0.5 # Dropout, probability to keep units
# tf Graph input
x = tf.placeholder(tf.float32, [None, n_input])
y = tf.placeholder(tf.float32, [None, n_classes])
keep_prob = tf.placeholder(tf.float32) #dropout (keep probability)
# Create some wrappers for simplicity
def conv2d(x, W, b, strides=1):
# Conv2D wrapper, with bias and relu activation
x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='VALID')
x = tf.nn.bias_add(x, b)
return tf.nn.relu(x)
def maxpool2d(x, k=2):
# MaxPool2D wrapper
return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1],
padding='VALID')
# Create model
def conv_net(x, weights, biases, dropout):
# Reshape input picture
x = tf.reshape(x, shape=[-1, 64, 64, 1])
# Convolution Layer
conv1 = conv2d(x, weights['wc1'], biases['bc1'])
# Max Pooling (down-sampling)
conv1 = maxpool2d(conv1, k=2)
# Convolution Layer
conv2 = conv2d(conv1, weights['wc2'], biases['bc2'])
# Max Pooling (down-sampling)
conv2 = maxpool2d(conv2, k=2)
# Convolution Layer
conv3 = conv2d(conv2, weights['wc3'], biases['bc3'])
# Max Pooling (down-sampling)
conv3 = maxpool2d(conv3, k=2)
# Fully connected layer
# Reshape conv2 output to fit fully connected layer input
fc1 = tf.reshape(conv3, [-1, weights['wd1'].get_shape().as_list()[0]])
fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
fc1 = tf.nn.relu(fc1)
# Apply Dropout
# fc1 = tf.nn.dropout(fc1, dropout)
# Output, class prediction
out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
return out
# Store layers weight & bias
weights = {
# 5x5 conv, 1 input, 16 outputs
'wc1': tf.Variable(tf.random_normal([5, 5, 1, 16])),
# 7x7 conv, 16 inputs, 8 outputs
'wc2': tf.Variable(tf.random_normal([7, 7, 16, 8])),
# 5x5 conv, 8 inputs, 16 outputs
'wc3': tf.Variable(tf.random_normal([5, 5, 8, 16])),
# fully connected, 7*7*64 inputs, 1024 outputs
'wd1': tf.Variable(tf.random_normal([4*4*16, 100])),
# 1024 inputs, 10 outputs (class prediction)
'out': tf.Variable(tf.random_normal([100, n_classes]))
}
biases = {
'bc1': tf.Variable(tf.random_normal([16])),
'bc2': tf.Variable(tf.random_normal([8])),
'bc3': tf.Variable(tf.random_normal([16])),
'bd1': tf.Variable(tf.random_normal([100])),
'out': tf.Variable(tf.random_normal([n_classes]))
}
# Construct model
pred = conv_net(x, weights, biases, keep_prob)
# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# Evaluate model
correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# Initializing the variables
init = tf.initialize_all_variables()
with tf.Session() as sess:
sess.run(init)
for epoch in range(0, train_epoch):
for batch in range (0, batch_num):
arr_3 = T_ind[batch * batch_size:(batch + 1) * batch_size]
batch_x = data_mat[arr_3, :]
batch_y = label_y[arr_3, :]
# Run optimization op (backprop)
sess.run(optimizer, feed_dict={x: batch_x, y: batch_y,
keep_prob: dropout})
# Calculate loss and accuracy
loss, acc = sess.run([cost, accuracy], feed_dict={x: data_mat,
y: label_y,
keep_prob: 1.})
print("Epoch: " + str(epoch) + ", Loss= " + \
"{:.3f}".format(loss) + ", Training Accuracy= " + \
"{:.3f}".format(acc))
100个训练周期的结果：
