# 十一、TF 服務：生產中的 TensorFlow 模型
TensorFlow 模型在開發環境中經過訓練和驗證。一旦發布，它們需要托管在某個地方，提供用工程師和軟件工程師使用，以集成到各種應用中。 TensorFlow 為此提供了一個高表現服務器，稱為 TensorFlow 服務。
要在生產中提供 TensorFlow 模型，需要在離線訓練后保存它們，然后在生產環境中恢復經過訓練的模型。 TensorFlow 模型在保存時包含以下文件：
* **元圖**：元圖表示圖的協議緩沖區定義。元圖保存在具有`.meta`擴展名的文件中。
* **檢查點**：檢查點代表各種變量的值。檢查點保存在兩個文件中：一個帶有`.index`擴展名，另一個帶有`.data-00000-of-00001`擴展名。
在本章中，我們將學習各種保存和恢復模型的方法以及如何使用 TF 服務來提供模型。我們將使用 MNIST 示例來簡化操作并涵蓋以下主題：
* 使用`Saver`類在 TensorFlow 中保存和恢復模型
* 保存和恢復 Keras 模型
* TensorFlow 服務
* 安裝 TF 服務
* 為 TF 服務保存模型
* 用 TF 服務來提供模型
* 在 Docker 容器中提供 TF 服務
* Kubernetes 上的 TF 服務
# 在 TensorFlow 中保存和恢復模型
您可以通過以下兩種方法之一在 TensorFlow 中保存和恢復模型和變量：
* 從`tf.train.Saver`類創建的保存器對象
* 從`tf.saved_model_builder.SavedModelBuilder`類創建的基于`SavedModel`格式的對象
讓我們看看兩種方法的實際應用。
您可以按照 Jupyter 筆記本中的代碼`ch-11a_Saving_and_Restoring_TF_Models`。
# 使用保存器類保存和恢復所有圖變量
我們進行如下：
1. 要使用`saver`類，首先要創建此類的對象：
```py
saver = tf.train.Saver()
```
1. 保存圖中所有變量的最簡單方法是使用以下兩個參數調用`save()`方法：會話對象和磁盤上保存變量的文件的路徑：
```py
with tf.Session() as tfs:
...
saver.save(tfs,"saved-models/model.ckpt")
```
1. 要恢復變量，調用`restore()`方法：
```py
with tf.Session() as tfs:
saver.restore(tfs,"saved-models/model.ckpt")
...
```
1. 讓我們重溫一下第 1 章，TensorFlow 101 的例子，在簡單的例子中保存變量的代碼如下：
```py
# Assume Linear Model y = w * x + b
# Define model parameters
w = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
# Define model input and output
x = tf.placeholder(tf.float32)
y = w * x + b
output = 0
# create saver object
saver = tf.train.Saver()
with tf.Session() as tfs:
# initialize and print the variable y
tfs.run(tf.global_variables_initializer())
output = tfs.run(y,{x:[1,2,3,4]})
saved_model_file = saver.save(tfs,
'saved-models/full-graph-save-example.ckpt')
print('Model saved in {}'.format(saved_model_file))
print('Values of variables w,b: {}{}'
.format(w.eval(),b.eval()))
print('output={}'.format(output))
```
我們得到以下輸出：
```py
Model saved in saved-models/full-graph-save-example.ckpt
Values of variables w,b: [ 0.30000001][-0.30000001]
output=[ 0\. 0.30000001 0.60000002 0.90000004]
```
1. 現在讓我們從剛剛創建的檢查點文件中恢復變量：
```py
# Assume Linear Model y = w * x + b
# Define model parameters
w = tf.Variable([0], dtype=tf.float32)
b = tf.Variable([0], dtype=tf.float32)
# Define model input and output
x = tf.placeholder(dtype=tf.float32)
y = w * x + b
output = 0
# create saver object
saver = tf.train.Saver()
with tf.Session() as tfs:
saved_model_file = saver.restore(tfs,
'saved-models/full-graph-save-example.ckpt')
print('Values of variables w,b: {}{}'
.format(w.eval(),b.eval()))
output = tfs.run(y,{x:[1,2,3,4]})
print('output={}'.format(output))
```
您會注意到在恢復代碼中我們沒有調用`tf.global_variables_initializer()`，因為不需要初始化變量，因為它們將從文件中恢復。我們得到以下輸出，它是根據恢復的變量計算得出的：
```py
INFO:tensorflow:Restoring parameters from saved-models/full-graph-save-example.ckpt
Values of variables w,b: [ 0.30000001][-0.30000001]
output=[ 0\. 0.30000001 0.60000002 0.90000004]
```
# 使用保存器類保存和恢復所選變量
默認情況下，`Saver()`類將所有變量保存在圖中，但您可以通過將變量列表傳遞給`Saver()`類的構造器來選擇要保存的變量：
```py
# create saver object
saver = tf.train.Saver({'weights': w})
```
變量名稱可以作為列表或字典傳遞。如果變量名稱作為列表傳遞，則列表中的每個變量將以其自己的名稱保存。變量也可以作為由鍵值對組成的字典傳遞，其中鍵是用于保存的名稱，值是要保存的變量的名稱。
以下是我們剛看到的示例的代碼，但這次我們只保存`w`變量的權重；保存時將其命名為`weights`：
```py
# Saving selected variables in a graph in TensorFlow
# Assume Linear Model y = w * x + b
# Define model parameters
w = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
# Define model input and output
x = tf.placeholder(tf.float32)
y = w * x + b
output = 0
# create saver object
saver = tf.train.Saver({'weights': w})
with tf.Session() as tfs:
# initialize and print the variable y
tfs.run(tf.global_variables_initializer())
output = tfs.run(y,{x:[1,2,3,4]})
saved_model_file = saver.save(tfs,
'saved-models/weights-save-example.ckpt')
print('Model saved in {}'.format(saved_model_file))
print('Values of variables w,b: {}{}'
.format(w.eval(),b.eval()))
print('output={}'.format(output))
```
我們得到以下輸出：
```py
Model saved in saved-models/weights-save-example.ckpt
Values of variables w,b: [ 0.30000001][-0.30000001]
output=[ 0\. 0.30000001 0.60000002 0.90000004]
```
檢查點文件僅保存權重而不是偏差。現在讓我們將偏差和權重初始化為零，并恢復權重。此示例的代碼在此處給出：
```py
# Restoring selected variables in a graph in TensorFlow
tf.reset_default_graph()
# Assume Linear Model y = w * x + b
# Define model parameters
w = tf.Variable([0], dtype=tf.float32)
b = tf.Variable([0], dtype=tf.float32)
# Define model input and output
x = tf.placeholder(dtype=tf.float32)
y = w * x + b
output = 0
# create saver object
saver = tf.train.Saver({'weights': w})
with tf.Session() as tfs:
b.initializer.run()
saved_model_file = saver.restore(tfs,
'saved-models/weights-save-example.ckpt')
print('Values of variables w,b: {}{}'
.format(w.eval(),b.eval()))
output = tfs.run(y,{x:[1,2,3,4]})
print('output={}'.format(output))
```
如您所見，這次我們必須使用`b.initializer.run()`初始化偏差。我們不使用`tfs.run(tf.global_variables_initializer())`因為它會初始化所有變量，并且不需要初始化權重，因為它們將從檢查點文件中恢復。
我們得到以下輸出，因為計算僅使用恢復的權重，而偏差設置為零：
```py
INFO:tensorflow:Restoring parameters from saved-models/weights-save-example.ckpt
Values of variables w,b: [ 0.30000001][ 0.]
output=[ 0.30000001 0.60000002 0.90000004 1.20000005]
```
# 保存和恢復 Keras 模型
在 Keras 中，保存和恢復模型非常簡單。 Keras 提供三種選擇：
* 使用其網絡架構，權重（參數），訓練配置和優化器狀態保存完整模型。
* 僅保存架構。
* 僅保存權重。
要保存完整模型，請使用`model.save(filepath)`函數。這將把完整的模型保存在 HDF5 文件中。可以使用`keras.models.load_model(filepath)`函數加載保存的模型。此函數將所有內容加載回來，然后還編譯模型。
要保存模型的架構，請使用`model.to_json()`或`model.to_yaml()`函數。這些函數返回一個可以寫入磁盤文件的字符串。在恢復架構時，可以回讀字符串，并使用`keras.models.model_from_json(json_string)`或`keras.models.model_from_yaml(yaml_string)`函數恢復模型架構。這兩個函數都返回一個模型實例。
要保存模型的權重，請使用`model.save_weights(path_to_h5_file)`函數。可以使用`model.load_weights(path_to_h5_file)`函數恢復權重。
# TensorFlow 服務
TensorFlow 服務（TFS）是一種高表現服務器架構，用于為生產中的機器學習模型提供服務。它提供與使用 TensorFlow 構建的模型的開箱即用集成。
在 TFS 中，**模型**由一個或多個**可服務對象**組成。 可服務對象用于執行計算，例如：
* 用于嵌入查找的查找表
* 返回預測的單個模型
* 返回一組預測的一組模型
* 查找表或模型的分片
**管理器**組件管理可服務對象的整個生命周期，包括加載/卸載可服務對象并提供可服務對象。
[TensorFlow 服務的內部架構和工作流程在此鏈接中描述](https://www.tensorflow.org/serving/architecture_overview)。
# 安裝 TF 服務
按照本節中的說明使用`aptitude`在 Ubuntu 上安裝 TensorFlow ModelServer。
1. 首先，在 shell 提示符下使用以下命令添加 TensorFlow 服務分發 URI 作為包源（一次性設置）：
```py
$ echo "deb [arch=amd64] http://storage.googleapis.com/tensorflow-serving-apt stable tensorflow-model-server tensorflow-model-server-universal" | sudo tee /etc/apt/sources.list.d/tensorflow-serving.list
$ curl https://storage.googleapis.com/tensorflow-serving-apt/tensorflow-serving.release.pub.gpg | sudo apt-key add -
```
1. 在 shell 提示符下使用以下命令安裝和更新 TensorFlow ModelServer：
```py
$ sudo apt-get update && sudo apt-get install tensorflow-model-server
```
這將安裝使用特定于平臺的編譯器優化的 ModelServer 版本，例如使用 SSE4 和 AVX 指令。但是，如果優化版本安裝在舊計算機上不起作用，則可以安裝通用版本：
```py
$ sudo apt-get remove tensorflow-model-server
$ sudo apt-get update && sudo apt-get install tensorflow-model-server-universal
```
對于其他操作系統以及從源安裝，請參閱[此鏈接](https://www.tensorflow.org/serving/setup)。
發布新版本的 ModelServer 時，可以使用以下命令升級到較新版本：
```py
$ sudo apt-get update && sudo apt-get upgrade tensorflow-model-server
```
1. 現在已安裝 ModelServer，使用以下命令運行服務器：
```py
$ tensorflow-model-server
```
1. 要連接到`tensorflow-model-server`，請使用 PIP 安裝 python 客戶端包：
```py
$ sudo pip2 install tensorflow-serving-api
```
TF 服務 API 僅適用于 Python 2，但尚不適用于 Python 3。
# 為 TF 服務保存模型
為了服務模型，需要先保存它們。在本節中，我們將從官方 TensorFlow 文檔中演示 MNIST 示例的略微修改版本，[可從此鏈接獲得](https://www.tensorflow.org/serving/serving_basic)。
TensorFlow 團隊建議使用 SavedModel 來保存和恢復在 TensorFlow 中構建和訓練的模型。根據 TensorFlow 文檔：
SavedModel 是一種語言中立的，可恢復的，密集的序列化格式。SavedModel 支持更高級別的系統和工具來生成，使用和轉換 TensorFlow 模型。您可以按照 Jupyter 筆記本中的代碼`ch-11b_Saving_TF_Models_with_SavedModel_for_TF_Serving`。我們按照以下方式繼續保存模型：
1. 定義模型變量：
```py
model_name = 'mnist'
model_version = '1'
model_dir = os.path.join(models_root,model_name,model_version)
```
1. 像我們在第 4 章中所做的那樣獲取 MNIST 數據 - MLP 模型：
```py
from tensorflow.examples.tutorials.mnist import input_data
dataset_home = os.path.join('.','mnist')
mnist = input_data.read_data_sets(dataset_home, one_hot=True)
x_train = mnist.train.images
x_test = mnist.test.images
y_train = mnist.train.labels
y_test = mnist.test.labels
pixel_size = 28
num_outputs = 10 # 0-9 digits
num_inputs = 784 # total pixels
```
1. 定義將構建并返回模型的 MLP 函數：
```py
def mlp(x, num_inputs, num_outputs,num_layers,num_neurons):
w=[]
b=[]
for i in range(num_layers):
w.append(tf.Variable(tf.random_normal(
[num_inputs if i==0 else num_neurons[i-1],
num_neurons[i]]),name="w_{0:04d}".format(i)
)
)
b.append(tf.Variable(tf.random_normal(
[num_neurons[i]]),
name="b_{0:04d}".format(i)
)
)
w.append(tf.Variable(tf.random_normal(
[num_neurons[num_layers-1] if num_layers > 0 \
else num_inputs, num_outputs]),name="w_out"))
b.append(tf.Variable(tf.random_normal([num_outputs]),
name="b_out"))
# x is input layer
layer = x
# add hidden layers
for i in range(num_layers):
layer = tf.nn.relu(tf.matmul(layer, w[i]) + b[i])
# add output layer
layer = tf.matmul(layer, w[num_layers]) + b[num_layers]
model = layer
probs = tf.nn.softmax(model)
return model,probs
```
上述`mlp()`函數返回模型和概率。概率是應用于模型的 softmax 激活。
1. 為圖像輸入和目標輸出定義`x_p`和`y_p`占位符：
```py
# input images
serialized_tf_example = tf.placeholder(tf.string,
name='tf_example')
feature_configs = {'x': tf.FixedLenFeature(shape=[784],
dtype=tf.float32),}
tf_example = tf.parse_example(serialized_tf_example,
feature_configs)
# use tf.identity() to assign name
x_p = tf.identity(tf_example['x'], name='x_p')
# target output
y_p = tf.placeholder(dtype=tf.float32, name="y_p",
shape=[None, num_outputs])
```
1. 創建模型，以及損失，優化器，準確率和訓練函數：
```py
num_layers = 2
num_neurons = []
for i in range(num_layers):
num_neurons.append(256)
learning_rate = 0.01
n_epochs = 50
batch_size = 100
n_batches = mnist.train.num_examples//batch_size
model,probs = mlp(x=x_p,
num_inputs=num_inputs,
num_outputs=num_outputs,
num_layers=num_layers,
num_neurons=num_neurons)
loss_op = tf.nn.softmax_cross_entropy_with_logits
loss = tf.reduce_mean(loss_op(logits=model, labels=y_p))
optimizer = tf.train.GradientDescentOptimizer(learning_rate)
train_op = optimizer.minimize(loss)
pred_check = tf.equal(tf.argmax(probs,1), tf.argmax(y_p,1))
accuracy_op = tf.reduce_mean(tf.cast(pred_check, tf.float32))
values, indices = tf.nn.top_k(probs, 10)
table = tf.contrib.lookup.index_to_string_table_from_tensor(
tf.constant([str(i) for i in range(10)]))
prediction_classes = table.lookup(tf.to_int64(indices))
```
1. 在 TensorFlow 會話中，像以前一樣訓練模型，但使用構建器對象來保存模型：
```py
from tf.saved_model.signature_constants import \
CLASSIFY_INPUTS
from tf.saved_model.signature_constants import \
CLASSIFY_OUTPUT_CLASSES
from tf.saved_model.signature_constants import \
CLASSIFY_OUTPUT_SCORES
from tf.saved_model.signature_constants import \
CLASSIFY_METHOD_NAME
from tf.saved_model.signature_constants import \
PREDICT_METHOD_NAME
from tf.saved_model.signature_constants import \
DEFAULT_SERVING_SIGNATURE_DEF_KEY
```
```py
with tf.Session() as tfs:
tfs.run(tf.global_variables_initializer())
for epoch in range(n_epochs):
epoch_loss = 0.0
for batch in range(n_batches):
x_batch, y_batch = mnist.train.next_batch(batch_size)
feed_dict = {x_p: x_batch, y_p: y_batch}
_,batch_loss = tfs.run([train_op,loss],
feed_dict=feed_dict)
epoch_loss += batch_loss
average_loss = epoch_loss / n_batches
print("epoch: {0:04d} loss = {1:0.6f}" .format(epoch,average_loss))
feed_dict={x_p: x_test, y_p: y_test}
accuracy_score = tfs.run(accuracy_op, feed_dict=feed_dict)
print("accuracy={0:.8f}".format(accuracy_score))
# save the model
# definitions for saving the models builder = tf.saved_model.builder.SavedModelBuilder(model_dir)
# build signature_def_map
bti_op = tf.saved_model.utils.build_tensor_info
bsd_op = tf.saved_model.utils.build_signature_def
classification_inputs = bti_op(serialized_tf_example)
classification_outputs_classes = bti_op(prediction_classes)
classification_outputs_scores = bti_op(values)
classification_signature = (bsd_op(
inputs={CLASSIFY_INPUTS: classification_inputs},
outputs={CLASSIFY_OUTPUT_CLASSES:
classification_outputs_classes,
CLASSIFY_OUTPUT_SCORES:
classification_outputs_scores
},
method_name=CLASSIFY_METHOD_NAME))
tensor_info_x = bti_op(x_p)
tensor_info_y = bti_op(probs)
prediction_signature = (bsd_op(
inputs={'inputs': tensor_info_x},
outputs={'outputs': tensor_info_y},
method_name=PREDICT_METHOD_NAME))
legacy_init_op = tf.group(tf.tables_initializer(),
name='legacy_init_op')
builder.add_meta_graph_and_variables(
tfs, [tf.saved_model.tag_constants.SERVING],
signature_def_map={
'predict_images':prediction_signature,
DEFAULT_SERVING_SIGNATURE_DEF_KEY:
classification_signature,
},
legacy_init_op=legacy_init_op)
builder.save()
```
一旦看到以下輸出，就會保存模型：
```py
accuracy=0.92979997
INFO:tensorflow:No assets to save.
INFO:tensorflow:No assets to write.
INFO:tensorflow:SavedModel written to: b'/home/armando/models/mnist/1/saved_model.pb'
```
接下來，我們運行 ModelServer 并提供剛剛保存的模型。
# 使用 TF 服務提供模型
要運行 ModelServer，請執行以下命令：
```py
$ tensorflow_model_server --model_name=mnist --model_base_path=/home/armando/models/mnist
```
服務器開始在端口 8500 上提供模型：
```py
I tensorflow_serving/model_servers/main.cc:147] Building single TensorFlow model file config: model_name: mnist model_base_path: /home/armando/models/mnist
I tensorflow_serving/model_servers/server_core.cc:441] Adding/updating models.
I tensorflow_serving/model_servers/server_core.cc:492] (Re-)adding model: mnist
I tensorflow_serving/core/basic_manager.cc:705] Successfully reserved resources to load servable {name: mnist version: 1}
I tensorflow_serving/core/loader_harness.cc:66] Approving load for servable version {name: mnist version: 1}
I tensorflow_serving/core/loader_harness.cc:74] Loading servable version {name: mnist version: 1}
I external/org_tensorflow/tensorflow/contrib/session_bundle/bundle_shim.cc:360] Attempting to load native SavedModelBundle in bundle-shim from: /home/armando/models/mnist/1
I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:236] Loading SavedModel from: /home/armando/models/mnist/1
I external/org_tensorflow/tensorflow/core/platform/cpu_feature_guard.cc:137] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:155] Restoring SavedModel bundle.
I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:190] Running LegacyInitOp on SavedModel bundle.
I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:284] Loading SavedModel: success. Took 29853 microseconds.
I tensorflow_serving/core/loader_harness.cc:86] Successfully loaded servable version {name: mnist version: 1}
E1121 ev_epoll1_linux.c:1051] grpc epoll fd: 3
I tensorflow_serving/model_servers/main.cc:288] Running ModelServer at 0.0.0.0:8500 ...
```
要通過調用模型對圖像進行分類來測試服務器，請按照筆記本`ch-11c_TF_Serving_MNIST`進行操作。
筆記本電腦的前兩個單元提供了服務倉庫中 TensorFlow 官方示例的測試客戶端功能。我們修改了示例以發送`'input'`并在函數簽名中接收`'output'`以調用 ModelServer。
使用以下代碼調用筆記本的第三個單元中的測試客戶端函數：
```py
error_rate = do_inference(hostport='0.0.0.0:8500',
work_dir='/home/armando/datasets/mnist',
concurrency=1,
num_tests=100)
print('\nInference error rate: %s%%' % (error_rate * 100))
```
我們得到差不多 7% 的錯誤率！ （您可能會得到不同的值）：
```py
Extracting /home/armando/datasets/mnist/train-images-idx3-ubyte.gz
Extracting /home/armando/datasets/mnist/train-labels-idx1-ubyte.gz
Extracting /home/armando/datasets/mnist/t10k-images-idx3-ubyte.gz
Extracting /home/armando/datasets/mnist/t10k-labels-idx1-ubyte.gz
..................................................
..................................................
Inference error rate: 7.0%
```
# 在 Docker 容器中提供 TF 服務
Docker 是一個用于在容器中打包和部署應用的平臺。如果您還不知道 Docker 容器，[請訪問此鏈接中的教程和信息](https://www.docker.com/what-container) 。
我們還可以在 Docker 容器中安裝和運行 TensorFlow 服務。本節中提供的 Ubuntu 16.04 的說明源自 TensorFlow 官方網站上的鏈接：
* <https://www.tensorflow.org/serving/serving_inception>
* <https://www.tensorflow.org/serving/serving_basic>
讓我們一起潛入！
# 安裝 Docker
我們按如下方式安裝 Docker：
1. 首先，刪除之前安裝的 Docker：
```py
$ sudo apt-get remove docker docker-engine docker.io
```
1. 安裝必備軟件：
```py
$ sudo apt-get install \
apt-transport-https \
ca-certificates \
curl \
software-properties-common
```
1. 添加 Docker 倉庫的 GPG 密鑰：
```py
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
```
1. 添加 Docker 倉庫：
```py
$ sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) \ stable"
```
1. 安裝 Docker 社區版：
```py
$ sudo apt-get update && sudo apt-get install docker-ce
```
1. 安裝成功完成后，將 Docker 添加為系統服務：
```py
$ sudo systemctl enable docker
```
1. 要以非`root`用戶身份運行 Docker 或不使用`sudo`，請添加`docker`組：
```py
$ sudo groupadd docker
```
1. 將您的用戶添加到`docker`組：
```py
$ sudo usermod -aG docker $USER
```
1. 現在注銷并再次登錄，以便組成員身份生效。登錄后，運行以下命令來測試 Docker 安裝：
```py
$ docker run --name hello-world-container hello-world
```
您應該看到類似于以下內容的輸出：
```py
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
ca4f61b1923c: Already exists
Digest: sha256:be0cd392e45be79ffeffa6b05338b98ebb16c87b255f48e297ec7f98e123905c
Status: Downloaded newer image for hello-world:latest
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1\. The Docker client contacted the Docker daemon.
2\. The Docker daemon pulled the "hello-world" image from the Docker Hub.
(amd64)
3\. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4\. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
https://cloud.docker.com/
For more examples and ideas, visit:
https://docs.docker.com/engine/userguide/
```
Docker 已成功安裝。現在讓我們為 TensorFlow 服務構建一個 Docker 鏡像。
# 為 TF 服務構建 Docker 鏡像
我們繼續使用 Docker 鏡像進行如下操作：
1. 使用以下內容創建名為`dockerfile`的文件：
```py
FROM ubuntu:16.04
MAINTAINER Armando Fandango <armando@geekysalsero.com>
RUN apt-get update && apt-get install -y \
build-essential \
curl \
git \
libfreetype6-dev \
libpng12-dev \
libzmq3-dev \
mlocate \
pkg-config \
python-dev \
python-numpy \
python-pip \
software-properties-common \
swig \
zip \
zlib1g-dev \
libcurl3-dev \
openjdk-8-jdk\
openjdk-8-jre-headless \
wget \
&& \
apt-get clean && \
rm -rf /var/lib/apt/lists/*
RUN echo "deb [arch=amd64] http://storage.googleapis.com/tensorflow-serving-apt stable tensorflow-model-server tensorflow-model-server-universal" \
| tee /etc/apt/sources.list.d/tensorflow-serving.list
RUN curl https://storage.googleapis.com/tensorflow-serving-apt/tensorflow-serving.release.pub.gpg \
| apt-key add -
RUN apt-get update && apt-get install -y \
tensorflow-model-server
RUN pip install --upgrade pip
RUN pip install mock grpcio tensorflow tensorflow-serving-api
CMD ["/bin/bash"]
```
1. 運行以下命令從此`dockerfile`構建 Docker 鏡像：
```py
$ docker build --pull -t $USER/tensorflow_serving -f dockerfile .
```
1. 創建圖像需要一段時間。當您看到類似于以下內容的內容時，您就會知道圖像已構建：
```py
Removing intermediate container 1d8e757d96e0
Successfully built 0f95ddba4362
Successfully tagged armando/tensorflow_serving:latest
```
1. 運行以下命令以啟動容器：
```py
$ docker run --name=mnist_container -it $USER/tensorflow_serving
```
1. 當您看到以下提示時，您將登錄到容器：
```py
root@244ea14efb8f:/#
```
1. 使用`cd`命令轉到主文件夾。
2. 在主文件夾中，提供以下命令以檢查 TensorFlow 是否正在提供代碼。我們將使用此代碼中的示例來演示，但您可以查看自己的 Git 倉庫來運行您自己的模型：
```py
$ git clone --recurse-submodules https://github.com/tensorflow/serving
```
克隆倉庫后，我們就可以構建，訓練和保存 MNIST 模型了。
1. 使用以下命令刪除臨時文件夾（如果尚未刪除）：
```py
$ rm -rf /tmp/mnist_model
```
1. 運行以下命令以構建，訓練和保存 MNIST 模型。
```py
$ python serving/tensorflow_serving/example/mnist_saved_model.py /tmp/mnist_model
```
您將看到類似于以下內容的內容：
```py
Training model...
Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.
Extracting /tmp/train-images-idx3-ubyte.gz
Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.
Extracting /tmp/train-labels-idx1-ubyte.gz
Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.
Extracting /tmp/t10k-images-idx3-ubyte.gz
Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.
Extracting /tmp/t10k-labels-idx1-ubyte.gz
2017-11-22 01:09:38.165391: I tensorflow/core/platform/cpu_feature_guard.cc:137] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA
training accuracy 0.9092
Done training!
Exporting trained model to /tmp/mnist_model/1
Done exporting!
```
1. 按`Ctrl + P`和`Ctrl + Q`從 Docker 鏡像中分離。
2. 提交對新映像的更改并使用以下命令停止容器：
```py
$ docker commit mnist_container $USER/mnist_serving
$ docker stop mnist_container
```
1. 現在，您可以通過提供以下命令隨時運行此容器：
```py
$ docker run --name=mnist_container -it $USER/mnist_serving
```
1. 刪除我們為保存圖像而構建的臨時 MNIST 容器：
```py
$ docker rm mnist_container
```
# 在 Docker 容器中提供模型
要在容器中提供模型，說明如下：
1. 啟動上一節中構建的 MNIST 容器：
```py
$ docker run --name=mnist_container -it $USER/mnist_serving
```
1. 使用`cd`命令轉到主文件夾。
2. 使用以下命令運行 ModelServer：
```py
$ tensorflow_model_server --model_name=mnist --model_base_path=/tmp/mnist_model/ &> mnist_log &
```
1. 使用示例客戶端檢查模型中的預測：
```py
$ python serving/tensorflow_serving/example/mnist_client.py --num_tests=100 --server=localhost:8500
```
1. 我們看到錯誤率為 7%，就像我們之前的筆記本示例執行一樣：
```py
Extracting /tmp/train-images-idx3-ubyte.gz
Extracting /tmp/train-labels-idx1-ubyte.gz
Extracting /tmp/t10k-images-idx3-ubyte.gz
Extracting /tmp/t10k-labels-idx1-ubyte.gz
....................................................................................................
Inference error rate: 7.0%
```
而已！您已經構建了 Docker 鏡像，并在 Docker 鏡像中為您的模型提供服務。發出`exit`命令退出容器。
# Kubernetes 中的 TensorFlow 服務
根據 {Kubernetes](https://kubernets.io)：
Kubernetes 是一個開源系統，用于自動化容器化應用的部署，擴展和管理。
TensorFlow 模型可以擴展為使用生產環境中的 Kubernetes 集群從數百或數千個`TF?Serving`服務中提供服務。 Kubernetes 集群可以在所有流行的公共云上運行，例如 GCP，AWS，Azure，以及您的本地私有云。因此，讓我們直接學習安裝 Kubernetes，然后在 Kubernetes 集群上部署 MNIST 模型。
# 安裝 Kubernetes
我們按照以下步驟在單節點本地群集模式下在 Ubuntu 16.04 上安裝了 Kubernetes：
1. 安裝 LXD 和 Docker，這是在本地安裝 Kubernetes 的先決條件。 LXD 是與 Linux 容器一起使用的容器管理器。我們已經在上一節中學習了如何安裝 Docker。要安裝 LXD，請運行以下命令：
```py
$ sudo snap install lxd
lxd 2.19 from 'canonical' installed
```
1. 初始化`lxd`并創建虛擬網絡：
```py
$ sudo /snap/bin/lxd init --auto
LXD has been successfully configured.
$ sudo /snap/bin/lxc network create lxdbr0 ipv4.address=auto ipv4.nat=true ipv6.address=none ipv6.nat=false
If this is your first time using LXD, you should also run: lxd init
To start your first container, try: lxc launch ubuntu:16.04
Network lxdbr0 created
```
1. 將您的用戶添加到`lxd`組：
```py
$ sudo usermod -a -G lxd $(whoami)
```
1. 安裝`conjure-up`并重啟機器：
```py
$ sudo snap install conjure-up --classic
conjure-up 2.3.1 from 'canonical' installed
```
1. 啟動`conjure-up`以安裝 Kubernetes：
```py
$ conjure-up kubernetes
```
1. 從法術列表中選擇`Kubernetes Core`。
2. 從可用云列表中選擇`localhost`。
3. 從網絡列表中選擇`lxbr0`網橋。
4. 提供選項的`sudo`密碼：將 kubectl 和 kubefed 客戶端程序下載到本地主機。
5. 在下一個屏幕中，它會要求選擇要安裝的應用。安裝其余五個應用。
您知道當安裝期間的最終屏幕如下所示時，Kubernetes 集群已準備好進行釀造：
如果您在安裝時遇到問題，請在互聯網上搜索幫助，從此鏈接的文檔開始：
<https://kubernetes.io/docs/getting-started-guides/ubuntu/local/>
<https://kubernetes.io/docs/getting-started-guides/ubuntu/>
<https://tutorials.ubuntu.com/tutorial/install-kubernetes-with-conjure-up>
# 將 Docker 鏡像上傳到 dockerhub
將 Docker 鏡像上傳到 dockerhub 的步驟如下：
1. 如果您還沒有，請在 dockerhub 上創建一個帳戶。
2. 使用以下命令登錄 dockerhub 帳戶：
```py
$ docker login --username=<username>
```
1. 使用您在 dockerhub 上創建的倉庫標記 MNIST 圖像。例如，我們創建了`neurasights/mnist-serving`：
```py
$ docker tag $USER/mnist_serving neurasights/mnist-serving
```
1. 將標記的圖像推送到 dockerhub 帳戶。
```py
$ docker push neurasights/mnist-serving
```
# 在 Kubernetes 部署
我們繼續在 Kubernotes 中進行部署，如下所示：
1. 使用以下內容創建`mnist.yaml`文件：
```py
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: mnist-deployment
spec:
replicas: 3
template:
metadata: labels: app: mnist-server
spec:
containers: - name: mnist-container
image: neurasights/mnist-serving
command:
- /bin/sh
args:
- -c
- tensorflow_model_server --model_name=mnist --model_base_path=/tmp/mnist_model
ports:
- containerPort: 8500
---
apiVersion: v1
kind: Service
metadata:
labels: run: mnist-service
name: mnist-service
spec:
ports: - port: 8500
targetPort: 8500
selector:
app: mnist-server
# type: LoadBalancer
```
如果您在 AWS 或 GCP 云中運行它，則取消注釋前一個文件中的`LoadBalancer`行。 由于我們在單個節點上本地運行整個集群，因此我們沒有外部負載均衡器。
1. 創建 Kubernetes 部署和服務：
```py
$ kubectl create -f mnist.yaml
deployment "mnist-deployment" created
service "mnist-service" created
```
1. 檢查部署，窗格和服務：
```py
$ kubectl get deployments
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
mnist-deployment 3 3 3 0 1m
$ kubectl get pods
NAME READY STATUS RESTARTS AGE
default-http-backend-bbchw 1/1 Running 3 9d
mnist-deployment-554f4b674b-pwk8z 0/1 ContainerCreating 0 1m
mnist-deployment-554f4b674b-vn6sd 0/1 ContainerCreating 0 1m
mnist-deployment-554f4b674b-zt4xt 0/1 ContainerCreating 0 1m
nginx-ingress-controller-724n5 1/1 Running 2 9d
```
```py
$ kubectl get services
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
default-http-backend ClusterIP 10.152.183.223 <none> 80/TCP 9d
kubernetes ClusterIP 10.152.183.1 <none> 443/TCP 9d
mnist-service LoadBalancer 10.152.183.66 <pending> 8500:32414/TCP 1m
```
```py
$ kubectl describe service mnist-service
Name: mnist-service
Namespace: default
Labels: run=mnist-service
Annotations: <none>
Selector: app=mnist-server
Type: LoadBalancer
IP: 10.152.183.66
Port: <unset> 8500/TCP
TargetPort: 8500/TCP
NodePort: <unset> 32414/TCP
Endpoints: 10.1.43.122:8500,10.1.43.123:8500,10.1.43.124:8500
Session Affinity: None
External Traffic Policy: Cluster
Events: <none>
```
1. 等到所有 pod 的狀態為`Running`：
```py
$ kubectl get pods
NAME READY STATUS RESTARTS AGE
default-http-backend-bbchw 1/1 Running 3 9d
mnist-deployment-554f4b674b-pwk8z 1/1 Running 0 3m
mnist-deployment-554f4b674b-vn6sd 1/1 Running 0 3m
mnist-deployment-554f4b674b-zt4xt 1/1 Running 0 3m
nginx-ingress-controller-724n5 1/1 Running 2 9d
```
1. 檢查其中一個 pod 的日志，您應該看到如下內容：
```py
$ kubectl logs mnist-deployment-59dfc5df64-g7prf
I tensorflow_serving/model_servers/main.cc:147] Building single TensorFlow model file config: model_name: mnist model_base_path: /tmp/mnist_model
I tensorflow_serving/model_servers/server_core.cc:441] Adding/updating models.
I tensorflow_serving/model_servers/server_core.cc:492] (Re-)adding model: mnist
I tensorflow_serving/core/basic_manager.cc:705] Successfully reserved resources to load servable {name: mnist version: 1}
I tensorflow_serving/core/loader_harness.cc:66] Approving load for servable version {name: mnist version: 1}
I tensorflow_serving/core/loader_harness.cc:74] Loading servable version {name: mnist version: 1}
I external/org_tensorflow/tensorflow/contrib/session_bundle/bundle_shim.cc:360] Attempting to load native SavedModelBundle in bundle-shim from: /tmp/mnist_model/1
I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:236] Loading SavedModel from: /tmp/mnist_model/1
I external/org_tensorflow/tensorflow/core/platform/cpu_feature_guard.cc:137] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA
I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:155] Restoring SavedModel bundle.
I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:190] Running LegacyInitOp on SavedModel bundle.
I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:284] Loading SavedModel: success. Took 45319 microseconds.
I tensorflow_serving/core/loader_harness.cc:86] Successfully loaded servable version {name: mnist version: 1}
E1122 12:18:04.566415410 6 ev_epoll1_linux.c:1051] grpc epoll fd: 3
I tensorflow_serving/model_servers/main.cc:288] Running ModelServer at 0.0.0.0:8500 ...
```
1. 您還可以使用以下命令查看 UI 控制臺：
```py
$ kubectl proxy xdg-open http://localhost:8001/ui
```
Kubernetes UI 控制臺如下圖所示：
由于我們在單個節點上本地運行集群，因此我們的服務僅在集群中公開，無法從外部訪問。登錄我們剛剛實例化的三個 pod 中的一個：
```py
$ kubectl exec -it mnist-deployment-59dfc5df64-bb24q -- /bin/bash
```
切換到主目錄并運行 MNIST 客戶端來測試服務：
```py
$ kubectl exec -it mnist-deployment-59dfc5df64-bb24q -- /bin/bash
root@mnist-deployment-59dfc5df64-bb24q:/# cd
root@mnist-deployment-59dfc5df64-bb24q:~# python serving/tensorflow_serving/example/mnist_client.py --num_tests=100 --server=10.152.183.67:8500
Extracting /tmp/train-images-idx3-ubyte.gz
Extracting /tmp/train-labels-idx1-ubyte.gz
Extracting /tmp/t10k-images-idx3-ubyte.gz
Extracting /tmp/t10k-labels-idx1-ubyte.gz
....................................................................................................
Inference error rate: 7.0%
root@mnist-deployment-59dfc5df64-bb24q:~#
```
我們學習了如何在本地單個節點上運行的 Kubernetes 集群上部署 TensorFlow 服務。您可以使用相同的概念知識在您的場所內的公共云或私有云上部署服務。
# 總結
在本章中，我們學習了如何利用 TensorFlow 服務來為生產環境中的模型提供服務。我們還學習了如何使用 TensorFlow 和 Keras 保存和恢復完整模型或選擇模型。我們構建了一個 Docker 容器，并從官方 TensorFlow 服務倉庫中提供了 Docker 容器中的示例 MNIST 示例代碼。我們還安裝了一個本地 Kubernetes 集群，并部署了 MNIST 模型，用于在 Kubernetes pod 中運行的 TensorFlow 服務。我們鼓勵讀者在這些例子的基礎上進行嘗試并嘗試提供不同的模型。 TF 服務文檔描述了各種選項，并提供了其他信息，使您可以進一步探索此主題。
在接下來的章節中，我們將繼續使用遷移學習的高級模型。 TensorFlow 倉庫中提供的預訓練模型是使用 TF 服務練習服務 TF 模型的最佳候選者。我們使用 Ubuntu 包安裝了 TF 服務，但您可能希望嘗試從源代碼構建以優化生產環境的 TF 服務安裝。
- TensorFlow 1.x 深度學習秘籍
- 零、前言
- 一、TensorFlow 簡介
- 二、回歸
- 三、神經網絡：感知器
- 四、卷積神經網絡
- 五、高級卷積神經網絡
- 六、循環神經網絡
- 七、無監督學習
- 八、自編碼器
- 九、強化學習
- 十、移動計算
- 十一、生成模型和 CapsNet
- 十二、分布式 TensorFlow 和云深度學習
- 十三、AutoML 和學習如何學習（元學習）
- 十四、TensorFlow 處理單元
- 使用 TensorFlow 構建機器學習項目中文版
- 一、探索和轉換數據
- 二、聚類
- 三、線性回歸
- 四、邏輯回歸
- 五、簡單的前饋神經網絡
- 六、卷積神經網絡
- 七、循環神經網絡和 LSTM
- 八、深度神經網絡
- 九、大規模運行模型 -- GPU 和服務
- 十、庫安裝和其他提示
- TensorFlow 深度學習中文第二版
- 一、人工神經網絡
- 二、TensorFlow v1.6 的新功能是什么？
- 三、實現前饋神經網絡
- 四、CNN 實戰
- 五、使用 TensorFlow 實現自編碼器
- 六、RNN 和梯度消失或爆炸問題
- 七、TensorFlow GPU 配置
- 八、TFLearn
- 九、使用協同過濾的電影推薦
- 十、OpenAI Gym
- TensorFlow 深度學習實戰指南中文版
- 一、入門
- 二、深度神經網絡
- 三、卷積神經網絡
- 四、循環神經網絡介紹
- 五、總結
- 精通 TensorFlow 1.x
- 一、TensorFlow 101
- 二、TensorFlow 的高級庫
- 三、Keras 101
- 四、TensorFlow 中的經典機器學習
- 五、TensorFlow 和 Keras 中的神經網絡和 MLP
- 六、TensorFlow 和 Keras 中的 RNN
- 七、TensorFlow 和 Keras 中的用于時間序列數據的 RNN
- 八、TensorFlow 和 Keras 中的用于文本數據的 RNN
- 九、TensorFlow 和 Keras 中的 CNN
- 十、TensorFlow 和 Keras 中的自編碼器
- 十一、TF 服務：生產中的 TensorFlow 模型
- 十二、遷移學習和預訓練模型
- 十三、深度強化學習
- 十四、生成對抗網絡
- 十五、TensorFlow 集群的分布式模型
- 十六、移動和嵌入式平臺上的 TensorFlow 模型
- 十七、R 中的 TensorFlow 和 Keras
- 十八、調試 TensorFlow 模型
- 十九、張量處理單元
- TensorFlow 機器學習秘籍中文第二版
- 一、TensorFlow 入門
- 二、TensorFlow 的方式
- 三、線性回歸
- 四、支持向量機
- 五、最近鄰方法
- 六、神經網絡
- 七、自然語言處理
- 八、卷積神經網絡
- 九、循環神經網絡
- 十、將 TensorFlow 投入生產
- 十一、更多 TensorFlow
- 與 TensorFlow 的初次接觸
- 前言
- 1.?TensorFlow 基礎知識
- 2. TensorFlow 中的線性回歸
- 3. TensorFlow 中的聚類
- 4. TensorFlow 中的單層神經網絡
- 5. TensorFlow 中的多層神經網絡
- 6. 并行
- 后記
- TensorFlow 學習指南
- 一、基礎
- 二、線性模型
- 三、學習
- 四、分布式
- TensorFlow Rager 教程
- 一、如何使用 TensorFlow Eager 構建簡單的神經網絡
- 二、在 Eager 模式中使用指標
- 三、如何保存和恢復訓練模型
- 四、文本序列到 TFRecords
- 五、如何將原始圖片數據轉換為 TFRecords
- 六、如何使用 TensorFlow Eager 從 TFRecords 批量讀取數據
- 七、使用 TensorFlow Eager 構建用于情感識別的卷積神經網絡（CNN）
- 八、用于 TensorFlow Eager 序列分類的動態循壞神經網絡
- 九、用于 TensorFlow Eager 時間序列回歸的遞歸神經網絡
- TensorFlow 高效編程
- 圖嵌入綜述：問題，技術與應用
- 一、引言
- 三、圖嵌入的問題設定
- 四、圖嵌入技術
- 基于邊重構的優化問題
- 應用
- 基于深度學習的推薦系統：綜述和新視角
- 引言
- 基于深度學習的推薦：最先進的技術
- 基于卷積神經網絡的推薦
- 關于卷積神經網絡我們理解了什么
- 第1章概論
- 第2章多層網絡
- 2.1.4生成對抗網絡
- 2.2.1最近ConvNets演變中的關鍵架構
- 2.2.2走向ConvNet不變性
- 2.3時空卷積網絡
- 第3章了解ConvNets構建塊
- 3.2整改
- 3.3規范化
- 3.4匯集
- 第四章現狀
- 4.2打開問題
- 參考
- 機器學習超級復習筆記
- Python 遷移學習實用指南
- 零、前言
- 一、機器學習基礎
- 二、深度學習基礎
- 三、了解深度學習架構
- 四、遷移學習基礎
- 五、釋放遷移學習的力量
- 六、圖像識別與分類
- 七、文本文件分類
- 八、音頻事件識別與分類
- 九、DeepDream
- 十、自動圖像字幕生成器
- 十一、圖像著色
- 面向計算機視覺的深度學習
- 零、前言
- 一、入門
- 二、圖像分類
- 三、圖像檢索
- 四、對象檢測
- 五、語義分割
- 六、相似性學習
- 七、圖像字幕
- 八、生成模型
- 九、視頻分類
- 十、部署
- 深度學習快速參考
- 零、前言
- 一、深度學習的基礎
- 二、使用深度學習解決回歸問題
- 三、使用 TensorBoard 監控網絡訓練
- 四、使用深度學習解決二分類問題
- 五、使用 Keras 解決多分類問題
- 六、超參數優化
- 七、從頭開始訓練 CNN
- 八、將預訓練的 CNN 用于遷移學習
- 九、從頭開始訓練 RNN
- 十、使用詞嵌入從頭開始訓練 LSTM
- 十一、訓練 Seq2Seq 模型
- 十二、深度強化學習
- 十三、生成對抗網絡
- TensorFlow 2.0 快速入門指南
- 零、前言
- 第 1 部分：TensorFlow 2.00 Alpha 簡介
- 一、TensorFlow 2 簡介
- 二、Keras：TensorFlow 2 的高級 API
- 三、TensorFlow 2 和 ANN 技術
- 第 2 部分：TensorFlow 2.00 Alpha 中的監督和無監督學習
- 四、TensorFlow 2 和監督機器學習
- 五、TensorFlow 2 和無監督學習
- 第 3 部分：TensorFlow 2.00 Alpha 的神經網絡應用
- 六、使用 TensorFlow 2 識別圖像
- 七、TensorFlow 2 和神經風格遷移
- 八、TensorFlow 2 和循環神經網絡
- 九、TensorFlow 估計器和 TensorFlow HUB
- 十、從 tf1.12 轉換為 tf2
- TensorFlow 入門
- 零、前言
- 一、TensorFlow 基本概念
- 二、TensorFlow 數學運算
- 三、機器學習入門
- 四、神經網絡簡介
- 五、深度學習
- 六、TensorFlow GPU 編程和服務
- TensorFlow 卷積神經網絡實用指南
- 零、前言
- 一、TensorFlow 的設置和介紹
- 二、深度學習和卷積神經網絡
- 三、TensorFlow 中的圖像分類
- 四、目標檢測與分割
- 五、VGG，Inception，ResNet 和 MobileNets
- 六、自編碼器，變分自編碼器和生成對抗網絡
- 七、遷移學習
- 八、機器學習最佳實踐和故障排除
- 九、大規模訓練
- 十、參考文獻