Merge pull request #484 from yinhaofeng/benchmark

benchmark

Author: seemingwang

models/rank/deepfm/config.yaml

@@ -16,21 +16,26 @@
 runner:
   train_data_dir: "data/sample_data/train"
   train_reader_path: "criteo_reader" # importlib format
-  use_gpu: True
+  use_gpu: False
   use_auc: True
   train_batch_size: 2
   epochs: 3
   print_interval: 2
-  #model_init_path: "output_model/0" # init model
+  # model_init_path: "output_model_deepfm/2" # init model
   model_save_path: "output_model_deepfm"
   test_data_dir: "data/sample_data/train"
   infer_reader_path: "criteo_reader" # importlib format
   infer_batch_size: 5
   infer_load_path: "output_model_deepfm"
   infer_start_epoch: 0
   infer_end_epoch: 3
-
-
+  #use inference save model
+  use_inference: False
+  save_inference_feed_varnames: ["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: ["sigmoid_0.tmp_0"]
+  # use fleet
+  use_fleet: False
+  
 # hyper parameters of user-defined network
 hyper_parameters:
   # optimizer config

models/rank/deepfm/criteo_reader.py

@@ -14,14 +14,33 @@
 
 from __future__ import print_function
 import numpy as np
-
+import paddle
 from paddle.io import IterableDataset
 
 
 class RecDataset(IterableDataset):
     def __init__(self, file_list, config):
         super(RecDataset, self).__init__()
         self.file_list = file_list
+        if config:
+            use_fleet = config.get("runner.use_fleet", False)
+            self.inference = config.get("runner.inference", False)
+        else:
+            use_fleet = False
+        if use_fleet:
+            worker_id = paddle.distributed.get_rank()
+            worker_num = paddle.distributed.get_world_size()
+            file_num = len(file_list)
+            if file_num < worker_num:
+                raise ValueError(
+                    "The number of data files is less than the number of workers"
+                )
+            blocksize = int(file_num / worker_num)
+            self.file_list = file_list[worker_id * blocksize:(worker_id + 1) *
+                                       blocksize]
+            remainder = file_num - (blocksize * worker_num)
+            if worker_id < remainder:
+                self.file_list.append(file_list[-(worker_id + 1)])
         self.init()
 
     def init(self):
@@ -78,4 +97,7 @@ def __iter__(self):
                     output_list.append(
                         np.array(output[-1][1]).astype("float32"))
                     # list
-                    yield output_list
+                    if self.inference:
+                        yield output_list[1:]
+                    else:
+                        yield output_list

models/rank/wide_deep/config.yaml

@@ -20,16 +20,16 @@ runner:
   use_gpu: False
   use_auc: True
   train_batch_size: 50
-  epochs: 3
+  epochs: 4
   print_interval: 2
-  # model_init_path: "output_model_wide_deep/2" # init model
+  # model_init_path: "models/rank/wide_deep/output_model_wide_deep/2" # init model
   model_save_path: "output_model_wide_deep"
   test_data_dir: "data/sample_data/train"
   infer_reader_path: "criteo_reader" # importlib format
   infer_batch_size: 5
   infer_load_path: "output_model_wide_deep"
-  infer_start_epoch: 2
-  infer_end_epoch: 3
+  infer_start_epoch: 3
+  infer_end_epoch: 4
   #use inference save model
   use_inference: False
   save_inference_feed_varnames: ["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"]

models/rank/wide_deep/config_bigdata.yaml

@@ -15,7 +15,7 @@
 # global settings 
 
 runner:
-    #train_data_dir: "data/slot_train_data_full"
+  #train_data_dir: "data/slot_train_data_full"
   train_data_dir: "../../../datasets/criteo/slot_train_data_full"
   train_reader_path: "criteo_reader" # importlib format
   use_gpu: True
@@ -29,8 +29,14 @@ runner:
   infer_reader_path: "criteo_reader" # importlib format
   infer_batch_size: 512
   infer_load_path: "output_model_all_wide_deep"
-  infer_start_epoch: 0
+  infer_start_epoch: 3
   infer_end_epoch: 4
+  #use inference save model
+  use_inference: False
+  save_inference_feed_varnames: ["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: ["sigmoid_0.tmp_0"]
+  #use fleet
+  use_fleet: False
 
 # hyper parameters of user-defined network
 hyper_parameters:

tools/paddle_infer.py

@@ -19,19 +19,16 @@
 import time
 import logging
 import sys
+import re
 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 utils.benchmark_utils import PaddleInferBenchmark
 from paddle.io import DistributedBatchSampler, DataLoader
 import argparse
 from paddle.inference import Config
 from paddle.inference import create_predictor
-import pynvml
-import psutil
-import GPUtil
 
 
 def parse_args():
@@ -47,18 +44,35 @@ def parse_args():
     parser.add_argument("--cpu_threads", type=int, default=1)
     parser.add_argument("--enable_mkldnn", type=str, default="False")
     parser.add_argument("--enable_tensorRT", type=str, default="False")
+    parser.add_argument("--benchmark", type=str, default="True")
+    parser.add_argument("--save_log_path", type=str, default="./output")
+    parser.add_argument("--precision", type=str)
     args = parser.parse_args()
     args.use_gpu = (True if args.use_gpu.lower() == "true" else False)
     args.enable_mkldnn = (True
                           if args.enable_mkldnn.lower() == "true" else False)
     args.enable_tensorRT = (True if args.enable_tensorRT.lower() == "true" else
                             False)
+    args.benchmark = (True if args.benchmark.lower() == "true" else False)
     return args
 
 
 def init_predictor(args):
     if args.model_dir:
-        config = Config(args.model_dir)
+        has_model = 0
+        pdmodel_name = 0
+        pdiparams_name = 0
+        for file_name in os.listdir(args.model_dir):
+            if re.search("__model__", file_name):
+                has_model = 1
+            if file_name.endswith(".pdmodel"):
+                pdmodel_name = os.path.join(args.model_dir, file_name)
+            if file_name.endswith(".pdiparams"):
+                pdiparams_name = os.path.join(args.model_dir, file_name)
+        if has_model == 1:
+            config = Config(args.model_dir)
+        elif pdmodel_name and pdiparams_name:
+            config = Config(pdmodel_name, pdiparams_name)
     else:
         config = Config(args.model_file, args.params_file)
 
@@ -67,7 +81,7 @@ def init_predictor(args):
         if args.enable_tensorRT:
             config.enable_tensorrt_engine(
                 max_batch_size=args.batchsize,
-                min_subgraph_size=1,
+                min_subgraph_size=9,
                 precision_mode=paddle.inference.PrecisionType.Float32)
     else:
         config.disable_gpu()
@@ -89,122 +103,64 @@ def create_data_loader(args):
     sys.path.append(reader_path)
     #sys.path.append(os.path.abspath("."))
     reader_class = import_module(reader_file)
-    config = {"inference": True}
+    config = {"runner.inference": True}
     dataset = reader_class.RecDataset(file_list, config=config)
     loader = DataLoader(
         dataset, batch_size=batchsize, places=place, drop_last=True)
     return loader
 
 
-class Times(object):
-    def __init__(self):
-        self.time = 0.
-        self.st = 0.
-        self.et = 0.
-
-    def start(self):
-        self.st = time.time()
-
-    def end(self, accumulative=True):
-        self.et = time.time()
-        if accumulative:
-            self.time += self.et - self.st
-        else:
-            self.time = self.et - self.st
-
-    def reset(self):
-        self.time = 0.
-        self.st = 0.
-        self.et = 0.
-
-    def value(self):
-        return round(self.time, 4)
-
-
-def get_current_memory_mb(gpu_id=None):
-    pid = os.getpid()
-    p = psutil.Process(pid)
-    info = p.memory_full_info()
-    cpu_mem = info.uss / 1024. / 1024.
-    gpu_mem = 0
-    gpu_precent = 0
-    if gpu_id is not None:
-        GPUs = GPUtil.getGPUs()
-        gpu_load = GPUs[gpu_id].load
-        gpu_precent = gpu_load
-        pynvml.nvmlInit()
-        handle = pynvml.nvmlDeviceGetHandleByIndex(0)
-        meminfo = pynvml.nvmlDeviceGetMemoryInfo(handle)
-        gpu_mem = meminfo.used / 1024. / 1024.
-    return cpu_mem, gpu_mem, gpu_precent
-
-
 def main(args):
     predictor, pred_config = 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)
-    preprocess_time = Times()
-    inference_time = Times()
-    postprocess_time = Times()
-    cpu_mem, gpu_mem = 0, 0
-    gpu_id = 0
-    gpu_util = 0
+
+    if args.benchmark:
+        import auto_log
+        pid = os.getpid()
+        autolog = auto_log.AutoLogger(
+            model_name=args.model_name,
+            model_precision=args.precision,
+            batch_size=args.batchsize,
+            data_shape="dynamic",
+            save_path=args.save_log_path,
+            inference_config=pred_config,
+            pids=pid,
+            process_name=None,
+            gpu_ids=0,
+            time_keys=[
+                'preprocess_time', 'inference_time', 'postprocess_time'
+            ])
+
     for batch_id, batch_data in enumerate(test_dataloader):
         name_data_pair = dict(zip(input_names, batch_data))
-        preprocess_time.start()
+        if args.benchmark:
+            autolog.times.start()
         for name in input_names:
             input_tensor = predictor.get_input_handle(name)
             input_tensor.copy_from_cpu(name_data_pair[name].numpy())
-        preprocess_time.end(accumulative=True)
-        inference_time.start()
+        if args.benchmark:
+            autolog.times.stamp()
         predictor.run()
         for name in output_names:
             output_tensor = predictor.get_output_handle(name)
             output_data = output_tensor.copy_to_cpu()
-        inference_time.end(accumulative=True)
         results = []
         results_type = []
-        postprocess_time.start()
+        if args.benchmark:
+            autolog.times.stamp()
         for name in output_names:
             results_type.append(output_tensor.type())
             results.append(output_data[0])
-        postprocess_time.end(accumulative=True)
-        cm, gm, gu = get_current_memory_mb(gpu_id)
-        cpu_mem += cm
-        gpu_mem += gm
-        gpu_util += gu
+        if args.benchmark:
+            autolog.times.end(stamp=True)
         print(results)
 
-    num_test_data = args.batchsize * (batch_id + 1)
-    average_preprocess_time = preprocess_time.value() / (batch_id + 1)
-    average_inference_time = inference_time.value() / (batch_id + 1)
-    average_postprocess_time = postprocess_time.value() / (batch_id + 1)
-    cpu_rss = cpu_mem / (batch_id + 1)
-    gpu_rss = gpu_mem / (batch_id + 1)
-    gpu_util = gpu_util / (batch_id + 1)
-
-    perf_info = {
-        'inference_time_s': average_inference_time,
-        'preprocess_time_s': average_preprocess_time,
-        'postprocess_time_s': average_postprocess_time
-    }
-    model_info = {'model_name': args.model_name, 'precision': "fp32"}
-    data_info = {
-        'batch_size': args.batchsize,
-        'shape': "dynamic_shape",
-        'data_num': num_test_data
-    }
-    resource_info = {
-        'cpu_rss_mb': cpu_rss,
-        'gpu_rss_mb': gpu_rss,
-        'gpu_util': gpu_util
-    }
-    rec_log = PaddleInferBenchmark(pred_config, model_info, data_info,
-                                   perf_info, resource_info)
-    rec_log('Rec')
+    if args.benchmark:
+        autolog.report()
 
 
 if __name__ == '__main__':

tools/to_static.py

@@ -37,6 +37,7 @@
 def parse_args():
     parser = argparse.ArgumentParser(description='paddle-rec run')
     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,17 @@ def main(args):
     config = load_yaml(args.config_yaml)
     dy_model_class = load_dy_model_class(args.abs_dir)
     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("=")
+            if type(config.get(key)) is int:
+                value = int(value)
+            if type(config.get(key)) is bool:
+                value = (True if value.lower() == "true" else False)
+            config[key] = value
+
     # tools.vars
     use_gpu = config.get("runner.use_gpu", True)
     train_data_dir = config.get("runner.train_data_dir", None)