Add Mbv3 Demo in Full Quant (#1413)

example/auto_compression/image_classification/infer.py

@@ -218,6 +218,7 @@ class Predictor(object):
                 results.append([top_1, top_5])
 
             result = np.mean(np.array(results), axis=0)
+            t.update()
         print('Evaluation result: {}'.format(result[0]))
 
 

example/auto_compression/image_classification/run.py

@@ -18,6 +18,7 @@ import argparse
 import functools
 from functools import partial
 import math
+from tqdm import tqdm
 
 import numpy as np
 import paddle
@@ -87,40 +88,43 @@ def eval_function(exe, compiled_test_program, test_feed_names, test_fetch_list):
         resize_size=resize_size)
 
     results = []
-    print('Evaluating...')
-    for batch_id, (image, label) in enumerate(val_loader):
-        # top1_acc, top5_acc
-        if len(test_feed_names) == 1:
-            image = np.array(image)
-            label = np.array(label).astype('int64')
-            pred = exe.run(compiled_test_program,
-                           feed={test_feed_names[0]: image},
-                           fetch_list=test_fetch_list)
-            pred = np.array(pred[0])
-            label = np.array(label)
-            sort_array = pred.argsort(axis=1)
-            top_1_pred = sort_array[:, -1:][:, ::-1]
-            top_1 = np.mean(label == top_1_pred)
-            top_5_pred = sort_array[:, -5:][:, ::-1]
-            acc_num = 0
-            for i in range(len(label)):
-                if label[i][0] in top_5_pred[i]:
-                    acc_num += 1
-            top_5 = float(acc_num) / len(label)
-            results.append([top_1, top_5])
-        else:
-            # eval "eval model", which inputs are image and label, output is top1 and top5 accuracy
-            image = np.array(image)
-            label = np.array(label).astype('int64')
-            result = exe.run(
-                compiled_test_program,
-                feed={test_feed_names[0]: image,
-                      test_feed_names[1]: label},
-                fetch_list=test_fetch_list)
-            result = [np.mean(r) for r in result]
-            results.append(result)
-        if batch_id % 100 == 0:
-            print('Eval iter: ', batch_id)
+    with tqdm(
+            total=len(val_loader),
+            bar_format='Evaluation stage, Run batch:|{bar}| {n_fmt}/{total_fmt}',
+            ncols=80) as t:
+        for batch_id, (image, label) in enumerate(val_loader):
+            # top1_acc, top5_acc
+            if len(test_feed_names) == 1:
+                image = np.array(image)
+                label = np.array(label).astype('int64')
+                pred = exe.run(compiled_test_program,
+                               feed={test_feed_names[0]: image},
+                               fetch_list=test_fetch_list)
+                pred = np.array(pred[0])
+                label = np.array(label)
+                sort_array = pred.argsort(axis=1)
+                top_1_pred = sort_array[:, -1:][:, ::-1]
+                top_1 = np.mean(label == top_1_pred)
+                top_5_pred = sort_array[:, -5:][:, ::-1]
+                acc_num = 0
+                for i in range(len(label)):
+                    if label[i][0] in top_5_pred[i]:
+                        acc_num += 1
+                top_5 = float(acc_num) / len(label)
+                results.append([top_1, top_5])
+            else:
+                # eval "eval model", which inputs are image and label, output is top1 and top5 accuracy
+                image = np.array(image)
+                label = np.array(label).astype('int64')
+                result = exe.run(compiled_test_program,
+                                 feed={
+                                     test_feed_names[0]: image,
+                                     test_feed_names[1]: label
+                                 },
+                                 fetch_list=test_fetch_list)
+                result = [np.mean(r) for r in result]
+                results.append(result)
+            t.update()
     result = np.mean(np.array(results), axis=0)
     return result[0]
 

example/full_quantization/detection/run.py

@@ -17,6 +17,7 @@ import sys
 import numpy as np
 import argparse
 import paddle
