用TFserving部署深度学习模型

1.什么是TFserving

当你训好你的模型，需要提供给外部使用的时候，你就需要把模型部署到线上，并提供合适的接口给外部调用。你可能会考虑一些问题：

  •  用什么来部署
  •  怎么提供api接口
  •  多个模型GPU资源如何分配
  •  线上模型如何更新而服务不中断

目前流行的深度学习框架Tensorflow和Pytorch， Pytorch官方并没有提供合适的线上部署方案；Tensorflow则提供了TFserving方案来部署线上模型推理。另外，Model Server for Apache MXNet 为MXNet模型提供推理服务。

本文为TFServing的使用指南。如果你是pytorch或者MXNet模型，也可以通过ONNX转成TFserving的模型，部署在TFServing上。

那什么是TFserving?

TFserving是Google 2017推出的线上推理服务；采用C/S架构，客户端可通过gRPC和RESTfull API与模型服务进行通信。

TFServing的特点：

  •  支持模型版本控制和回滚：Manager会进行模型的版本的管理
  •  支持并发，实现高吞吐量
  •  开箱即用，并且可定制化
  •  支持多模型服务
  •  支持批处理
  •  支持热更新：Source加载本地模型，通知Manager有新的模型需要加载，Manager检查模型的版本，通知Source创建的Loader进行加载模型
  •  支持分布式模型

2.TFserving安装

强烈建议采用docker方式安装TFserving，安装依赖docker和nvidia-docker（TFserving的gpu需要）

  •  docker 安装 
 
 
 
 
    
  
  
  
  
  1. #安装yum-utils工具和device-mapper相关依赖包  
    2.   
  
  
  
  2. yum install -y yum-utils \  
    3.   
  
  
  
  3. device-mapper-persistent-data \  
    4.   
  
  
  
  4. lvm2  
    5.   
  
  
  
  5. #添加docker-ce stable版本的仓库  
    6.   
  
  
  
  6. yum-config-manager \  
    7.   
  
  
  
  7. --add-repo \  
    8.   
  
  
  
  8. https://download.docker.com/linux/centos/docker-ce.repo  
    9.   
  
  
  
  9. #更新yum缓存文件  
    10.   
  
  
  
  10. yum makecache fast  
    11.   
  
  
  
  11. #查看所有可安装的docker-ce版本  
    12.   
  
  
  
  12. yum list docker-ce --showduplicates | sort -r  
    13.   
  
  
  
  13. # 安装docker-ce  
    14.   
  
  
  
  14. yum install docker-ce-17.12.1.ce-1.el7.centos  
    15.   
  
  
  
  15. #允许开机启动docker-ce服务  
    16.   
  
  
  
  16. systemctl enable docker.service  
    17.   
  
  
  
  17. #启动Docker-ce服务  
    18.   
  
  
  
  18. systemctl start docker  
    19.   
  
  
  
  19. #运行测试容器hello-world  
    20.   
  
  
  
  20. docker run --rm hello-world 
    21.
  •  nvidia-docker 安装 
 
 
 
 
    
  
  
  
  
  1. # 安装nvidia-docker2  
    2.   
  
  
  
  2. yum install -y nvidia-docker2-2.0.3-1.docker17.12.1.ce  
    3.   
  
  
  
  3. # 重启docker服务  
    4.   
  
  
  
  4. service docker restart 
    5.
  •  安装TFserving 
 
 
 
 
    
  
  
  
  
  1. docker pull tensorflow/serving:latest-gpu  
    2.   
  
  
  
  2. # 可以选择其他版本如 docker pull tensorflow/serving:1.14.0-rc0-gpu 
    3.

注意：docker版本和nvidia-docker要匹配

  •  目前最新的nvidia-docker需要Docker为19.03 可参考官方https://github.com/NVIDIA/nvidia-docker
  •  nvidia-docker2 支持Docker版本低于19.03的其他版本（需>=1.12），现有服务器有18.09,1.17,1.13  https://github.com/NVIDIA/nvidia-docker/wiki/Installation-(version-2.0)

3.TFserving使用说明

3.1 模型转换

TFserving的模型需要转换成TFserving的格式， 不支持通常的checkpoint和pb格式。

