{

 "model_version_status": [

  {

   "version": "1684833957",

   "state": "AVAILABLE",

   "status": {

    "error_code": "OK",

    "error_message": ""

   }

  }

 ]

}

其中，version就是我们要找的东西。
到你保存.pb模型的父目录下（可能是HDFS或本地磁盘），无脑搜version对应的关键字 1684833957，找到哪个目录，就是我们要找的.pb模型所在的目录。
通常这个目录下会有一个 saved_model.pb 文件，以及一个 variables 子目录。
为什么可以这样做？因为version里的时间戳就是导出 .pb 模型的时间戳，这个时间戳精确到秒，一般情况下，两个模型几乎不太可能在同一秒生成，所以这个时间戳是唯一的，因此只要能找到这个目录名，那么目录里的 .pb 模型几乎肯定是我们要找的模型。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

在大数据处理流程中，TFRecord文件通常是由map-reduce job生成的，数据量通常很大。有时为了验证文件内容正确，我们需要取少量数据来检查，例如，我们可以拿map-reduce job生成的N个TFRecord文件中的一个，在本地解析出来，打印出其中的内容看是否正确。
下面就是一个用JAVA程序读取TFRecord文件并打印出其中一个Example的例子：

    String localTfRecordFile = "/path/to/your/tfrecord/file";
    InputStream inputStream = Files.newInputStream(Paths.get(localTfRecordFile));
    DataInput dataInput = new DataInputStream(inputStream);
    TFRecordReader reader = new TFRecordReader(dataInput, true);

    byte[] recordBytes = reader.read();
    while (recordBytes != null) {
      Example example = Example.parseFrom(recordBytes);
      System.out.println(example.toString());
      break;  // 只打印一个Example
    }
    inputStream.close();

唯一需要注意的就是一个引入：import java.nio.file.Paths;
文章来源：https://www.codelast.com/
再详细说明一下：

• 适用于小型、中型的强化学习实验。什么叫中型？举个“大型”的例子：像OpenAI的Dota那种使用上百个GPU的强化学习实验叫“大型”。对一般的RL应用来说，这个适用范围绰绰有余了。
• 可以用串行方式运行，也可以完全并行的方式运行采样器（采样就是指agent与environment交互获取training data的过程），并且支持用CPU或GPU训练，也支持用单GPU或多GPU来优化（优化指的是强化学习算法里更新网络参数的操作）。
• 实现了各种主流RL算法，例如A2C，PPO，DQN，Double DQN，Dueling DQN，Rainbow，DDPG等（这里不一一列出），可以说是比较全面了。

文章来源：https://www.codelast.com/
 你也需要知道的一些事实

• rlpyt 是基于PyTorch开发的，它利用了PyTorch的很多特性。如果你想用TensorFlow，那只能出门右转去下一家了。

• rlpyt 中包含的并行性仅限于单节点情况——尽管它的组件可以作为分布式框架的构建块。这里的意思大概是说，只能在一台物理机上使用rlpyt，并行是发生在这台机器内的，不能在多台物理机上并行。

文章来源：https://www.codelast.com/
 下面来说一下 rlpyt 的并行功能
下面是官方的图：

虚线表示一个Python进程。
左图表示以Serial（串行）方式来训练模型，这种方式就跟其他大多数RL框架提供的功能一样，平淡无奇。
中图表示以Parallel-CPU（CPU并行）的方式来训练模型，这有就点意思了：你可以在多个CPU上运行多个worker，每个worker自带agent的一个副本，在worker内选择action，与environment交互。尽管worker是运行在CPU上的，但你仍然可以把优化（optimization）设置成跑在GPU上，当你这样做的时候，模型参数会被拷贝到共享内存（shared memory）上，供CPU使用来选择action——因为action selection是在CPU上做的，因此CPU需要知道网络的参数，如果这些参数在GPU上，CPU要能获取到才能使用。
右图表示以Parallel-GPU（GPU并行）的方式来训练模型，这就更有意思了：仍然在多个CPU上运行多个worker来与environment交互，但在交互的过程中，并不是在每个worker内部做的action selection，把所有worker里的observation（可以理解为state，或feature）汇总到一个主进程里去做action selection。假设你把优化（optimization）设置成跑在GPU上，那么这些action selection也会使用GPU来完成。这样做的好处是什么？大家知道对Deep RL来说，action selection其实就是神经网络正向传播的过程，因此如果能利用GPU的话，也是能快不少的。
还有一种并行模型，rlpyt 称之为 Alternating-GPU（交替GPU） 模式，这种模式和右图的GPU并行模式差不多，但与之不同的是，它有两组worker，其中一组用于在environment中步进（同样不做action selection），另一组就等着做action selection的工作。我从直观介绍上来看，认为它就是加强了Parallel-GPU模式下的action selection那一块的能力，使得负责action selection的主进程在某些情况下不至于“忙不过来”，不知道这样理解对不对。

这么丰富的并行（parallelism）方式支持，可以说是不知道比市面上的其他RL框架要强了多少倍了，管它们是什么大公司出品的，rlpyt 照样能把它们的脸踩在地上使劲摩擦。
文章来源：https://www.codelast.com/

 下面再来说一说 rlpyt 的优化（optimization）功能
依然引用官方的原图：