+from tqdm import tqdm
 from ppdet.core.workspace import load_config, merge_config
 from ppdet.core.workspace import create
 from ppdet.metrics import COCOMetric, VOCMetric, KeyPointTopDownCOCOEval
@@ -78,31 +79,34 @@ def convert_numpy_data(data, metric):
 
 def eval_function(exe, compiled_test_program, test_feed_names, test_fetch_list):
     metric = global_config['metric']
-    for batch_id, data in enumerate(val_loader):
-        data_all = convert_numpy_data(data, metric)
-        data_input = {}
-        for k, v in data.items():
-            if isinstance(global_config['input_list'], list):
-                if k in test_feed_names:
-                    data_input[k] = np.array(v)
-            elif isinstance(global_config['input_list'], dict):
-                if k in global_config['input_list'].keys():
-                    data_input[global_config['input_list'][k]] = np.array(v)
-        outs = exe.run(compiled_test_program,
-                       feed=data_input,
-                       fetch_list=test_fetch_list,
-                       return_numpy=False)
-        res = {}
-        for out in outs:
-            v = np.array(out)
-            if len(v.shape) > 1:
-                res['bbox'] = v
-            else:
-                res['bbox_num'] = v
-
-        metric.update(data_all, res)
-        if batch_id % 100 == 0:
-            print('Eval iter:', batch_id)
+    with tqdm(
+            total=len(val_loader),
+            bar_format='Evaluation stage, Run batch:|{bar}| {n_fmt}/{total_fmt}',
+            ncols=80) as t:
+        for batch_id, data in enumerate(val_loader):
+            data_all = convert_numpy_data(data, metric)
+            data_input = {}
+            for k, v in data.items():
+                if isinstance(global_config['input_list'], list):
+                    if k in test_feed_names:
+                        data_input[k] = np.array(v)
+                elif isinstance(global_config['input_list'], dict):
+                    if k in global_config['input_list'].keys():
+                        data_input[global_config['input_list'][k]] = np.array(v)
+            outs = exe.run(compiled_test_program,
+                           feed=data_input,
+                           fetch_list=test_fetch_list,
+                           return_numpy=False)
+            res = {}
+            for out in outs:
+                v = np.array(out)
+                if len(v.shape) > 1:
+                    res['bbox'] = v
+                else:
+                    res['bbox_num'] = v
+
+            metric.update(data_all, res)
+            t.update()
     metric.accumulate()
     metric.log()
     map_res = metric.get_results()

example/full_quantization/image_classification/README.md

