Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

通知 7
Star 2
Fork 0
F
FluidDoc
未验证 提交 2c2c20d8 编写于 作者: Y YixinKristy 提交者： GitHub
浏览文件
操作

update vdl2.0=document_preview (#2315)

上级 26019f3e
隐藏空白更改
内联 并排
Showing with 738 addition and 583 deletion
doc/fluid/user_guides/howto/evaluation_and_debugging/debug/visualdl.md
浏览文件 @ 2c2c20d8
# VisualDL 工具简介
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/docs/images/vs-logo.png" width="60%" />
<img src="http://visualdl.bj.bcebos.com/images/vdl-logo.png" width="70%"/>
</p>
## 介绍
VisualDL是一个面向深度学习任务设计的可视化工具，包含了scalar、参数分布、模型结构、图像可视化等功能，项目正处于高速迭代中，新的组件会不断加入。
目前大多数DNN平台均使用Python作为配置语言，VisualDL原生支持python的使用，
通过在模型的Python配置中添加几行，便可以为训练过程提供丰富的可视化支持。
VisualDL是飞桨可视化分析工具，以丰富的图表呈现训练参数变化趋势、模型结构、数据样本、直方图、PR曲线及高维数据分布。可帮助用户更清晰直观地理解深度学习模型训练过程及模型结构，进而实现高效的模型优化。
除了Python SDK之外，VisualDL底层采用C++编写，其暴露的C++ SDK也可以集成到其他平台中，
实现原生的性能和定制效果。
具体功能使用方式请参见**VisualDL使用指南**。项目正处于高速迭代中，敬请期待新组件的加入。
## 组件
VisualDL 目前支持以下组件：
VisualDL支持浏览器种类：Chrome（81和83）、Safari 13、FireFox（77和78）、Edge（Chromium版）。
- scalar
- histogram
- image
- audio
- graph
- high dimensional
VisualDL原生支持python的使用， 通过在模型的Python配置中添加几行代码，便可为训练过程提供丰富的可视化支持。
### Scalar
可以用于展示训练测试的误差趋势
<p align="center">
<img src="https://raw.githubusercontent.com/daming-lu/large_files/master/loss_scalar.gif" width="60%"/>
</p>
### Histogram
## 目录
用于可视化任何tensor中元素分布的变化趋势
* [核心亮点](#核心亮点)
* [安装方式](#安装方式)
* [使用方式](#使用方式)
* [可视化功能概览](#可视化功能概览)
* [开源贡献](#开源贡献)
* [更多细节](#更多细节)
* [技术交流](#技术交流)
<p align="center">
<img src="https://raw.githubusercontent.com/daming-lu/large_files/master/histogram.gif" width="60%"/>
</p>
### Image
可以用于可视化任何tensor，或模型生成的图片
<p align="center">
<img src="https://raw.githubusercontent.com/daming-lu/large_files/master/loss_image.gif" width="60%"/>
</p>
## 核心亮点
### Audio
可用于播放输入或生成的音频样本
### 简单易用
### Graph
API设计简洁易懂，使用简单。模型结构一键实现可视化。
VisualDL的graph支持paddle program的展示，同时兼容 ONNX(Open Neural Network Exchange)[https://github.com/onnx/onnx]，通过与 python SDK的结合，VisualDL可以兼容包括 PaddlePaddle, pytorch, mxnet在内的大部分主流DNN平台。
### 功能丰富
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/docs/images/graph_demo.gif" width="60%" />
</p>
功能覆盖标量、数据样本、图结构、直方图、PR曲线及数据降维可视化。
要进行paddle模型的展示，需要进行以下两步操作：
### 高兼容性
1. 在paddle代码中，调用`fluid.io.save_inference_model()`接口保存模型
2. 在命令行界面，使用`visualdl --model_pb [paddle_model_dir]` 加载paddle模型
全面支持Paddle、ONNX、Caffe等市面主流模型结构可视化，广泛支持各类用户进行可视化分析。
### 全面支持
### High Dimensional
用高维度数据映射在2D/3D来可视化嵌入
与飞桨服务平台及工具组件全面打通，为您在飞桨生态系统中提供最佳使用体验。
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/docs/getting_started/high_dimensional_3d.png" width="60%"/>
</p>
## 快速尝试
请使用下面的命令，来快速测试 VisualDL。
## 安装方式
### 使用pip安装
```shell
pip install --upgrade --pre visualdl
```
# 安装，建議是在虚拟环境或anaconda下。
pip install --upgrade visualdl
# 运行一个例子，vdl_create_scratch_log 将创建测试日志
vdl_create_scratch_log
visualdl --logdir=scratch_log --port=8080
### 使用代码安装
# 访问 http://127.0.0.1:8080
```
git clone https://github.com/PaddlePaddle/VisualDL.git
cd VisualDL
如果出现`TypeError: __init__() got an unexpected keyword argument 'file'`, 是因为protobuf不是3.5以上，运行`pip install --upgrade protobuf`就能解决。
python setup.py bdist_wheel
pip install --upgrade dist/visualdl-*.whl
```
需要注意，官方自2020年1月1日起不再维护Python2，为了保障代码可用性，VisualDL现仅支持Python3
如果以上步骤还有出现其他问题，很可能是因为python或pip不同版本或不同位置所致，以下安装方法能解决。
## 使用方式
## 使用 virtualenv 安装
VisualDL将训练过程中的数据、参数等信息储存至日志文件中后，启动面板即可查看可视化结果。
[Virtualenv](https://virtualenv.pypa.io/en/stable/) 能创建独立Python环境，也能确保Python和pip的相对位置正确。
### 1. 记录日志
在macOS上，安装pip和virtualenv如下：
```
sudo easy_install pip
pip install --upgrade virtualenv
```
VisualDL的后端提供了Python SDK，可通过LogWriter定制一个日志记录器，接口如下：
在Linux上，安装pip和virtualenv如下:
```
sudo apt-get install python3-pip python3-dev python-virtualenv
```python
class LogWriter(logdir=None,
comment='',
max_queue=10,
flush_secs=120,
filename_suffix='',
write_to_disk=True,
**kwargs)
```
然后创建一个虚拟环境：
#### 接口参数
| 参数 | 格式 | 含义 |
| --------------- | ------- | ------------------------------------------------------------ |
| logdir | string | 日志文件所在的路径，VisualDL将在此路径下建立日志文件并进行记录，如果不填则默认为`runs/${CURRENT_TIME}` |
| comment | string | 为日志文件夹名添加后缀，如果制定了logdir则此项无效 |
| max_queue | int | 日志记录消息队列的最大容量，达到此容量则立即写入到日志文件 |
| flush_secs | int | 日志记录消息队列的最大缓存时间，达到此时间则立即写入到日志文件 |
| filename_suffix | string | 为默认的日志文件名添加后缀 |
| write_to_disk | boolean | 是否写入到磁盘 |
#### 示例
设置日志文件并记录标量数据：
```python
from visualdl import LogWriter
# 在`./log/scalar_test/train`路径下建立日志文件
with LogWriter(logdir="./log/scalar_test/train") as writer:
# 使用scalar组件记录一个标量数据
writer.add_scalar(tag="acc", step=1, value=0.5678)
writer.add_scalar(tag="acc", step=2, value=0.6878)
writer.add_scalar(tag="acc", step=3, value=0.9878)
```
virtualenv ~/vdl # for Python2.7
virtualenv -p python3 ~/vdl for Python 3.x
### 2. 启动面板
在上述示例中，日志已记录三组标量数据，现可启动VisualDL面板查看日志的可视化结果，共有两种启动方式：
#### 在命令行启动
使用命令行启动VisualDL面板，命令格式如下：
```python
visualdl --logdir <dir_1, dir_2, ... , dir_n> --host <host> --port <port> --cache-timeout <cache_timeout> --language <language> --public-path <public_path> --api-only
```
```~/vdl``` 是你的Virtualenv目录, 你也可以选择任一目录。
参数详情：
| 参数 | 意义 |
| --------------- | ------------------------------------------------------------ |
| --logdir | 设定日志所在目录，可以指定多个目录，VisualDL将遍历并且迭代寻找指定目录的子目录，将所有实验结果进行可视化 |
| --model | 设定模型文件路径(非文件夹路径)，VisualDL将在此路径指定的模型文件进行可视化，目前可支持PaddlePaddle、ONNX、Keras、Core ML、Caffe等多种模型结构，详情可查看[graph支持模型种类]([https://github.com/PaddlePaddle/VisualDL/blob/develop/docs/components/README.md#Graph--%E7%BD%91%E7%BB%9C%E7%BB%93%E6%9E%84%E7%BB%84%E4%BB%B6](https://github.com/PaddlePaddle/VisualDL/blob/develop/docs/components/README.md#Graph--网络结构组件)) |
| --host | 设定IP，默认为`127.0.0.1` |
| --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' |
针对上一步生成的日志，启动命令为：
激活虚拟环境如下：
```
source ~/vdl/bin/activate
visualdl --logdir ./log
```
现在再安装 VisualDL 和运行范例：
#### 在Python脚本中启动
支持在Python脚本中启动VisualDL面板，接口如下：
```python
visualdl.server.app.run(logdir,
host="127.0.0.1",
port=8080,
cache_timeout=20,
language=None,
public_path=None,
api_only=False,
open_browser=False)
```
pip install --upgrade visualdl
# 运行一个例子，vdl_create_scratch_log 将创建测试日志
vdl_create_scratch_log
visualdl --logdir=scratch_log --port=8080
请注意：除`logdir`外，其他参数均为不定参数，传递时请指明参数名。
接口参数具体如下：
# 访问 http://127.0.0.1:8080
| 参数 | 格式 | 含义 |
| ------------- | ------------------------------------------------ | ------------------------------------------------------------ |
| logdir | string或list[string_1, string_2, ... , string_n] | 日志文件所在的路径，VisualDL将在此路径下递归搜索日志文件并进行可视化，可指定单个或多个路径 |
| model | string | 模型文件路径(非文件夹路径)，VisualDL将在此路径指定的模型文件进行可视化 |
| host | string | 指定启动服务的ip，默认为`127.0.0.1` |
| port | int | 启动服务端口，默认为`8040` |
| cache_timeout | int | 后端缓存时间，在缓存时间内前端多次请求同一url，返回的数据从缓存中获取，默认为20秒 |
| language | string | VisualDL面板语言，可指定为'en'或'zh'，默认为浏览器使用语言 |
| public_path | string | VisualDL面板URL路径，默认是'/app'，即访问地址为'http://<host>:<port>/app' |
| api_only | boolean | 是否只提供API，如果设置此参数，则VisualDL不提供页面展示，只提供API服务，此时API地址为'http://<host>:<port>/<public_path>/api'；若没有设置public_path参数，则默认为http://<host>:<port>/api' |
| open_browser | boolean | 是否打开浏览器，设置为True则在启动后自动打开浏览器并访问VisualDL面板，若设置api_only，则忽略此参数 |
针对上一步生成的日志，我们的启动脚本为：
```python
from visualdl.server import app
app.run(logdir="./log")
```
如果在虚拟环境下仍然遇到安装问题，请尝试以下方法。
在使用任意一种方式启动VisualDL面板后，打开浏览器访问VisualDL面板，即可查看日志的可视化结果，如图：
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/82786044-67ae9880-9e96-11ea-8a2b-3a0951a6ec19.png" width="60%"/>
</p>
## 使用 Anaconda 安装
Anaconda是一个用于科学计算的Python发行版，提供了包管理与环境管理的功能，可以很方便地解决多版本python并存、切换以及各种第三方包安装问题。
## 可视化功能概览
请根据[Anaconda下载网站](https://www.anaconda.com/download) 的指示去下载和安装Anaconda.
下载Python 3.6版本的command-Line installer.
### Scalar
以图表形式实时展示训练过程参数，如loss、accuracy。让用户通过观察单组或多组训练参数变化，了解训练过程，加速模型调优。具有两大特点：
创建conda环境名字为```vdl```或任何名字:
```
conda create -n vdl pip python=2.7 # or python=3.3, etc.
```
#### 动态展示
激活conda环境如下:
```
source activate vdl
```
在启动VisualDL后，LogReader将不断增量的读取日志中数据并供前端调用展示，因此能够在训练中同步观测指标变化，如下图：
现在再安装 VisualDL 和运行范例：
<p align="center">
<img src="http://visualdl.bj.bcebos.com/images/dynamic_display.gif" width="60%"/>
</p>
```
pip install --upgrade visualdl
# 运行一个例子，vdl_create_scratch_log 将创建测试日志
vdl_create_scratch_log
visualdl --logdir=scratch_log --port=8080
#### 多实验对比
# 访问 http://127.0.0.1:8080
```
只需在启动VisualDL时将每个实验日志所在路径同时传入即可，每个实验中相同tag的指标将绘制在一张图中同步呈现，如下图：
如果仍然遇到安装问题，请尝试以下用源代码安装方法。
<p align="center">
<img src="http://visualdl.bj.bcebos.com/images/multi_experiments.gif" width="100%"/>
</p>
### 使用代码安装
```
#建議是在虚拟环境或anaconda下。
git clone https://github.com/PaddlePaddle/VisualDL.git
cd VisualDL
python setup.py bdist_wheel
pip install --upgrade dist/visualdl-*.whl
```
### Image
实时展示训练过程中的图像数据，用于观察不同训练阶段的图像变化，进而深入了解训练过程及效果。
<p align="center">
<img src="http://visualdl.bj.bcebos.com/images/image-eye.gif" width="60%"/>
</p>
如果打包和安装遇到其他问题，不安装只想运行Visual DL可以看[这里](https://github.com/PaddlePaddle/VisualDL/blob/develop/docs/develop/how_to_dev_frontend_cn.md)
### Audio
实时查看训练过程中的音频数据，监控语音识别与合成等任务的训练过程。
## SDK
VisualDL 同时提供了python SDK 和 C++ SDK 来实现不同方式的使用。
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/89017647-38605000-d34d-11ea-9d75-7d10b9854c36.gif" width="100%"/>
</p>
### Python SDK
VisualDL 现在支持 Python 2和 Python 3。
以最简单的Scalar组件为例，尝试创建一个scalar组件并插入多个时间步的数据：
### Graph
```python
import random
from visualdl import LogWriter
一键可视化模型的网络结构。可查看模型属性、节点信息、节点输入输出等，并支持节点搜索，辅助用户快速分析模型结构与了解数据流向。
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84483052-5acdd980-accb-11ea-8519-1608da7ee698.png" width="100%"/>
</p>
logdir = "./tmp"
logger = LogWriter(logdir, sync_cycle=10000)
# mark the components with 'train' label.
with logger.mode("train"):
# create a scalar component called 'scalars/scalar0'
scalar0 = logger.scalar("scalars/scalar0")
### Histogram
# add some records during DL model running.
for step in range(100):
scalar0.add_record(step, random.random())
```
以直方图形式展示Tensor（weight、bias、gradient等）数据在训练过程中的变化趋势。深入了解模型各层效果，帮助开发者精准调整模型结构。
### C++ SDK
上面 Python SDK 中代码完全一致的C++ SDK用法如下
```c++
#include <cstdlib>
#include <string>
#include "visualdl/sdk.h"
- Offset模式
namespace vs = visualdl;
namespace cp = visualdl::components;
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86551031-86647c80-bf76-11ea-8ec2-8c86826c8137.png" width="100%"/>
</p>
int main() {
const std::string dir = "./tmp";
vs::LogWriter logger(dir, 10000);
logger.SetMode("train");
auto tablet = logger.AddTablet("scalars/scalar0");
- Overlay模式
cp::Scalar<float> scalar0(tablet);
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86551033-882e4000-bf76-11ea-8e6a-af954c662ced.png" width="100%"/>
</p>
for (int step = 0; step < 1000; step++) {
float v = (float)std::rand() / RAND_MAX;
scalar0.AddRecord(step, v);
}
return 0;
}
```
## 启动Board
当训练过程中已经产生了日志数据，就可以启动board进行实时预览可视化信息
### PR Curve
```
visualdl --logdir <some log dir>
```
精度-召回率曲线，帮助开发者权衡模型精度和召回率之间的平衡，设定最佳阈值。
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86738774-ee46c000-c067-11ea-90d2-a98aac445cca.png" width="100%"/>
</p>
### High Dimensional
board 还支持一下参数来实现远程的访问：
将高维数据进行降维展示，目前支持T-SNE、PCA两种降维方式，用于深入分析高维数据间的关系，方便用户根据数据特征进行算法优化。
- `--host` 设定IP
- `--port` 设定端口
- `-m / --model_pb` 指定 ONNX 格式的模型文件
<p align="center">
<img src="http://visualdl.bj.bcebos.com/images/high_dimensional_test.png" width="100%"/>
</p>
## 开源贡献
### 贡献
VisualDL 是由 [PaddlePaddle](https://www.paddlepaddle.org/) 和 [ECharts](https://echarts.apache.org/) 合作推出的开源项目。
Graph 相关功能由 [Netron](https://github.com/lutzroeder/netron) 提供技术支持。
欢迎所有人使用，提意见以及贡献代码。
VisualDL 是由 [PaddlePaddle](http://www.paddlepaddle.org/) 和
[ECharts](http://echarts.baidu.com/) 合作推出的开源项目。我们欢迎所有人使用，提意见以及贡献代码。
## 更多细节
想了解更多关于VisualDL的使用介绍，请查看[文档](https://github.com/PaddlePaddle/VisualDL/tree/develop/demo)
想了解更多关于VisualDL可视化功能的使用详情介绍，请查看**VisualDL使用指南**。
## 技术交流
欢迎您加入VisualDL官方QQ群：1045783368 与飞桨团队以及其他用户共同针对VisualDL进行讨论与交流。
\ No newline at end of file
doc/fluid/user_guides/howto/evaluation_and_debugging/debug/visualdl_usage.md
浏览文件 @ 2c2c20d8
# VisualDL 使用指南
## 概述
VisualDL 是一个面向深度学习任务设计的可视化工具。VisualDL 利用了丰富的图表来展示数据，用户可以更直观、清晰地查看数据的特征与变化趋势，有助于分析数据、及时发现错误，进而改进神经网络模型的设计。
目前，VisualDL 支持 scalar, histogram, image, text, audio, high dimensional, graph 这七个组件：
# VisualDL 使用指南
|组件名称|展示图表|作用|
|:----:|:---:|:---|
|<a href="#1">scalar</a>|折线图|动态展示损失函数值、准确率等标量数据|
|<a href="#2">histogram</a>|直方图|动态展示参数矩阵的数值分布与变化趋势，便于查看权重矩阵、偏置项、梯度等参数的变化|
|<a href="#3">image</a>|图片|显示图片，可显示输入图片和处理后的结果，便于查看中间过程的变化|
|<a href="#4">text</a>|文本|展示文本，有助于 NLP 等领域的用户进行数据分析和结果判断|
|<a href="#5">audio</a>|音频|可直接播放音频，也支持下载，有助于语音识别等领域的用户进行数据分析和结果判断|
|<a href="#6">high dimensional</a>|坐标|将高维数据映射到 2D/3D 空间来可视化嵌入，便于观察不同数据的相关性|
|<a href="#7">graph</a>|有向图|展示神经网络的模型结构|
### 概述
## 动态添加数据组件
VisualDL 是一个面向深度学习任务设计的可视化工具。VisualDL 利用了丰富的图表来展示数据，用户可以更直观、清晰地查看数据的特征与变化趋势，有助于分析数据、及时发现错误，进而改进神经网络模型的设计。
要想使用 VisualDL 的 scalar, histogram, image, text, audio, high dimensional 这六个组件来添加数据，都必须先初始化记录器 `LogWriter`，以设置数据在本地磁盘的保存路径以及同步周期。此后各个组件的输入数据会先保存到本地磁盘，进而才能加载到前端网页中展示。
目前，VisualDL 支持 scalar, image, audio, graph, histogram, pr curve, high dimensional 七个组件，项目正处于高速迭代中，敬请期待新组件的加入。
### LogWriter -- 记录器
| 组件名称 | 展示图表 | 作用 |
| :-------------------------------------------------: | :--------: | :----------------------------------------------------------- |
| [ Scalar](#Scalar--标量组件) | 折线图 | 动态展示损失函数值、准确率等标量数据 |
| [Image](#Image--图片可视化组件) | 图片可视化 | 显示图片，可显示输入图片和处理后的结果，便于查看中间过程的变化 |
| [Audio](#Audio--音频播放组件) | 音频播放 | 播放训练过程中的音频数据，监控语音识别与合成等任务的训练过程 |
| [Graph](#Graph--网络结构组件) | 网络结构 | 展示网络结构、节点属性及数据流向，辅助学习、优化网络结构 |
| [Histogram](#Histogram--直方图组件) | 直方图 | 展示训练过程中权重、梯度等张量的分布 |
| [PR Curve](#PR-Curve--PR曲线组件) | 折线图 | 权衡精度与召回率之间的平衡关系，便于选择最佳阈值 |
| [High Dimensional](#High-Dimensional--数据降维组件) | 数据降维 | 将高维数据映射到 2D/3D 空间来可视化嵌入，便于观察不同数据的相关性 |
LogWriter 是一个数据记录器，在数据记录过程中，LogWriter 会周期性地将数据写入指定路径。
## Scalar -- 折线图组件
LogWriter 的定义为：
### 介绍
```python
class LogWriter(dir, sync_cycle)
```
Scalar 组件的输入数据类型为标量，该组件的作用是将训练参数以折线图形式呈现。将损失函数值、准确率等标量数据作为参数传入 scalar 组件，即可画出折线图，便于观察变化趋势。
> :param dir : 指定日志文件的保存路径。
> :param sync_cycle : 同步周期。经过 sync_cycle 次添加数据的操作，就执行一次将数据从内存写入磁盘的操作。
> :return: 函数返回一个 LogWriter 对象。
### 记录接口
例1 创建一个 LogWriter 对象
Scalar 组件的记录接口如下：
```python
# 创建一个 LogWriter 对象 log_writer
log_writer = LogWriter("./log", sync_cycle=10)
add_scalar(tag, value, step, walltime=None)
```
LogWriter类的成员函数包括：
接口参数说明如下：
* `mode()`；
* `scalar()`, `histogram()`, `image()`, `text()`, `audio()`, `embedding()`；
| 参数 | 格式 | 含义 |
| -------- | ------ | ------------------------------------------- |
| tag | string | 记录指标的标志，如`train/loss`，不能含有`%` |
| value | float | 要记录的数据值 |
| step | int | 记录的步数 |
| walltime | int | 记录数据的时间戳，默认为当前时间戳 |
成员函数 `mode()` 用于指定模式。模式的名称是自定义的，比如训练`train`，验证`validation`，测试`test`，第一层卷积`conv_layer1`。 有着相同模式名称的组件作为一个整体，用户可在前端网页中的 `Runs` 按钮中选择显示哪个模式的数据（默认是显示全部模式）。
### Demo
成员函数 `scalar()`, `histogram()`, `image()`, `text()`, `audio()`, `embedding()` 用于创建组件。
- 基础使用
例2 LogWriter 创建组件
下面展示了使用 Scalar 组件记录数据的示例，代码文件请见[Scalar组件](https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/components/scalar_test.py)
```python
# 设定模式为 train，创建一个 scalar 组件
with log_writer.mode("train") as logger:
train_scalar = logger.scalar("acc")
# 设定模式为test，创建一个 image 组件
with log_writer.mode("test") as shower:
test_image = shower.image("conv_image", 10, 1)
```
from visualdl import LogWriter
### scalar -- 折线图组件
if __name__ == '__main__':
value = [i/1000.0 for i in range(1000)]
# 初始化一个记录器
with LogWriter(logdir="./log/scalar_test/train") as writer:
for step in range(1000):
# 向记录器添加一个tag为`acc`的数据
writer.add_scalar(tag="acc", step=step, value=value[step])
# 向记录器添加一个tag为`loss`的数据
writer.add_scalar(tag="loss", step=step, value=1/(value[step] + 1))
```
<a name="1">scalar</a> 组件的输入数据类型为标量，该组件的作用是画折线图。将损失函数值、准确率等标量数据作为参数传入 scalar 组件，即可画出折线图，便于观察变化趋势。
运行上述程序后，在命令行执行
想通过 scalar 组件画折线图，只需先设定 LogWriter 对象的成员函数 `scalar()`，即可使用 `add_record()` 函数添加数据。这两个函数的具体用法如下：
```shell
visualdl --logdir ./log --port 8080
```
* LogWriter 对象的成员函数 `scalar()`：
接着在浏览器打开`http://127.0.0.1:8080`，即可查看以下折线图。
```python
def scalar(tag, type)
```
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/82397559-478c6d00-9a83-11ea-80db-a0844dcaca35.png" width="100%"/>
</p>
> :param tag : 标签，tag 相同的折线在同一子框，否则不同，tag 的名称中不能有 % 这个字符。
> :param type : 数据类型，可选“float”, "double", "int"，默认值为 "float"。
> :return: 函数返回一个 ScalarWriter 对象。
* scalar 组件的成员函数 `add_record()`：
- 多组实验对比
```python
def add_record(step, value)
```
下面展示了使用Scalar组件实现多组实验对比
> :param step : 步进数，标记这是第几个添加的数据。
> :param value : 输入数据。
多组实验对比的实现分为两步：
例3 scalar 组件示例程序 [Github](https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/component/scalar-demo.py)
1. 创建子日志文件储存每组实验的参数数据
2. 将数据写入scalar组件时，**使用相同的tag**，即可实现对比**不同实验**的**同一类型参数**
```python
# coding=utf-8
from visualdl import LogWriter
# 创建 LogWriter 对象
log_writer = LogWriter("./log", sync_cycle=20)
if __name__ == '__main__':
value = [i/1000.0 for i in range(1000)]
# 步骤一：创建父文件夹：log与子文件夹：scalar_test
with LogWriter(logdir="./log/scalar_test") as writer:
for step in range(1000):
# 步骤二：向记录器添加一个tag为`train/acc`的数据
writer.add_scalar(tag="train/acc", step=step, value=value[step])
# 步骤二：向记录器添加一个tag为`train/loss`的数据
writer.add_scalar(tag="train/loss", step=step, value=1/(value[step] + 1))
# 步骤一：创建第二个子文件夹scalar_test2
value = [i/500.0 for i in range(1000)]
with LogWriter(logdir="./log/scalar_test2") as writer:
for step in range(1000):
# 步骤二：在同样名为`train/acc`下添加scalar_test2的accuracy的数据
writer.add_scalar(tag="train/acc", step=step, value=value[step])
# 步骤二：在同样名为`train/loss`下添加scalar_test2的loss的数据
writer.add_scalar(tag="train/loss", step=step, value=1/(value[step] + 1))
```
运行上述程序后，在命令行执行
# 创建 scalar 组件，模式为 train
with log_writer.mode("train") as logger:
train_acc = logger.scalar("acc")
train_loss = logger.scalar("loss")
```shell
visualdl --logdir ./log --port 8080
```
# 创建 scalar 组件，模式设为 test， tag 设为 acc
with log_writer.mode("test") as logger:
test_acc = logger.scalar("acc")
接着在浏览器打开`http://127.0.0.1:8080`，即可查看以下折线图，对比「scalar_test」和「scalar_test2」的Accuracy和Loss。
value = [i/1000.0 for i in range(1000)]
for step in range(1000):
# 向名称为 acc 的图中添加模式为train的数据
train_acc.add_record(step, value[step])
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84644158-5efb3080-af31-11ea-8e64-bbe4078425f4.png" width="100%"/>
</p>
# 向名称为 loss 的图中添加模式为train的数据
train_loss.add_record(step, 1 / (value[step] + 1))
# 向名称为 acc 的图中添加模式为test的数据
test_acc.add_record(step, 1 - value[step])
```
*多组实验对比的应用案例可参考AI Studio项目：[VisualDL 2.0--眼疾识别训练可视化](https://aistudio.baidu.com/aistudio/projectdetail/502834)
运行上述程序后，在命令行中执行
```shell
visualdl --logdir ./log --host 0.0.0.0 --port 8080
```
### 功能操作说明
接着在浏览器打开 [http://0.0.0.0:8080](http://0.0.0.0:8080)，即可查看以下折线图。
* 支持数据卡片「最大化」、「还原」、「坐标系转化」（y轴对数坐标）、「下载」折线图
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/demo/component/usage-interface/scalar-interface.png" width=800><br/>
图1. scalar 组件展示折线图 <br/>
<img src="http://visualdl.bj.bcebos.com/images/scalar-icon.png" width="55%"/>
</p>
VisualDL 页面的右边侧栏有各个组件的调节选项，以 scalar 组件为例：
* Smoothing : 用于调节曲线的平滑度。
* X-axis : 折线图的横坐标参数，可选 `Step`, `Relative`, `Wall Time`，分别表示横轴设为步进数、相对值、数据采集的时间。
* Tooltip sorting : 标签排序方法，可选 `default`, `descending`, `ascending`, `nearest`，分别表示默认排序、按名称降序、按名称升序、按最新更新时间排序。
VisualDL 页面的右边侧栏的最下方还有一个 `RUNNING` 按钮，此时前端定期从后端同步数据，刷新页面。点击可切换为红色的 `STOPPED`，暂停前端的数据更新。
### histogram -- 直方图组件
* 数据点Hover展示详细信息
<a name="2">histogram</a> 组件的作用是以直方图的形式显示输入数据的分布。在训练过程中，把一些参数（例如权重矩阵 w，偏置项 b，梯度）传给 histogram 组件，就可以查看参数分布在训练过程中的变化趋势。
<p align="center">
<img src="http://visualdl.bj.bcebos.com/images/scalar-tooltip.png" width="60%"/>
</p>
想通过 histogram 组件画参数直方图，只需先设定 LogWriter 对象的成员函数 `histogram()`，即可使用 `add_record()` 函数添加数据。这两个函数的具体用法如下：
* LogWriter 对象的成员函数 `histogram()`：
```python
def histogram(tag, num_buckets, type)
```
> :param tag : 标签，结合 LogWriter 指定的模式，决定输入参数显示的子框。
> :param num_buckets : 直方图的柱子数量。
> :param type : 数据类型，可选“float”, "double", "int"，默认值为 "float"。
> :return: 函数返回一个 HistogramWriter 对象。
* 可搜索卡片标签，展示目标图像
* histogram 组件的成员函数 `add_record()`：
<p align="center">
<img src="http://visualdl.bj.bcebos.com/images/scalar-searchlabel.png" width="90%"/>
</p>
```python
def add_record(step, data)
```
> :param step : 步进数，标记这是第几组添加的数据。
> :param data : 输入参数， 数据类型为 list[]。
例4 histogram 组件示例程序 [Github](https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/component/histogram-demo.py)
```python
# coding=utf-8
import numpy as np
from visualdl import LogWriter
* 可搜索打点数据标签，展示特定数据
# 创建 LogWriter 对象
log_writer = LogWriter('./log', sync_cycle=10)
<p align="center">
<img src="http://visualdl.bj.bcebos.com/images/scalar-searchstream.png" width="40%"/>
</p>
# 创建 histogram 组件，模式为train
with log_writer.mode("train") as logger:
param1_histogram = logger.histogram("param1", num_buckets=100)
# 设定步数为 1 - 100
for step in range(1, 101):
# 添加的数据为随机分布，所在区间值变小
interval_start = 1 + 2 * step/100.0
interval_end = 6 - 2 * step/100.0
data = np.random.uniform(interval_start, interval_end, size=(10000))
# 使用 add_record() 函数添加数据
param1_histogram.add_record(step, data)
```
* X轴有三种衡量尺度
运行上述程序后，在命令行中执行
1. Step：迭代次数
2. Walltime：训练绝对时间
3. Relative：训练时长
```shell
visualdl --logdir ./log --host 0.0.0.0 --port 8080
```
<p align="center">
<img src="http://visualdl.bj.bcebos.com/images/x-axis.png" width="40%"/>
</p>
接着在浏览器打开[http://0.0.0.0:8080](http://0.0.0.0:8080)，即可查看 histogram 组件的直方图。其中横坐标为参数的数值，曲线上的值为相应参数的个数。右边纵轴的值为 Step，不同 Step 的数据组用不同颜色加以区分。
* 可调整曲线平滑度，以便更好的展现参数整体的变化趋势
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/demo/component/usage-interface/histogram-interface.png" width=800><br/>
图2. histogram 组件展示直方图 <br/>
<img src="http://visualdl.bj.bcebos.com/images/scalar-smooth.png" width="37%"/>
</p>
### image -- 图片可视化组件
<a name="3">image</a> 组件用于显示图片。在程序运行过程中，将图片数据传入 image 组件，就可在 VisualDL 的前端网页看到相应图片。
使用 image 组件添加数据，需要先设定 LogWriter 对象的成员函数 `image()`，即可结合 `start_sampling()`, `is_sample_taken()`, `set_sample()` 和 `finish_sample()` 这四个 image 组件的成员函数来完成。这几个函数的定义及用法如下：
* LogWriter 对象的成员函数 `image()`：
```python
def image(tag, num_samples, step_cycle)
```
## Image -- 图片可视化组件
> :param tag : 标签，结合 set_sample() 的参数 index，决定图片显示的子框。
> :param num_samples : 设置单个 step 的采样数，页面上的图片数目也等于 num_samples。
> :param step_cycle : 将 step_cycle 个 step 的数据存储到日志中，默认值为 1。
> :return: 函数返回一个 ImageWriter 对象。
### 介绍
* 开始新的采样周期 - 开辟一块内存空间，用于存放采样的数据：
Image 组件用于显示图片数据随训练的变化。在模型训练过程中，将图片数据传入 Image 组件，就可在 VisualDL 的前端网页查看相应图片。
```python
def start_sampling()
```
### 记录接口
* 判断该图片是否应被采样，当返回值为 `-1`，表示不用采样，否则，应被采样：
Image 组件的记录接口如下：
```python
def is_sample_taken()
add_image(tag, img, step, walltime=None)
```
* 使用函数 `set_sample()` 添加图片数据：
接口参数说明如下：
```python
def set_sample(index, image_shape, image_data)
```
| 参数 | 格式 | 含义 |
| -------- | ------------- | ------------------------------------------- |
| tag | string | 记录指标的标志，如`train/loss`，不能含有`%` |
| img | numpy.ndarray | 以ndarray格式表示的图片 |
| step | int | 记录的步数 |
| walltime | int | 记录数据的时间戳，默认为当前时间戳 |
> :param index : 索引号，与 tag 组合使用，决定图片显示的子框。
> :param image_shape : 图片的形状，[weight, height, 通道数(RGB 为 3，灰度图为 1)]。
> :param image_data : 图片的数据格式为矩阵，通常为 numpy.ndarray，经 flatten() 后变为行向量。
### Demo
* 结束当前的采样周期，将已采样的数据存到磁盘，并释放这一块内存空间：
```python
def finish_sample()
```
下面展示了使用 Image 组件记录数据的示例，代码文件请见[Image组件](https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/components/image_test.py)
例5 image 组件示例程序 [Github](https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/component/image-demo.py)
```python
# coding=utf-8
import numpy as np
from visualdl import LogWriter
from PIL import Image
from visualdl import LogWriter
def random_crop(img):
'''
此函数用于获取图片数据 img 的 100*100 的随机分块
'''
"""获取图片的随机 100x100 分片
"""
img = Image.open(img)
w, h = img.size
random_w = np.random.randint(0, w - 100)
random_h = np.random.randint(0, h - 100)
return img.crop((random_w, random_h, random_w + 100, random_h + 100))
# 创建 LogWriter 对象
log_writer = LogWriter("./log", sync_cycle=10)
# 创建 image 组件，模式为train, 采样数设为 ns
ns = 2
with log_writer.mode("train") as logger:
input_image = logger.image(tag="test", num_samples=ns)
# 一般要设置一个变量 sample_num，用于记录当前已采样了几个 image 数据
sample_num = 0
for step in range(6):
# 设置start_sampling() 的条件，满足条件时，开始采样
if sample_num == 0:
input_image.start_sampling()
# 获取idx
idx = input_image.is_sample_taken()
# 如果 idx != -1，采样，否则跳过
if idx != -1:
# 获取图片数据
image_path = "test.jpg"
image_data = np.array(random_crop(image_path))
# 使用 set_sample() 函数添加数据
# flatten() 用于把 ndarray 由矩阵变为行向量
input_image.set_sample(idx, image_data.shape, image_data.flatten())
sample_num += 1
# 如果完成了当前轮的采样，则调用finish_sample()
if sample_num % ns == 0:
input_image.finish_sampling()
sample_num = 0
r = img.crop((random_w, random_h, random_w + 100, random_h + 100))
return np.asarray(r)
if __name__ == '__main__':
# 初始化一个记录器
with LogWriter(logdir="./log/image_test/train") as writer:
for step in range(6):
# 添加一个图片数据
writer.add_image(tag="eye",
img=random_crop("../../docs/images/eye.jpg"),
step=step)
```
运行上述程序后，在命令行中执行
运行上述程序后，在命令行执行
```shell
visualdl --logdir ./log --host 0.0.0.0 --port 8080
visualdl --logdir ./log --port 8080
```
接着在浏览器打开 [http://0.0.0.0:8080](http://0.0.0.0:8080)，点击页面最上方的`SAMPLES`选项，即可查看 image 组件的展示图片。每一张子图都有一条浅绿色的横轴，拖动即可展示不同 step 的图片。
在浏览器输入`http://127.0.0.1:8080`，即可查看图片数据。
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/demo/component/usage-interface/image-interface.png" width=800><br/>
图3. image 组件展示图片 <br/>
<img src="http://visualdl.bj.bcebos.com/images/image-static.png" width="90%"/>
</p>
### text -- 文本组件
<a name="4">text</a> 组件用于显示文本，在程序运行过程中，将文本数据传入 text 组件，即可在 VisualDL 的前端网页中查看。
想要通过 text 组件添加数据，只需先设定 LogWriter 对象的成员函数 `text()`，即可使用 `add_record()` 函数来完成。这两个函数的具体用法如下：
* LogWriter 对象的成员函数 `text()`：
```python
def text(tag)
```
> :param tag : 标签，结合 LogWriter 设定的模式，决定文本显示的子框。
> :return: 函数返回一个 TextWriter 对象。
* text 组件的成员函数 `add_record()`：
```python
def add_record(step, str)
```
> :param step : 步进数，标记这是第几组添加的数据。
> :param str : 输入文本，数据类型为 string。
### 功能操作说明
例6 text 组件示例程序 [Github](https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/component/text-demo.py)
可搜索图片标签显示对应图片数据
```python
# coding=utf-8
from visualdl import LogWriter
# 创建 LogWriter 对象
log_writter = LogWriter("./log", sync_cycle=10)
# 创建 text 组件，模式为 train， 标签为 test
with log_writter.mode("train") as logger:
vdl_text_comp = logger.text(tag="test")
# 使用 add_record() 函数添加数据
for i in range(1, 6):
vdl_text_comp.add_record(i, "这是第 %d 个 step 的数据。" % i)
vdl_text_comp.add_record(i, "This is data %d ." % i)
```
<p align="center">
<img src="http://visualdl.bj.bcebos.com/images/image-search.png" width="90%"/>
</p>
运行上述程序后，在命令行中执行
```shell
visualdl --logdir ./log --host 0.0.0.0 --port 8080
```
接着在浏览器打开 [http://0.0.0.0:8080](http://0.0.0.0:8080)，点击页面最上方的 `SAMPLES` 选项，即可查看 text 组件的展示文本。每一张小框都有一条浅绿色的横轴，拖动即可显示不同 step 的文本。
支持滑动Step/迭代次数查看不同迭代次数下的图片数据
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/demo/component/usage-interface/text-interface.png" width=800><br/>
图4. text 组件展示文本 <br/>
<img src="http://visualdl.bj.bcebos.com/images/image-eye.gif" width="60%"/>
</p>
### audio -- 音频播放组件
<a name="5"> audio</a> 为音频播放组件，在程序运行过程中，将音频数据传入 audio 组件，就可以在 VisualDL 的前端网页中直接播放或下载。
使用 audio 组件添加数据，需要先设定 LogWriter 对象的成员函数 `audio()`，即可结合 `start_sampling()`, `is_sample_taken()`, `set_sample()` 和 `finish_sample()` 这四个 audio 组件的成员函数来完成。这几个函数的定义和用法如下：
* LogWriter 对象的成员函数 `audio()`：
```python
def audio(tag, num_samples, step_cycle)
```
## Audio--音频播放组件
> :param tag : 标签，结合 set_sample() 的参数 index，决定音频播放的子框。
> :param num_samples : 设置单个 step 的采样数，页面上的音频数目也等于 num_samples。
> :param step_cycle : 将 step_cycle 个 step 的数据存储到日志中，默认值为 1。
> :return: 函数返回一个 AudioWriter 对象。
### 介绍
* 开始新的采样周期 - 开辟一块内存空间，用于存放采样的数据：
Audio组件实时查看训练过程中的音频数据，监控语音识别与合成等任务的训练过程。
```python
def start_sampling()
```
### 记录接口
* 判断该音频是否应被采样，当返回值为 `-1`，表示不用采样，否则，应被采样：
Audio 组件的记录接口如下：
```python
def is_sample_taken()
add_audio(tag, audio_array, step, sample_rate)
```
* 使用函数 `set_sample()` 添加音频数据：
```python
def set_sample(index, audio_params, audio_data)
```
接口参数说明如下：
> :param index : 索引号，结合 tag，决定音频播放的子框。
> :param audio_params : 音频的参数 [sample rate, sample width, channel]，其中 sample rate 为采样率， sample width 为每一帧采样的字节数， channel 为通道数（单声道设为1，双声道设为2，四声道设为4，以此类推）。
> :param audio_data ：音频数据，音频数据的格式一般为 numpy.ndarray，经 flatten() 后变为行向量。
| 参数 | 格式 | 含义 |
| ----------- | ------------- | ------------------------------------------ |
| tag | string | 记录指标的标志，如`audio_tag`，不能含有`%` |
| audio_arry | numpy.ndarray | 以ndarray格式表示的音频 |
| step | int | 记录的步数 |
| sample_rate | int | 采样率，**注意正确填写对应音频的原采样率** |
* 结束当前的采样周期，将已采样的数据存到磁盘，并释放这一块内存空间：
### Demo
```python
def finish_sample()
```
下面展示了使用 Audio 组件记录数据的示例，代码文件请见[Audio组件](https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/components/audio_test.py)
例7 audio 组件示例程序 [Github](https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/component/audio-demo.py)
```python
# coding=utf-8
from visualdl import LogWriter
import numpy as np
import wave
from visualdl import LogWriter
def read_audio_data(audio_path):
"""
读取音频数据
Get audio data.
"""
CHUNK = 4096
f = wave.open(audio_path, "rb")
wavdata = []
chunk = f.readframes(CHUNK)
while chunk:
data = np.fromstring(chunk, dtype='uint8')
data = np.frombuffer(chunk, dtype='uint8')
wavdata.extend(data)
chunk = f.readframes(CHUNK)
# 8k sample rate, 16bit frame, 1 channel
shape = [8000, 2, 1]
return shape, wavdata
# 创建一个 LogWriter 对象
log_writter = LogWriter("./log", sync_cycle=10)
# 创建 audio 组件，模式为 train
ns = 2
with log_writter.mode("train") as logger:
input_audio = logger.audio(tag="test", num_samples=ns)
# 一般要设定一个变量 audio_sample_num，用来记录当前已采样了几段 audio 数据
audio_sample_num = 0
for step in range(9):
# 设置 start_sampling() 的条件，满足条件时，开始采样
if audio_sample_num == 0:
input_audio.start_sampling()
# 获取 idx
idx = input_audio.is_sample_taken()
# 如果 idx != -1，采样，否则跳过
if idx != -1:
# 读取数据，音频文件的格式可以为 .wav .mp3 等
audio_path = "test.wav"
audio_shape, audio_data = read_audio_data(audio_path)
# 使用 set_sample()函数添加数据
input_audio.set_sample(idx, audio_shape, audio_data)
audio_sample_num += 1
# 如果完成了当前轮的采样，则调用 finish_sample()
if audio_sample_num % ns ==0:
input_audio.finish_sampling()
audio_sample_num = 0
if __name__ == '__main__':
with LogWriter(logdir="./log") as writer:
audio_shape, audio_data = read_audio_data("./testing.wav")
audio_data = np.array(audio_data)
writer.add_audio(tag="audio_tag",
audio_array=audio_data,
step=0,
sample_rate=8000)
```
运行上述程序后，在命令行中执行
运行上述程序后，在命令行执行
```shell
visualdl --logdir ./log --host 0.0.0.0 --port 8080
visualdl --logdir ./log --port 8080
```
接着在浏览器打开[http://0.0.0.0:8080](http://0.0.0.0:8080)，点击页面最上方的 `SAMPLES` 选项，即有音频的小框，可以播放和下载。每一张小框中都有一条浅绿色的横轴，拖动即可选择不同 step 的音频段。
在浏览器输入`http://127.0.0.1:8080`，即可查看音频数据。
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/87659138-b4746880-c78f-11ea-965b-c33804e7c296.png" width="100%"/>
</p>
### 功能操作说明
- 可搜索音频标签显示对应音频数据
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/87661431-29956d00-c793-11ea-833b-172d8fc1b221.png" width="100%"/>
</p>
- 支持滑动Step/迭代次数试听不同迭代次数下的音频数据
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/87661089-a07e3600-c792-11ea-8740-cbe99a64d830.png" width="60%"/>
</p>
- 支持播放/暂停音频数据
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/87661130-b3910600-c792-11ea-9f9f-2ae66132e9de.png" width="60%"/>
</p>
- 支持音量调节
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/87661497-49c52c00-c793-11ea-9eeb-471543cd2a0b.png" width="60%"/>
</p>
- 支持音频下载
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/demo/component/usage-interface/audio-interface.png" width=800><br/>
图5. audio 组件播放音频 <br/>
<img src="https://user-images.githubusercontent.com/48054808/87661166-c277b880-c792-11ea-8ad7-5c60bb08379b.png" width="60%"/>
</p>
### high dimensional -- 数据降维组件
<a name="6">high dimensional</a> 组件的作用就是将数据映射到 2D/3D 空间来做可视化嵌入，这有利于了解不同数据的相关性。high dimensional 组件支持以下两种降维算法：
* PCA : Principle Component Analysis 主成分分析
* [t-SNE](https://lvdmaaten.github.io/tsne/) : t-distributed stochastic neighbor embedding t-分布式随机领域嵌入
## Graph--网络结构组件
### 介绍
Graph组件一键可视化模型的网络结构。用于查看模型属性、节点信息、节点输入输出等，并进行节点搜索，协助开发者们快速分析模型结构与了解数据流向。
### Demo
共有两种启动方式：
- 前端模型文件拖拽上传：
- 如只需使用Graph组件，则无需添加任何参数，在命令行执行`visualdl`后即可启动面板进行上传。
- 如果同时需使用其他功能，在命令行指定日志文件路径（以`./log`为例）即可启动面板进行上传：
想使用 high dimensional 组件，只需先设定 LogWriter 对象的成员函数 `embedding()`，即可使用 `add_embeddings_with_word_dict()` 函数添加数据。这两个函数的定义及用法如下：
```shell
visualdl --logdir ./log --port 8080
```
* LogWriter 对象的成员函数 `embedding()` 不需输入参数，函数返回一个 embeddingWriter 对象：
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84487396-44c31780-acd1-11ea-831a-1632e636613d.png" width="80%"/>
</p>
- 后端启动Graph：
- 在命令行加入参数`--model`并指定**模型文件**路径（非文件夹路径），即可启动并查看网络结构可视化：
```shell
visualdl --model ./log/model --port 8080
```
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84490149-51e20580-acd5-11ea-9663-1f156892c0e0.png" width="100%"/>
</p>
### 功能操作说明
- 一键上传模型
- 支持模型格式：PaddlePaddle、ONNX、Keras、Core ML、Caffe、Caffe2、Darknet、MXNet、ncnn、TensorFlow Lite
- 实验性支持模型格式：TorchScript、PyTorch、Torch、 ArmNN、BigDL、Chainer、CNTK、Deeplearning4j、MediaPipe、ML.NET、MNN、OpenVINO、Scikit-learn、Tengine、TensorFlow.js、TensorFlow
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84487396-44c31780-acd1-11ea-831a-1632e636613d.png" width="80%"/>
</p>
- 支持上下左右任意拖拽模型、放大和缩小模型
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84487568-8784ef80-acd1-11ea-9da1-befedd69b872.GIF" width="100%"/>
</p>
- 搜索定位到对应节点
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84487694-b9965180-acd1-11ea-8214-34f3febc1828.png" width="30%"/>
</p>
- 点击查看模型属性
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84487751-cadf5e00-acd1-11ea-9ce2-4fdfeeea9c5a.png" width="30%"/>
</p>
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84487759-d03ca880-acd1-11ea-9294-520ef7f9e0b1.png" width="30%"/>
</p>
- 支持选择模型展示的信息
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84487829-ee0a0d80-acd1-11ea-8563-6682a15483d9.png" width="23%"/>
</p>
- 支持以PNG、SVG格式导出模型结构图
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84487884-ff531a00-acd1-11ea-8b12-5221db78683e.png" width="30%"/>
</p>
- 点击节点即可展示对应属性信息
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84487941-13971700-acd2-11ea-937d-42fb524b9ee1.png" width="30%"/>
</p>
- 支持一键更换模型
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/84487998-27db1400-acd2-11ea-83d7-5d75832ef41d.png" width="25%"/>
</p>
## Histogram--直方图组件
### 介绍
Histogram组件以直方图形式展示Tensor（weight、bias、gradient等）数据在训练过程中的变化趋势。深入了解模型各层效果，帮助开发者精准调整模型结构。
### 记录接口
Histogram 组件的记录接口如下：
```python
add_histogram(tag, values, step, walltime=None, buckets=10)
```
接口参数说明如下：
| 参数 | 格式 | 含义 |
| -------- | --------------------- | ------------------------------------------- |
| tag | string | 记录指标的标志，如`train/loss`，不能含有`%` |
| values | numpy.ndarray or list | 以ndarray或list格式表示的数据 |
| step | int | 记录的步数 |
| walltime | int | 记录数据的时间戳，默认为当前时间戳 |
| buckets | int | 生成直方图的分段数，默认为10 |
### Demo
下面展示了使用 Histogram组件记录数据的示例，代码文件请见[Histogram组件](https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/components/histogram_test.py)
```python
def embedding()
from visualdl import LogWriter
import numpy as np
if __name__ == '__main__':
values = np.arange(0, 1000)
with LogWriter(logdir="./log/histogram_test/train") as writer:
for index in range(1, 101):
interval_start = 1 + 2 * index / 100.0
interval_end = 6 - 2 * index / 100.0
data = np.random.uniform(interval_start, interval_end, size=(10000))
writer.add_histogram(tag='default tag',
values=data,
step=index,
buckets=10)
```
运行上述程序后，在命令行执行
```shell
visualdl --logdir ./log --port 8080
```
* high dimensional 的成员函数 `add_embeddings_with_word_dict()`：
在浏览器输入`http://127.0.0.1:8080`，即可查看训练参数直方图。
### 功能操作说明
- 支持数据卡片「最大化」、直方图「下载」
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86535351-42d82700-bf12-11ea-89f0-171280e7c526.png" width="60%"/>
</p>
- 可选择Offset或Overlay模式
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86535413-c134c900-bf12-11ea-9ad6-f0ad8eafa76f.png" width="30%"/>
</p>
- Offset模式
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86536435-2b9d3780-bf1a-11ea-9981-92f837d22ae5.png" width="60%"/>
</p>
- Overlay模式
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86536458-5ab3a900-bf1a-11ea-985e-05f06c1b762b.png" width="60%"/>
</p>
- 数据点Hover展示参数值、训练步数、频次
- 在第240次训练步数时，权重为-0.0031，且出现的频次是2734次
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86536482-80d94900-bf1a-11ea-9e12-5bea9f382b34.png" width="60%"/>
</p>
- 可搜索卡片标签，展示目标直方图
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86536503-baaa4f80-bf1a-11ea-80ab-cd988617d018.png" width="30%"/>
</p>
- 可搜索打点数据标签，展示特定数据流
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86536639-b894c080-bf1b-11ea-9ee5-cf815dd4bbd7.png" width="30%"/>
</p>
## PR Curve--PR曲线组件
### 介绍
PR Curve以折线图形式呈现精度与召回率的权衡分析，清晰直观了解模型训练效果，便于分析模型是否达到理想标准。
### 记录接口
PR Curve组件的记录接口如下：
```python
def add_embeddings_with_word_dict(data, Dict)
add_pr_curve(tag, labels, predictions, step=None, num_thresholds=10)
```
> :param data : 输入数据，数据类型为 List[List(float)]。
> :param Dict : 字典， 数据类型为 Dict[str, int]。
接口参数说明如下：
| 参数 | 格式 | 含义 |
| -------------- | --------------------- | ------------------------------------------- |
| tag | string | 记录指标的标志，如`train/loss`，不能含有`%` |
| labels | numpy.ndarray or list | 以ndarray或list格式表示的实际类别 |
| predictions | numpy.ndarray or list | 以ndarray或list格式表示的预测类别 |
| step | int | 记录的步数 |
| num_thresholds | int | 阈值设置的个数，默认为10，最大值为127 |
### Demo
例8 high dimensional 组件示例程序 [Github](https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/component/embedding-demo.py)
下面展示了使用 PR Curve 组件记录数据的示例，代码文件请见[PR Curve组件](#https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/components/pr_curve_test.py)
```python
# coding=utf-8
import numpy as np
from visualdl import LogWriter
import numpy as np
# 创建一个 LogWriter 对象
log_writer = LogWriter("./log", sync_cycle=10)
# 创建一个 high dimensional 组件，模式设为 train
with log_writer.mode("train") as logger:
train_embedding = logger.embedding()
# 第一个参数为数据，数据类型为 List[List(float)]
hot_vectors = np.random.uniform(1, 2, size=(10, 3))
# 第二个参数为字典，数据类型为 Dict[str, int]
# 其中第一个分量为坐标点的名称, 第二个分量为该坐标对应原数据的第几行分量
word_dict = {
"label_1": 5,
"label_2": 4,
"label_3": 3,
"label_4": 2,
"label_5": 1,}
# 使用 add_embeddings_with_word_dict(data, Dict)
train_embedding.add_embeddings_with_word_dict(hot_vectors, word_dict)
with LogWriter("./log/pr_curve_test/train") as writer:
for step in range(3):
labels = np.random.randint(2, size=100)
predictions = np.random.rand(100)
writer.add_pr_curve(tag='pr_curve',
labels=labels,
predictions=predictions,
step=step,
num_thresholds=5)
```
运行上述程序后，在命令行中执行
运行上述程序后，在命令行执行
```shell
visualdl --logdir ./log --host 0.0.0.0 --port 8080
visualdl --logdir ./log --port 8080
```
接着在浏览器打开[http://0.0.0.0:8080](http://0.0.0.0:8080)，点击页面最上方的 `HIGHDIMENSIONAL` 选项，即可查看数据映射后的相对位置。
接着在浏览器打开`http://127.0.0.1:8080`，即可查看PR Curve
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/demo/component/usage-interface/embedding-2D.png" width=800><br/>
图6. high dimensional 组件展示平面坐标 <br/>
<img src="https://user-images.githubusercontent.com/48054808/86738774-ee46c000-c067-11ea-90d2-a98aac445cca.png" width="100%"/>
</p>
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/demo/component/usage-interface/embedding-3D.png" width=800><br/>
图7. high dimensional 组件展示直角坐标 <br/>
</p>
## graph -- 神经网络可视化组件
### 功能操作说明
<a name="7">graph</a> 组件用于神经网络模型结构的可视化，该组件可以展示 Paddle 格式和 [ONNX](https://onnx.ai) 格式保存的模型。graph 组件可帮助用户理解神经网络的模型结构，也有助于排查神经网络的配置错误。
- 支持数据卡片「最大化」，「还原」、「下载」PR曲线
与其他需要记录数据的组件不同，使用 graph 组件的唯一要素就是指定模型文件的存放位置，即在 `visualdl` 命令中增加选项 `--model_pb` 来指定模型文件的存放路径，则可在前端看到相应效果。
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86740067-f18e7b80-c068-11ea-96bf-52cb7da1f799.png" width="60%"/>
</p>
例9 graph 组件示例程序（下面示例展示了如何用 Paddle 保存一个 Lenet-5 模型）[Github](https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/component/graph-demo.py)
- 数据点Hover展示详细信息：阈值对应的TP、TN、FP、FN
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86740477-43370600-c069-11ea-93f0-f4d05445fbab.png" width="70%"/>
</p>
- 可搜索卡片标签，展示目标图表
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86740670-66fa4c00-c069-11ea-9ee3-0a22e2d0dbec.png" width="50%"/>
</p>
- 可搜索打点数据标签，展示特定数据
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86740817-809b9380-c069-11ea-9453-6531e3ff5f43.png" width="50%"/>
</p>
- 支持查看不同训练步数下的PR曲线
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86741057-b04a9b80-c069-11ea-9fef-2dcc16f9cd46.png" width="50%"/>
</p>
- X轴-时间显示类型有三种衡量尺度
- Step：迭代次数
- Walltime：训练绝对时间
- Relative：训练时长
<p align="center">
<img src="https://user-images.githubusercontent.com/48054808/86741304-db34ef80-c069-11ea-86eb-787b49ed3705.png" width="50%"/>
</p>
## High Dimensional -- 数据降维组件
### 介绍
High Dimensional 组件将高维数据进行降维展示，用于深入分析高维数据间的关系。目前支持以下两种降维算法：
- PCA : Principle Component Analysis 主成分分析
- t-SNE : t-distributed stochastic neighbor embedding t-分布式随机领域嵌入
### 记录接口
High Dimensional 组件的记录接口如下：
```python
add_embeddings(tag, labels, hot_vectors, walltime=None)
```
接口参数说明如下：
| 参数 | 格式 | 含义 |
| ----------- | ------------------- | ---------------------------------------------------- |
| tag | string | 记录指标的标志，如`default`，不能含有`%` |
| labels | numpy.array 或 list | 一维数组表示的标签，每个元素是一个string类型的字符串 |
| hot_vectors | numpy.array or list | 与labels一一对应，每个元素可以看作是某个标签的特征 |
| walltime | int | 记录数据的时间戳，默认为当前时间戳 |
### Demo
下面展示了使用 High Dimensional 组件记录数据的示例，代码文件请见[High Dimensional组件](https://github.com/PaddlePaddle/VisualDL/blob/develop/demo/components/high_dimensional_test.py)
```python
# coding=utf-8
import paddle.fluid as fluid
def lenet_5(img):
'''
定义神经网络结构
'''
conv1 = fluid.nets.simple_img_conv_pool(
input=img,
filter_size=5,
num_filters=20,
pool_size=2,
pool_stride=2,
act="relu")
conv1_bn = fluid.layers.batch_norm(input=conv1)
conv2 = fluid.nets.simple_img_conv_pool(
input=conv1_bn,
filter_size=5,
num_filters=50,
pool_size=2,
pool_stride=2,
act="relu")
predition = fluid.layers.fc(input=conv2, size=10, act="softmax")
return predition
# 变量赋值
image = fluid.layers.data(name="img", shape=[1, 28, 28], dtype="float32")
predition = lenet_5(image)
place = fluid.CPUPlace()
exe = fluid.Executor(place=place)
exe.run(fluid.default_startup_program())
# 使用函数 save_inference_model() 保存 paddle 模型
fluid.io.save_inference_model(
"./paddle_lenet_5_model",
feeded_var_names=[image.name],
target_vars=[predition],
executor=exe)
from visualdl import LogWriter
if __name__ == '__main__':
hot_vectors = [
[1.3561076367500755, 1.3116267195134017, 1.6785401875616097],
[1.1039614644440658, 1.8891609992484688, 1.32030488587171],
[1.9924524852447711, 1.9358920727142739, 1.2124401279391606],
[1.4129542689796446, 1.7372166387197474, 1.7317806077076527],
[1.3913371800587777, 1.4684674577930312, 1.5214136352476377]]
labels = ["label_1", "label_2", "label_3", "label_4", "label_5"]
# 初始化一个记录器
with LogWriter(logdir="./log/high_dimensional_test/train") as writer:
# 将一组labels和对应的hot_vectors传入记录器进行记录
writer.add_embeddings(tag='default',
labels=labels,
hot_vectors=hot_vectors)
```
运行上述程序后，在命令行中执行
运行上述程序后，在命令行执行
```shell
visualdl --logdir ./log --host 0.0.0.0 --port 8080 --model_pb paddle_lenet_5_model
visualdl --logdir ./log --port 8080
```
接着在浏览器打开[http://0.0.0.0:8080](http://0.0.0.0:8080)，点击页面最上方的`GRAPHS`选项，即可查看 Lenet-5 的模型结构。
接着在浏览器打开`http://127.0.0.1:8080`，即可查看降维后的可视化数据。
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/demo/component/usage-interface/graph.png" width=800><br/>
图8. graph 组件展示 Lenet-5 的模型结构 <br/>
</p>
\ No newline at end of file
<img src="http://visualdl.bj.bcebos.com/images/dynamic_high_dimensional.gif" width="100%"/>
</p>
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或