上面是 rlpyt 支持的一种优化模式，称之为同步多进程优化模式（按我的理解这仅限于GPU并行模式），一个虚线框代表一个Python进程，它在每一个Python进程里都运行一个完整的[采样器-算法]栈的副本（图里的[Sampler-Algo]），并在PyTorch的DistribuedDataParallel类的反向传播期间隐式强制执行同步。前面说了 rlpyt 为什么要基于 PyTorch 开发，是因为它依赖于 PyTorch 的很多特性，这里就是一个。
这里的All-Reduce是什么呢？

在同步数据并行分布式深度学习中，主要的计算步骤是：

(1) 在每个GPU上使用一个minibatch来计算loss function的梯度

(2) 通过GPU间的通信计算梯度的均值

(3) 更新模型

AllReduce就是用来计算上面第2步中的多GPU之间梯度的均值的方法。

 

文章来源：https://www.codelast.com/
除了上面的同步模式，rlpyt 还支持一种异步采样/优化模式，如下图所示：

• 光看Google自己出品的那些RL框架，什么Dopamine，TF-Agents，目前都没有对并行的支持，而且都还不是Google的正式产品；还有一个2015年就发了论文的Gorilla，它应该不是一个框架，而是一个架构，但它号称是支持大规模并发DRL的架构，不过这玩意并不开源啊。感觉就是Google内部，现在还没有扶持一个“正牌”的产品上位，各个RL团队们在为了KPI各自为战，而Google现在还没有想在开源世界里把哪个团队的RL框架扶植到TensorFlow那种地位上，等哪天Google真的下定决心想把这事给做好了，我们恐怕才有机会在Google那里看到一个像样的RL框架。
• 如果把DeepMind的开源产品也算做Google的话，那么还有类似于TRFL这样的RL lib，但是截至目前它都已经半年多没更新了好吗，看样子DeepMind自己都要放弃它了。
• 还有其他一些RL框架，是在Ray这个分布式框架的基础上搭建的，比如RLlib，可能会把小的实验复杂化。
• 一个最有力的竞争者恐怕就是Tensorforce了，当前该框架仍然处于活跃的开发中，并且它是支持并行的！但并行功能没有 rlpyty 支持的那么丰富。从一些文章的介绍中可以看出来，如果你是TensorFlow的死忠，这个框架可能是你当前的最优选择了。不过也需要提醒一下，Tensorforce是剑桥大学的几个博士生在开发维护，Tensorforce原来的主页已经挂了，现在只剩GitHub源码页，不知道会不会有后续开发保障。

在TensorFlow中，tf.layers.dense 定义了一个全连接层，其实现的是（来自官方文档）：

This layer implements the operation: outputs = activation(inputs * kernel + bias) Where activation is the activation function passed as the activation argument (if not None), kernel is a weights matrix created by the layer, and bias is a bias vector created by the layer (only if use_bias is True).

意思就是它实现了 y = activation(x * kernel + bias) 的操作，其中，activation是激活函数。在这里，kernel 就是指我们通常所说的 weight，它被TF称为 kernel 而不是 weight。因此，如果你想从这个模型里取出weight参数的话，就要注意它的名字了，否则会读不到这个参数。
下面我们就来看具体的例子。

下面这段代码的逻辑非常简单，它干了下面这些事情：
* 创建了一个非常简单的2层全连接网络
* 训练网络
* 训练完成后把它保存成checkpoint格式的模型文件
* 从保存的checkpoint读取模型里第一层的 weight 和 bias 参数值，打印出来
文章来源：https://www.codelast.com/

import tensorflow as tf
import numpy as np

LAYER_1_NAME = 'layer1'  # 第一层的名字
LAYER_2_NAME = 'layer2'  # 第二层的名字

# 创建一个非常简单的神经网络，它有两层
x = tf.placeholder(shape=[None, 2], dtype=tf.float32)
layer1 = tf.layers.dense(x, 5, activation=tf.nn.sigmoid, name=LAYER_1_NAME)
layer2 = tf.layers.dense(layer1, 2, activation=tf.nn.sigmoid, name=LAYER_2_NAME)

loss = tf.reduce_mean((layer2 - x) ** 2)
optimizer = tf.train.AdamOptimizer(0.01).minimize(loss)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    x_values = np.random.normal(0, 1, (5000, 2))  # 生成用于输入的随机数
    for step in range(1000):
        _, loss_value = sess.run([optimizer, loss], feed_dict={x: x_values})
        if step % 100 == 0:
            print("step: %d, loss: %f" % (step, loss_value))

    # 把模型保存成checkpoint
    saver = tf.compat.v1.train.Saver()
    save_path = saver.save(sess, './checkpoint/model.ckpt')
    print("model saved in path: %s" % save_path, flush=True)

    # 读取刚保存的checkpoint
    reader = tf.train.NewCheckpointReader(save_path)
    weights = reader.get_tensor(LAYER_1_NAME + '/kernel')  # weight的名字，是由对应层的名字，加上默认的"kernel"组成的
    bias = reader.get_tensor(LAYER_1_NAME + '/bias')  # bias的名字
    print(weights)
    print(bias)

    # 如果想打印模型中的所有参数名和参数值的话，把下面几行取消注释
    # var_to_shape_map = reader.get_variable_to_shape_map()
    # for key in var_to_shape_map:
    #     print("tensor name: ", key)
    #     print(reader.get_tensor(key))

文章来源：https://www.codelast.com/
上面程序的输出：

step: 0, loss: 1.166642

step: 100, loss: 0.764896

step: 200, loss: 0.659553

step: 300, loss: 0.622590

step: 400, loss: 0.604577

step: 500, loss: 0.595308

