Add notebook demo for quantization strategy on MobileNetV1-SSD.

PaddleSlim/notebook/Mobile-SSD-Quantization.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "该示例内容为对[MobileNet-SSD](https://github.com/PaddlePaddle/models/tree/v1.4/PaddleCV/object_detection)的主干网络进行int8量化训练。\n",
+    "\n",
+    "## 0. 目录\n",
+    "\n",
+    "[1. 定义工具函数](http://10.255.142.41:8888/notebooks/slim/Mobile-SSD-Quantization.ipynb#1.-%E5%AE%9A%E4%B9%89%E5%B7%A5%E5%85%B7%E5%87%BD%E6%95%B0)\n",
+    "\n",
+    "[2. 数据准备](http://10.255.142.41:8888/notebooks/slim/Mobile-SSD-Quantization.ipynb#2.-%E6%95%B0%E6%8D%AE%E5%87%86%E5%A4%87)\n",
+    "\n",
+    "[3. 定义网络](http://10.255.142.41:8888/notebooks/slim/Mobile-SSD-Quantization.ipynb#3.-%E5%AE%9A%E4%B9%89%E7%BD%91%E7%BB%9C)\n",
+    "\n",
+    "[4. 配置压缩任务](http://10.255.142.41:8888/notebooks/slim/Mobile-SSD-Quantization.ipynb#4.-%E9%85%8D%E7%BD%AE%E5%8E%8B%E7%BC%A9%E4%BB%BB%E5%8A%A1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. 定义工具函数\n",
+    "\n",
+    "在[image_util.py](https://github.com/PaddlePaddle/models/blob/v1.4/PaddleCV/object_detection/image_util.py)中定义了图像数据预处理处理使用到的工具函数。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "from PIL import Image, ImageEnhance, ImageDraw\n",
+    "from PIL import ImageFile\n",
+    "import numpy as np\n",
+    "import random\n",
+    "import math\n",
+    "\n",
+    "ImageFile.LOAD_TRUNCATED_IMAGES = True  #otherwise IOError raised image file is truncated\n",
+    "\n",
+    "\n",
+    "class sampler():\n",
+    "    def __init__(self, max_sample, max_trial, min_scale, max_scale,\n",
+    "                 min_aspect_ratio, max_aspect_ratio, min_jaccard_overlap,\n",
+    "                 max_jaccard_overlap):\n",
+    "        self.max_sample = max_sample\n",
+    "        self.max_trial = max_trial\n",
+    "        self.min_scale = min_scale\n",
+    "        self.max_scale = max_scale\n",
+    "        self.min_aspect_ratio = min_aspect_ratio\n",
+    "        self.max_aspect_ratio = max_aspect_ratio\n",
+    "        self.min_jaccard_overlap = min_jaccard_overlap\n",
+    "        self.max_jaccard_overlap = max_jaccard_overlap\n",
+    "\n",
+    "\n",
+    "class bbox():\n",
+    "    def __init__(self, xmin, ymin, xmax, ymax):\n",
+    "        self.xmin = xmin\n",
+    "        self.ymin = ymin\n",
+    "        self.xmax = xmax\n",
+    "        self.ymax = ymax\n",
+    "\n",
+    "\n",
+    "def bbox_area(src_bbox):\n",
+    "    width = src_bbox.xmax - src_bbox.xmin\n",
+    "    height = src_bbox.ymax - src_bbox.ymin\n",
+    "    return width * height\n",
+    "\n",
+    "\n",
+    "def generate_sample(sampler):\n",
+    "    scale = np.random.uniform(sampler.min_scale, sampler.max_scale)\n",
+    "    aspect_ratio = np.random.uniform(sampler.min_aspect_ratio,\n",
+    "                                  sampler.max_aspect_ratio)\n",
+    "    aspect_ratio = max(aspect_ratio, (scale**2.0))\n",
+    "    aspect_ratio = min(aspect_ratio, 1 / (scale**2.0))\n",
+    "\n",
+    "    bbox_width = scale * (aspect_ratio**0.5)\n",
+    "    bbox_height = scale / (aspect_ratio**0.5)\n",
+    "    xmin_bound = 1 - bbox_width\n",
+    "    ymin_bound = 1 - bbox_height\n",
+    "    xmin = np.random.uniform(0, xmin_bound)\n",
+    "    ymin = np.random.uniform(0, ymin_bound)\n",
+    "    xmax = xmin + bbox_width\n",
+    "    ymax = ymin + bbox_height\n",
+    "    sampled_bbox = bbox(xmin, ymin, xmax, ymax)\n",
+    "    return sampled_bbox\n",
+    "\n",
+    "\n",
+    "def jaccard_overlap(sample_bbox, object_bbox):\n",
+    "    if sample_bbox.xmin >= object_bbox.xmax or \\\n",
+    "            sample_bbox.xmax <= object_bbox.xmin or \\\n",
+    "            sample_bbox.ymin >= object_bbox.ymax or \\\n",
+    "            sample_bbox.ymax <= object_bbox.ymin:\n",
+    "        return 0\n",
+    "    intersect_xmin = max(sample_bbox.xmin, object_bbox.xmin)\n",
+    "    intersect_ymin = max(sample_bbox.ymin, object_bbox.ymin)\n",
+    "    intersect_xmax = min(sample_bbox.xmax, object_bbox.xmax)\n",
+    "    intersect_ymax = min(sample_bbox.ymax, object_bbox.ymax)\n",
+    "    intersect_size = (intersect_xmax - intersect_xmin) * (\n",
+    "        intersect_ymax - intersect_ymin)\n",
+    "    sample_bbox_size = bbox_area(sample_bbox)\n",
+    "    object_bbox_size = bbox_area(object_bbox)\n",
+    "    overlap = intersect_size / (\n",
+    "        sample_bbox_size + object_bbox_size - intersect_size)\n",
+    "    return overlap\n",
+    "\n",
+    "\n",
+    "def satisfy_sample_constraint(sampler, sample_bbox, bbox_labels):\n",
+    "    if sampler.min_jaccard_overlap == 0 and sampler.max_jaccard_overlap == 0:\n",
+    "        return True\n",
+    "    for i in range(len(bbox_labels)):\n",
+    "        object_bbox = bbox(bbox_labels[i][1], bbox_labels[i][2],\n",
+    "                           bbox_labels[i][3], bbox_labels[i][4])\n",
+    "        overlap = jaccard_overlap(sample_bbox, object_bbox)\n",
+    "        if sampler.min_jaccard_overlap != 0 and \\\n",
+    "                overlap < sampler.min_jaccard_overlap:\n",
+    "            continue\n",
+    "        if sampler.max_jaccard_overlap != 0 and \\\n",
+    "                overlap > sampler.max_jaccard_overlap:\n",
+    "            continue\n",
+    "        return True\n",
+    "    return False\n",
+    "\n",
+    "\n",
+    "def generate_batch_samples(batch_sampler, bbox_labels):\n",
+    "    sampled_bbox = []\n",
+    "    index = []\n",
+    "    c = 0\n",
+    "    for sampler in batch_sampler:\n",
+    "        found = 0\n",
+    "        for i in range(sampler.max_trial):\n",
+    "            if found >= sampler.max_sample:\n",
+    "                break\n",
+    "            sample_bbox = generate_sample(sampler)\n",
+    "            if satisfy_sample_constraint(sampler, sample_bbox, bbox_labels):\n",
+    "                sampled_bbox.append(sample_bbox)\n",
+    "                found = found + 1\n",
+    "                index.append(c)\n",
+    "        c = c + 1\n",
+    "    return sampled_bbox\n",
+    "\n",
+    "\n",
+    "def clip_bbox(src_bbox):\n",
+    "    src_bbox.xmin = max(min(src_bbox.xmin, 1.0), 0.0)\n",
+    "    src_bbox.ymin = max(min(src_bbox.ymin, 1.0), 0.0)\n",
+    "    src_bbox.xmax = max(min(src_bbox.xmax, 1.0), 0.0)\n",
+    "    src_bbox.ymax = max(min(src_bbox.ymax, 1.0), 0.0)\n",
+    "    return src_bbox\n",
+    "\n",
+    "\n",
+    "def meet_emit_constraint(src_bbox, sample_bbox):\n",
+    "    center_x = (src_bbox.xmax + src_bbox.xmin) / 2\n",
+    "    center_y = (src_bbox.ymax + src_bbox.ymin) / 2\n",
+    "    if center_x >= sample_bbox.xmin and \\\n",
+    "        center_x <= sample_bbox.xmax and \\\n",
+    "        center_y >= sample_bbox.ymin and \\\n",
+    "        center_y <= sample_bbox.ymax:\n",
+    "        return True\n",
+    "    return False\n",
+    "\n",
+    "\n",
+    "def transform_labels(bbox_labels, sample_bbox):\n",
+    "    proj_bbox = bbox(0, 0, 0, 0)\n",
+    "    sample_labels = []\n",
+    "    for i in range(len(bbox_labels)):\n",
+    "        sample_label = []\n",
+    "        object_bbox = bbox(bbox_labels[i][1], bbox_labels[i][2],\n",
+    "                           bbox_labels[i][3], bbox_labels[i][4])\n",
+    "        if not meet_emit_constraint(object_bbox, sample_bbox):\n",
+    "            continue\n",
+    "        sample_width = sample_bbox.xmax - sample_bbox.xmin\n",
+    "        sample_height = sample_bbox.ymax - sample_bbox.ymin\n",
+    "        proj_bbox.xmin = (object_bbox.xmin - sample_bbox.xmin) / sample_width\n",
+    "        proj_bbox.ymin = (object_bbox.ymin - sample_bbox.ymin) / sample_height\n",
+    "        proj_bbox.xmax = (object_bbox.xmax - sample_bbox.xmin) / sample_width\n",
+    "        proj_bbox.ymax = (object_bbox.ymax - sample_bbox.ymin) / sample_height\n",
+    "        proj_bbox = clip_bbox(proj_bbox)\n",
+    "        if bbox_area(proj_bbox) > 0:\n",
+    "            sample_label.append(bbox_labels[i][0])\n",
+    "            sample_label.append(float(proj_bbox.xmin))\n",
+    "            sample_label.append(float(proj_bbox.ymin))\n",
+    "            sample_label.append(float(proj_bbox.xmax))\n",
+    "            sample_label.append(float(proj_bbox.ymax))\n",
+    "            #sample_label.append(bbox_labels[i][5])\n",
+    "            sample_label = sample_label + bbox_labels[i][5:]\n",
+    "            sample_labels.append(sample_label)\n",
+    "    return sample_labels\n",
+    "\n",
+    "\n",
+    "def crop_image(img, bbox_labels, sample_bbox, image_width, image_height):\n",
+    "    sample_bbox = clip_bbox(sample_bbox)\n",
+    "    xmin = int(sample_bbox.xmin * image_width)\n",
+    "    xmax = int(sample_bbox.xmax * image_width)\n",
+    "    ymin = int(sample_bbox.ymin * image_height)\n",
+    "    ymax = int(sample_bbox.ymax * image_height)\n",
+    "    sample_img = img[ymin:ymax, xmin:xmax]\n",
+    "    sample_labels = transform_labels(bbox_labels, sample_bbox)\n",
+    "    return sample_img, sample_labels\n",
+    "\n",
+    "\n",
+    "def random_brightness(img, settings):\n",
+    "    prob = np.random.uniform(0, 1)\n",
+    "    if prob < settings._brightness_prob:\n",
+    "        delta = np.random.uniform(-settings._brightness_delta,\n",
+    "                               settings._brightness_delta) + 1\n",
+    "        img = ImageEnhance.Brightness(img).enhance(delta)\n",
+    "    return img\n",
+    "\n",
+    "\n",
+    "def random_contrast(img, settings):\n",
+    "    prob = np.random.uniform(0, 1)\n",
+    "    if prob < settings._contrast_prob:\n",
+    "        delta = np.random.uniform(-settings._contrast_delta,\n",
+    "                               settings._contrast_delta) + 1\n",
+    "        img = ImageEnhance.Contrast(img).enhance(delta)\n",
+    "    return img\n",
+    "\n",
+    "\n",
+    "def random_saturation(img, settings):\n",
+    "    prob = np.random.uniform(0, 1)\n",
+    "    if prob < settings._saturation_prob:\n",
+    "        delta = np.random.uniform(-settings._saturation_delta,\n",
+    "                               settings._saturation_delta) + 1\n",
+    "        img = ImageEnhance.Color(img).enhance(delta)\n",
+    "    return img\n",
+    "\n",
+    "\n",
+    "def random_hue(img, settings):\n",
+    "    prob = np.random.uniform(0, 1)\n",
+    "    if prob < settings._hue_prob:\n",
+    "        delta = np.random.uniform(-settings._hue_delta, settings._hue_delta)\n",
+    "        img_hsv = np.array(img.convert('HSV'))\n",
+    "        img_hsv[:, :, 0] = img_hsv[:, :, 0] + delta\n",
+    "        img = Image.fromarray(img_hsv, mode='HSV').convert('RGB')\n",
+    "    return img\n",
+    "\n",
+    "\n",
+    "def distort_image(img, settings):\n",
+    "    prob = np.random.uniform(0, 1)\n",
+    "    # Apply different distort order\n",
+    "    if prob > 0.5:\n",
+    "        img = random_brightness(img, settings)\n",
+    "        img = random_contrast(img, settings)\n",
+    "        img = random_saturation(img, settings)\n",
+    "        img = random_hue(img, settings)\n",
+    "    else:\n",
+    "        img = random_brightness(img, settings)\n",
+    "        img = random_saturation(img, settings)\n",
+    "        img = random_hue(img, settings)\n",
+    "        img = random_contrast(img, settings)\n",
+    "    return img\n",
+    "\n",
+    "\n",
+    "def expand_image(img, bbox_labels, img_width, img_height, settings):\n",
+    "    prob = np.random.uniform(0, 1)\n",
+    "    if prob < settings._expand_prob:\n",
+    "        if settings._expand_max_ratio - 1 >= 0.01:\n",
+    "            expand_ratio = np.random.uniform(1, settings._expand_max_ratio)\n",
+    "            height = int(img_height * expand_ratio)\n",
+    "            width = int(img_width * expand_ratio)\n",
+    "            h_off = math.floor(np.random.uniform(0, height - img_height))\n",
+    "            w_off = math.floor(np.random.uniform(0, width - img_width))\n",
+    "            expand_bbox = bbox(-w_off / img_width, -h_off / img_height,\n",
+    "                               (width - w_off) / img_width,\n",
+    "                               (height - h_off) / img_height)\n",
+    "            expand_img = np.ones((height, width, 3))\n",
+    "            expand_img = np.uint8(expand_img * np.squeeze(settings._img_mean))\n",
+    "            expand_img = Image.fromarray(expand_img)\n",
+    "            expand_img.paste(img, (int(w_off), int(h_off)))\n",
+    "            bbox_labels = transform_labels(bbox_labels, expand_bbox)\n",
+    "            return expand_img, bbox_labels, width, height\n",
+    "    return img, bbox_labels, img_width, img_height\n",
+    "\n",
+    "class Settings(object):\n",
+    "    def __init__(self,\n",
+    "                 dataset=None,\n",
+    "                 data_dir=None,\n",
+    "                 label_file=None,\n",
+    "                 resize_h=300,\n",
+    "                 resize_w=300,\n",
+    "                 mean_value=[127.5, 127.5, 127.5],\n",
+    "                 apply_distort=True,\n",
+    "                 apply_expand=True,\n",
+    "                 ap_version='11point'):\n",
+    "        self._dataset = dataset\n",
+    "        self._ap_version = ap_version\n",
+    "        self._data_dir = data_dir\n",
+    "        if 'pascalvoc' in dataset:\n",
+    "            self._label_list = []\n",
+    "            label_fpath = os.path.join(data_dir, label_file)\n",
+    "            for line in open(label_fpath):\n",
+    "                self._label_list.append(line.strip())\n",
+    "\n",
+    "        self._apply_distort = apply_distort\n",
+    "        self._apply_expand = apply_expand\n",
+    "        self._resize_height = resize_h\n",
+    "        self._resize_width = resize_w\n",
+    "        self._img_mean = np.array(mean_value)[:, np.newaxis, np.newaxis].astype(\n",
+    "            'float32')\n",
+    "        self._expand_prob = 0.5\n",
+    "        self._expand_max_ratio = 4\n",
+    "        self._hue_prob = 0.5\n",
+    "        self._hue_delta = 18\n",
+    "        self._contrast_prob = 0.5\n",
+    "        self._contrast_delta = 0.5\n",
+    "        self._saturation_prob = 0.5\n",
+    "        self._saturation_delta = 0.5\n",
+    "        self._brightness_prob = 0.5\n",
+    "        self._brightness_delta = 0.125\n",
+    "\n",
+    "    @property\n",
+    "    def dataset(self):\n",
+    "        return self._dataset\n",
+    "\n",
+    "    @property\n",
+    "    def ap_version(self):\n",
+    "        return self._ap_version\n",
+    "\n",
+    "    @property\n",
+    "    def apply_distort(self):\n",
+    "        return self._apply_expand\n",
+    "\n",
+    "    @property\n",
+    "    def apply_distort(self):\n",
+    "        return self._apply_distort\n",
+    "\n",
+    "    @property\n",
+    "    def data_dir(self):\n",
+    "        return self._data_dir\n",
+    "\n",
+    "    @data_dir.setter\n",
+    "    def data_dir(self, data_dir):\n",
+    "        self._data_dir = data_dir\n",
+    "\n",
+    "    @property\n",
+    "    def label_list(self):\n",
+    "        return self._label_list\n",
+    "\n",
+    "    @property\n",
+    "    def resize_h(self):\n",
+    "        return self._resize_height\n",
+    "\n",
+    "    @property\n",
+    "    def resize_w(self):\n",
+    "        return self._resize_width\n",
+    "\n",
+    "    @property\n",
+    "    def img_mean(self):\n",
+    "        return self._img_mean\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. 数据准备\n",
+    "\n",
+    "### 2.1 下载数据\n",
+    "使用PaddlePaddle/models repo下提供的[数据下载脚本](https://github.com/PaddlePaddle/models/blob/release/1.4/PaddleCV/object_detection/data/coco/download.sh)下载数据。\n",
+    "或通过其它更便捷的方式准备数据\n",
+    "\n",
+    "### 2.2 下载pretrained model\n",
+    "\n",
+    "使用PaddlePaddle/models repo下提供的[下载脚本](https://github.com/PaddlePaddle/models/blob/release/1.4/PaddleCV/object_detection/pretrained/download_coco.sh)下载pretrained model.\n",
+    "\n",
+    "### 2.3 设置数据变量\n",
+    "\n",
+    "- args_image_shape：训练数据的shape, 格式为‘channel, height, width’\n",
+    "- args_mean_BGR: BGR三通道的均值\n",
+    "- args_data_dir： 数据存放的地址\n",
+    "- coco2014：使用的数据集名称，该变量主要影响了下文中data reader的表现。\n",
+    "- args_pretrained_model：pretrained model存放的地址。\n",
+    "\n",
+    "代码如下："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 68,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "args_image_shape = '3,300,300'\n",
+    "args_mean_BGR = '127.5,127.5,127.5'\n",
+    "args_data_dir = '/root/data/coco'\n",
+    "args_dataset = 'coco2014'\n",
+    "args_pretrained_model = 'pretrained/ssd_mobilenet_v1_coco/'\n",
+    "args_ap_version = '11point'\n",
+    "\n",
+    "\n",
+    "data_dir = args_data_dir\n",
+    "dataset = args_dataset\n",
+    "assert dataset in ['pascalvoc', 'coco2014', 'coco2017']\n",
+    "\n",
+    "# for pascalvoc\n",
+    "label_file = 'label_list'\n",
+    "train_file_list = 'trainval.txt'\n",
+    "val_file_list = 'test.txt'\n",
+    "\n",
+    "if dataset == 'coco2014':\n",
+    "    train_file_list = 'annotations/instances_train2014.json'\n",
+    "    val_file_list = 'annotations/instances_val2014.json'\n",
+    "elif dataset == 'coco2017':\n",
+    "    train_file_list = 'annotations/instances_train2017.json'\n",
+    "    val_file_list = 'annotations/instances_val2017.json'\n",
+    "\n",
+    "mean_BGR = [float(m) for m in args_mean_BGR.split(\",\")]\n",
+    "image_shape = [int(m) for m in args_image_shape.split(\",\")]\n",
+    "\n",
+    "data_args = Settings(\n",
+    "dataset=args_dataset,\n",
+    "data_dir=data_dir,\n",
+    "label_file=label_file,\n",
+    "resize_h=image_shape[1],\n",
+    "resize_w=image_shape[2],\n",
+    "mean_value=mean_BGR,\n",
+    "apply_distort=True,\n",
+    "apply_expand=True,\n",
+    "ap_version = args_ap_version)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.4 准备data reader\n",
+    "\n",
+    "在paddle中通过data reader为训练网络或测试网络提供数据，reader就是一个数据迭代产生器。\n",
+    "\n",
+    "参考[reader.py](https://github.com/PaddlePaddle/models/blob/v1.4/PaddleCV/object_detection/reader.py)实现代码如下："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import xml.etree.ElementTree\n",
+    "import os\n",
+    "import time\n",
+    "import copy\n",
+    "import six\n",
+    "import math\n",
+    "import numpy as np\n",
+    "from PIL import Image\n",
+    "from PIL import ImageDraw\n",
+    "import paddle\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "def preprocess(img, bbox_labels, mode, settings):\n",
+    "    img_width, img_height = img.size\n",
+    "    sampled_labels = bbox_labels\n",
+    "    if mode == 'train':\n",
+    "        if settings._apply_distort:\n",
+    "            img = distort_image(img, settings)\n",
+    "        if settings._apply_expand:\n",
+    "            img, bbox_labels, img_width, img_height = expand_image(\n",
+    "                img, bbox_labels, img_width, img_height, settings)\n",
+    "        # sampling\n",
+    "        batch_sampler = []\n",
+    "        # hard-code here\n",
+    "        batch_sampler.append(\n",
+    "            sampler(1, 1, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0))\n",
+    "        batch_sampler.append(\n",
+    "            sampler(1, 50, 0.3, 1.0, 0.5, 2.0, 0.1, 0.0))\n",
+    "        batch_sampler.append(\n",
+    "            sampler(1, 50, 0.3, 1.0, 0.5, 2.0, 0.3, 0.0))\n",
+    "        batch_sampler.append(\n",
+    "            sampler(1, 50, 0.3, 1.0, 0.5, 2.0, 0.5, 0.0))\n",
+    "        batch_sampler.append(\n",
+    "            sampler(1, 50, 0.3, 1.0, 0.5, 2.0, 0.7, 0.0))\n",
+    "        batch_sampler.append(\n",
+    "            sampler(1, 50, 0.3, 1.0, 0.5, 2.0, 0.9, 0.0))\n",
+    "        batch_sampler.append(\n",
+    "            sampler(1, 50, 0.3, 1.0, 0.5, 2.0, 0.0, 1.0))\n",
+    "        sampled_bbox = generate_batch_samples(batch_sampler,\n",
+    "                                                         bbox_labels)\n",
+    "\n",
+    "        img = np.array(img)\n",
+    "        if len(sampled_bbox) > 0:\n",
+    "            idx = int(np.random.uniform(0, len(sampled_bbox)))\n",
+    "            img, sampled_labels = crop_image(\n",
+    "                img, bbox_labels, sampled_bbox[idx], img_width, img_height)\n",
+    "\n",
+    "        img = Image.fromarray(img)\n",
+    "    img = img.resize((settings.resize_w, settings.resize_h), Image.ANTIALIAS)\n",
+    "    img = np.array(img)\n",
+    "\n",
+    "    if mode == 'train':\n",
+    "        mirror = int(np.random.uniform(0, 2))\n",
+    "        if mirror == 1:\n",
+    "            img = img[:, ::-1, :]\n",
+    "            for i in six.moves.xrange(len(sampled_labels)):\n",
+    "                tmp = sampled_labels[i][1]\n",
+    "                sampled_labels[i][1] = 1 - sampled_labels[i][3]\n",
+    "                sampled_labels[i][3] = 1 - tmp\n",
+    "    # HWC to CHW\n",
+    "    if len(img.shape) == 3:\n",
+    "        img = np.swapaxes(img, 1, 2)\n",
+    "        img = np.swapaxes(img, 1, 0)\n",
+    "    # RBG to BGR\n",
+    "    img = img[[2, 1, 0], :, :]\n",
+    "    img = img.astype('float32')\n",
+    "    img -= settings.img_mean\n",
+    "    img = img * 0.007843\n",
+    "    return img, sampled_labels\n",
+    "\n",
+    "\n",
+    "def coco(settings, coco_api, file_list, mode, batch_size, shuffle, data_dir):\n",
+    "    from pycocotools.coco import COCO\n",
+    "\n",
+    "    def reader():\n",
+    "        if mode == 'train' and shuffle:\n",
+    "            np.random.shuffle(file_list)\n",
+    "        batch_out = []\n",
+    "        for image in file_list:\n",
+    "            image_name = image['file_name']\n",
+    "            image_path = os.path.join(data_dir, image_name)\n",
+    "            if not os.path.exists(image_path):\n",
+    "                raise ValueError(\"%s is not exist, you should specify \"\n",
+    "                                 \"data path correctly.\" % image_path)\n",
+    "            im = Image.open(image_path)\n",
+    "            if im.mode == 'L':\n",
+    "                im = im.convert('RGB')\n",
+    "            im_width, im_height = im.size\n",
+    "            im_id = image['id']\n",
+    "\n",
+    "            # layout: category_id | xmin | ymin | xmax | ymax | iscrowd\n",
+    "            bbox_labels = []\n",
+    "            annIds = coco_api.getAnnIds(imgIds=image['id'])\n",
+    "            anns = coco_api.loadAnns(annIds)\n",
+    "            for ann in anns:\n",
+    "                bbox_sample = []\n",
+    "                # start from 1, leave 0 to background\n",
+    "                bbox_sample.append(float(ann['category_id']))\n",
+    "                bbox = ann['bbox']\n",
+    "                xmin, ymin, w, h = bbox\n",
+    "                xmax = xmin + w\n",
+    "                ymax = ymin + h\n",
+    "                bbox_sample.append(float(xmin) / im_width)\n",
+    "                bbox_sample.append(float(ymin) / im_height)\n",
+    "                bbox_sample.append(float(xmax) / im_width)\n",
+    "                bbox_sample.append(float(ymax) / im_height)\n",
+    "                bbox_sample.append(float(ann['iscrowd']))\n",
+    "                bbox_labels.append(bbox_sample)\n",
+    "            im, sample_labels = preprocess(im, bbox_labels, mode, settings)\n",
+    "            sample_labels = np.array(sample_labels)\n",
+    "            if len(sample_labels) == 0: continue\n",
+    "            im = im.astype('float32')\n",
+    "            boxes = sample_labels[:, 1:5]\n",
+    "            lbls = sample_labels[:, 0].astype('int32')\n",
+    "            iscrowd = sample_labels[:, -1].astype('int32')\n",
+    "            if 'cocoMAP' in settings.ap_version:\n",
+    "                batch_out.append((im, boxes, lbls, iscrowd,\n",
+    "                                  [im_id, im_width, im_height]))\n",
+    "            else:\n",
+    "                batch_out.append((im, boxes, lbls, iscrowd))\n",
+    "\n",
+    "            if len(batch_out) == batch_size:\n",
+    "                yield batch_out\n",
+    "                batch_out = []\n",
+    "\n",
+    "        if mode == 'test' and len(batch_out) > 1:\n",
+    "            yield batch_out\n",
+    "            batch_out = []\n",
+    "\n",
+    "    return reader\n",
+    "\n",
+    "\n",
+    "def pascalvoc(settings, file_list, mode, batch_size, shuffle):\n",
+    "    def reader():\n",
+    "        if mode == 'train' and shuffle:\n",
+    "            np.random.shuffle(file_list)\n",
+    "        batch_out = []\n",
+    "        cnt = 0\n",
+    "        for image in file_list:\n",
+    "            image_path, label_path = image.split()\n",
+    "            image_path = os.path.join(settings.data_dir, image_path)\n",
+    "            label_path = os.path.join(settings.data_dir, label_path)\n",
+    "            if not os.path.exists(image_path):\n",
+    "                raise ValueError(\"%s is not exist, you should specify \"\n",
+    "                                 \"data path correctly.\" % image_path)\n",
+    "            im = Image.open(image_path)\n",
+    "            if im.mode == 'L':\n",
+    "                im = im.convert('RGB')\n",
+    "            im_width, im_height = im.size\n",
+    "\n",
+    "            # layout: label | xmin | ymin | xmax | ymax | difficult\n",
+    "            bbox_labels = []\n",
+    "            root = xml.etree.ElementTree.parse(label_path).getroot()\n",
+    "            for object in root.findall('object'):\n",
+    "                bbox_sample = []\n",
+    "                # start from 1\n",
+    "                bbox_sample.append(\n",
+    "                    float(settings.label_list.index(object.find('name').text)))\n",
+    "                bbox = object.find('bndbox')\n",
+    "                difficult = float(object.find('difficult').text)\n",
+    "                bbox_sample.append(float(bbox.find('xmin').text) / im_width)\n",
+    "                bbox_sample.append(float(bbox.find('ymin').text) / im_height)\n",
+    "                bbox_sample.append(float(bbox.find('xmax').text) / im_width)\n",
+    "                bbox_sample.append(float(bbox.find('ymax').text) / im_height)\n",
+    "                bbox_sample.append(difficult)\n",
+    "                bbox_labels.append(bbox_sample)\n",
+    "            im, sample_labels = preprocess(im, bbox_labels, mode, settings)\n",
+    "            sample_labels = np.array(sample_labels)\n",
+    "            if len(sample_labels) == 0: continue\n",
+    "            im = im.astype('float32')\n",
+    "            boxes = sample_labels[:, 1:5]\n",
+    "            lbls = sample_labels[:, 0].astype('int32')\n",
+    "            difficults = sample_labels[:, -1].astype('int32')\n",
+    "\n",
+    "            batch_out.append((im, boxes, lbls, difficults))\n",
+    "            if len(batch_out) == batch_size:\n",
+    "                yield batch_out\n",
+    "                cnt += len(batch_out)\n",
+    "                batch_out = []\n",
+    "\n",
+    "        if mode == 'test' and len(batch_out) > 1:\n",
+    "            yield batch_out\n",
+    "            cnt += len(batch_out)\n",
+    "            batch_out = []\n",
+    "\n",
+    "    return reader\n",
+    "\n",
+    "\n",
+    "def train_data_reader(settings,\n",
+    "          file_list,\n",
+    "          batch_size,\n",
+    "          shuffle=True,\n",
+    "          num_workers=8,\n",
+    "          enable_ce=False):\n",
+    "    file_path = os.path.join(settings.data_dir, file_list)\n",
+    "    readers = []\n",
+    "    if 'coco' in settings.dataset:\n",
+    "        # cocoapi\n",
+    "        from pycocotools.coco import COCO\n",
+    "        coco_api = COCO(file_path)\n",
+    "        image_ids = coco_api.getImgIds()\n",
+    "        images = coco_api.loadImgs(image_ids)\n",
+    "        n = int(math.ceil(len(images) // num_workers))\n",
+    "        image_lists = [images[i:i + n] for i in range(0, len(images), n)]\n",
+    "\n",
+    "        if '2014' in file_list:\n",
+    "            sub_dir = \"train2014\"\n",
+    "        elif '2017' in file_list:\n",
+    "            sub_dir = \"train2017\"\n",
+    "        data_dir = os.path.join(settings.data_dir, sub_dir)\n",
+    "        for l in image_lists:\n",
+    "            readers.append(\n",
+    "                coco(settings, coco_api, l, 'train', batch_size, shuffle,\n",
+    "                     data_dir))\n",
+    "    else:\n",
+    "        images = [line.strip() for line in open(file_path)]\n",
+    "        n = int(math.ceil(len(images) // num_workers))\n",
+    "        image_lists = [images[i:i + n] for i in range(0, len(images), n)]\n",
+    "        for l in image_lists:\n",
+    "            readers.append(pascalvoc(settings, l, 'train', batch_size, shuffle))\n",
+    "\n",
+    "    return paddle.reader.multiprocess_reader(readers, False)\n",
+    "\n",
+    "\n",
+    "def test_data_reader(settings, file_list, batch_size):\n",
+    "    file_list = os.path.join(settings.data_dir, file_list)\n",
+    "    if 'coco' in settings.dataset:\n",
+    "        from pycocotools.coco import COCO\n",
+    "        coco_api = COCO(file_list)\n",
+    "        image_ids = coco_api.getImgIds()\n",
+    "        images = coco_api.loadImgs(image_ids)\n",
+    "        if '2014' in file_list:\n",
+    "            sub_dir = \"val2014\"\n",
+    "        elif '2017' in file_list:\n",
+    "            sub_dir = \"val2017\"\n",
+    "        data_dir = os.path.join(settings.data_dir, sub_dir)\n",
+    "        return coco(settings, coco_api, images, 'test', batch_size, False,\n",
+    "                    data_dir)\n",
+    "    else:\n",
+    "        image_list = [line.strip() for line in open(file_list)]\n",
+    "        return pascalvoc(settings, image_list, 'test', batch_size, False)\n",
+    "\n",
+    "\n",
+    "def infer(settings, image_path):\n",
+    "    def reader():\n",
+    "        if not os.path.exists(image_path):\n",
+    "            raise ValueError(\"%s is not exist, you should specify \"\n",
+    "                             \"data path correctly.\" % image_path)\n",
+    "        img = Image.open(image_path)\n",
+    "        if img.mode == 'L':\n",
+    "            img = im.convert('RGB')\n",
+    "        im_width, im_height = img.size\n",
+    "        img = img.resize((settings.resize_w, settings.resize_h),\n",
+    "                         Image.ANTIALIAS)\n",
+    "        img = np.array(img)\n",
+    "        # HWC to CHW\n",
+    "        if len(img.shape) == 3:\n",
+    "            img = np.swapaxes(img, 1, 2)\n",
+    "            img = np.swapaxes(img, 1, 0)\n",
+    "        # RBG to BGR\n",
+    "        img = img[[2, 1, 0], :, :]\n",
+    "        img = img.astype('float32')\n",
+    "        img -= settings.img_mean\n",
+    "        img = img * 0.007843\n",
+    "        return img\n",
+    "\n",
+    "    return reader"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "在以上实现的reader中，通过调用`train_data_reader`函数返回一个数据迭代器, 以下代码示例简单展示了该迭代器如何使用："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#train_reader = train_data_reader(data_args,\n",
+    "#                                train_file_list,\n",
+    "#                                2,\n",
+    "#                                shuffle=False,\n",
+    "#                                num_workers=1)\n",
+    "\n",
+    "#for i, data in enumerate(train_reader()):\n",
+    "#    print(\"len: {}\".format(len(data)))\n",
+    "#    if i > 1:\n",
+    "#        break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. 定义网络\n",
+    "\n",
+    "MobileNet-V1-SSD网络结构如下：\n",
+    "![MobileNet-V1-SSD](https://images2017.cnblogs.com/blog/310015/201710/310015-20171008120716074-895532111.png)\n",
+    "\n",
+    "在文件[mobilenet_ssd.py](https://github.com/PaddlePaddle/models/blob/v1.4/PaddleCV/object_detection/mobilenet_ssd.py)中定义了MobileNet-V1-SSD网络结构。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import paddle.fluid as fluid\n",
+    "from paddle.fluid.initializer import MSRA\n",
+    "from paddle.fluid.param_attr import ParamAttr\n",
+    "\n",
+    "\n",
+    "def conv_bn(input,\n",
+    "            filter_size,\n",
+    "            num_filters,\n",
+    "            stride,\n",
+    "            padding,\n",
+    "            channels=None,\n",
+    "            num_groups=1,\n",
+    "            act='relu',\n",
+    "            use_cudnn=True,\n",
+    "            name=None):\n",
+    "    parameter_attr = ParamAttr(learning_rate=0.1, initializer=MSRA())\n",
+    "    conv = fluid.layers.conv2d(\n",
+    "        input=input,\n",
+    "        num_filters=num_filters,\n",
+    "        filter_size=filter_size,\n",
+    "        stride=stride,\n",
+    "        padding=padding,\n",
+    "        groups=num_groups,\n",
+    "        act=None,\n",
+    "        use_cudnn=use_cudnn,\n",
+    "        param_attr=parameter_attr,\n",
+    "        bias_attr=False)\n",
+    "    return fluid.layers.batch_norm(input=conv, act=act)\n",
+    "\n",
+    "\n",
+    "def depthwise_separable(input, num_filters1, num_filters2, num_groups, stride,\n",
+    "                        scale):\n",
+    "    depthwise_conv = conv_bn(\n",
+    "        input=input,\n",
+    "        filter_size=3,\n",
+    "        num_filters=int(num_filters1 * scale),\n",
+    "        stride=stride,\n",
+    "        padding=1,\n",
+    "        num_groups=int(num_groups * scale),\n",
+    "        use_cudnn=False)\n",
+    "\n",
+    "    pointwise_conv = conv_bn(\n",
+    "        input=depthwise_conv,\n",
+    "        filter_size=1,\n",
+    "        num_filters=int(num_filters2 * scale),\n",
+    "        stride=1,\n",
+    "        padding=0)\n",
+    "    return pointwise_conv\n",
+    "\n",
+    "\n",
+    "def extra_block(input, num_filters1, num_filters2, num_groups, stride, scale):\n",
+    "    # 1x1 conv\n",
+    "    pointwise_conv = conv_bn(\n",
+    "        input=input,\n",
+    "        filter_size=1,\n",
+    "        num_filters=int(num_filters1 * scale),\n",
+    "        stride=1,\n",
+    "        num_groups=int(num_groups * scale),\n",
+    "        padding=0)\n",
+    "\n",
+    "    # 3x3 conv\n",
+    "    normal_conv = conv_bn(\n",
+    "        input=pointwise_conv,\n",
+    "        filter_size=3,\n",
+    "        num_filters=int(num_filters2 * scale),\n",
+    "        stride=2,\n",
+    "        num_groups=int(num_groups * scale),\n",
+    "        padding=1)\n",
+    "    return normal_conv\n",
+    "\n",
+    "\n",
+    "def mobile_net(num_classes, img, img_shape, scale=1.0):\n",
+    "    # 300x300\n",
+    "    tmp = conv_bn(img, 3, int(32 * scale), 2, 1, 3)\n",
+    "    # 150x150\n",
+    "    tmp = depthwise_separable(tmp, 32, 64, 32, 1, scale)\n",
+    "    tmp = depthwise_separable(tmp, 64, 128, 64, 2, scale)\n",
+    "    # 75x75\n",
+    "    tmp = depthwise_separable(tmp, 128, 128, 128, 1, scale)\n",
+    "    tmp = depthwise_separable(tmp, 128, 256, 128, 2, scale)\n",
+    "    # 38x38\n",
+    "    tmp = depthwise_separable(tmp, 256, 256, 256, 1, scale)\n",
+    "    tmp = depthwise_separable(tmp, 256, 512, 256, 2, scale)\n",
+    "\n",
+    "    # 19x19\n",
+    "    for i in range(5):\n",
+    "        tmp = depthwise_separable(tmp, 512, 512, 512, 1, scale)\n",
+    "    module11 = tmp\n",
+    "    tmp = depthwise_separable(tmp, 512, 1024, 512, 2, scale)\n",
+    "\n",
+    "    # 10x10\n",
+    "    module13 = depthwise_separable(tmp, 1024, 1024, 1024, 1, scale)\n",
+    "    module14 = extra_block(module13, 256, 512, 1, 2, scale)\n",
+    "    # 5x5\n",
+    "    module15 = extra_block(module14, 128, 256, 1, 2, scale)\n",
+    "    # 3x3\n",
+    "    module16 = extra_block(module15, 128, 256, 1, 2, scale)\n",
+    "    # 2x2\n",
+    "    module17 = extra_block(module16, 64, 128, 1, 2, scale)\n",
+    "\n",
+    "    mbox_locs, mbox_confs, box, box_var = fluid.layers.multi_box_head(\n",
+    "        inputs=[module11, module13, module14, module15, module16, module17],\n",
+    "        image=img,\n",
+    "        num_classes=num_classes,\n",
+    "        min_ratio=20,\n",
+    "        max_ratio=90,\n",
+    "        min_sizes=[60.0, 105.0, 150.0, 195.0, 240.0, 285.0],\n",
+    "        max_sizes=[[], 150.0, 195.0, 240.0, 285.0, 300.0],\n",
+    "        aspect_ratios=[[2.], [2., 3.], [2., 3.], [2., 3.], [2., 3.], [2., 3.]],\n",
+    "        base_size=img_shape[2],\n",
+    "        offset=0.5,\n",
+    "        flip=True)\n",
+    "\n",
+    "    return mbox_locs, mbox_confs, box, box_var"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. 配置压缩任务\n",
+    "\n",
+    "### 4.1 配置int8量化压缩策略\n",
+    "\n",
+    "现阶段的量化训练主要针对卷积层（包括二维卷积和Depthwise卷积）以及全连接层进行量化。卷积层和全连接层在PaddlePaddle框架中对应算子包括conv2d、depthwise_conv2d和mul等。量化训练会对所有的conv2d、depthwise_conv2d和mul进行量化操作，且要求它们的输入中必须包括激活和参数两部分。\n",
+    "int8量化训练策略目前可配置的参数如下：\n",
+    "\n",
+    "- **class:** 量化策略的类名称，目前仅支持QuantizationStrategy\n",
+    "\n",
+    "- **start_epoch:** 在start_epoch开始之前，量化训练策略会往train_program和eval_program插入量化operators和反量化operators. 从start_epoch开始，进入量化训练阶段。\n",
+    "\n",
+    "- **end_epoch:** 在end_epoch结束之后，会保存用户指定格式的模型。注意：end_epoch之后并不会停止量化训练，而是继续训练到compressor.epoch为止。\n",
+    "\n",
+    "- **float_model_save_path:** 保存float数据格式模型的路径。模型weight的实际大小在int8可表示范围内，但是是以float格式存储的。如果设置为None, 则不存储float格式的模型。默认为None.\n",
+    "\n",
+    "- **int8_model_save_path:** 保存int8数据格式模型的路径。如果设置为None, 则不存储int8格式的模型。默认为None.\n",
+    "\n",
+    "- **mobile_model_save_path:** 保存兼容paddle-mobile框架的模型的路径。如果设置为None, 则不存储mobile格式的模型。默认为None.\n",
+    "\n",
+    "- **weight_bits:** 量化weight的bit数，bias不会被量化。\n",
+    "\n",
+    "- **activation_bits:** 量化activation的bit数。\n",
+    "\n",
+    "- **weight_quantize_type:** 对于weight的量化方式，目前支持'abs_max'， 'channel_wise_abs_max'.\n",
+    "\n",
+    "- **activation_quantize_type:** 对activation的量化方法，目前可选abs_max或range_abs_max。abs_max意为在训练的每个step和inference阶段动态的计算量化范围。range_abs_max意为在训练阶段计算出一个静态的范围，并将其用于inference阶段。\n",
+    "\n",
+    "- **save_in_nodes:** variable名称列表。在保存量化后模型的时候，需要根据save_in_nodes对eval programg 网络进行前向遍历剪枝。默认为eval_feed_list内指定的variable的名称列表。\n",
+    "\n",
+    "- **save_out_nodes:** varibale名称列表。在保存量化后模型的时候，需要根据save_out_nodes对eval programg 网络进行回溯剪枝。默认为eval_fetch_list内指定的variable的名称列表。\n",
+    "\n",
+    "其中`save_in_nodes`和`save_out_nodes`中的variable名称，可以在构建网络时，通过`print`打印。例如：\n",
+    "\n",
+    "\n",
+    "```\n",
+    "\n",
+    "nmsed_out = fluid.layers.detection_output(\n",
+    "                        locs, confs, box, box_var, nms_threshold=0.45)\n",
+    "print(nms_out.name)\n",
+    "\n",
+    "```\n",
+    "\n",
+    "以下代码将配置文件写到当前工作路径下："
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config=\"\"\"\n",
+    "version: 1.0\n",
+    "strategies:\n",
+    "    quantization_strategy:\n",
+    "        class: 'QuantizationStrategy'\n",
+    "        start_epoch: 0\n",
+    "        end_epoch: 20\n",
+    "        float_model_save_path: './output/float'\n",
+    "        mobile_model_save_path: './output/mobile'\n",
+    "        int8_model_save_path: './output/int8'\n",
+    "        weight_bits: 8\n",
+    "        activation_bits: 8\n",
+    "        weight_quantize_type: 'abs_max'\n",
+    "        activation_quantize_type: 'abs_max'\n",
+    "        save_in_nodes: ['image']\n",
+    "        save_out_nodes: ['inferenceinferencedetection_output_0.tmp_0']\n",
+    "compressor:\n",
+    "    epoch: 2\n",
+    "    checkpoint_path: './checkpoints/'\n",
+    "    strategies:\n",
+    "        - quantization_strategy\n",
+    "\"\"\"\n",
+    "\n",
+    "f = open(\"./compress.yaml\", 'w')\n",
+    "f.write(config)\n",
+    "f.close()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.2 配置Compressor\n",
+    "\n",
+    "压缩目标即我们要压缩的网络，我们需要为其准一下内容：\n",
+    "#### 4.2.1 准备工作\n",
+    "##### step1: import"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import time\n",
+    "import numpy as np\n",
+    "import argparse\n",
+    "import functools\n",
+    "import shutil\n",
+    "import math\n",
+    "import multiprocessing\n",
+    "\n",
+    "import paddle\n",
+    "import paddle.fluid as fluid\n",
+    "from paddle.fluid.contrib.slim import Compressor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### step2: 设置训练相关参数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 74,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "args_learning_rate= 0.001\n",
+    "args_batch_size = 32\n",
+    "args_epoc_num = 120\n",
+    "args_use_gpu = False\n",
+    "args_parallel = True\n",
+    "\n",
+    "args_model_save_dir = 'model'\n",
+    "\n",
+    "\n",
+    "train_parameters = {\n",
+    "    \"pascalvoc\": {\n",
+    "        \"train_images\": 16551,\n",
+    "        \"image_shape\": [3, 300, 300],\n",
+    "        \"class_num\": 21,\n",
+    "        \"batch_size\": 64,\n",
+    "        \"lr\": 0.001,\n",
+    "        \"lr_epochs\": [40, 60, 80, 100],\n",
+    "        \"lr_decay\": [1, 0.5, 0.25, 0.1, 0.01],\n",
+    "        \"ap_version\": '11point',\n",
+    "    },\n",
+    "    \"coco2014\": {\n",
+    "        \"train_images\": 82783,\n",
+    "        \"image_shape\": [3, 300, 300],\n",
+    "        \"class_num\": 91,\n",
+    "        \"batch_size\": 64,\n",
+    "        \"lr\": 0.001,\n",
+    "        \"lr_epochs\": [12, 19],\n",
+    "        \"lr_decay\": [1, 0.5, 0.25],\n",
+    "        \"ap_version\": 'integral', # should use eval_coco_map.py to test model\n",
+    "    },\n",
+    "    \"coco2017\": {\n",
+    "        \"train_images\": 118287,\n",
+    "        \"image_shape\": [3, 300, 300],\n",
+    "        \"class_num\": 91,\n",
+    "        \"batch_size\": 64,\n",
+    "        \"lr\": 0.001,\n",
+    "        \"lr_epochs\": [12, 19],\n",
+    "        \"lr_decay\": [1, 0.5, 0.25],\n",
+    "        \"ap_version\": 'integral', # should use eval_coco_map.py to test model\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "train_parameters[dataset]['image_shape'] = image_shape\n",
+    "train_parameters[dataset]['batch_size'] = args_batch_size\n",
+    "train_parameters[dataset]['lr'] = args_learning_rate\n",
+    "train_parameters[dataset]['epoc_num'] = args_epoc_num\n",
+    "train_parameters[dataset]['ap_version'] = args_ap_version"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### step3: 定义优化器生成函数"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 75,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def optimizer_setting(train_params):\n",
+    "    batch_size = train_params[\"batch_size\"]\n",
+    "    iters = train_params[\"train_images\"] // batch_size\n",
+    "    lr = train_params[\"lr\"]\n",
+    "    boundaries = [i * iters  for i in train_params[\"lr_epochs\"]]\n",
+    "    values = [ i * lr for i in train_params[\"lr_decay\"]]\n",
+    "\n",
+    "    optimizer = fluid.optimizer.RMSProp(\n",
+    "        # learning_rate=fluid.layers.piecewise_decay(boundaries, values),\n",
+    "        learning_rate=0.1,\n",
+    "        regularization=fluid.regularizer.L2Decay(0.00005), )\n",
+    "\n",
+    "    return optimizer"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### step4: 定义构建网络函数\n",
+    "\n",
+    ">注意：Paddle1.5版本的压缩库才开始支持py_reader. 本步骤的示例代码用的是普通reader，而不是py_reader.\n",
+    "如果需要py_reader, 需要修改build_program函数。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def build_program(main_prog, startup_prog, train_params, is_train):\n",
+    "    image_shape = train_params['image_shape']\n",
+    "    class_num = train_params['class_num']\n",
+    "    ap_version = train_params['ap_version']\n",
+    "    outs = []\n",
+    "    with fluid.program_guard(main_prog, startup_prog):\n",
+    "        #py_reader = fluid.layers.py_reader(\n",
+    "        #    capacity=64,\n",
+    "        #    shapes=[[-1] + image_shape, [-1, 4], [-1, 1], [-1, 1]],\n",
+    "        #    lod_levels=[0, 1, 1, 1],\n",
+    "        #    dtypes=[\"float32\", \"float32\", \"int32\", \"int32\"],\n",
+    "        #    use_double_buffer=True)\n",
+    "        with fluid.unique_name.guard():\n",
+    "            \n",
+    "            image = fluid.layers.data(name=\"image\", shape=[-1]+image_shape, dtype=\"float32\", lod_level=0)\n",
+    "            gt_box = fluid.layers.data(name=\"gt_box\", shape=[-1, 4], dtype=\"float32\", lod_level=1)\n",
+    "            gt_label = fluid.layers.data(name=\"gt_label\", shape=[-1, 1], dtype=\"float32\", lod_level=1)\n",
+    "            difficult = fluid.layers.data(name=\"difficult\", shape=[-1, 1], dtype=\"float32\", lod_level=1)\n",
+    "            fluid.layers.Print(image, message=\"image\", summarize=10)\n",
+    "            fluid.layers.Print(gt_box, message=\"gt_box\", summarize=10)\n",
+    "            fluid.layers.Print(gt_label, message=\"gt_label\", summarize=10)\n",
+    "            fluid.layers.Print(difficult, message=\"difficult\", summarize=10)\n",
+    "            #image, gt_box, gt_label, difficult = fluid.layers.read_file(py_reader)\n",
+    "            locs, confs, box, box_var = mobile_net(class_num, image, image_shape)\n",
+    "            gt_label.stop_gradient=True\n",
+    "            difficult.stop_gradient=True\n",
+    "            gt_box.stop_gradient=True\n",
+    "            if is_train:\n",
+    "                with fluid.unique_name.guard(\"train\"):\n",
+    "                    \n",
+    "                    loss = fluid.layers.ssd_loss(locs, confs, gt_box, gt_label, box,\n",
+    "                        box_var)\n",
+    "                    loss = fluid.layers.reduce_sum(loss)\n",
+    "                    optimizer = optimizer_setting(train_parameters[dataset])\n",
+    "                    optimizer.minimize(loss)\n",
+    "                outs = ((image, gt_box, gt_label, difficult), loss, optimizer)\n",
+    "            else:\n",
+    "                with fluid.unique_name.guard(\"inference\"):\n",
+    "                    nmsed_out = fluid.layers.detection_output(\n",
+    "                        locs, confs, box, box_var, nms_threshold=0.45)\n",
+    "                    \n",
+    "                    print(\"nmsed_out: {}\".format(nmsed_out))\n",
+    "                    gt_label = fluid.layers.cast(x=gt_label, dtype=gt_box.dtype)\n",
+    "                    if difficult:\n",
+    "                        difficult = fluid.layers.cast(x=difficult, dtype=gt_box.dtype)\n",
+    "                        gt_label = fluid.layers.reshape(gt_label, [-1, 1])\n",
+    "                        difficult = fluid.layers.reshape(difficult, [-1, 1])\n",
+    "                        label = fluid.layers.concat([gt_label, difficult, gt_box], axis=1)\n",
+    "                    else:\n",
+    "                        label = fluid.layers.concat([gt_label, gt_box], axis=1)\n",
+    "                    map_var = fluid.layers.detection.detection_map(\n",
+    "                            nmsed_out,\n",
+    "                            label,\n",
+    "                            class_num,\n",
+    "                            background_label=0,\n",
+    "                            overlap_threshold=0.5,\n",
+    "                            evaluate_difficult=False,\n",
+    "                            ap_version=ap_version)\n",
+    "                    \n",
+    "                # nmsed_out and image is used to save mode for inference\n",
+    "                outs = ((image, gt_box, gt_label, difficult), map_var, nmsed_out, image)\n",
+    "    return outs"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 4.2.2 配置Compressor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#def compress(args,\n",
+    "#          data_args,\n",
+    "#          train_params,\n",
+    "#          train_file_list,\n",
+    "#          val_file_list):\n",
+    "\n",
+    "model_save_dir = args_model_save_dir\n",
+    "pretrained_model = args_pretrained_model\n",
+    "use_gpu = args_use_gpu\n",
+    "parallel = args_parallel\n",
+    "is_shuffle = True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### 设置device信息，并根据device信息设置batch size"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if not use_gpu:\n",
+    "    devices_num = int(os.environ.get('CPU_NUM',\n",
+    "                          multiprocessing.cpu_count()))\n",
+    "    devices_num = 1\n",
+    "else:\n",
+    "    devices_num = fluid.core.get_cuda_device_count()\n",
+    "\n",
+    "batch_size = train_parameters[dataset]['batch_size']\n",
+    "batch_size_per_device = batch_size // devices_num    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### 声明并构造train_program和test_program\n",
+    "\n",
+    "- **train_program:** 用于在压缩过程中迭代训练模型，该program必须包含loss。一般改program不要有backward op和weights update op，否则不能使用蒸馏策略。\n",
+    "\n",
+    "- **test_program:** 用于在压缩过程中评估模型的精度，一般会包含accuracy、IoU等评估指标的计算layer。"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 79,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "nmsed_out: name: \"inferenceinferencedetection_output_0.tmp_0\"\n",
+      "type {\n",
+      "  type: LOD_TENSOR\n",
+      "  lod_tensor {\n",
+      "    tensor {\n",
+      "      data_type: FP32\n",
+      "      dims: 1917\n",
+      "      dims: 6\n",
+      "    }\n",
+      "  }\n",
+      "}\n",
+      "persistable: false\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "epoc_num = train_parameters[dataset]['epoc_num']\n",
+    "\n",
+    "startup_prog = fluid.Program()\n",
+    "train_prog = fluid.Program()\n",
+    "test_prog = fluid.Program()\n",
+    "\n",
+    "train_inputs, loss, optimizer = build_program(\n",
+    "        main_prog=train_prog,\n",
+    "        startup_prog=startup_prog,\n",
+    "        train_params=train_parameters[dataset],\n",
+    "        is_train=True)\n",
+    "    \n",
+    "test_inputs, map_var, _, _ = build_program(\n",
+    "        main_prog=test_prog,\n",
+    "        startup_prog=startup_prog,\n",
+    "        train_params=train_parameters[dataset],\n",
+    "        is_train=False)\n",
+    "    \n",
+    "test_prog = test_prog.clone(for_test=True) "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 初始化网络并加载预训练模型"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 80,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()\n",
+    "exe = fluid.Executor(place)\n",
+    "exe.run(startup_prog)\n",
+    "    \n",
+    "if pretrained_model:\n",
+    "    def if_exist(var):\n",
+    "        return os.path.exists(os.path.join(pretrained_model, var.name))\n",
+    "    fluid.io.load_vars(exe, pretrained_model, main_program=train_prog,\n",
+    "                           predicate=if_exist)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### 构造data reader\n",
+    "\n",
+    "- train_reader: 用于给train_program的执行提供数据\n",
+    "\n",
+    "- eval_reader: 用于给eval_program的执行提供数据"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_workers = 8\n",
+    "train_reader = train_data_reader(data_args,\n",
+    "                                train_file_list,\n",
+    "                                batch_size_per_device,\n",
+    "                                shuffle=is_shuffle,\n",
+    "                                num_workers=num_workers)\n",
+    "test_reader = test_data_reader(data_args, val_file_list, batch_size)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### 指定训练网络和测试网络的input和output\n",
+    "\n",
+    "feed list和fetch list是两个有序的字典, 其中，feed_list中的key为自定义的有一定含义的字符串，value是Variable的名称, feed_list中的顺序需要和DataReader提供的数据的顺序对应。\n",
+    "\n",
+    "对于train_program和test_program都需要有与其对应的feed_list和fetch_list。\n",
+    "\n",
+    ">注意： 在train_program对应的fetch_list中，loss variable(loss layer的输出)对应的key一定要是‘‘loss’’"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 85,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "image, gt_box, gt_label, difficult = train_inputs\n",
+    "train_feed_list = [(\"image\", \"image\"), (\"gt_box\", \"gt_box\"), (\"gt_label\", \"gt_label\"), (\"difficult\", \"difficult\")]\n",
+    "train_fetch_list=[(\"loss\", loss.name)]\n",
+    "\n",
+    "image, gt_box, gt_label, difficult = test_inputs\n",
+    "val_feed_list=[(\"image\", \"image\"), (\"gt_box\", \"gt_box\"), (\"gt_label\", \"gt_label\"), (\"difficult\", \"difficult\")]\n",
+    "val_fetch_list=[(\"map\",  map_var.name)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4.3 构造并执行Compressor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "com_pass = Compressor(\n",
+    "        place,\n",
+    "        fluid.global_scope(),\n",
+    "        train_prog,\n",
+    "        train_reader=train_reader,\n",
+    "        train_feed_list=train_feed_list,\n",
+    "        train_fetch_list=train_fetch_list,\n",
+    "        eval_program=test_prog,\n",
+    "        eval_reader=test_reader,\n",
+    "        eval_feed_list=val_feed_list,\n",
+    "        eval_fetch_list=val_fetch_list,\n",
+    "        train_optimizer=None)\n",
+    "com_pass.config('./compress.yaml')\n",
+    "eval_graph = com_pass.run()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 2",
+   "language": "python",
+   "name": "python2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}