Merge pull request #404 from yinhaofeng/visualDL

visualDL

Author: seemingwang

doc/visualization.md

@@ -0,0 +1,70 @@
+# 可视化功能介绍
+PaddleRec通过飞桨生态的可视化分析工具VisualDL，支持将训练的过程可视化，让您清晰而直观的看到模型的训练效果。
+
+## 可视化功能的依赖
+可视化功能依赖飞桨生态的可视化分析工具VisualDL完成，如果需要开启这项功能需要先安装VisualDL。安装命令如下：
+```bash
+python -m pip install visualdl -i https://mirror.baidu.com/pypi/simple
+```
+
+## 开启可视化功能
+1. 在各模型的yaml配置文件中，runner项下添加新的参数“use_visual”，并将该项的值填写为True。该参数为bool类型，默认值为False，用于在安装VisualDL完成的情况下开启可视化训练。
+2. 在模型的dygraph_model.py文件中，可以通过train_forward函数的metrics_list, print_dict两个返回值来输出动态图运行时您需要打印的指标或变量。同理在模型的static_model.py文件中，可以通过net函数的fetch_dict返回值来输出静态图运行时您需要打印的指标。可视化功能会自动收集这些指标，并创建一个visualDL_log目录存放他们。
+3. 您可以正常的训练模型
+4. 启动VisualDL面板，有一下两种方法供您选择：
+
+使用命令行启动VisualDL面板，命令格式如下：
+```python
+visualdl --logdir <dir_1, dir_2, ... , dir_n> --model <model_file> --host <host> --port <port> --cache-timeout <cache_timeout> --language <language> --public-path <public_path> --api-only
+```
+
+参数详情：
+
+| 参数            | 意义                                                         |
+| --------------- | ------------------------------------------------------------ |
+| --logdir        | 设定日志所在目录，可以指定多个目录，VisualDL将遍历并且迭代寻找指定目录的子目录，将所有实验结果进行可视化 |
+| --model         | 设定模型文件路径(非文件夹路径)，VisualDL将在此路径指定的模型文件进行可视化，目前可支持PaddlePaddle、ONNX、Keras、Core ML、Caffe等多种模型结构，详情可查看[graph支持模型种类](./docs/components/README.md#%E5%8A%9F%E8%83%BD%E6%93%8D%E4%BD%9C%E8%AF%B4%E6%98%8E-2) |
+| --host          | 设定IP，默认为`127.0.0.1`，若想使得本机以外的机器访问启动的VisualDL面板，需指定此项为`0.0.0.0`或自己的公网IP地址                                    |
+| --port          | 设定端口，默认为`8040`                                       |
+| --cache-timeout | 后端缓存时间，在缓存时间内前端多次请求同一url，返回的数据从缓存中获取，默认为20秒 |
+| --language      | VisualDL面板语言，可指定为'en'或'zh'，默认为浏览器使用语言   |
+| --public-path   | VisualDL面板URL路径，默认是'/app'，即访问地址为'http://&lt;host&gt;:&lt;port&gt;/app' |
+| --api-only      | 是否只提供API，如果设置此参数，则VisualDL不提供页面展示，只提供API服务，此时API地址为'http://&lt;host&gt;:&lt;port&gt;/&lt;public_path&gt;/api'；若没有设置public_path参数，则默认为'http://&lt;host&gt;:&lt;port&gt;/api' |
+
+使用Python脚本启动VisualDL面板，接口如下：
+
+```python
+visualdl.server.app.run(logdir,
+                        model="path/to/model",
+                        host="127.0.0.1",
+                        port=8080,
+                        cache_timeout=20,
+                        language=None,
+                        public_path=None,
+                        api_only=False,
+                        open_browser=False)
+```
+
+请注意：除`logdir`外，其他参数均为不定参数，传递时请指明参数名。
+
+接口参数具体如下：
+
+| 参数          | 格式                                             | 含义                                                         |
+| ------------- | ------------------------------------------------ | ------------------------------------------------------------ |
+| logdir        | string或list[string_1, string_2, ... , string_n] | 日志文件所在的路径，VisualDL将在此路径下递归搜索日志文件并进行可视化，可指定单个或多个路径，每个路径中及其子目录中的日志都将视为独立日志展现在前端面板上 |
+| model         | string                                           | 模型文件路径(非文件夹路径)，VisualDL将在此路径指定的模型文件进行可视化，目前可支持PaddlePaddle、ONNX、Keras、Core ML、Caffe等多种模型结构，详情可查看[graph支持模型种类](./docs/components/README.md#%E5%8A%9F%E8%83%BD%E6%93%8D%E4%BD%9C%E8%AF%B4%E6%98%8E-2) |
+| host          | string                                           | 设定IP，默认为`127.0.0.1`，若想使得本机以外的机器访问启动的VisualDL面板，需指定此项为`0.0.0.0`或自己的公网IP地址                       |
+| port          | int                                              | 启动服务端口，默认为`8040`                                   |
+| cache_timeout | int                                              | 后端缓存时间，在缓存时间内前端多次请求同一url，返回的数据从缓存中获取，默认为20秒 |
+| language      | string                                           | VisualDL面板语言，可指定为'en'或'zh'，默认为浏览器使用语言   |
+| public_path   | string                                           | VisualDL面板URL路径，默认是'/app'，即访问地址为'http://&lt;host&gt;:&lt;port&gt;/app' |
+| api_only      | boolean                                          | 是否只提供API，如果设置此参数，则VisualDL不提供页面展示，只提供API服务，此时API地址为'http://&lt;host&gt;:&lt;port&gt;/&lt;public_path&gt;/api'；若没有设置public_path参数，则默认为'http://&lt;host&gt;:&lt;port&gt;/api' |
+| open_browser  | boolean                                          | 是否打开浏览器，设置为True则在启动后自动打开浏览器并访问VisualDL面板，若设置api_only，则忽略此参数 |
+
+5. 在使用任意一种方式启动VisualDL面板后，打开浏览器访问VisualDL面板，即可查看日志的可视化结果
+
+## 注意：
+1. 可视化功能依赖visualDL实现，请先安装最新版visualDL再开启yaml文件中的use_visual功能，不然会报错。
+2. 目前我们不支持静态图中dataset方式的可视化
+3. 目前可视化功能仅支持生成折线图，后续会逐步添加更多功能的可视化，敬请期待。
+4. 若对功能有疑问欢迎来用户群中交流：QQ群号码：861717190，微信小助手微信号：paddlerec2020

doc/yaml.md

@@ -20,6 +20,7 @@
 |             epochs            |    int    |                           >= 1                           |    是    |                       指定train阶段需要训练几个epoch                        |
 |             print_interval            |    int    |                           >= 1                           |    是    |                       训练指标打印batch间隔                        |
 |             use_auc            |    bool    |                           True/False                           |    否    |                       在每个epoch开始时重置auc指标的值                        |
+|             use_visual            |    bool    |                           True/False                           |    否    |                       开启模型训练的可视化功能，开启时需要安装visualDL                        |
 
 
 ## hyper_parameters变量

tools/infer.py

@@ -64,6 +64,7 @@ def main(args):
     config["config_abs_dir"] = args.abs_dir
     # tools.vars
     use_gpu = config.get("runner.use_gpu", True)
+    use_visual = config.get("runner.use_visual", False)
     test_data_dir = config.get("runner.test_data_dir", None)
     print_interval = config.get("runner.print_interval", None)
     model_load_path = config.get("runner.infer_load_path", "model_output")
@@ -72,15 +73,20 @@ def main(args):
 
     logger.info("**************common.configs**********")
     logger.info(
-        "use_gpu: {}, test_data_dir: {}, start_epoch: {}, end_epoch: {}, print_interval: {}, model_load_path: {}".
-        format(use_gpu, test_data_dir, start_epoch, end_epoch, print_interval,
-               model_load_path))
+        "use_gpu: {}, use_visual: {}, test_data_dir: {}, start_epoch: {}, end_epoch: {}, print_interval: {}, model_load_path: {}".
+        format(use_gpu, use_visual, test_data_dir, start_epoch, end_epoch,
+               print_interval, model_load_path))
     logger.info("**************common.configs**********")
 
     place = paddle.set_device('gpu' if use_gpu else 'cpu')
 
     dy_model = dy_model_class.create_model(config)
 
+    # Create a log_visual object and store the data in the path
+    if use_visual:
+        from visualdl import LogWriter
+        log_visual = LogWriter(args.abs_dir + "/visualDL_log/infer")
+
     # to do : add optimizer function
     #optimizer = dy_model_class.create_optimizer(dy_model, config)
 
@@ -92,6 +98,7 @@ def main(args):
     interval_begin = time.time()
 
     metric_list, metric_list_name = dy_model_class.create_metrics()
+    step_num = 0
 
     for epoch_id in range(start_epoch, end_epoch):
         logger.info("load model epoch {}".format(epoch_id))
@@ -110,18 +117,29 @@ def main(args):
                     for var_name, var in tensor_print_dict.items():
                         tensor_print_str += (
                             "{}:".format(var_name) + str(var.numpy()) + ",")
+                        if use_visual:
+                            log_visual.add_scalar(
+                                tag="infer/" + var_name,
+                                step=step_num,
+                                value=var.numpy())
                 metric_str = ""
                 for metric_id in range(len(metric_list_name)):
                     metric_str += (
                         metric_list_name[metric_id] +
                         ": {:.6f},".format(metric_list[metric_id].accumulate())
                     )
+                    if use_visual:
+                        log_visual.add_scalar(
+                            tag="infer/" + metric_list_name[metric_id],
+                            step=step_num,
+                            value=metric_list[metric_id].accumulate())
                 logger.info("epoch: {}, batch_id: {}, ".format(
                     epoch_id, batch_id) + metric_str + tensor_print_str +
                             " speed: {:.2f} ins/s".format(
                                 print_interval * batch_size / (time.time(
                                 ) - interval_begin)))
                 interval_begin = time.time()
+            step_num = step_num + 1
 
         metric_str = ""
         for metric_id in range(len(metric_list_name)):

tools/static_infer.py

@@ -24,7 +24,6 @@
 
 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, load_static_model
-
 import time
 import argparse
 
@@ -59,6 +58,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)
     auc_num = config.get("runner.auc_num", 1)
     test_data_dir = config.get("runner.test_data_dir", None)
     print_interval = config.get("runner.print_interval", None)
