本篇博客主要介绍如何使用 tensorflow 通过 CNN 实现 MNIST 手写数字识别问题，并将模型持久化在Android端运行。
整体介绍
主要需要通过以下几步：
-
模型生成过程：使用 tensorflow 通过 CNN 的方式实现 MNIST 手写数字识别，并将最后训练好的模型持久化（这里模型以
.pb 后缀名的方式保存，因为目前只在Android端使用模型，只会用到前向传播过程，不对模型再训练） - Android端实现： Android端读取模型并进行识别
模型生成过程
一、大体过程
- 创建模型输出目录，获取训练和测试使用的数据集
- 构建输入数据和真实结果的占位符，待训练的时候传入值
- 构建weight、bias初始化函数和封装卷积层和池化层函数
- 交错进行两次卷积和池化操作，并做两次全连接操作
- 使用交叉熵和梯度下降算法不断进程前向传播和反向传播优化参数
- 进行准确率测试，构建Session并开始执行训练和验证
- 保存训练结束后的所有参数值
- 新建一个graph计算图，实现前向传播整个过程，并将模型持久化
二、代码实现
# coding=UTF-8
#Python的默认编码文件是用的ASCII码,上面的代码让其支持中文
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data
import shutil
import os.path
#创建模型输出目录
EXPORT_DIR = "./model"
if os.path.exists(EXPORT_DIR):
shutil.rmtree(EXPORT_DIR)
mnist = input_data.read_data_sets("MNIST_data/",one_hot=True)
x = tf.placeholder(tf.float32, [None,784])
y_actual = tf.placeholder(tf.float32, shape=[None,10])
#定义一个函数，用于初始化所有的权值 W
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
#定义一个函数，用于初始化所有的偏置项 b
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
#定义一个函数，用于构建卷积层
def conv2d(x, w):
return tf.nn.conv2d(x, w, strides=[1,1,1,1], padding="SAME")
#定义一个函数，用于构建池化层
def max_pool(x):
return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding="SAME")
#构建网络
x_image = tf.reshape(x, [-1,28,28,1]) #将输入的一行向量转换成一个矩阵，便于后面做卷积和池化
w_conv1 = weight_variable([5,5,1,32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_image, w_conv1) + b_conv1) #第一个卷积层
h_pool1 = max_pool(h_conv1) #第一个池化层
w_conv2 = weight_variable([5,5,32,64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, w_conv2) + b_conv2) #第二个卷积层
h_pool2 = max_pool(h_conv2) #第二个池化层
w_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64]) #reshape成一个向量，便于后面的矩阵运算，重这里开始就像前面的 ANN 的过程了
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, w_fc1) + b_fc1) #第一个全连接层，做 公式计算
keep_prob = tf.placeholder("float")
#dropout 可以进一步提升模型可靠性并防止过拟合，只在训练时使用
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
w_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
y_predict = tf.nn.softmax(tf.matmul(h_fc1_drop, w_fc2) + b_fc2) #第二个全连接层，并将结果做softmax计算
cross_entropy = -tf.reduce_sum(y_actual*tf.log(y_predict)) #交叉熵
train_step = tf.train.GradientDescentOptimizer(1e-3).minimize(cross_entropy) #梯度下降法
correct_prediction = tf.equal(tf.argmax(y_predict, 1), tf.argmax(y_actual, 1)) #测试准确度计算
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) #多个批次的准确度均值
sess = tf.InteractiveSession() #得到一个sess
sess.run(tf.global_variables_initializer())
for i in range(20000): #执行 20000次
batch = mnist.train.next_batch(50) #每次从 mnist 中读取50个数据
if i % 100 == 0: #每100次执行一次
train_acc = accuracy.eval(feed_dict={x: batch[0], y_actual: batch[1], keep_prob: 1.0}) #输出当前准确率
print('step', i, 'training accuracy', train_acc)
train_step.run(feed_dict={x: batch[0], y_actual: batch[1], keep_prob: 0.5}) #开始训练
test_acc = accuracy.eval(feed_dict={x: mnist.test.images, y_actual: mnist.test.labels, keep_prob: 1.0}) #使用测试数据集里面的数据 来测试模型的准确率
print("test accuracy", test_acc)
# 功能：将字符串str当成有效的表达式来求值并返回计算结果
# 字符串转换成列表 --> a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]" --> eval(a) --> [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
#保存前面train过程生成的参数，供后续验证 graph 使用
WC1 = w_conv1.eval()
BC1 = b_conv1.eval()
WC2 = w_conv2.eval()
BC2 = b_conv2.eval()
WF1 = w_fc1.eval()
BF1 = b_fc1.eval()
WF2 = w_fc2.eval()
BF2 = b_fc2.eval()
#构建一个新的图，用于模型持久化保存
g = tf.Graph()
with g.as_default():
x_2 = tf.placeholder("float", shape=[None,784], name="input")
WC1 = tf.constant(WC1, name="WC1")
BC1 = tf.constant(BC1, name="BC1")
x_image2 = tf.reshape(x_2, [-1,28,28,1])
CONV1 = tf.nn.relu(conv2d(x_image2, WC1) + BC1)
MAXPOOL1 = max_pool(CONV1)
WC2 = tf.constant(WC2, name="WC2")
BC2 = tf.constant(BC2, name="BC2")
CONV2 = tf.nn.relu(conv2d(MAXPOOL1, WC2) + BC2)
MAXPOOL2 = max_pool(CONV2)
WF1 = tf.constant(WF1, name="WF1")
BF1 = tf.constant(BF1, name="BF1")
FC1 = tf.reshape(MAXPOOL2, [-1, 7*7*64])
FC1 = tf.nn.relu(tf.matmul(FC1, WF1) + BF1)
WF2 = tf.constant(WF2, name="WF2")
BF2 = tf.constant(BF2, name="BF2")
#这里不需要做dropout、交叉熵、梯度下降这些操作，因为对于这个图所有的 weight 和bias都是确定的，直接使用就可以了
OUTPUT = tf.nn.softmax(tf.matmul(FC1, WF2) + BF2,name="output")
sess = tf.Session()
sess.run(tf.global_variables_initializer())
graph_def = g.as_graph_def()
tf.train.write_graph(graph_def, EXPORT_DIR, "mnist_model_graph.pb", as_text=False)
Android端实现
一、so库、jar包、模型的引入
so库：我们知道 tensorflow 的很多核心代码是C++实现的，所以我们想在Android端调用里面的方法，我们就必须使用tensorflow源码通过bazel将其编译成so的库方式来使用，libtensorflow_inference.so，这个so库需要放在项目的\app\src\main\jniLibs\armeabi-v7a目录下面（AS以project方式查看项目目录）现成的SO库下载路径
jar包：我们还需要通过tensorflow源码编译一个libandroid_tensorflow_inference_java.jar 这个jar文件向外暴露了很多java API 便于我们通过它去调用 libtensorflow_inference.so 中的native方法，这个jar包需要放在\app\libs目录下面（同上），并且需要在模块的build.gradle中配置依赖： compile files('libs/libandroid_tensorflow_inference_java.jar') 现成的JAR包下载路径
模型：我们需要把上面生成的模型 mnist_model_graph.pb 放到我们的项目中，需要放在\app\src\main\assets 这个目录下，还需构建一个文件包含所有的种类（0-9十个数字）并一起放在这个目录，方便模型识别后通过它找到对应的识别的结果。
二、android端代码编写
大体过程
- 获取TensorFlowInferenceInterface实例，并初始化tensorflow模型
- 使用fillNodeFloat方法，通过模型输入节点名字将待识别数据传入模型
- 使用runInference方法，通过模型输出节点名字启动模型进行识别操作
- 使用readNodeFloat方法，通过输出节点名字将模型的输出结果取出
tensorflow java API的大部分调用接口都实现在TensorFlowInferenceInterface这个类里面，下面就介绍一下比较常用的几个方法：
- inferenceInterface = new TensorFlowInferenceInterface()
注释：创建TensorFlowInferenceInterface实例的时候调用，它内部会去执行System.loadLibrary("tensorflow_inference");
加载我们生成的SO库，这样我们就可以通过JNI的方式访问tensorflow的核心代码了 - inferenceInterface.initializeTensorFlow(assetManager, modelFilename)
注释：初始化tensorflow，参数1：AssetManager 用以操作assets目录下面的文件、参数2：modelFilename
assets目录下模型的路径，这个方法内部会生成一个Graph图，然后将模型中的图和数据导入，到此整个模型就加载完成了。 - inferenceInterface.fillNodeFloat(inputName, new int[]{inputSize *
inputSize}, pixels)
注释：参数1：inputName 模型图中输入节点数据占位符的名字、参数2：new int[]输入数据的大小、参数3：输入数据，此处为float类型的数组。通过这个方法将待验证数据传入模型中。 - inferenceInterface.runInference(outputNames);
注释：参数1：outputNames string类型的数组，模型中输出节点操作占位符的名字，即模型最后一层运算方法的名字，内部会通过Session.Runner去执行这个节点的操作。 - inferenceInterface.readNodeFloat(outputName, outputs);
注释：参数1：string类型 outputName 输出节点名字，参数2：float类型数组 outputs，这个方法会将outputName 节点的输出存入 outputs数组里面
以上就是一些比较重要的方法，通过上面的方法，我们使用了模型进行识别并返回了结果，当然android端还需要进行一些封装来实现数据的获取和结果的呈现，完整的实现可以参考：这个开源项目
完！
参考：
http://www.cnblogs.com/denny402/p/5853538.html
https://github.com/MindorksOpenSource/AndroidTensorFlowMNISTExample