step: 600, loss: 0.590193

step: 700, loss: 0.587147

step: 800, loss: 0.585213

step: 900, loss: 0.583916

model saved in path: ./checkpoint/model.ckpt

[[-3.0937738   3.6378026   0.91563785 -1.2663897  -0.09645918]

 [ 0.727915    0.22842272 -2.656725   -2.0831287  -3.4844823 ]]

[ 0.906906   -1.6009021   0.46897942  0.75946033  1.4348172 ]

注意，在取某一层的 weight 参数值的时候，我们用了以下方法：

weights = reader.get_tensor(LAYER_1_NAME + '/kernel')

这里，weight 的名字，是类似于 "layer1/kernel" 这样的字符串，其中，"layer1"就是在用 tf.layers.dense() 创建网络的一个layer的时候，设置的 "name=xxx" 里的名字。前面已经说过了，TF 里把 weight 叫做 kernel，所以这里的 weight 名是 "layer1/kernel" 而不是 "layer1/weight"！
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

checkpoint文件是TensorFlow保存出来的一种模型文件格式。通常save下来的时候会得到4个文件，例如：

checkpoint
model.ckpt-1.data-00000-of-00001
model.ckpt-1.index
model.ckpt-1.meta

如何查看这些文件里的模型参数名称呢？

[1] 方法一：用TensorFlow自带的 inspect_checkpoint 工具
首先 cd 到那4个model文件所在的目录，然后执行：

python -m tensorflow.python.tools.inspect_checkpoint --file_name=model.ckpt-1 "$@"

pi/actor13/bias (DT_FLOAT) [32]

pi/actor13/kernel (DT_FLOAT) [101,32]

pi/actor15/bias (DT_FLOAT) [8]

pi/actor15/kernel (DT_FLOAT) [32,8]

pi/ap/bias (DT_FLOAT) [2]

pi/ap/kernel (DT_FLOAT) [8,2]

 

# Total number of params: 3546

TFRecord 文件格式是一种面向记录的简单二进制格式，很多 TensorFlow 应用采用此格式来训练数据。
TFRecord 内部有一系列的 Example ，Example 是 protocolbuf 协议下的消息体。

把一个一维的numpy数组保存为TFRecord文件很容易，但如果numpy数组是二维的可能就比较容易写错。下面是一个例子。

1. """ 
2. 本程序演示了如何保存numpy array为TFRecords文件，并将其读取出来。 
3. """  
4. import random  
5.   
6. import numpy as np  
7. import tensorflow as tf  
8.   
9. __author__ = 'Darran Zhang @ codelast.com'  
10.   
11.   
12. def save_tfrecords(state_data, action_data, reward_data, dest_file):  
13.     """ 
14.     保存numpy array到TFRecord文件中。 
15.     这里输入了三个不同的numpy array来做演示，它们含有不同类型的元素。 
16.     Args: 
17.         state_data: 要保存到TFRecord文件的第1个numpy array，每一个 state_data[i] 是一个 numpy.ndarray（数组里的每个元素又是一个浮点 
18.                     数），因此不能用 Int64List 或 FloatList 来存储，只能用 BytesList。 
19.         action_data: 要保存到TFRecord文件的第2个numpy array，每一个 action_data[i] 是一个整数，使用 Int64List 来存储。 
20.         reward_data: 要保存到TFRecord文件的第3个numpy array，每一个 reward_data[i] 是一个整数，使用 Int64List 来存储。 
21.         dest_file: 输出文件的路径。 
22.     Returns: 
23.         不返回任何值 
24.     """  
25.     with tf.io.TFRecordWriter(dest_file) as writer:  
26.         for i in range(len(state_data)):  
27.             features = tf.train.Features(  
28.                 feature={  
29.                     "state": tf.train.Feature(  
30.                         bytes_list=tf.train.BytesList(value=[state_data[i].astype(np.float32).tostring()])),  
31.                     "action": tf.train.Feature(  
32.                         int64_list=tf.train.Int64List(value=[action_data[i]])),  
33.                     "reward": tf.train.Feature(  
34.                         int64_list=tf.train.Int64List(value=[reward_data[i]]))  
35.                 }  
36.             )  
37.             tf_example = tf.train.Example(features=features)  
38.             serialized = tf_example.SerializeToString()  
39.             writer.write(serialized)  
40.   
41.   
42. def parse_fn(example_proto):  
43.     features = {"state": tf.FixedLenFeature((), tf.string),  
44.                 "action": tf.FixedLenFeature((), tf.int64),  
45.                 "reward": tf.FixedLenFeature((), tf.int64)}  
46.     parsed_features = tf.parse_single_example(example_proto, features)  
47.     return tf.decode_raw(parsed_features['state'], tf.float32), parsed_features['action'], parsed_features['reward']  
48.   
49.   
50. if __name__ == '__main__':  
51.     buffer_s, buffer_a, buffer_r = [], [], []  
52.   
53.     # 随机生成一些数据  
54.     for i in range(3):  
55.         state = [round(random.random() * 100, 2) for _ in range(0, 10)]  # 一个数组，里面有10个数，每个都是一个浮点数  
56.         action = random.randrange(0, 2)  # 一个数，值为 0 或 1  
57.         reward = random.randrange(0, 100)  # 一个数，值域 [0, 100)  
58.         # 把生成的数分别添加到3个list中  
59.         buffer_s.append(state)  
60.         buffer_a.append(action)  
61.         buffer_r.append(reward)  
62.   
63.     # 查看生成的数据  
64.     print(buffer_s)  
65.     print(buffer_a)  
66.     print(buffer_r)  
67.   
68.     # 在水平方向把各个list堆叠起来，堆叠的结果：得到3个矩阵  
69.     s_stacked = np.vstack(buffer_s)  
70.     a_stacked = np.vstack(buffer_a)  
71.     r_stacked = np.vstack(buffer_r)  
72.   
73.     print(s_stacked.shape)  # (3, 10)  
74.     print(a_stacked.shape)  # (3, 1)  
75.     print(r_stacked.shape)  # (3, 1)  
76.   
77.     # 写入TFRecord文件  
78.     output_file = './data.tfrecord'  # 输出文件的路径  
79.     save_tfrecords(s_stacked, a_stacked, r_stacked, output_file)  
80.   
81.     # 读取TFRecord文件并打印出其内容  
82.     for example in tf.io.tf_record_iterator(output_file):  
83.         print(tf.train.Example.FromString(example))  
84.         # 或者用下面的方法  
85.         # from google.protobuf.json_format import MessageToJson  
86.         # jsonMessage = MessageToJson(tf.train.Example.FromString(example))  
87.         # print(jsonMessage)  
88.   
89.     # 读取TFRecord文件并还原成numpy array，再打印出来  
90.     with tf.Session() as sess:  
91.         dataset = tf.data.TFRecordDataset(output_file)  # 加载TFRecord文件  
92.         dataset = dataset.map(parse_fn)  # 解析data到Tensor  
93.         dataset = dataset.repeat(1)  # 重复N epochs  
94.         dataset = dataset.batch(3)  # batch size  
95.   
96.         iterator = dataset.make_one_shot_iterator()  
97.         next_data = iterator.get_next()  
98.   
99.         while True:  
100.             try:  
101.                 state, action, reward = sess.run(next_data)  
102.                 print(state)  
103.                 print(action)  
104.                 print(reward)  
105.             except tf.errors.OutOfRangeError:  
106.                 break  