@@ -69,9 +69,9 @@ def main(args):
     os.environ["CPU_NUM"] = str(config.get("runner.thread_num", 1))
     logger.info("**************common.configs**********")
     logger.info(
-        "use_gpu: {}, test_data_dir: {}, start_epoch: {}, end_epoch: {}, print_interval: {}, model_load_path: {}".
-        format(use_gpu, test_data_dir, start_epoch, end_epoch, print_interval,
-               model_load_path))
+        "use_gpu: {}, use_visual: {}, test_data_dir: {}, start_epoch: {}, end_epoch: {}, print_interval: {}, model_load_path: {}".
+        format(use_gpu, use_visual, test_data_dir, start_epoch, end_epoch,
+               print_interval, model_load_path))
     logger.info("**************common.configs**********")
 
     place = paddle.set_device('gpu' if use_gpu else 'cpu')
@@ -82,6 +82,12 @@ def main(args):
     test_dataloader = create_data_loader(
         config=config, place=place, mode="test")
 
+    # Create a log_visual object and store the data in the path
+    if use_visual:
+        from visualdl import LogWriter
+        log_visual = LogWriter(args.abs_dir + "/visualDL_log/infer")
+    step_num = 0
+
     for epoch_id in range(start_epoch, end_epoch):
         logger.info("load model epoch {}".format(epoch_id))
         model_path = os.path.join(model_load_path, str(epoch_id))