TFserving的模型包含一个.pb文件和variables目录（可以为空）,导出格式如下：.

 
 
 
 
    
  
  
  
  
  1. ├── 1  
    2.   
  
  
  
  2. │   ├── saved_model.pb  
    3.   
  
  
  
  3. │   └── variables  
    4.   
  
  
  
  4. ├── 2  
    5.   
  
  
  
  5. │   ├── saved_model.pb  
    6.   
  
  
  
  6. │   └── variables 
    7.

不同的深度学习框架的转换路径：

 
 
 
 
    
  
  
  
  
  1. (1) pytorch(.pth)--> onnx(.onnx)--> tensorflow(.pb) --> TFserving  
    2.   
  
  
  
  2. (2) keras(.h5)--> tensorflow(.pb) --> TFserving  
    3.   
  
  
  
  3. (3) tensorflow(.pb) --> TFserving 
    4.

这里详细介绍下pb转换成TFserving模型

 
 
 
 
    
  
  
  
  
  1. import tensorflow as tf  
    2.   
  
  
  
  2. def create_graph(pb_file):  
    3.   
  
  
  
  3.     """Creates a graph from saved GraphDef file and returns a saver."""  
    4.   
  
  
  
  4.     # Creates graph from saved graph_def.pb.  
    5.   
  
  
  
  5.     with tf.gfile.FastGFile(pb_file, 'rb') as f:  
    6.   
  
  
  
  6.         graph_def = tf.GraphDef()  
    7.   
  
  
  
  7.         graph_def.ParseFromString(f.read())  
    8.   
  
  
  
  8.         _ = tf.import_graph_def(graph_def, name='')  
    9.   
  
  
  
  9. def pb_to_tfserving(pb_file, export_path, pb_io_name=[], input_node_name='input', output_node_name='output', signature_name='default_tfserving'):  
    10.   
  
  
  
  10.     # pb_io_name 为 pb模型输入和输出的节点名称，  
    11.   
  
  
  
  11.     # input_node_name为转化后输入名  
    12.   
  
  
  
  12.     # output_node_name为转化后输出名  
    13.   
  
  
  
  13.     # signature_name 为签名  
    14.   
  
  
  
  14.     create_graph(pb_file) 
    15.   
  
  
  
  15.      # tensor_name_list = [tensor.name for tensor in tf.get_default_graph().as_graph_def().node]  
    16.   
  
  
  
  16.     input_name = '%s:0' % pb_io_name[0]  
    17.   
  
  
  
  17.     output_name = '%s:0' % pb_io_name[1]  
    18.   
  
  
  
  18.     with tf.Session() as sess:  
    19.   
  
  
  
  19.         in_tensor = sess.graph.get_tensor_by_name(input_name)  
    20.   
  
  
  
  20.         out_tensor = sess.graph.get_tensor_by_name(output_name)  
    21.   
  
  
  
  21.         builder = tf.saved_model.builder.SavedModelBuilder(export_path)  ## export_path导出路径  
    22.   
  
  
  
  22.         inputs = {input_node_name: tf.saved_model.utils.build_tensor_info(in_tensor)}    
    23.   
  
  
  
  23.         outputs = {output_node_name: tf.saved_model.utils.build_tensor_info(out_tensor)}  
    24.   
  
  
  
  24.         signature = tf.saved_model.signature_def_utils.build_signature_def(  
    25.   
  
  
  
  25.             inputs, outputs, method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME)  
    26.   
  
  
  
  26.         builder.add_meta_graph_and_variables(  
    27.   
  
  
  
  27.             sesssess=sess, tags=[tf.saved_model.tag_constants.SERVING],  
    28.   
  
  
  
  28.             signature_def_map={signature_name: signature}, clear_devices=True)  ## signature_name为签名，可自定义  
    29.   
  
  
  
  29.         builder.save()  
    30.   
  
  
  
  30. pb_model_path = 'test.pb'  
    31.   
  
  
  
  31. pb_to_tfserving(pb_model_path, './1', pb_io_name=['input_1_1','output_1'],signature_name='your_model') 
    32.

3.2 TFserving配置和启动