注意：对二维数组，需要用 tf.train.BytesList 来保存，还原成numpy array的时候，要用 tf.decode_raw() 来解析。
由于生成的数据是随机数，因此你看到的输出会和我不一样。
文章来源：https://www.codelast.com/
生成的数据：

[[56.31, 8.72, 78.21, 44.52, 98.18, 95.23, 85.89, 95.76, 63.96, 41.56], [21.78, 66.52, 17.58, 35.36, 29.25, 63.54, 49.12, 82.71, 77.38, 20.04], [65.86, 78.81, 17.64, 3.21, 60.88, 92.98, 80.63, 92.86, 80.7, 4.12]]

[1, 0, 1]

[55, 97, 89]

numpy数组写成TFRecord后再重新读取出来，并重新转成numpy数组后，数据是：

[[56.31  8.72 78.21 44.52 98.18 95.23 85.89 95.76 63.96 41.56]

 [21.78 66.52 17.58 35.36 29.25 63.54 49.12 82.71 77.38 20.04]

 [65.86 78.81 17.64  3.21 60.88 92.98 80.63 92.86 80.7   4.12]]

[1 0 1]

[55 97 89]

可见数据和生成的一样，这说明上面的程序互相转没有问题。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

n. 瓦 / 瓷砖 / 软木片 / 亚麻油地毡片

v. 用瓦盖 / 贴砖于 / 铺以瓦 / 铺以瓷砖

函数定义：

def tile(input, multiples, name=None):

函数功能：

Constructs a tensor by tiling a given tensor.

即：通过“平铺”一个给定的 tensor 来构造一个新的 tensor。用人话讲就是：把输入的 tensor，在指定的维度上复制N遍（就像铺瓷砖一样），来创建出一个新的 tensor。
3个参数：
input：输入的tensor
multiples：在指定的维度上复制原tensor的次数
name：operation的名字

下面举例：

import tensorflow as tf

with tf.Session() as sess:
    a = tf.constant([[15, 16], [17, 18]])
    b = tf.tile(a, [1, 3])
    c = tf.tile(a, [3, 2])
    print('------------------------------------')
    print(sess.run(a))
    print('------------------------------------')
    print(sess.run(b))
    print('------------------------------------')
    print(sess.run(c))

文章来源：https://www.codelast.com/
输出：

[[15 16]

 [17 18]]

------------------------------------

[[15 16 15 16 15 16]

 [17 18 17 18 17 18]]

------------------------------------

[[15 16 15 16]

 [17 18 17 18]

 [15 16 15 16]

 [17 18 17 18]

 [15 16 15 16]

 [17 18 17 18]]

ValueError: Shape must be rank 3 but is rank 1 for 'Tile_1' (op: 'Tile') with input shapes

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

TensorBoard是Tensorflow的可视化工具。当我们用这篇文章里的方法在树莓派上安装好Tensorflow之后，TensorBoard自然就装好了。于是，下面只剩下怎么启动它的问题。
以下是一个例子。

首先，我们从TensorFlow的官方Github里下载这个文件：

https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/tutorials/mnist/mnist_with_summaries.py

它实现了一个模型训练的过程，并且在模型训练的过程中，将TensorBoard所需的数据文件，输出到了 /tmp/tensorflow/mnist/logs/mnist_with_summaries 这个目录下（写死在 mnist_with_summaries.py 文件中，为了简单无需修改）。
文章来源：http://www.codelast.com/
之后我们把这个模型训练的程序跑起来：

