本篇博客主要介绍如何使用 tensorflow 通过 CNN 实现 MNIST 手写数字识别问题，并将模型持久化在Android端运行。

整体介绍

主要需要通过以下几步：

1. 模型生成过程：使用 tensorflow 通过 CNN 的方式实现 MNIST 手写数字识别，并将最后训练好的模型持久化（这里模型以
   .pb 后缀名的方式保存，因为目前只在Android端使用模型，只会用到前向传播过程，不对模型再训练）
2. Android端实现： Android端读取模型并进行识别

模型生成过程

一、大体过程

1. 创建模型输出目录，获取训练和测试使用的数据集
2. 构建输入数据和真实结果的占位符，待训练的时候传入值
3. 构建weight、bias初始化函数和封装卷积层和池化层函数
4. 交错进行两次卷积和池化操作，并做两次全连接操作
5. 使用交叉熵和梯度下降算法不断进程前向传播和反向传播优化参数
6. 进行准确率测试，构建Session并开始执行训练和验证
7. 保存训练结束后的所有参数值
8. 新建一个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端代码编写

大体过程

1. 获取TensorFlowInferenceInterface实例，并初始化tensorflow模型
2. 使用fillNodeFloat方法，通过模型输入节点名字将待识别数据传入模型
3. 使用runInference方法，通过模型输出节点名字启动模型进行识别操作
4. 使用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