Restructure of docs.

doc/api_guide.md

-
-## [模型分析](./analysis_api.md)
-
-## [卷积通道剪裁](./prune_api.md)
-
-## [蒸馏]()
-
-- [单进程蒸馏](../paddleslim/dist/single_distiller_api_doc.md)
-
-- [通道剪裁](../paddleslim/prune/prune_api.md)
-
-### [量化](../paddleslim/quant/quantization_api_doc.md)
-
-- [量化训练](../paddleslim/quant/quantization_api_doc.md#量化训练API)
-
-- [离线量化](../paddleslim/quant/quantization_api_doc.md#离线量化API)
-
-- [embedding量化](../paddleslim/quant/quantization_api_doc.md#Embedding量化API)
-
-## [小模型结构搜索]()

docs-src/api/api_guide.md

+# PaddleSlim API文档导航
+
+## [模型分析](./analysis_api.md)
+
+## [卷积通道剪裁](./prune_api.md)
+
+## [蒸馏]()
+
+- [单进程蒸馏](./single_distiller_api_doc.md)
+
+- [通道剪裁](./prune_api.md)
+
+### [量化](./quantization_api_doc.md)
+
+- [量化训练](./quantization_api_doc.md#量化训练API)
+
+- [离线量化](./quantization_api_doc.md#离线量化API)
+
+- [embedding量化](./quantization_api_doc.md#Embedding量化API)
+
+## [小模型结构搜索]()
+
+- [nas API](./nas_api.md)
+- [SearchSpace](./search_space_doc.md)

docs-src/api/search_space_doc.md

+# paddleslim.nas 提供的搜索空间：
+
+1. 根据原本模型结构构造搜索空间：
+
+  1.1 MobileNetV2Space
+  
+  1.2 MobileNetV1Space
+  
+  1.3 ResNetSpace
+
+
+2. 根据相应模型的block构造搜索空间
+
+  2.1 MobileNetV1BlockSpace
+  
+  2.2 MobileNetV2BlockSpace
+  
+  2.3 ResNetBlockSpace
+  
+  2.4 InceptionABlockSpace
+  
+  2.5 InceptionCBlockSpace
+
+
+##搜索空间的配置介绍：
+
+**input_size(int|None)**：`input_size`表示输入feature map的大小。
+**output_size(int|None)**：`output_size`表示输出feature map的大小。
+**block_num(int|None)**：`block_num`表示搜索空间中block的数量。
+**block_mask(list|None)**：`block_mask`表示当前的block是一个reduction block还是一个normal block，是一组由0、1组成的列表，0表示当前block是normal block，1表示当前block是reduction block。如果设置了`block_mask`，则主要以`block_mask`为主要配置，`input_size`，`output_size`和`block_num`三种配置是无效的。
+
+**Note:** 
+1. reduction block表示经过这个block之后的feature map大小下降为之前的一半，normal block表示经过这个block之后feature map大小不变。
+2. `input_size`和`output_size`用来计算整个模型结构中reduction block数量。
+
+
+##搜索空间示例：
+
+1. 使用paddleslim中提供用原本的模型结构来构造搜索空间的话，仅需要指定搜索空间名字即可。例如：如果使用原本的MobileNetV2的搜索空间进行搜索的话，传入SANAS中的config直接指定为[('MobileNetV2Space')]。
+2. 使用paddleslim中提供的block搜索空间构造搜索空间：
+  2.1 使用`input_size`, `output_size`和`block_num`来构造搜索空间。例如：传入SANAS的config可以指定为[('MobileNetV2BlockSpace', {'input_size': 224, 'output_size': 32, 'block_num': 10})]。
+  2.2 使用`block_mask`构造搜索空间。例如：传入SANAS的config可以指定为[('MobileNetV2BlockSpace', {'block_mask': [0, 1, 1, 1, 1, 0, 1, 0]})]。
+
+
+# 自定义搜索空间(search space)
+
+自定义搜索空间类需要继承搜索空间基类并重写以下几部分：
+  1. 初始化的tokens(`init_tokens`函数)，可以设置为自己想要的tokens列表, tokens列表中的每个数字指的是当前数字在相应的搜索列表中的索引。例如本示例中若tokens=[0, 3, 5]，则代表当前模型结构搜索到的通道数为[8, 40, 128]。
+  2. token中每个数字的搜索列表长度(`range_table`函数)，tokens中每个token的索引范围。
+  3. 根据token产生模型结构(`token2arch`函数)，根据搜索到的tokens列表产生模型结构。
+
+以新增reset block为例说明如何构造自己的search space。自定义的search space不能和已有的search space同名。
+
+```python
+### 引入搜索空间基类函数和search space的注册类函数
+from .search_space_base import SearchSpaceBase
+from .search_space_registry import SEARCHSPACE
+import numpy as np
+
+### 需要调用注册函数把自定义搜索空间注册到space space中
+@SEARCHSPACE.register
+### 定义一个继承SearchSpaceBase基类的搜索空间的类函数
+class ResNetBlockSpace2(SearchSpaceBase):
+    def __init__(self, input_size, output_size, block_num, block_mask):
+        ### 定义一些实际想要搜索的内容，例如：通道数、每个卷积的重复次数、卷积核大小等等
+        ### self.filter_num 代表通道数的搜索列表
+        self.filter_num = np.array([8, 16, 32, 40, 64, 128, 256, 512])
+
+    ### 定义初始化token，初始化token的长度根据传入的block_num或者block_mask的长度来得到的
+    def init_tokens(self):
+        return [0] * 3 * len(self.block_mask)
+
+    ### 定义
+    def range_table(self):
+        return [len(self.filter_num)] * 3 * len(self.block_mask)
+
+    def token2arch(self, tokens=None):
+        if tokens == None:
+            tokens = self.init_tokens()
+
+        self.bottleneck_params_list = []
+        for i in range(len(self.block_mask)):
+            self.bottleneck_params_list.append(self.filter_num[tokens[i * 3 + 0]], 
+                                               self.filter_num[tokens[i * 3 + 1]],
+                                               self.filter_num[tokens[i * 3 + 2]],
+                                               2 if self.block_mask[i] == 1 else 1)
+
+        def net_arch(input):
+            for i, layer_setting in enumerate(self.bottleneck_params_list):
+                channel_num, stride = layer_setting[:-1], layer_setting[-1]
+                input = self._resnet_block(input, channel_num, stride, name='resnet_layer{}'.format(i+1))
+
+            return input
+
+        return net_arch
+
+    ### 构造具体block的操作
+    def _resnet_block(self, input, channel_num, stride, name=None):
+        shortcut_conv = self._shortcut(input, channel_num[2], stride, name=name)
+        input = self._conv_bn_layer(input=input, num_filters=channel_num[0], filter_size=1, act='relu', name=name + '_conv0')
+        input = self._conv_bn_layer(input=input, num_filters=channel_num[1], filter_size=3, stride=stride, act='relu', name=name + '_conv1')
+        input = self._conv_bn_layer(input=input, num_filters=channel_num[2], filter_size=1, name=name + '_conv2')
+        return fluid.layers.elementwise_add(x=shortcut_conv, y=input, axis=0, name=name+'_elementwise_add')
+
+    def _shortcut(self, input, channel_num, stride, name=None):
+        channel_in = input.shape[1]
+        if channel_in != channel_num or stride != 1:
+            return self.conv_bn_layer(input, num_filters=channel_num, filter_size=1, stride=stride, name=name+'_shortcut')
+        else:
+            return input
+
+    def _conv_bn_layer(self, input, num_filters, filter_size, stride=1, padding='SAME', act=None, name=None):
+        conv = fluid.layers.conv2d(input, num_filters, filter_size, stride, name=name+'_conv')
+        bn = fluid.layers.batch_norm(conv, act=act, name=name+'_bn')
+        return bn
+``` 

doc/demo_guide.md → docs-src/demo/demo_guide.md

@@ -9,6 +9,10 @@ demo中对teahcer模型和student模型的一层特征图添加了l2_loss的蒸
 
 ## 量化
 
-### [量化训练demo文档](../demo/quant/quant_aware/README.md)
-### [离线量化demo文档](../demo/quant/quant_post/README.md)
-### [Embedding量化demo文档](../demo/quant/quant_embedding/README.md)
+### [量化训练demo文档](./quant_aware_demo.md)
+### [离线量化demo文档](./quant_post_demo.md)
+### [Embedding量化demo文档](./quant_embedding_demo.md)
+
+## NAS
+
+### [NAS示例](./nas_demo.md)

docs-src/demo/nas_demo.md

+# 网络结构搜索示例
+
+本示例介绍如何使用网络结构搜索接口，搜索到一个更小或者精度更高的模型，该文档仅介绍paddleslim中SANAS的使用及如何利用SANAS得到模型结构，完整示例代码请参考sa_nas_mobilenetv2.py或者block_sa_nas_mobilenetv2.py。
+
+## 接口介绍
+请参考。
+
+### 1. 配置搜索空间
+详细的搜索空间配置可以参考<a href='../../../paddleslim/nas/nas_api.md'>神经网络搜索API文档</a>。
+```
+config = [('MobileNetV2Space')]
+
+```
+
+### 2. 利用搜索空间初始化SANAS实例
+```
+from paddleslim.nas import SANAS
+
+sa_nas = SANAS(
+    config,
+    server_addr=("", 8881),
+    init_temperature=10.24,
+    reduce_rate=0.85,
+    search_steps=300,
+    is_server=True)
+
+```
+
+### 3. 根据实例化的NAS得到当前的网络结构
+```
+archs = sa_nas.next_archs()
+```
+
+### 4. 根据得到的网络结构和输入构造训练和测试program
+```
+import paddle.fluid as fluid
+
+train_program = fluid.Program()
+test_program = fluid.Program()
+startup_program = fluid.Program()
+
+with fluid.program_guard(train_program, startup_program):
+    data = fluid.data(name='data', shape=[None, 3, 32, 32], dtype='float32')
+    label = fluid.data(name='label', shape=[None, 1], dtype='int64')
+    for arch in archs:
+        data = arch(data)
+    output = fluid.layers.fc(data, 10)
+    softmax_out = fluid.layers.softmax(input=output, use_cudnn=False)
+    cost = fluid.layers.cross_entropy(input=softmax_out, label=label)
+    avg_cost = fluid.layers.mean(cost)
+    acc_top1 = fluid.layers.accuracy(input=softmax_out, label=label, k=1)
+
+    test_program = train_program.clone(for_test=True)
+    sgd = fluid.optimizer.SGD(learning_rate=1e-3)
+    sgd.minimize(avg_cost)
+    
+```
+
+### 5. 根据构造的训练program添加限制条件
+```
+from paddleslim.analysis import flops
+
+if flops(train_program) > 321208544:
+    continue
+```
+
+### 6. 回传score
+```
+sa_nas.reward(score)
+```

docs-src/demo/quant_aware_demo.md

+# 在线量化示例
+
+本示例介绍如何使用在线量化接口，来对训练好的分类模型进行量化, 可以减少模型的存储空间和显存占用。
+
+## 接口介绍
+
+请参考 <a href='../../../paddleslim/quant/quantization_api_doc.md'>量化API文档</a>。
+
+## 分类模型的离线量化流程
+
+### 1. 配置量化参数
+
+```
+quant_config = {
+    'weight_quantize_type': 'abs_max',
+    'activation_quantize_type': 'moving_average_abs_max',
+    'weight_bits': 8,
+    'activation_bits': 8,
+    'not_quant_pattern': ['skip_quant'],
+    'quantize_op_types': ['conv2d', 'depthwise_conv2d', 'mul'],
+    'dtype': 'int8',
+    'window_size': 10000,
+    'moving_rate': 0.9,
+    'quant_weight_only': False
+}
+```
+
+### 2. 对训练和测试program插入可训练量化op
+
+```
+val_program = quant_aware(val_program, place, quant_config, scope=None, for_test=True)
+
+compiled_train_prog = quant_aware(train_prog, place, quant_config, scope=None, for_test=False)
+```
+
+### 3.关掉指定build策略
+
+```
+build_strategy = fluid.BuildStrategy()
+build_strategy.fuse_all_reduce_ops = False
+build_strategy.sync_batch_norm = False
+exec_strategy = fluid.ExecutionStrategy()
+compiled_train_prog = compiled_train_prog.with_data_parallel(
+        loss_name=avg_cost.name,
+        build_strategy=build_strategy,
+        exec_strategy=exec_strategy)
+```
+
+### 4. freeze program
+
+```
+float_program, int8_program = convert(val_program, 
+                                      place,
+                                      quant_config,
+                                      scope=None,
+                                      save_int8=True)
+```
+
+### 5.保存预测模型
+
+```
+fluid.io.save_inference_model(
+    dirname=float_path,
+    feeded_var_names=[image.name],
+    target_vars=[out], executor=exe,
+    main_program=float_program,
+    model_filename=float_path + '/model',
+    params_filename=float_path + '/params')
+
+fluid.io.save_inference_model(
+    dirname=int8_path,
+    feeded_var_names=[image.name],
+    target_vars=[out], executor=exe,
+    main_program=int8_program,
+    model_filename=int8_path + '/model',
+    params_filename=int8_path + '/params')
+```

docs-src/demo/quant_embedding_demo.md

+# Embedding量化示例
+
+本示例介绍如何使用Embedding量化的接口 [paddleslim.quant.quant_embedding]() 。``quant_embedding``接口将网络中的Embedding参数从``float32``类型量化到 ``8-bit``整数类型，在几乎不损失模型精度的情况下减少模型的存储空间和显存占用。
+
+
+接口介绍请参考 <a href='../../../paddleslim/quant/quantization_api_doc.md'>量化API文档</a>。
+
+该接口对program的修改：
+
+量化前:
+
+<p align="center">
+<img src="./image/before.png" height=200 width=100 hspace='10'/> <br />
+<strong>图1：量化前的模型结构</strong>
+</p>
+
+量化后：
+
+<p align="center">
+<img src="./image/after.png" height=300 width=300 hspace='10'/> <br />
+<strong>图2: 量化后的模型结构</strong>
+</p>
+
+以下将以 ``基于skip-gram的word2vector模型`` 为例来说明如何使用``quant_embedding``接口。首先介绍 ``基于skip-gram的word2vector模型`` 的正常训练和测试流程。
+
+## 基于skip-gram的word2vector模型
+
+以下是本例的简要目录结构及说明：
+
+```text
+.
+├── cluster_train.py    # 分布式训练函数
+├── cluster_train.sh    # 本地模拟多机脚本
+├── train.py            # 训练函数
+├── infer.py            # 预测脚本
+├── net.py              # 网络结构
+├── preprocess.py       # 预处理脚本，包括构建词典和预处理文本
+├── reader.py           # 训练阶段的文本读写
+├── train.py            # 训练函数
+└── utils.py            # 通用函数
+
+```
+
+### 介绍
+本例实现了skip-gram模式的word2vector模型。
+
+同时推荐用户参考[ IPython Notebook demo](https://aistudio.baidu.com/aistudio/projectDetail/124377)
+
+### 数据下载
+全量数据集使用的是来自1 Billion Word Language Model Benchmark的(http://www.statmt.org/lm-benchmark) 的数据集.
+
+```bash
+mkdir data
+wget http://www.statmt.org/lm-benchmark/1-billion-word-language-modeling-benchmark-r13output.tar.gz
+tar xzvf 1-billion-word-language-modeling-benchmark-r13output.tar.gz
+mv 1-billion-word-language-modeling-benchmark-r13output/training-monolingual.tokenized.shuffled/ data/
+```
+
+备用数据地址下载命令如下
+
+```bash
+mkdir data
+wget https://paddlerec.bj.bcebos.com/word2vec/1-billion-word-language-modeling-benchmark-r13output.tar
+tar xvf 1-billion-word-language-modeling-benchmark-r13output.tar
+mv 1-billion-word-language-modeling-benchmark-r13output/training-monolingual.tokenized.shuffled/ data/
+```
+
+为了方便快速验证，我们也提供了经典的text8样例数据集，包含1700w个词。 下载命令如下
+
+```bash
+mkdir data
+wget https://paddlerec.bj.bcebos.com/word2vec/text.tar
+tar xvf text.tar
+mv text data/
+```
+
+
+### 数据预处理
+以样例数据集为例进行预处理。全量数据集注意解压后以training-monolingual.tokenized.shuffled 目录为预处理目录，和样例数据集的text目录并列。
+
+词典格式: 词<空格>词频。注意低频词用'UNK'表示
+
+可以按格式自建词典，如果自建词典跳过第一步。
+```
+the 1061396
+of 593677
+and 416629
+one 411764
+in 372201
+a 325873
+<UNK> 324608
+to 316376
+zero 264975
+nine 250430
+```
+
+第一步根据英文语料生成词典，中文语料可以通过修改text_strip方法自定义处理方法。
+
+```bash
+python preprocess.py --build_dict --build_dict_corpus_dir data/text/ --dict_path data/test_build_dict
+```
+
+第二步根据词典将文本转成id, 同时进行downsample，按照概率过滤常见词, 同时生成word和id映射的文件，文件名为词典+"_word_to_id_"。
+
+```bash
+python preprocess.py --filter_corpus --dict_path data/test_build_dict --input_corpus_dir data/text --output_corpus_dir data/convert_text8 --min_count 5 --downsample 0.001
+```
+
+### 训练
+具体的参数配置可运行
+
+
+```bash
+python train.py -h
+```
+
+单机多线程训练
+```bash
+OPENBLAS_NUM_THREADS=1 CPU_NUM=5 python train.py --train_data_dir data/convert_text8 --dict_path data/test_build_dict --num_passes 10 --batch_size 100 --model_output_dir v1_cpu5_b100_lr1dir --base_lr 1.0 --print_batch 1000 --with_speed --is_sparse
+```
+
+本地单机模拟多机训练
+
+```bash
+sh cluster_train.sh
+```
+
+本示例中按照单机多线程训练的命令进行训练，训练完毕后，可看到在当前文件夹下保存模型的路径为:     ``v1_cpu5_b100_lr1dir``, 运行 ``ls v1_cpu5_b100_lr1dir``可看到该文件夹下保存了训练的10个epoch的模型文件。
+```
+pass-0  pass-1  pass-2  pass-3  pass-4  pass-5  pass-6  pass-7  pass-8  pass-9
+```
+
+### 预测
+测试集下载命令如下
+
+```bash
+#全量数据集测试集
+wget https://paddlerec.bj.bcebos.com/word2vec/test_dir.tar
+#样本数据集测试集
+wget https://paddlerec.bj.bcebos.com/word2vec/test_mid_dir.tar
+```
+
+预测命令，注意词典名称需要加后缀"_word_to_id_", 此文件是预处理阶段生成的。
+```bash
+python infer.py --infer_epoch --test_dir data/test_mid_dir --dict_path data/test_build_dict_word_to_id_ --batch_size 20000 --model_dir v1_cpu5_b100_lr1dir/  --start_index 0 --last_index 9
+```
+运行该预测命令, 可看到如下输出
+```
+('start index: ', 0, ' last_index:', 9)
+('vocab_size:', 63642)
+step:1 249
+epoch:0          acc:0.014
+step:1 590
+epoch:1          acc:0.033
+step:1 982
+epoch:2          acc:0.055
+step:1 1338
+epoch:3          acc:0.075
+step:1 1653
+epoch:4          acc:0.093
+step:1 1914
+epoch:5          acc:0.107
+step:1 2204
+epoch:6          acc:0.124
+step:1 2416
+epoch:7          acc:0.136
+step:1 2606
+epoch:8          acc:0.146
+step:1 2722
+epoch:9          acc:0.153
+```
+
+## 量化``基于skip-gram的word2vector模型``
+
+量化配置为:
+```
+config = {
+        'params_name': 'emb',
+        'quantize_type': 'abs_max'
+        }
+```
+
+运行命令为：
+
+```bash
+python infer.py --infer_epoch --test_dir data/test_mid_dir --dict_path data/test_build_dict_word_to_id_ --batch_size 20000 --model_dir v1_cpu5_b100_lr1dir/  --start_index 0 --last_index 9 --emb_quant True
+```
+
+运行输出为:
+
+```
+('start index: ', 0, ' last_index:', 9)
+('vocab_size:', 63642)
+quant_embedding config {'quantize_type': 'abs_max', 'params_name': 'emb', 'quantize_bits': 8, 'dtype': 'int8'}
+step:1 253
+epoch:0          acc:0.014
+quant_embedding config {'quantize_type': 'abs_max', 'params_name': 'emb', 'quantize_bits': 8, 'dtype': 'int8'}
+step:1 586
+epoch:1          acc:0.033
+quant_embedding config {'quantize_type': 'abs_max', 'params_name': 'emb', 'quantize_bits': 8, 'dtype': 'int8'}
+step:1 970
+epoch:2          acc:0.054
+quant_embedding config {'quantize_type': 'abs_max', 'params_name': 'emb', 'quantize_bits': 8, 'dtype': 'int8'}
+step:1 1364
+epoch:3          acc:0.077
+quant_embedding config {'quantize_type': 'abs_max', 'params_name': 'emb', 'quantize_bits': 8, 'dtype': 'int8'}
+step:1 1642
+epoch:4          acc:0.092
+quant_embedding config {'quantize_type': 'abs_max', 'params_name': 'emb', 'quantize_bits': 8, 'dtype': 'int8'}
+step:1 1936
+epoch:5          acc:0.109
+quant_embedding config {'quantize_type': 'abs_max', 'params_name': 'emb', 'quantize_bits': 8, 'dtype': 'int8'}
+step:1 2216
+epoch:6          acc:0.124
+quant_embedding config {'quantize_type': 'abs_max', 'params_name': 'emb', 'quantize_bits': 8, 'dtype': 'int8'}
+step:1 2419
+epoch:7          acc:0.136
+quant_embedding config {'quantize_type': 'abs_max', 'params_name': 'emb', 'quantize_bits': 8, 'dtype': 'int8'}
+step:1 2603
+epoch:8          acc:0.146
+quant_embedding config {'quantize_type': 'abs_max', 'params_name': 'emb', 'quantize_bits': 8, 'dtype': 'int8'}
+step:1 2719
+epoch:9          acc:0.153
+```
+
+量化后的模型保存在``./output_quant``中，可看到量化后的参数``'emb.int8'``的大小为3.9M, 在``./v1_cpu5_b100_lr1dir``中可看到量化前的参数``'emb'``的大小为16M。

docs-src/demo/quant_post_demo.md

+# 离线量化示例
+
+本示例介绍如何使用离线量化接口``paddleslim.quant.quant_post``来对训练好的分类模型进行离线量化, 该接口无需对模型进行训练就可得到量化模型，减少模型的存储空间和显存占用。
+
+## 接口介绍
+
+请参考 <a href='../../../paddleslim/quant/quantization_api_doc.md'>量化API文档</a>。
+
+## 分类模型的离线量化流程
+
+### 准备数据
+
+在当前文件夹下创建``data``文件夹，将``imagenet``数据集解压在``data``文件夹下，解压后``data``文件夹下应包含以下文件：
+- ``'train'``文件夹，训练图片
+- ``'train_list.txt'``文件
+- ``'val'``文件夹，验证图片
+- ``'val_list.txt'``文件
+
+### 准备需要量化的模型
+因为离线量化接口只支持加载通过``fluid.io.save_inference_model``接口保存的模型，因此如果您的模型是通过其他接口保存的，那需要先将模型进行转化。本示例将以分类模型为例进行说明。
+
+首先在[imagenet分类模型](https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/image_classification#%E5%B7%B2%E5%8F%91%E5%B8%83%E6%A8%A1%E5%9E%8B%E5%8F%8A%E5%85%B6%E6%80%A7%E8%83%BD)中下载训练好的``mobilenetv1``模型。
+
+在当前文件夹下创建``'pretrain'``文件夹，将``mobilenetv1``模型在该文件夹下解压，解压后的目录为``pretrain/MobileNetV1_pretrained``
+
+### 导出模型
+通过运行以下命令可将模型转化为离线量化接口可用的模型：
+```
+python export_model.py --model "MobileNet" --pretrained_model ./pretrain/MobileNetV1_pretrained --data imagenet
+```
+转化之后的模型存储在``inference_model/MobileNet/``文件夹下，可看到该文件夹下有``'model'``, ``'weights'``两个文件。
+
+### 离线量化
+接下来对导出的模型文件进行离线量化，离线量化的脚本为[quant_post.py](./quant_post.py)，脚本中使用接口``paddleslim.quant.quant_post``对模型进行离线量化。运行命令为：
+```
+python quant_post.py --model_path ./inference_model/MobileNet --save_path ./quant_model_train/MobileNet --model_filename model --params_filename weights
+```
+
+- ``model_path``: 需要量化的模型坐在的文件夹
+- ``save_path``: 量化后的模型保存的路径
+- ``model_filename``: 如果需要量化的模型的参数文件保存在一个文件中，则设置为该模型的模型文件名称，如果参数文件保存在多个文件中，则不需要设置。
+- ``params_filename``: 如果需要量化的模型的参数文件保存在一个文件中，则设置为该模型的参数文件名称，如果参数文件保存在多个文件中，则不需要设置。
+
+运行以上命令后，可在``${save_path}``下看到量化后的模型文件和参数文件。
+
+> 使用的量化算法为``'KL'``, 使用训练集中的160张图片进行量化参数的校正。
+
+
+### 测试精度
+
+使用[eval.py](./eval.py)脚本对量化前后的模型进行测试，得到模型的分类精度进行对比。
+
+首先测试量化前的模型的精度，运行以下命令：
+```
+python eval.py --model_path ./inference_model/MobileNet --model_name model --params_name weights
+```
+精度输出为:
+```
+top1_acc/top5_acc= [0.70913923 0.89548034]
+```
+
+使用以下命令测试离线量化后的模型的精度：
+
+```
+python eval.py --model_path ./quant_model_train/MobileNet
+```
+
+精度输出为
+```
+top1_acc/top5_acc= [0.70141864 0.89086477]
+```
+从以上精度对比可以看出，对``mobilenet``在``imagenet``上的分类模型进行离线量化后 ``top1``精度损失为``0.77%``， ``top5``精度损失为``0.46%``.