python2 mnist_with_summaries.py

然后程序会自动去下载MNIST数据，并开始训练模型：

Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.

Extracting /tmp/tensorflow/mnist/input_data/train-images-idx3-ubyte.gz

Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.

Extracting /tmp/tensorflow/mnist/input_data/train-labels-idx1-ubyte.gz

Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.

Extracting /tmp/tensorflow/mnist/input_data/t10k-images-idx3-ubyte.gz

Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.

Extracting /tmp/tensorflow/mnist/input_data/t10k-labels-idx1-ubyte.gz

Accuracy at step 0: 0.1114

Accuracy at step 10: 0.6652

Accuracy at step 20: 0.8119

Accuracy at step 30: 0.8533

Accuracy at step 40: 0.868

Accuracy at step 50: 0.8723

Accuracy at step 60: 0.8779

Accuracy at step 70: 0.879

Accuracy at step 80: 0.8817

Accuracy at step 90: 0.8876

Adding run metadata for 99

Accuracy at step 100: 0.896

Accuracy at step 110: 0.9061

Accuracy at step 120: 0.9116

Accuracy at step 130: 0.9167

Accuracy at step 140: 0.9216

Accuracy at step 150: 0.915

Accuracy at step 160: 0.9246

Accuracy at step 170: 0.9267

Accuracy at step 180: 0.9215

Accuracy at step 190: 0.9207

Adding run metadata for 199

Accuracy at step 200: 0.9287

Accuracy at step 210: 0.933

Accuracy at step 220: 0.9307

Accuracy at step 230: 0.9308

......

tensorboard --logdir=/tmp/tensorflow/mnist/logs/mnist_with_summaries

其中，--logdir参数指定的目录就是 mnist_with_summaries.py 程序里用 --log_dir 参数指定的那个路径，TensorBoard会从这个路径下读取数据并可视化展示在web页面中。
过一会就会看到命令行提示：

Starting TensorBoard 41 on port 6006

