add inference python

yinhaofeng · yinhaofeng · commit 0373178d6be3 · 2021-04-07T06:30:49.000Z
diff --git a/doc/inference.md b/doc/inference.md
@@ -0,0 +1,46 @@
+# Paddle Inference的使用方法
+paddlerec目前提供在静态图训练时使用save_inference_model接口保存模型，以及将保存的模型使用Inference预测库进行服务端部署的功能。本教程将以wide_deep模型为例，说明如何使用这两项功能。  
+
+## 使用save_inference_model接口保存模型
+在服务器端使用python部署需要先使用save_inference_model接口保存模型。  
+1. 首先需要在模型的yaml配置中，加入use_inference参数。use_inference决定是否使用save_inference_model接口保存模型，默认为否。若使用save_inference_model接口保存模型，保存下来的模型支持使用Paddle Inference的方法预测，但不支持直接使用paddlerec原生的的预测方法加载模型。  
+2. 确定需要的输入和输出的预测模型变量，将其变量名以字符串的形式填入save_inference_feed_varnames和save_inference_fetch_varnames列表中。  
+以wide_deep模型为例，可以在其config.yaml文件中观察到如下结构。训练及测试数据集选用[Display Advertising Challenge](https://www.kaggle.com/c/criteo-display-ad-challenge/)所用的Criteo数据集。该数据集包括两部分：训练集和测试集。训练集包含一段时间内Criteo的部分流量，测试集则对应训练数据后一天的广告点击流量。feed参数的名字中```<label>```表示广告是否被点击，点击用1表示，未点击用0表示，```<integer feature>```代表数值特征（连续特征dense_input），共有13个连续特征，```<categorical feature>```代表分类特征（离散特征C1~C26），共有26个离散特征。fetch参数输出的是auc，具体意义为static_model.py里def net（）函数中将auc使用cast转换为float32类型语句中的cast算子。  
+```yaml
+runner:
+  # 通用配置不再赘述
+  ...
+  # use inference save model
+  use_inference: True  # 静态图训练时保存为inference model
+  save_inference_feed_varnames: ["label","C1","C2","C3","C4","C5","C6","C7","C8","C9","C10","C11","C12","C13","C14","C15","C16","C17","C18","C19","C20","C21","C22","C23","C24","C25","C26","dense_input"] # inference model 的feed参数的名字
+  save_inference_fetch_varnames: ["cast_0.tmp_0"] # inference model 的fetch参数的名字
+```
+3. 启动静态图训练
+```bash
+# 进入模型目录
+# cd models/rank/wide_deep # 在任意目录均可运行
+# 静态图训练
+python -u ../../../tools/static_trainer.py -m config.yaml # 全量数据运行config_bigdata.yaml 
+```
+
+## 将保存的模型使用Inference预测库进行服务端部署
+paddlerec提供tools/paddle_infer.py脚本，供您方便的使用inference预测库高效的对模型进行预测。  
+
+1. 启动paddle_infer.py脚本的参数：
+
+|        名称         |    类型    |             取值             | 是否必须 |                               作用描述                               |
+| :-----------------: | :-------: | :--------------------------: | :-----: | :------------------------------------------------------------------: |
+|       --model_file        |    string    |       任意路径         |    是    |                            模型文件路径（当需要从磁盘加载 Combined 模型时使用）                           |
+|       --params_file        |    string    |       任意路径         |    是    |                            参数文件路径 （当需要从磁盘加载 Combined 模型时使用）                           |
+|       --model_dir        |    string    |       任意路径         |    是    |                            模型文件夹路径 （当需要从磁盘加载非 Combined 模型时使用）                           |
+|       --use_gpu        |    bool    |       True/False         |    是    |                            是否使用gpu                            |
+|       --data_dir        |    string    |       任意路径         |    是    |                            测试数据目录                            |
+|       --reader_file        |    string    |       任意路径         |    是    |                          测试时用的Reader()所在python文件地址                            |
+|       --batchsize        |    int    |       >= 1         |    是    |                            批训练样本数量                            |
+
+2. 以wide_deep模型的demo数据为例，启动预测：
+```bash
+# 进入模型目录
+# cd models/rank/wide_deep # 在任意目录均可运行
+python -u ../../../tools/paddle_infer.py --model_file=output_model_wide_deep/2/rec_inference.pdmodel --params_file=output_model_wide_deep/2/rec_inference.pdiparams --use_gpu=False --data_dir=data/sample_data/train --reader_file=criteo_reader.py --batchsize=5
+```
diff --git a/doc/yaml.md b/doc/yaml.md
@@ -21,6 +21,9 @@
 |             print_interval            |    int    |                           >= 1                           |    是    |                       训练指标打印batch间隔                        |
 |             use_auc            |    bool    |                           True/False                           |    否    |                       在每个epoch开始时重置auc指标的值                        |
 |             use_visual            |    bool    |                           True/False                           |    否    |                       开启模型训练的可视化功能，开启时需要安装visualDL                        |
+|             use_inference            |    bool    |                           True/False                           |    否    |                     是否使用save_inference_model接口保存                      |
+|             save_inference_feed_varnames         |    list[string]    |                      组网中指定Variable的name                      |    否    |                     预测模型的入口变量name                     |
+|             save_inference_fetch_varnames         |    list[string]    |                      组网中指定Variable的name                      |    否    |                     预测模型的出口变量name                     |
 
 
 ## hyper_parameters变量
diff --git a/models/rank/wide_deep/config.yaml b/models/rank/wide_deep/config.yaml
@@ -28,8 +28,12 @@ runner:
   infer_reader_path: "criteo_reader" # importlib format
   infer_batch_size: 5
   infer_load_path: "output_model_wide_deep"
-  infer_start_epoch: 0
+  infer_start_epoch: 2
   infer_end_epoch: 3
+  #use inference save model
+  use_inference: True
+  save_inference_feed_varnames: ["label","C1","C2","C3","C4","C5","C6","C7","C8","C9","C10","C11","C12","C13","C14","C15","C16","C17","C18","C19","C20","C21","C22","C23","C24","C25","C26","dense_input"]
+  save_inference_fetch_varnames: ["cast_0.tmp_0"]
 
 # hyper parameters of user-defined network
 hyper_parameters:
diff --git a/models/rank/wide_deep/static_model.py b/models/rank/wide_deep/static_model.py
@@ -84,6 +84,7 @@ def net(self, input, is_infer=False):
                                               label=self.label_input,
                                               num_thresholds=2**12,
                                               slide_steps=20)