模型导出后，同一个模型可以导出不同的版本（版本后数字），可以TFserving配置中指定模型和指定版本。TFserving的模型是通过模型名称和签名来唯一定位。TFserving 可以配置多个模型，充分利用GPU资源。

  •  模型配置 
 
 
 
 
    
  
  
  
  
  1. # models.config  
    2.   
  
  
  
  2. model_config_list {  
    3.   
  
  
  
  3.   config {  
    4.   
  
  
  
  4.     name: 'your_model'  
    5.   
  
  
  
  5.     base_path: '/models/your_model/'  
    6.   
  
  
  
  6.     model_platform: 'tensorflow'  
    7.   
  
  
  
  7. #     model_version_policy {  
    8.   
  
  
  
  8. #       specific {  
    9.   
  
  
  
  9. #         versions: 42  
    10.   
  
  
  
  10. #         versions: 43  
    11.   
  
  
  
  11. #       }  
    12.   
  
  
  
  12. #     }  
    13.   
  
  
  
  13. #     version_labels {  
    14.   
  
  
  
  14. #       key: 'stable'  
    15.   
  
  
  
  15. #       value: 43  
    16.   
  
  
  
  16. #     }  
    17.   
  
  
  
  17. #     version_labels {  
    18.   
  
  
  
  18. #       key: 'canary'  
    19.   
  
  
  
  19. #       value: 43  
    20.   
  
  
  
  20. #     }  
    21.   
  
  
  
  21.   }  
    22.   
  
  
  
  22.   config {  
    23.   
  
  
  
  23.     name: "mnist",  
    24.   
  
  
  
  24.     base_path: "/models/mnist",  
    25.   
  
  
  
  25.     model_platform: "tensorflow",  
    26.   
  
  
  
  26.     model_version_policy: {  
    27.   
  
  
  
  27.        specific: {  
    28.   
  
  
  
  28.         versions: 1,  
    29.   
  
  
  
  29.         versions: 2  
    30.   
  
  
  
  30.        }  
    31.   
  
  
  
  31.   }  
    32.   
  
  
  
  32. }  
    33.   
  
  
  
  33. # 可以通过model_version_policy 进行版本的控制 
    34.
  •  启动服务 
 
 
 
 
    
  
  
  
  
  1. # 建议把模型和配置文件放在docker外的本地路径，如/home/tfserving/models， 通过-v 挂载到docker内部  
    2.   
  
  
  
  2. # --model_config_file： 指定模型配置文件  
    3.   
  
  
  
  3. # -e NVIDIA_VISIBLE_DEVICES=0： 指定GPU  
    4.   
  
  
  
  4. # -p 指定端口映射 8500为gRpc 8501为restful api端口  
    5.   
  
  
  
  5. # -t 为docker镜像  
    6.   
  
  
  
  6. nvidia-docker run  -it --privileged  -d -e NVIDIA_VISIBLE_DEVICES=0  -v /home/tfserving/models:/models  -p 8500:8500 -p 8501:8501 \  
    7.   
  
  
  
  7.  -t tensorflow/serving:latest-gpu \  
    8.   
  
  
  
  8. --model_config_file=/models/models.config  
    9.   
  
  
  
  9. # /home/tfserving/models 结构  
    10.   
  
  
  
  10. ├── models.config  
    11.   
  
  
  
  11. └── your_model  
    12.   
  
  
  
  12.     ├── 1  
    13.   
  
  
  
  13.     │   ├── saved_model.pb  
    14.   
  
  
  
  14.     │   └── variables  
    15.   
  
  
  
  15.     └── 2  
    16.   
  
  
  
  16.         ├── saved_model.pb  
    17.   
  
  
  
  17.         └── variables  
    18.   
  
  
  
  18. # test  
    19.   
  
  
  
  19. curl http://192.168.0.3:8501/v1/models/your_model  
    20.   
  
  
  
  20. {  
    21.   
  
  
  
  21.     "model_version_status": [  
    22.   
  
  
  
  22.         {  
    23.   
  
  
  
  23.             "version": "2",  
    24.   
  
  
  
  24.             "state": "AVAILABLE",  
    25.   
  
  
  
  25.             "status": {  
    26.   
  
  
  
  26.             "error_code": "OK",  
    27.   
  
  
  
  27.             "error_message": ""  
    28.   
  
  
  
  28.             }  
    29.   
  
  
  
  29.         }  
    30.   
  
  
  
  30.     ]        
    31.   
  
  
  
  31. }  
    32.   
  
  
  
  32. # 其他启动方式  
    33.   
  
  
  
  33. # 如果多个模型在不同的目录，可以通过-mount 单独加载  
    34.   
  
  
  
  34. nvidia-docker run  -it --privileged  -d -e NVIDIA_VISIBLE_DEVICES=0 \  
    35.   
  
  
  
  35. --mount type=bind,source=/home/tfserving/models/your_model,target=/models/your_model \  
    36.   
  
  
  
  36. --mount type=bind,source=/home/tfserving/models/your_model/models.config,target=/models/models.config \  
    37.   
  
  
  
  37. -p 8510:8500 -p 8501:8501 \  
    38.   
  
  
  
  38. -t tensorflow/serving:latest-gpu \  
    39.   
  
  
  
  39. --model_config_file=/models/models.config 
    40.

3.3 TFserving服务调用

客户端可以通过gRpc和http方式调用TFserving服务模型，支持多种客户端语言，这里提供python的调用方式; 调用都是通过模型名称和签名来唯一对应一个模型

  •  gRpc调用, gRpc的端口是8500 
 
 
 
 
    
  
  
  
  
  1. #  
    2.   
  
  
  
  2. # -*-coding:utf-8 -*-  
    3.   
  
  
  
  3. import tensorflow as tf  
    4.   
  
  
  
  4. from tensorflow_serving.apis import predict_pb2  
    5.   
  
  
  
  5. from tensorflow_serving.apis import prediction_service_pb2_grpc  
    6.   
  
  
  
  6. import grpc  
    7.   
  
  
  
  7. import time  
    8.   
  
  
  
  8. import numpy as np  
    9.   
  
  
  
  9. import cv2 
    10.   
  
  
  
  10. class YourModel(object):  
    11.   
  
  
  
  11.     def __init__(self, socket):  
    12.   
  
  
  
  12.         """ 
    13.   
  
  
  
  13.         Args:  
    14.   
  
  
  
  14.             socket: host and port of the tfserving, like 192.168.0.3:8500  
    15.   
  
  
  
  15.         """  
    16.   
  
  
  
  16.         self.socket = socket  
    17.   
  
  
  
  17.         start = time.time()  
    18.   
  
  
  
  18.         self.request, selfself.stub = self.__get_request()  
    19.   
  
  
  
  19.         end = time.time()  
    20.   
  
  
  
  20.         print('initialize cost time: ' + str(end - start) + ' s')  
    21.   
  
  
  
  21.     def __get_request(self):  
    22.   
  
  
  
  22.         channel = grpc.insecure_channel(self.socket, options=[('grpc.max_send_message_length', 1024 * 1024 * 1024),  
    23.   
  
  
  
  23.                                                               ('grpc.max_receive_message_length', 1024 * 1024 * 1024)]) # 可设置大小  
    24.   
  
  
  
  24.         stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)  
    25.   
  
  
  
  25.         request = predict_pb2.PredictRequest()  
    26.   
  
  
  
  26.         request.model_spec.name = "your_model"  # model name  
    27.   
  
  
  
  27.         request.model_spec.signature_name = "your_model"  # model signature name  
    28.   
  
  
  
  28.         return request, stub  
    29.   
  
  
  
  29.     def run(self, image):  
    30.   
  
  
  
  30.         """  
    31.   
  
  
  
  31.         Args:  
    32.   
  
  
  
  32.             image: the input image（rgb format）  
    33.   
  
  
  
  33.         Returns: embedding is output of model  
    34.   
  
  
  
  34.         """  
    35.   
  
  
  
  35.         img = image[..., ::-1]   
    36.   
  
  
  
  36.         self.request.inputs['input'].CopyFrom(tf.contrib.util.make_tensor_proto(img))  # images is input of model  
    37.   
  
  
  
  37.         result = self.stub.Predict(self.request, 30.0)  
    38.   
  
  
  
  38.         return tf.make_ndarray(result.outputs['output'])  
    39.   
  
  
  
  39.     def run_file(self, image_file):  
    40.   
  
  
  
  40.         """  
    41.   
  
  
  
  41.         Args:  
    42.   
  
  
  
  42.             image_file: the input image file  
    43.   
  
  
  
  43.         Returns:  
    44.   
  
  
  
  44.         """  
    45.   
  
  
  
  45.         image = cv2.imread(image_file)  
    46.   
  
  
  
  46.         image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  
    47.   
  
  
  
  47.         return self.run(image)  
    48.   
  
  
  
  48. if __name__ == '__main__': 
    49.   
  
  
  
  49.      model = YourModel('192.168.0.3:8500')  
    50.   
  
  
  
  50.     test_file = './test.jpg'  
    51.   
  
  
  
  51.     result = model.run_file(test_file)  
    52.   
  
  
  
  52.     print(result)  
    53.   
  
  
  
  53.     # [8.014745e-05 9.999199e-01] 
    54.
  •  restful api调用: restful端口是8501 
 
 
 
 
    
  
  
  
  
  1. import cv2  
    2.   
  
  
  
  2. import requests  
    3.   
  
  
  
  3. class SelfEncoder(json.JSONEncoder):  
    4.   
  
  
  
  4.     def default(self, obj):  
    5.   
  
  
  
  5.         if isinstance(obj, np.ndarray):  
    6.   
  
  
  
  6.             return obj.tolist()  
    7.   
  
  
  
  7.         elif isinstance(obj, np.floating):  
    8.   
  
  
  
  8.             return float(obj)  
    9.   
  
  
  
  9.         elif isinstance(obj, bytes):  
    10.   
  
  
  
  10.             return str(obj, encoding='utf-8');  
    11.   
  
  
  
  11.         return json.JSONEncoder.default(self, obj)  
    12.   
  
  
  
  12. image_file = '/home/tfserving/test.jpg'  
    13.   
  
  
  
  13. image = cv2.imread(image_file)  
    14.   
  
  
  
  14. image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  
    15.   
  
  
  
  15. img = image[..., ::-1]  
    16.   
  
  
  
  16. input_data = {  
    17.   
  
  
  
  17.     "signature_name": "your_model",  
    18.   
  
  
  
  18.     "instances": img  
    19.   
  
  
  
  19. }  
    20.   
  
  
  
  20. data = json.dumps(input_data, cls=SelfEncoder, indent=None)  
    21.   
  
  
  
  21. result = requests.post("http://192.168.0.3:8501/v1/models/your_model:predict", datadata=data)  
    22.   
  
  
  
  22. eval(result .content)  
    23.   
  
  
  
  23. # {'predictions': [8.01474525e-05, 0.999919891]} 
    24.