@@ -104,12 +110,18 @@ def main(args):
                 for var_idx, var_name in enumerate(fetch_vars):
                     metric_str += "{}: {}, ".format(
                         var_name, fetch_batch_var[var_idx][0])
+                    if use_visual:
+                        log_visual.add_scalar(
+                            tag="infer/" + var_name,
+                            step=step_num,
+                            value=fetch_batch_var[var_idx][0])
                 logger.info("epoch: {}, batch_id: {}, ".format(
                     epoch_id, batch_id) + metric_str + "speed: {:.2f} ins/s".
                             format(print_interval * batch_size / (time.time(
                             ) - interval_begin)))
                 interval_begin = time.time()
             reader_start = time.time()
+            step_num = step_num + 1
 
         metric_str = ""
         for var_idx, var_name in enumerate(fetch_vars):

tools/static_trainer.py

@@ -62,6 +62,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)
     auc_num = config.get("runner.auc_num", 1)
     train_data_dir = config.get("runner.train_data_dir", None)
     epochs = config.get("runner.epochs", None)
@@ -73,8 +74,8 @@ def main(args):
     os.environ["CPU_NUM"] = str(config.get("runner.thread_num", 1))
     logger.info("**************common.configs**********")
     logger.info(
-        "use_gpu: {}, train_data_dir: {}, epochs: {}, print_interval: {}, model_save_path: {}".
-        format(use_gpu, train_data_dir, epochs, print_interval,
+        "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))
     logger.info("**************common.configs**********")
 
@@ -85,6 +86,14 @@ def main(args):
 
     last_epoch_id = config.get("last_epoch", -1)
 
+    # Create a log_visual object and store the data in the path
+    if use_visual:
+        from visualdl import LogWriter
+        log_visual = LogWriter(args.abs_dir + "/visualDL_log/train")
+    else:
+        log_visual = None
+    step_num = 0
+
     if reader_type == 'QueueDataset':
         dataset, file_list = get_reader(input_data, config)
     elif reader_type == 'DataLoader':
@@ -96,9 +105,9 @@ def main(args):
         if use_auc:
             reset_auc(auc_num)
         if reader_type == 'DataLoader':
-            fetch_batch_var = dataloader_train(epoch_id, train_dataloader,
-                                               input_data_names, fetch_vars,
-                                               exe, config)
+            fetch_batch_var, step_num = dataloader_train(
+                epoch_id, train_dataloader, input_data_names, fetch_vars, exe,
+                config, use_visual, log_visual, step_num)
             metric_str = ""
             for var_idx, var_name in enumerate(fetch_vars):
                 metric_str += "{}: {}, ".format(var_name,
@@ -139,7 +148,7 @@ def dataset_train(epoch_id, dataset, fetch_vars, exe, config):
 
 
 def dataloader_train(epoch_id, train_dataloader, input_data_names, fetch_vars,
-                     exe, config):
+                     exe, config, use_visual, log_visual, step_num):
     print_interval = config.get("runner.print_interval", None)
     batch_size = config.get("runner.train_batch_size", None)
     interval_begin = time.time()
@@ -162,6 +171,11 @@ def dataloader_train(epoch_id, train_dataloader, input_data_names, fetch_vars,
             for var_idx, var_name in enumerate(fetch_vars):
                 metric_str += "{}: {}, ".format(var_name,
                                                 fetch_batch_var[var_idx])
+                if use_visual:
+                    log_visual.add_scalar(
+                        tag="train/" + var_name,
+                        step=step_num,
+                        value=fetch_batch_var[var_idx])
             logger.info(
                 "epoch: {}, batch_id: {}, ".format(epoch_id,
                                                    batch_id) + metric_str +
@@ -174,7 +188,8 @@ def dataloader_train(epoch_id, train_dataloader, input_data_names, fetch_vars,
             train_run_cost = 0.0
             total_samples = 0
         reader_start = time.time()
-    return fetch_batch_var
+        step_num = step_num + 1
+    return fetch_batch_var, step_num
 
 
 if __name__ == "__main__":