+        auc = paddle.cast(auc, "float32")
         self.inference_target_var = auc
         if is_infer:
             fetch_dict = {'auc': auc}
diff --git a/tools/paddle_infer.py b/tools/paddle_infer.py
@@ -0,0 +1,97 @@
+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import paddle
+import os
+import paddle.nn as nn
+import numpy as np
+import time
+import logging
+import sys
+from importlib import import_module
+__dir__ = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(os.path.abspath(os.path.join(__dir__, '..')))
+from utils.utils_single import load_yaml, load_dy_model_class, get_abs_model
+from utils.save_load import save_model, load_model
+from paddle.io import DistributedBatchSampler, DataLoader
+import argparse
+from paddle.inference import Config
+from paddle.inference import create_predictor
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_file", type=str)
+    parser.add_argument("--params_file", type=str)
+    parser.add_argument("--model_dir", type=str)
+    parser.add_argument("--use_gpu", type=bool)
+    parser.add_argument("--data_dir", type=str)
+    parser.add_argument("--reader_file", type=str)
+    parser.add_argument("--batchsize", type=int)
+    args = parser.parse_args()
+    return args
+
+
+def init_predictor(args):
+    if args.model_dir:
+        config = Config(args.model_dir)
+    else:
+        config = Config(args.model_file, args.params_file)
+
+    if args.use_gpu:
+        config.enable_use_gpu(1000, 0)
+    else:
+        config.disable_gpu()
+    predictor = create_predictor(config)
+    return predictor
+
+
+def create_data_loader(args):
+    data_dir = args.data_dir
+    reader_file = args.reader_file.split(".")[0]
+    batchsize = args.batchsize
+    place = args.place
+    file_list = [os.path.join(data_dir, x) for x in os.listdir(data_dir)]
+    sys.path.append(os.path.abspath("."))
+    reader_class = import_module(reader_file)
+    dataset = reader_class.RecDataset(file_list, config=None)
+    loader = DataLoader(
+        dataset, batch_size=batchsize, places=place, drop_last=True)
+    return loader
+
+
+def main(args):
+    predictor = init_predictor(args)
+    place = paddle.set_device('gpu' if args.use_gpu else 'cpu')
+    args.place = place
+    input_names = predictor.get_input_names()
+    output_names = predictor.get_output_names()
+    test_dataloader = create_data_loader(args)
+    for batch_id, batch_data in enumerate(test_dataloader):
+        name_data_pair = dict(zip(input_names, batch_data))
+        for name in input_names:
+            input_tensor = predictor.get_input_handle(name)
+            input_tensor.copy_from_cpu(name_data_pair[name].numpy())
+        predictor.run()
+        results = []
+        for name in output_names:
+            output_tensor = predictor.get_output_handle(name)
+            output_data = output_tensor.copy_to_cpu()[0]
+            results.append(output_data)
+        print(results)
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    main(args)
diff --git a/tools/static_trainer.py b/tools/static_trainer.py
@@ -24,7 +24,7 @@
 
 from utils.static_ps.reader_helper import get_reader
 from utils.utils_single import load_yaml, load_static_model_class, get_abs_model, create_data_loader, reset_auc