+# 图像分类模型全量化示例
+
+目录：
+- [1. 简介](#1简介)
+- [2. Benchmark](#2Benchmark)
+- [3. 全量化流程](#全量化流程)
+  - [3.1 准备环境](#31-准备准备)
+  - [3.2 准备数据集](#32-准备数据集)
+  - [3.3 准备预测模型](#33-准备预测模型)
+  - [3.4 全量化并产出模型](#34-全量化并产出模型)
+- [4. 预测部署](#4预测部署)
+  - [4.1 PaddleLite端侧部署](#42-PaddleLite端侧部署)
+- [5. FAQ](5FAQ)
+
+
+## 1. 简介
+本示例将以图像分类模型MobileNetV1为例，介绍如何使用PaddleClas中Inference部署模型进行全量化。本示例全量化的策略使用了量化训练和蒸馏。
+
+## 2. Benchmark
+
+### PaddleClas模型
+
+| 模型 | 策略 | Top-1 Acc | GPU 耗时(ms) | ARM CPU 耗时(ms) | 配置文件 | Inference模型 |
+|:------:|:------:|:------:|:------:|:------:|:------:|:------:|
+| MobileNetV3_large_x1_0 | Baseline | 75.32 | - | - | - | [Model](https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/MobileNetV3_large_x1_0_infer.tar) |
+| MobileNetV3_large_x1_0 | 全量化 | 74.41 | - | - | [Config](./configs/MobileNetV3_large_x1_0/qat_dis.yaml) | [Model](https://paddle-slim-models.bj.bcebos.com/act/MobileNetV3_large_x1_0_QAT.tar) |
+
+
+## 3. 全量化流程
+
+#### 3.1 准备环境
+
+- python >= 3.6
+- PaddlePaddle >= 2.3 （可从[Paddle官网](https://www.paddlepaddle.org.cn/install/quick?docurl=/documentation/docs/zh/install/pip/linux-pip.html)下载安装）
+- PaddleSlim >= 2.3
+
+安装paddlepaddle：
+```shell
+# CPU
+pip install paddlepaddle
+# GPU
+pip install paddlepaddle-gpu
+```
+
+安装paddleslim：
+```shell
+pip install paddleslim
+```
+
+#### 3.2 准备数据集
+本案例默认以ImageNet1k数据进行全量化实验，如数据集为非ImageNet1k格式数据， 请参考[PaddleClas数据准备文档](https://github.com/PaddlePaddle/PaddleClas/blob/release/2.3/docs/zh_CN/data_preparation/classification_dataset.md)。将下载好的数据集放在当前目录下`./ILSVRC2012`。
+
+
+#### 3.3 准备预测模型
+预测模型的格式为：`model.pdmodel` 和 `model.pdiparams`两个，带`pdmodel`的是模型文件，带`pdiparams`后缀的是权重文件。
+
+注：其他像`__model__`和`__params__`分别对应`model.pdmodel` 和 `model.pdiparams`文件。
+
+可在[PaddleClas预训练模型库](https://github.com/PaddlePaddle/PaddleClas/blob/release/2.3/docs/zh_CN/algorithm_introduction/ImageNet_models.md)中直接获取Inference模型，具体可参考下方获取MobileNetV1模型示例：
+
+```shell
+wget https://paddle-imagenet-models-name.bj.bcebos.com/dygraph/inference/MobileNetV3_large_x1_0_infer.tar
+tar -xf MobileNetV3_large_x1_0_infer.tar
+```
+也可根据[PaddleClas文档](https://github.com/PaddlePaddle/PaddleClas/blob/release/2.3/docs/zh_CN/inference_deployment/export_model.md)导出Inference模型。
+
+#### 3.4 全量化并产出模型
+
+全量化示例通过run.py脚本启动，会使用接口 ```paddleslim.auto_compression.AutoCompression``` 对模型进行量化训练和蒸馏。配置config文件中模型路径、数据集路径、蒸馏、量化和训练等部分的参数，配置完成后便可开始全量化。
+
+**单卡启动**
+
+```shell
+export CUDA_VISIBLE_DEVICES=0
+python run.py --save_dir='./save_quant_mobilev3/' --config_path='./configs/mobilenetv3_large_qat_dis.yaml'
+```
+
+**多卡启动**
+
+图像分类训练任务中往往包含大量训练数据，以ImageNet为例，ImageNet22k数据集中包含1400W张图像，如果使用单卡训练，会非常耗时，使用分布式训练可以达到几乎线性的加速比。
+
+```shell
+export CUDA_VISIBLE_DEVICES=0,1,2,3
+python -m paddle.distributed.launch run.py --save_dir='./save_quant_mobilev3/' --config_path='./configs/mobilenetv3_large_qat_dis.yaml'
+```
+多卡训练指的是将训练任务按照一定方法拆分到多个训练节点完成数据读取、前向计算、反向梯度计算等过程，并将计算出的梯度上传至服务节点。服务节点在收到所有训练节点传来的梯度后，会将梯度聚合并更新参数。最后将参数发送给训练节点，开始新一轮的训练。多卡训练一轮训练能训练```batch size * num gpus```的数据，比如单卡的```batch size```为32，单轮训练的数据量即32，而四卡训练的```batch size```为32，单轮训练的数据量为128。
+
+注意 ```learning rate``` 与 ```batch size``` 呈线性关系，这里单卡 ```batch size``` 为32，对应的 ```learning rate``` 为0.015，那么如果 ```batch size``` 减小4倍改为8，```learning rate``` 也需除以4；多卡时 ```batch size``` 为32，```learning rate``` 需乘上卡数。所以改变 ```batch size``` 或改变训练卡数都需要对应修改 ```learning rate```。
+
+**验证精度**
+
+根据训练log可以看到模型验证的精度，若需再次验证精度，修改配置文件```./configs/MobileNetV1/qat_dis.yaml```中所需验证模型的文件夹路径及模型和参数名称```model_dir, model_filename, params_filename```，然后使用以下命令进行验证：
+
+```shell
+export CUDA_VISIBLE_DEVICES=0
+python eval.py --config_path='./configs/eval.yaml'
+```
+
+
+## 4.预测部署
+
+#### 4.1 PaddleLite端侧部署
+PaddleLite端侧部署可参考：
+- [Paddle Lite部署](https://github.com/PaddlePaddle/PaddleClas/blob/develop/docs/zh_CN/inference_deployment/paddle_lite_deploy.md)
+
+## 5.FAQ

example/full_quantization/image_classification/configs/eval.yaml

+model_dir: ./MobileNetV3_large_x1_0_infer
+model_filename: inference.pdmodel
+params_filename: inference.pdiparams
+batch_size: 128
+data_dir: ./ILSVRC2012_data_demo/ILSVRC2012/
+img_size: 224
+resize_size: 256

example/full_quantization/image_classification/configs/mobilenetv3_large_qat_dis.yaml

+Global:
+  input_name: inputs
+  model_dir: MobileNetV3_large_x1_0_infer
+  model_filename: inference.pdmodel
+  params_filename: inference.pdiparams
+  batch_size: 128
+  data_dir: ./ILSVRC2012_data_demo/ILSVRC2012/
+
+Distillation:
+  alpha: 1.0
+  loss: soft_label
+Quantization:
+  use_pact: true
+  activation_bits: 8
+  activation_quantize_type: moving_average_abs_max
+  weight_quantize_type: channel_wise_abs_max
+  not_quant_pattern:
+  - skip_quant
+  quantize_op_types:
+  - conv2d
+  - depthwise_conv2d
+  - matmul
+  weight_bits: 8
+TrainConfig:
+  epochs: 2
+  eval_iter: 5000
+  learning_rate: 0.001
+  optimizer_builder:
+    optimizer:
+      type: Momentum
+    weight_decay: 0.00002
+  origin_metric: 0.7896

example/full_quantization/image_classification/eval.py

+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import sys
+import argparse
+import functools
+from functools import partial
+
+import numpy as np
+import paddle
+import paddle.nn as nn
+from paddle.io import DataLoader
+from imagenet_reader import ImageNetDataset
+from paddleslim.common import load_config as load_slim_config
+
+
+def argsparser():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        '--config_path',
+        type=str,
+        default='./image_classification/configs/eval.yaml',
+        help="path of compression strategy config.")
+    parser.add_argument(
+        '--model_dir',
+        type=str,
+        default='./MobileNetV1_infer',
+        help='model directory')
+    return parser
+
+
+def eval_reader(data_dir, batch_size, crop_size, resize_size):
+    val_reader = ImageNetDataset(
+        mode='val',
+        data_dir=data_dir,
+        crop_size=crop_size,
+        resize_size=resize_size)
+    val_loader = DataLoader(
+        val_reader,
+        batch_size=global_config['batch_size'],
+        shuffle=False,
+        drop_last=False,
+        num_workers=0)
+    return val_loader
+
+
+def eval():
+    devices = paddle.device.get_device().split(':')[0]
+    places = paddle.device._convert_to_place(devices)
+    exe = paddle.static.Executor(places)
+    val_program, feed_target_names, fetch_targets = paddle.static.load_inference_model(
+        global_config["model_dir"],
+        exe,
+        model_filename=global_config["model_filename"],
+        params_filename=global_config["params_filename"])
+    print('Loaded model from: {}'.format(global_config["model_dir"]))
+
+    val_loader = eval_reader(
+        data_dir,
+        batch_size=global_config['batch_size'],
+        crop_size=img_size,
+        resize_size=resize_size)
+    results = []
+    print('Evaluating...')
+    for batch_id, (image, label) in enumerate(val_loader):
+        image = np.array(image)
+        label = np.array(label).astype('int64')
+        pred = exe.run(val_program,
+                       feed={feed_target_names[0]: image},
+                       fetch_list=fetch_targets)
+        pred = np.array(pred[0])
+        label = np.array(label)
+        sort_array = pred.argsort(axis=1)
+        top_1_pred = sort_array[:, -1:][:, ::-1]
+        top_1 = np.mean(label == top_1_pred)
+        top_5_pred = sort_array[:, -5:][:, ::-1]
+        acc_num = 0
+        for i in range(len(label)):
+            if label[i][0] in top_5_pred[i]:
+                acc_num += 1
+        top_5 = float(acc_num) / len(label)
+        results.append([top_1, top_5])
+    result = np.mean(np.array(results), axis=0)
+    return result[0]
+
+
+def main(args):
+    global global_config
+    global_config = load_slim_config(args.config_path)
+
+    global data_dir
+    data_dir = global_config['data_dir']
+    if args.model_dir != global_config['model_dir']:
+        global_config['model_dir'] = args.model_dir
+
+    global img_size, resize_size
+    img_size = int(global_config[
+        'img_size']) if 'img_size' in global_config else 224
+    resize_size = int(global_config[
+        'resize_size']) if 'resize_size' in global_config else 256
+
+    result = eval()
+    print('Eval Top1:', result)
+
+
+if __name__ == '__main__':
+    paddle.enable_static()
+    parser = argsparser()
+    args = parser.parse_args()
+    main(args)

example/full_quantization/image_classification/imagenet_reader.py

+import os
+import math
+import random
+import functools
+import numpy as np
+import paddle
+from PIL import Image, ImageEnhance
+from paddle.io import Dataset
+
+random.seed(0)
+np.random.seed(0)
+
+DATA_DIM = 224
+RESIZE_DIM = 256
+
+THREAD = 16
+BUF_SIZE = 10240
+
+DATA_DIR = 'data/ILSVRC2012/'
+DATA_DIR = os.path.join(os.path.split(os.path.realpath(__file__))[0], DATA_DIR)
+
+img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
+img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
+
+
+def resize_short(img, target_size):
+    percent = float(target_size) / min(img.size[0], img.size[1])
+    resized_width = int(round(img.size[0] * percent))
+    resized_height = int(round(img.size[1] * percent))
+    img = img.resize((resized_width, resized_height), Image.LANCZOS)
+    return img
+
+
+def crop_image(img, target_size, center):
+    width, height = img.size
+    size = target_size
+    if center == True:
+        w_start = (width - size) // 2
+        h_start = (height - size) // 2
+    else:
+        w_start = np.random.randint(0, width - size + 1)
+        h_start = np.random.randint(0, height - size + 1)
+    w_end = w_start + size
+    h_end = h_start + size
+    img = img.crop((w_start, h_start, w_end, h_end))
+    return img
+
+
+def random_crop(img, size, scale=[0.08, 1.0], ratio=[3. / 4., 4. / 3.]):
+    aspect_ratio = math.sqrt(np.random.uniform(*ratio))
+    w = 1. * aspect_ratio
+    h = 1. / aspect_ratio
+
+    bound = min((float(img.size[0]) / img.size[1]) / (w**2),
+                (float(img.size[1]) / img.size[0]) / (h**2))
+    scale_max = min(scale[1], bound)
+    scale_min = min(scale[0], bound)
+
+    target_area = img.size[0] * img.size[1] * np.random.uniform(scale_min,
+                                                                scale_max)
+    target_size = math.sqrt(target_area)
+    w = int(target_size * w)
+    h = int(target_size * h)
+
+    i = np.random.randint(0, img.size[0] - w + 1)
+    j = np.random.randint(0, img.size[1] - h + 1)
+
+    img = img.crop((i, j, i + w, j + h))
+    img = img.resize((size, size), Image.LANCZOS)
+    return img
+
+
+def rotate_image(img):
+    angle = np.random.randint(-10, 11)
+    img = img.rotate(angle)
+    return img
+
+
+def distort_color(img):
+    def random_brightness(img, lower=0.5, upper=1.5):
+        e = np.random.uniform(lower, upper)
+        return ImageEnhance.Brightness(img).enhance(e)
+
+    def random_contrast(img, lower=0.5, upper=1.5):
+        e = np.random.uniform(lower, upper)
+        return ImageEnhance.Contrast(img).enhance(e)
+
+    def random_color(img, lower=0.5, upper=1.5):
+        e = np.random.uniform(lower, upper)
+        return ImageEnhance.Color(img).enhance(e)
+
+    ops = [random_brightness, random_contrast, random_color]
+    np.random.shuffle(ops)
+
+    img = ops[0](img)
+    img = ops[1](img)
+    img = ops[2](img)
+
+    return img
+
+
+def process_image(sample, mode, color_jitter, rotate, crop_size, resize_size):
+    img_path = sample[0]
+
+    try:
+        img = Image.open(img_path)
+    except:
+        print(img_path, "not exists!")
+        return None
+    if mode == 'train':
+        if rotate: img = rotate_image(img)
+        img = random_crop(img, crop_size)
+    else:
+        img = resize_short(img, target_size=resize_size)
+        img = crop_image(img, target_size=crop_size, center=True)
+    if mode == 'train':
+        if color_jitter:
+            img = distort_color(img)
+        if np.random.randint(0, 2) == 1:
+            img = img.transpose(Image.FLIP_LEFT_RIGHT)
+
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+
+    img = np.array(img).astype('float32').transpose((2, 0, 1)) / 255
+    img -= img_mean
+    img /= img_std
+
+    if mode == 'train' or mode == 'val':
+        return img, sample[1]
+    elif mode == 'test':
+        return [img]
+
+
+def _reader_creator(file_list,
+                    mode,
+                    shuffle=False,
+                    color_jitter=False,
+                    rotate=False,
+                    data_dir=DATA_DIR,
+                    batch_size=1):
+    def reader():
+        try:
+            with open(file_list) as flist:
+                full_lines = [line.strip() for line in flist]
+                if shuffle:
+                    np.random.shuffle(full_lines)
+                lines = full_lines
+                for line in lines:
+                    if mode == 'train' or mode == 'val':
+                        img_path, label = line.split()
+                        img_path = os.path.join(data_dir, img_path)
+                        yield img_path, int(label)
+                    elif mode == 'test':
+                        img_path = os.path.join(data_dir, line)
+                        yield [img_path]
+        except Exception as e:
+            print("Reader failed!\n{}".format(str(e)))
+            os._exit(1)
+
+    mapper = functools.partial(
+        process_image, mode=mode, color_jitter=color_jitter, rotate=rotate)
+
+    return paddle.reader.xmap_readers(mapper, reader, THREAD, BUF_SIZE)
+
+
+def train(data_dir=DATA_DIR):
+    file_list = os.path.join(data_dir, 'train_list.txt')
+    return _reader_creator(
+        file_list,
+        'train',
+        shuffle=True,
+        color_jitter=False,
+        rotate=False,
+        data_dir=data_dir)
+
+
+def val(data_dir=DATA_DIR):
+    file_list = os.path.join(data_dir, 'val_list.txt')
+    return _reader_creator(file_list, 'val', shuffle=False, data_dir=data_dir)
+
+
+def test(data_dir=DATA_DIR):
+    file_list = os.path.join(data_dir, 'test_list.txt')
+    return _reader_creator(file_list, 'test', shuffle=False, data_dir=data_dir)
+
+
+class ImageNetDataset(Dataset):
+    def __init__(self,
+                 data_dir=DATA_DIR,
+                 mode='train',
+                 crop_size=DATA_DIM,
+                 resize_size=RESIZE_DIM):
+        super(ImageNetDataset, self).__init__()
+        self.data_dir = data_dir
+        self.crop_size = crop_size
+        self.resize_size = resize_size
+        train_file_list = os.path.join(data_dir, 'train_list.txt')
+        val_file_list = os.path.join(data_dir, 'val_list.txt')
+        test_file_list = os.path.join(data_dir, 'test_list.txt')
+        self.mode = mode
+        if mode == 'train':
+            with open(train_file_list) as flist:
+                full_lines = [line.strip() for line in flist]
+                np.random.shuffle(full_lines)
+                lines = full_lines
+            self.data = [line.split() for line in lines]
+        else:
+            with open(val_file_list) as flist:
+                lines = [line.strip() for line in flist]
+                self.data = [line.split() for line in lines]
+
+    def __getitem__(self, index):
+        sample = self.data[index]
+        data_path = os.path.join(self.data_dir, sample[0])
+        if self.mode == 'train':
+            data, label = process_image(
+                [data_path, sample[1]],
+                mode='train',
+                color_jitter=False,
+                rotate=False,
+                crop_size=self.crop_size,
+                resize_size=self.resize_size)
+            return data, np.array([label]).astype('int64')
+        elif self.mode == 'val':
+            data, label = process_image(
+                [data_path, sample[1]],
+                mode='val',
+                color_jitter=False,
+                rotate=False,
+                crop_size=self.crop_size,
+                resize_size=self.resize_size)
+            return data, np.array([label]).astype('int64')
+        elif self.mode == 'test':
+            data = process_image(
+                [data_path, sample[1]],
+                mode='test',
+                color_jitter=False,
+                rotate=False,
+                crop_size=self.crop_size,
+                resize_size=self.resize_size)
+            return data
+
+    def __len__(self):
+        return len(self.data)

example/full_quantization/image_classification/run.py

+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import sys
+import argparse
+import functools
+from functools import partial
+import math
+from tqdm import tqdm
+
+import numpy as np
+import paddle
+import paddle.nn as nn
+from paddle.io import DataLoader
+from imagenet_reader import ImageNetDataset
+from paddleslim.common import load_config as load_slim_config
+from paddleslim.auto_compression import AutoCompression
+
+
+def argsparser():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        '--config_path',
+        type=str,
+        default=None,
+        help="path of compression strategy config.",
+        required=True)
+    parser.add_argument(
+        '--save_dir',
+        type=str,
+        default='output',
+        help="directory to save compressed model.")
+    parser.add_argument(
+        '--total_images',
+        type=int,
+        default=1281167,
+        help="the number of total training images.")
+    parser.add_argument(
+        '--devices',
+        type=str,
+        default='gpu',
+        help="which device used to compress.")
+    return parser
+
+
+# yapf: enable
+def reader_wrapper(reader, input_name):
+    def gen():
+        for i, (imgs, label) in enumerate(reader()):
+            yield {input_name: imgs}
+
+    return gen
+
+
+def eval_reader(data_dir, batch_size, crop_size, resize_size, place=None):
+    val_reader = ImageNetDataset(
+        mode='val',
+        data_dir=data_dir,
+        crop_size=crop_size,
+        resize_size=resize_size)
+    val_loader = DataLoader(
+        val_reader,
+        places=[place] if place is not None else None,
+        batch_size=global_config['batch_size'],
+        shuffle=False,
+        drop_last=False,
+        num_workers=0)
+    return val_loader
+
+
+def eval_function(exe, compiled_test_program, test_feed_names, test_fetch_list):
+    val_loader = eval_reader(
+        data_dir,
+        batch_size=global_config['batch_size'],
+        crop_size=img_size,
+        resize_size=resize_size)
+
+    results = []
+    with tqdm(
+            total=len(val_loader),
+            bar_format='Evaluation stage, Run batch:|{bar}| {n_fmt}/{total_fmt}',
+            ncols=80) as t:
+        for batch_id, (image, label) in enumerate(val_loader):
+            # top1_acc, top5_acc
+            if len(test_feed_names) == 1:
+                image = np.array(image)
+                label = np.array(label).astype('int64')
+                pred = exe.run(compiled_test_program,
+                               feed={test_feed_names[0]: image},
+                               fetch_list=test_fetch_list)
+                pred = np.array(pred[0])
+                label = np.array(label)
+                sort_array = pred.argsort(axis=1)
+                top_1_pred = sort_array[:, -1:][:, ::-1]
+                top_1 = np.mean(label == top_1_pred)
+                top_5_pred = sort_array[:, -5:][:, ::-1]
+                acc_num = 0
+                for i in range(len(label)):
+                    if label[i][0] in top_5_pred[i]:
+                        acc_num += 1
+                top_5 = float(acc_num) / len(label)
+                results.append([top_1, top_5])
+            else:
+                # eval "eval model", which inputs are image and label, output is top1 and top5 accuracy
+                image = np.array(image)
+                label = np.array(label).astype('int64')
+                result = exe.run(compiled_test_program,
+                                 feed={
+                                     test_feed_names[0]: image,
+                                     test_feed_names[1]: label
+                                 },
+                                 fetch_list=test_fetch_list)
+                result = [np.mean(r) for r in result]
+                results.append(result)
+            t.update()
+    result = np.mean(np.array(results), axis=0)
+    return result[0]
+
+
+def main():
+    rank_id = paddle.distributed.get_rank()
+    if args.devices == 'gpu':
+        place = paddle.CUDAPlace(rank_id)
+        paddle.set_device('gpu')
+    else:
+        place = paddle.CPUPlace()
+        paddle.set_device('cpu')
+    global global_config
+    all_config = load_slim_config(args.config_path)
+
+    assert "Global" in all_config, f"Key 'Global' not found in config file. \n{all_config}"
+    global_config = all_config["Global"]
+
+    gpu_num = paddle.distributed.get_world_size()
+    if isinstance(all_config['TrainConfig']['learning_rate'],
+                  dict) and all_config['TrainConfig']['learning_rate'][
+                      'type'] == 'CosineAnnealingDecay':
+        step = int(
+            math.ceil(
+                float(args.total_images) / (global_config['batch_size'] *
+                                            gpu_num)))
+        all_config['TrainConfig']['learning_rate']['T_max'] = step
+        print('total training steps:', step)
+
+    global data_dir
+    data_dir = global_config['data_dir']
+
+    global img_size, resize_size
+    img_size = global_config['img_size'] if 'img_size' in global_config else 224
+    resize_size = global_config[
+        'resize_size'] if 'resize_size' in global_config else 256
+
+    train_dataset = ImageNetDataset(
+        mode='train',
+        data_dir=data_dir,
+        crop_size=img_size,
+        resize_size=resize_size)
+
+    train_loader = DataLoader(
+        train_dataset,
+        places=[place],
+        batch_size=global_config['batch_size'],
+        shuffle=True,
+        drop_last=True,
+        num_workers=0)
+    train_dataloader = reader_wrapper(train_loader, global_config['input_name'])
+
+    ac = AutoCompression(
+        model_dir=global_config['model_dir'],
+        model_filename=global_config['model_filename'],
+        params_filename=global_config['params_filename'],
+        save_dir=args.save_dir,
+        config=all_config,
+        train_dataloader=train_dataloader,
+        eval_callback=eval_function if rank_id == 0 else None,
+        eval_dataloader=reader_wrapper(
+            eval_reader(
+                data_dir,
+                global_config['batch_size'],
+                crop_size=img_size,
+                resize_size=resize_size,
+                place=place),
+            global_config['input_name']))
+
+    ac.compress()
+
+
+if __name__ == '__main__':
+    paddle.enable_static()
+    parser = argsparser()
+    args = parser.parse_args()
+    main()