5.总结

本文介绍了TFserving部署线上推理服务，从模型的转换，部署启动和调用推理，欢迎交流，希望对你有帮助。我们来回答下开篇提出的问题

  •  用什么来部署：当然是TFserving
  •  怎么提供api接口：TFserving有提供restful api接口，现实部署时会在前面再加一层如flask api
  •  多个模型GPU资源如何分配：TFserving支持部署多模型，通过配置
  •  线上模型如何更新而服务不中断：TFserving支持模型的不同的版本，如your_model中1和2两个版本，当你新增一个3模型时，TFserving会自动判断，自动加载模型3为当前模型，不需要重启 

网站名称：用TFserving部署深度学习模型
文章起源：http://www.shufengxianlan.com/qtweb/news8/378408.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站导航知识

各行业网站

成都网站设计公司　　 　柔性防护网　　 　合江网站建设　　 　广汉锦华橡塑　　 　画册设计制作　　 　四川电信机房托管　　 　眉山主机托管　　 　云主机　　 　SSL认证　　 　温江做网站　　 　边坡防护网厂家　　 　vi形象设计　　 　成都力比特　　 　企业网站建设　　 　简阳网站建设　　 　南充电信机房托管　　 　香港云服务器租用　　 　成都电信光华数据中心　　 　成都二枢电信服务器托管　　 　服务器租用