-from utils.save_load import save_static_model
+from utils.save_load import save_static_model, save_inference_model
 
 import time
 import argparse
@@ -36,6 +36,7 @@
 def parse_args():
     parser = argparse.ArgumentParser("PaddleRec train static script")
     parser.add_argument("-m", "--config_yaml", type=str)
+    parser.add_argument("-o", "--opt", nargs='*', type=str)
     args = parser.parse_args()
     args.abs_dir = os.path.dirname(os.path.abspath(args.config_yaml))
     args.config_yaml = get_abs_model(args.config_yaml)
@@ -49,6 +50,12 @@ def main(args):
     config = load_yaml(args.config_yaml)
     config["yaml_path"] = args.config_yaml
     config["config_abs_dir"] = args.abs_dir
+    # modify config from command
+    if args.opt:
+        for parameter in args.opt:
+            parameter = parameter.strip()
+            key, value = parameter.split("=")
+            config[key] = value
     # load static model class
     static_model_class = load_static_model_class(config)
 
@@ -63,6 +70,7 @@ def main(args):
     use_gpu = config.get("runner.use_gpu", True)
     use_auc = config.get("runner.use_auc", False)
     use_visual = config.get("runner.use_visual", False)
+    use_inference = config.get("runner.use_inference", False)
     auc_num = config.get("runner.auc_num", 1)
     train_data_dir = config.get("runner.train_data_dir", None)
     epochs = config.get("runner.epochs", None)
@@ -74,9 +82,9 @@ def main(args):
     os.environ["CPU_NUM"] = str(config.get("runner.thread_num", 1))
     logger.info("**************common.configs**********")
     logger.info(
-        "use_gpu: {}, use_visual: {}, train_data_dir: {}, epochs: {}, print_interval: {}, model_save_path: {}".
-        format(use_gpu, use_visual, train_data_dir, epochs, print_interval,
-               model_save_path))
+        "use_gpu: {}, use_visual: {}, train_batch_size: {}, train_data_dir: {}, epochs: {}, print_interval: {}, model_save_path: {}".
+        format(use_gpu, use_visual, batch_size, train_data_dir, epochs,
+               print_interval, model_save_path))
     logger.info("**************common.configs**********")
 
     place = paddle.set_device('gpu' if use_gpu else 'cpu')