(You can navigate to http://10.0.0.2:6006)

所以现在打开浏览器，访问这个地址，就可以看到图了：

文章来源：http://www.codelast.com/

 

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

在上一篇文章中，我尝试了加快TensorFlow预测速度的一个方法——模型“预热”，实验证明它非常有效，但那仍然没有解决一个问题：每次运行程序，都要加载一次模型，然后预热N次，这个过程非常耗时，因此减少这部分时间也是非常关键的。把TensorFlow做成一个常驻内存的服务就可以解决这个问题。
解决这个问题的正确姿势是：TensorFlow已经提供了一个叫作 TensorFlow Serving 的library来实现这个需求。但麻烦的是，在树莓派上编译TensorFlow Serving会遇到很多问题，所以，在没有人搞出在树莓派上一键安装的Python wheel包之前，还是算了吧...
因此，下面我用一个很挫的办法来实现一个简陋的TensorFlow service。

『1』简单的思路
服务端，用Python实现一个web server，处理HTTP Get请求，通过解析URL中的参数（例如 http://127.0.0.1:8080/?image_path=/root/abc.jpg 中的 /root/abc.jpg），来获取待处理的图片的路径，处理完之后，把处理结果返回给客户端。
客户端，通过 curl 命令就可以调用服务了，例如：

curl http://127.0.0.1:8080/?image_path=/root/abc.jpg

这表示让服务端处理 /root/abc.jpg 这个文件。
当然，为了简单，这里的设定有一个局限：server和client都在同一个树莓派上，如果要跨机器，那么需要client把图片post到server端，server取出来之后再处理，但本文不涉及这种情况。
文章来源：http://www.codelast.com/
『2』简单Python web server的实现
不考虑什么并发，多线程之类的情况，我们可以用非常简单的一点代码就实现一个Python web server。

#!/usr/bin/python3.5


from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import parse_qsl

class MyRequestHandler(BaseHTTPRequestHandler):
  def do_GET(self):
    # e.g. "/?image_path=/root/mobike.jpg"                                                                                                                   
    path = self.path
    # e.g. "/root/mobike.jpg"                                                                                                                                
    image_path = parse_qsl(path[2:])[0][1] + '\n'

    # send response status code                                                                                                                              
    self.send_response(200)

    # send headers                                                                                                                                           
    self.send_header('Content-type','text/html')
    self.end_headers()

    # send message back to client, write content as utf-8 data                                                                                               
    self.wfile.write(bytes(image_path, "utf8"))
    return

def start_web_server():
  print('Starting web server...')

  server_address = ('127.0.0.1', 8080)
  httpd = HTTPServer(server_address, MyRequestHandler)
  httpd.serve_forever()


start_web_server()

其中，在 MyRequestHandler 这个类中，我们会处理每一个客户端的请求，这里只是把从URL中解析到的图片文件路径简单地发送回客户端。
此代码可在我的GitHub中下载。
文章来源：http://www.codelast.com/
『3』TensorFlow服务测试
按“模型加载1次，预热10次”的原则，再结合上面的简单web server代码，我们可以很容易地把TensorFlow做成服务。具体代码比较长，这里就不粘贴上来了，在我的GitHub可以下载到。

下面测试一下效果。
把service启动起来：

./run-tensorflow-service.sh

经历几十秒的漫长等待之后，模型加载&预热就完成了（命令行输出会有提示），此时，我们再在同一台树莓派上运行client，向server发送一个处理图片的请求：

./client.sh /root/raspberry-pi/ai/tensorflow-related/resource/test-images/mobike.jpg

大概4秒多之后，client端会打印出如下信息：

mountain bike, all-terrain bike, off-roader (score = 0.56671)

tricycle, trike, velocipede (score = 0.12035)

bicycle-built-for-two, tandem bicycle, tandem (score = 0.08768)

lawn mower, mower (score = 0.00651)

alp (score = 0.00387)

Prediction used time:4.171393394470215 Seconds

在上一篇文章中，我写了在树莓派上用TensorFlow做的一个深度学习（图像识别）实验，但正如文中所说，50秒执行一次预测的实用性为0。因此，有必要采取一些措施来加快TensorFlow的执行速度，其中一个可行的方法就是“预热”（warm-up），把TensorFlow移植到树莓派上的作者Sam Abrahams已经比较详细地在GitHub上列出了性能测试的结果。依照作者的描述，我也测试了一下，看看那悲催的50秒时间能减少到多少秒。

『1』什么是预热（warm-up）
首先，本文还是对TensorFlow的Python图像分类程序 classify_image.py 来描述的。
预热就是指在真正执行一次预测之前，先执行若干次 Session.run() 方法，从而达到加快一次预测的执行速度的目的。
文章来源：http://www.codelast.com/
『2』代码修改
代码改起来其实很简单。为了能衡量程序运行时间，需要使用Python的time模块，因此在一开始需要import：

import time

然后对 run_inference_on_image 方法做一些修改，如下：

def run_inference_on_image(image):
  """Runs inference on an image.

  Args:
    image: Image file name.

  Returns:
    Nothing
  """
  if not tf.gfile.Exists(image):
    tf.logging.fatal('File does not exist %s', image)
  image_data = tf.gfile.FastGFile(image, 'rb').read()

  # the image used to warm-up TensorFlow model
  warm_up_image_data = tf.gfile.FastGFile('/root/tensorflow-related/test-images/ubike.jpg', 'rb').read()

  # Creates graph from saved GraphDef.
  create_graph()

  with tf.Session() as sess:
    # Some useful tensors:
    # 'softmax:0': A tensor containing the normalized prediction across
    #   1000 labels.
    # 'pool_3:0': A tensor containing the next-to-last layer containing 2048
    #   float description of the image.
    # 'DecodeJpeg/contents:0': A tensor containing a string providing JPEG
    #   encoding of the image.
    # Runs the softmax tensor by feeding the image_data as input to the graph.
    softmax_tensor = sess.graph.get_tensor_by_name('softmax:0')

    print("Warm-up start")
    for i in range(10):
      print("Warm-up for time {}".format(i))
      predictions = sess.run(softmax_tensor,
                           {'DecodeJpeg/contents:0': warm_up_image_data})

    print("Warm-up finished")

    # record the start time of the actual prediction
    start_time = time.time()

    predictions = sess.run(softmax_tensor,
                           {'DecodeJpeg/contents:0': image_data})
    predictions = np.squeeze(predictions)

    # Creates node ID --> English string lookup.
    node_lookup = NodeLookup()

    top_k = predictions.argsort()[-FLAGS.num_top_predictions:][::-1]
    for node_id in top_k:
      human_string = node_lookup.id_to_string(node_id)
      score = predictions[node_id]
      print('%s (score = %.5f)' % (human_string, score))

    print("Prediction used time:{} S".format(time.time() - start_time))

其中，我们自己添加的代码有如下几部分：

# the image used to warm-up TensorFlow model
warm_up_image_data = tf.gfile.FastGFile('/root/tensorflow-related/test-images/ubike.jpg', 'rb').read()

这里使用了另外一张图片来预热模型（和真正预测时使用的不是同一张图片），为了简单写死了路径。

print("Warm-up start")
for i in range(10):
  print("Warm-up for time {}".format(i))
  predictions = sess.run(softmax_tensor,
   {'DecodeJpeg/contents:0': warm_up_image_data})

print("Warm-up finished")

这里循环10次来预热模型。

# record the start time of the actual prediction
start_time = time.time()
# (中间省略)
print("Prediction used time:{} S".format(time.time() - start_time))

这里打印出了真正预测一张图片的执行时间（秒数），这个时间就是我们真正需要关心的，看它能减少到多少秒。
文章来源：http://www.codelast.com/
『3』测试结果
执行和上一篇文章一样的命令，输出如下：

/usr/lib/python3.5/site-packages/tensorflow/python/ops/array_ops.py:1750: VisibleDeprecationWarning: converting an array with ndim > 0 to an index will result in an error in the future

  result_shape.insert(dim, 1)

Warm-up start

Warm-up for time 0

W tensorflow/core/framework/op_def_util.cc:332] Op BatchNormWithGlobalNormalization is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().

Warm-up for time 1

Warm-up for time 2

Warm-up for time 3

Warm-up for time 4

Warm-up for time 5

Warm-up for time 6

Warm-up for time 7

Warm-up for time 8

Warm-up for time 9

Warm-up finished

mountain bike, all-terrain bike, off-roader (score = 0.56671)

tricycle, trike, velocipede (score = 0.12035)

bicycle-built-for-two, tandem bicycle, tandem (score = 0.08768)

lawn mower, mower (score = 0.00651)

alp (score = 0.00387)

Prediction used time:4.141446590423584 Seconds

深度学习（Deep Learning）现在这么火，树莓派玩家们当然也不会放过，目前已经有很多树莓派项目都搭上了Deep Learning的车，纯粹出于“好玩”的目的，我在树莓派上也实验了一把，用TensorFlow来识别一张图片里的物体“是什么”。

『1』对深度学习（Deep Learning）的简单介绍
以下解释来自维基百科：

深度学习是机器学习拉出的分支，它试图使用包含复杂结构或由多重非线性变换构成的多个处理层对数据进行高层抽象的算法。

深度学习的用途实在太广泛，最为普通人所熟知的，就是以下和民生相关的应用：人脸识别，语音识别，图像搜索，在线翻译，等等。
目前流行的深度学习框架有TensorFlow（Google开源），MXNet（得到Amazon支持），Theano等，利用这些框架，我们只需要做比较少的工作，就能把深度学习能力带入我们自己的程序。
文章来源：http://www.codelast.com/
『3』树莓派上的深度学习
当前，主流的深度学习框架都不是主要为了移动平台／嵌入式平台而准备的——这是由于计算能力所限，在移动平台上运行local的深度学习程序，计算速度通常会非常慢。因此，移动平台上主要还是采用向云端提交计算请求、云端计算完成后返回结果的方式来处理数据。
作为一个“类嵌入式”平台，树莓派虽然是同类型里最受关注的产品，但我认为在深度学习的世界里，树莓派还没到像Android、iOS那种“开发一个App必须要支持”的程度。
因此，把任何一个主流的深度学习框架，在树莓派上跑起来都将是一个耗时耗力的工作。
好在TensorFlow是如此流行，并且IT界永远不缺牛人，已经有人把它成功地“移植”到了树莓派3代上（看这里），所以，在树莓派上用TensorFlow来实现深度学习应用是一个不错的选择。
文章来源：http://www.codelast.com/
『3』在树莓派上安装TensorFlow
按作者的文档，通过极其简单的几步操作，就可以在树莓派上把TensorFlow跑起来。如果你有兴趣，可以直接去看作者写的教程。
首先要声明的是：

• 作者在树莓派上使用的最流行的Linux发行版Raspbian，而我使用的OS是Arch Linux ARM，不过这无所谓，经过我的测试，没有问题（至少我没遇到）
• 由于在树莓派上开发其他程序的原因，我已经预先安装过了比较多的开发库／软件，类似于Protocol Buffers，NumPy，pip等，而这些软件有些可能会被TensorFlow依赖，所以，我就不需要像作者的文档里说的一样另外再去安装它们了

文章来源：http://www.codelast.com/
然后剩下最关键的一步就是，从GitHub下载一个wheel文件并安装。
wheel是众多Python软件安装包格式中的一种，本质上是一个zip包格式，它使用.whl作为扩展名，用于安装Python模块。

如果你使用Python 2.7：

wget https://github.com/samjabrahams/tensorflow-on-raspberry-pi/releases/download/v0.11.0/tensorflow-0.11.0-cp27-none-linux_armv7l.whl
sudo pip install tensorflow-0.11.0-cp27-none-linux_armv7l.whl

如果你使用Python 3.3+（但据作者所说，3.5以及3.6是不保证能支持的，不过，我用3.5.2还是安装成功了）：

wget https://github.com/samjabrahams/tensorflow-on-raspberry-pi/releases/download/v0.11.0/tensorflow-0.11.0-py3-none-any.whl
sudo pip3 install tensorflow-0.11.0-py3-none-any.whl

下载whl安装包的过程可能会比较漫长，我使用的是Python 3.5.2，下面是我的命令行输出内容：

Processing ./tensorflow-0.10.0-py3-none-any.whl

Collecting protobuf==3.0.0b2 (from tensorflow==0.10.0)

  Downloading protobuf-3.0.0b2-py2.py3-none-any.whl (326kB)

    100% |████████████████████████████████| 327kB 11kB/s

Collecting wheel>=0.26 (from tensorflow==0.10.0)

  Downloading wheel-0.29.0-py2.py3-none-any.whl (66kB)

    100% |████████████████████████████████| 71kB 18kB/s

Requirement already satisfied (use --upgrade to upgrade): numpy>=1.8.2 in /usr/lib/python3.5/site-packages (from tensorflow==0.10.0)

Requirement already satisfied (use --upgrade to upgrade): six>=1.10.0 in /usr/lib/python3.5/site-packages (from tensorflow==0.10.0)

Requirement already satisfied (use --upgrade to upgrade): setuptools in /usr/lib/python3.5/site-packages (from protobuf==3.0.0b2->tensorflow==0.10.0)

Installing collected packages: protobuf, wheel, tensorflow

Successfully installed protobuf-3.0.0b2 tensorflow-0.10.0 wheel-0.29.0

You are using pip version 8.1.2, however version 9.0.1 is available.

You should consider upgrading via the 'pip install --upgrade pip' command.

文章来源：http://www.codelast.com/
然后呢？然后就搞定了！就这么简单！

如果上面的步骤失败了，那么你就只能选择从源码来编译TensorFlow，这是一个相当麻烦的工作，只能祝你好运了，不过好消息就是，作者已经帮大家踩过很多坑了，教程在这里。

『4』在树莓派上使用TensorFlow
要识别一张图片里的物体是什么，我们需要先训练一个图像分类模型，这个过程非常消耗计算资源，在树莓派上干这事是不明智的，我们可以直接使用Google已经训练好的Inception-v3模型。

Inception-v3 is trained for the ImageNet Large Visual Recognition Challenge using the data from 2012. This is a standard task in computer vision, where models try to classify entire images into 1000 classes, like "Zebra", "Dalmatian", and "Dishwasher".