@@ -124,11 +132,44 @@ def main(args):
         else:
             logger.info("reader type wrong")
 
-        save_static_model(
-            paddle.static.default_main_program(),
-            model_save_path,
-            epoch_id,
-            prefix='rec_static')
+        if use_inference:
+            feed_var_names = config.get("runner.save_inference_feed_varnames",
+                                        [])
+            feedvars = []
+            fetch_var_names = config.get(
+                "runner.save_inference_fetch_varnames", [])
+            fetchvars = []
+            for var_name in feed_var_names:
+                if var_name not in paddle.static.default_main_program(
+                ).global_block().vars:
+                    raise ValueError(
+                        "Feed variable: {} not in default_main_program, global block has follow vars: {}".
+                        format(var_name,
+                               paddle.static.default_main_program()
+                               .global_block().vars.keys()))
+                else:
+                    feedvars.append(paddle.static.default_main_program()
+                                    .global_block().vars[var_name])
+            for var_name in fetch_var_names:
+                if var_name not in paddle.static.default_main_program(
+                ).global_block().vars:
+                    raise ValueError(
+                        "Fetch variable: {} not in default_main_program, global block has follow vars: {}".
+                        format(var_name,
+                               paddle.static.default_main_program()
+                               .global_block().vars.keys()))
+                else:
+                    fetchvars.append(paddle.static.default_main_program()
+                                     .global_block().vars[var_name])
+
+            save_inference_model(model_save_path, epoch_id, feedvars,
+                                 fetchvars, exe)
+        else:
+            save_static_model(
+                paddle.static.default_main_program(),
+                model_save_path,
+                epoch_id,
+                prefix='rec_static')
 
 
 def dataset_train(epoch_id, dataset, fetch_vars, exe, config):
@@ -179,7 +220,7 @@ def dataloader_train(epoch_id, train_dataloader, input_data_names, fetch_vars,
             logger.info(
                 "epoch: {}, batch_id: {}, ".format(epoch_id,
                                                    batch_id) + metric_str +
-                "avg_reader_cost: {:.5f} sec, avg_batch_cost: {:.5f} sec, avg_samples: {:.5f}, ips: {:.5f} images/sec".
+                "avg_reader_cost: {:.5f} sec, avg_batch_cost: {:.5f} sec, avg_samples: {:.5f}, ips: {:.5f} ins/s".
                 format(train_reader_cost / print_interval, (
                     train_reader_cost + train_run_cost) / print_interval,
                        total_samples / print_interval, total_samples / (
diff --git a/tools/utils/save_load.py b/tools/utils/save_load.py
@@ -61,6 +61,25 @@ def save_static_model(program, model_path, epoch_id, prefix='rec_static'):
     logger.info("Already save model in {}".format(model_path))
 
 
+def save_inference_model(model_path,
+                         epoch_id,
+                         feed_vars,
+                         fetch_vars,
+                         exe,
+                         prefix='rec_inference'):
+    """
+    save inference model to target path
+    """
+    model_path = os.path.join(model_path, str(epoch_id))
+    _mkdir_if_not_exist(model_path)
+    model_prefix = os.path.join(model_path, prefix)
+    paddle.static.save_inference_model(
+        path_prefix=model_prefix,
+        feed_vars=feed_vars,
+        fetch_vars=fetch_vars,
+        executor=exe)
+
+
 def load_static_model(program, model_path, prefix='rec_static'):
     logger.info("start load model from {}".format(model_path))
     model_prefix = os.path.join(model_path, prefix)