先下载Inception-V3模型到任意目录中，并解压出来：

mkdir ~/tensorflow-related/model
cd ~/tensorflow-related/model
wget http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz
tar xf inception-2015-12-05.tgz

解压出来一堆文件：

classify_image_graph_def.pb

cropped_panda.jpg

imagenet_2012_challenge_label_map_proto.pbtxt

imagenet_synset_to_human_label_map.txt

LICENSE

然后就可以开始进行图像识别啦。在这里我从网上找了一张时下很流行的摩拜单车（Mobike）的图片：

文章来源：http://www.codelast.com/
用TensorFlow来识别它：

cd /usr/lib/python3.5/site-packages/tensorflow/models/image/imagenet
python3.5 classify_image.py --model_dir /root/tensorflow-related/model --image_file /root/tensorflow-related/test-images/mobike.jpg

其中，/usr/lib/python3.5/site-packages/tensorflow/models/image/imagenet 这个路径是TensorFlow的 Python图像分类程序 classify_image.py 所在的路径，不同的OS可能不一样。
--model_dir 参数传入的是我们前面解压出来的模型文件所在的路径，--image_file 是待识别的图片的路径。
注：如果找不到classify_image.py文件，请参考本文末的更新说明。
输出如下：

/usr/lib/python3.5/site-packages/tensorflow/python/ops/array_ops.py:1750: VisibleDeprecationWarning: converting an array with ndim > 0 to an index will result in an error in the future

  result_shape.insert(dim, 1)

W tensorflow/core/framework/op_def_util.cc:332] Op BatchNormWithGlobalNormalization is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().

bicycle-built-for-two, tandem bicycle, tandem (score = 0.33731)

tricycle, trike, velocipede (score = 0.16082)

unicycle, monocycle (score = 0.12926)

mountain bike, all-terrain bike, off-roader (score = 0.10689)

parking meter (score = 0.01563)

[root@alarmpi imagenet]# python3.5 classify_image.py --model_dir /root/tensorflow-related/model --image_file /root/tensorflow-related/test-images/mobike.jpg

/usr/lib/python3.5/site-packages/tensorflow/python/ops/array_ops.py:1750: VisibleDeprecationWarning: converting an array with ndim > 0 to an index will result in an error in the future

  result_shape.insert(dim, 1)

W tensorflow/core/framework/op_def_util.cc:332] Op BatchNormWithGlobalNormalization is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().

mountain bike, all-terrain bike, off-roader (score = 0.56671)

tricycle, trike, velocipede (score = 0.12035)

bicycle-built-for-two, tandem bicycle, tandem (score = 0.08768)

lawn mower, mower (score = 0.00651)

alp (score = 0.00387)

可见，TensorFlow认为图片是山地自行车（mountain bike）／全地形自行车（all-terrain bike）／越野车（off-roader）的概率是0.56671，识别结果还算可以。
文章来源：http://www.codelast.com/
『5』计算速度问题
上面的一次图像识别试验，总共花了50多秒的时间！这么慢的速度在实际应用中基本没有实用价值。
但实际上，这个时间是可以大幅缩短的。

• 为模型“预热”很有必要。根据作者等人的性能测试结果，在合理预热的情况下，计算时间会减少较多。我测试了一下，请看这篇文章。
• 我们每运行一次程序，就重新加载一次模型，而模型文件又很大，这非常浪费时间，所以，应该把程序做成一个常驻内存的程序，只加载一次模型，每次识别一幅图像就能减少很多很多时间。我也实验了一下，请看这篇文章。
• 使用TensorFlow的C++接口来实现程序应该比Python版速度快，可以尝试。
• 暂时还不能让TensorFlow使用树莓派的GPU来计算（看这里），但大家期待未来有一天这个愿望会实现。

所以至少50多秒这种恐怖的数字是可以避免的。
文章来源：http://www.codelast.com/
『6』在树莓派上跑TensorFlow有什么用
我随意想到的一个可能有意义的应用就是：一个幼儿辅助学习系统。在树莓派上挂载一个摄像头，孩子在摄像头前拿着一样东西，摄像头抓拍一张图片，识别出里面的东西，朗读出概率最大的那个英文单词。
当然，这里面有非常多的工程上的问题需要解决。

我相信，随着树莓派下一代的计算能力继续增强，以及TensorFlow每一次发布，都让性能提高一些，在不久的将来，在树莓派上跑TensorFlow应用的实用性将会非常好。
文章来源：http://www.codelast.com/
『7』更新

• 2017.03.19更新

在本文写完之后不久，作者就发布了基于TensorFlow 1.0.0的Python wheel包，我试验了一下，它无法在Python 3.6.0的环境下安装，提示错误是：

tensorflow-1.0.0-cp34-cp34m-linux_armv7l.whl is not a supported wheel on this platform

作者说这是因为暂时不支持Python 3.5+。所以为了装上新版的TensorFlow，我用回了Python 2.7，然后就发现可以正常安装了：

pacman -S python2 python2-pip
pip2 install tensorflow-1.0.0-cp27-none-linux_armv7l.whl

期待以后能支持。

• 2017.08.19更新

如果你安装的是1.1.0版本的TensorFlow on Raspberry Pi，那么你会发现你找不到classify_image.py文件，这是因为此版本确实不再包含该文件，这时你可以在TensorFlow的这个子项目里找到该文件。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：