[0m", buffer))
+ buffer = re.sub(r"___(\d+)___(.*?):", r"[\1m\2[0m:", buffer)
+ print(buffer)
diff --git a/ppdet/utils/coco_eval.py b/ppdet/utils/coco_eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb5df475fb16f10fffa18a02920687780a3fe298
--- /dev/null
+++ b/ppdet/utils/coco_eval.py
@@ -0,0 +1,560 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import os
+import sys
+import json
+import cv2
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')
+
+import logging
+logger = logging.getLogger(__name__)
+
+__all__ = [
+ 'bbox_eval',
+ 'mask_eval',
+ 'bbox2out',
+ 'mask2out',
+ 'get_category_info',
+ 'proposal_eval',
+ 'cocoapi_eval',
+]
+
+
+def clip_bbox(bbox):
+ xmin = max(min(bbox[0], 1.), 0.)
+ ymin = max(min(bbox[1], 1.), 0.)
+ xmax = max(min(bbox[2], 1.), 0.)
+ ymax = max(min(bbox[3], 1.), 0.)
+ return xmin, ymin, xmax, ymax
+
+
+def proposal_eval(results, anno_file, outfile, max_dets=(100, 300, 1000)):
+ assert 'proposal' in results[0]
+ assert outfile.endswith('.json')
+
+ xywh_results = proposal2out(results)
+ assert len(
+ xywh_results) > 0, "The number of valid proposal detected is zero.\n \
+ Please use reasonable model and check input data."
+
+ with open(outfile, 'w') as f:
+ json.dump(xywh_results, f)
+
+ cocoapi_eval(outfile, 'proposal', anno_file=anno_file, max_dets=max_dets)
+ # flush coco evaluation result
+ sys.stdout.flush()
+
+
+def bbox_eval(results,
+ anno_file,
+ outfile,
+ with_background=True,
+ is_bbox_normalized=False):
+ assert 'bbox' in results[0]
+ assert outfile.endswith('.json')
+ from pycocotools.coco import COCO
+
+ coco_gt = COCO(anno_file)
+ cat_ids = coco_gt.getCatIds()
+
+ # when with_background = True, mapping category to classid, like:
+ # background:0, first_class:1, second_class:2, ...
+ clsid2catid = dict(
+ {i + int(with_background): catid
+ for i, catid in enumerate(cat_ids)})
+
+ xywh_results = bbox2out(
+ results, clsid2catid, is_bbox_normalized=is_bbox_normalized)
+
+ if len(xywh_results) == 0:
+ logger.warning("The number of valid bbox detected is zero.\n \
+ Please use reasonable model and check input data.\n \
+ stop eval!")
+ return [0.0]
+ with open(outfile, 'w') as f:
+ json.dump(xywh_results, f)
+
+ map_stats = cocoapi_eval(outfile, 'bbox', coco_gt=coco_gt)
+ # flush coco evaluation result
+ sys.stdout.flush()
+ return map_stats
+
+
+def mask_eval(results, anno_file, outfile, resolution, thresh_binarize=0.5):
+ assert 'mask' in results[0]
+ assert outfile.endswith('.json')
+ from pycocotools.coco import COCO
+
+ coco_gt = COCO(anno_file)
+ clsid2catid = {i + 1: v for i, v in enumerate(coco_gt.getCatIds())}
+
+ segm_results = mask2out(results, clsid2catid, resolution, thresh_binarize)
+ if len(segm_results) == 0:
+ logger.warning("The number of valid mask detected is zero.\n \
+ Please use reasonable model and check input data.")
+ return
+
+ with open(outfile, 'w') as f:
+ json.dump(segm_results, f)
+
+ cocoapi_eval(outfile, 'segm', coco_gt=coco_gt)
+
+
+def cocoapi_eval(jsonfile,
+ style,
+ coco_gt=None,
+ anno_file=None,
+ max_dets=(100, 300, 1000)):
+ """
+ Args:
+ jsonfile: Evaluation json file, eg: bbox.json, mask.json.
+ style: COCOeval style, can be `bbox` , `segm` and `proposal`.
+ coco_gt: Whether to load COCOAPI through anno_file,
+ eg: coco_gt = COCO(anno_file)
+ anno_file: COCO annotations file.
+ max_dets: COCO evaluation maxDets.
+ """
+ assert coco_gt != None or anno_file != None
+ from pycocotools.coco import COCO
+ from pycocotools.cocoeval import COCOeval
+
+ if coco_gt == None:
+ coco_gt = COCO(anno_file)
+ logger.info("Start evaluate...")
+ coco_dt = coco_gt.loadRes(jsonfile)
+ if style == 'proposal':
+ coco_eval = COCOeval(coco_gt, coco_dt, 'bbox')
+ coco_eval.params.useCats = 0
+ coco_eval.params.maxDets = list(max_dets)
+ else:
+ coco_eval = COCOeval(coco_gt, coco_dt, style)
+ coco_eval.evaluate()
+ coco_eval.accumulate()
+ coco_eval.summarize()
+ return coco_eval.stats
+
+
+def proposal2out(results, is_bbox_normalized=False):
+ xywh_res = []
+ for t in results:
+ bboxes = t['proposal'][0]
+ lengths = t['proposal'][1][0]
+ im_ids = np.array(t['im_id'][0])
+ if bboxes.shape == (1, 1) or bboxes is None:
+ continue
+
+ k = 0
+ for i in range(len(lengths)):
+ num = lengths[i]
+ im_id = int(im_ids[i][0])
+ for j in range(num):
+ dt = bboxes[k]
+ xmin, ymin, xmax, ymax = dt.tolist()
+
+ if is_bbox_normalized:
+ xmin, ymin, xmax, ymax = \
+ clip_bbox([xmin, ymin, xmax, ymax])
+ w = xmax - xmin
+ h = ymax - ymin
+ else:
+ w = xmax - xmin + 1
+ h = ymax - ymin + 1
+
+ bbox = [xmin, ymin, w, h]
+ coco_res = {
+ 'image_id': im_id,
+ 'category_id': 1,
+ 'bbox': bbox,
+ 'score': 1.0
+ }
+ xywh_res.append(coco_res)
+ k += 1
+ return xywh_res
+
+
+def bbox2out(results, clsid2catid, is_bbox_normalized=False):
+ """
+ Args:
+ results: request a dict, should include: `bbox`, `im_id`,
+ if is_bbox_normalized=True, also need `im_shape`.
+ clsid2catid: class id to category id map of COCO2017 dataset.
+ is_bbox_normalized: whether or not bbox is normalized.
+ """
+ xywh_res = []
+ for t in results:
+ bboxes = t['bbox'][0]
+ lengths = t['bbox'][1][0]
+ im_ids = np.array(t['im_id'][0])
+ if bboxes.shape == (1, 1) or bboxes is None:
+ continue
+
+ k = 0
+ for i in range(len(lengths)):
+ num = lengths[i]
+ im_id = int(im_ids[i][0])
+ for j in range(num):
+ dt = bboxes[k]
+ clsid, score, xmin, ymin, xmax, ymax = dt.tolist()
+ catid = (clsid2catid[int(clsid)])
+
+ if is_bbox_normalized:
+ xmin, ymin, xmax, ymax = \
+ clip_bbox([xmin, ymin, xmax, ymax])
+ w = xmax - xmin
+ h = ymax - ymin
+ im_height, im_width = t['im_shape'][0][i].tolist()
+ xmin *= im_width
+ ymin *= im_height
+ w *= im_width
+ h *= im_height
+ else:
+ w = xmax - xmin + 1
+ h = ymax - ymin + 1
+
+ bbox = [xmin, ymin, w, h]
+ coco_res = {
+ 'image_id': im_id,
+ 'category_id': catid,
+ 'bbox': bbox,
+ 'score': score
+ }
+ xywh_res.append(coco_res)
+ k += 1
+ return xywh_res
+
+
+def mask2out(results, clsid2catid, resolution, thresh_binarize=0.5):
+ import pycocotools.mask as mask_util
+ scale = (resolution + 2.0) / resolution
+
+ segm_res = []
+
+ # for each batch
+ for t in results:
+ bboxes = t['bbox'][0]
+
+ lengths = t['bbox'][1][0]
+ im_ids = np.array(t['im_id'][0])
+ if bboxes.shape == (1, 1) or bboxes is None:
+ continue
+ if len(bboxes.tolist()) == 0:
+ continue
+
+ masks = t['mask'][0]
+
+ s = 0
+ # for each sample
+ for i in range(len(lengths)):
+ num = lengths[i]
+ im_id = int(im_ids[i][0])
+ im_shape = t['im_shape'][0][i]
+
+ bbox = bboxes[s:s + num][:, 2:]
+ clsid_scores = bboxes[s:s + num][:, 0:2]
+ mask = masks[s:s + num]
+ s += num
+
+ im_h = int(im_shape[0])
+ im_w = int(im_shape[1])
+
+ expand_bbox = expand_boxes(bbox, scale)
+ expand_bbox = expand_bbox.astype(np.int32)
+
+ padded_mask = np.zeros(
+ (resolution + 2, resolution + 2), dtype=np.float32)
+
+ for j in range(num):
+ xmin, ymin, xmax, ymax = expand_bbox[j].tolist()
+ clsid, score = clsid_scores[j].tolist()
+ clsid = int(clsid)
+ padded_mask[1:-1, 1:-1] = mask[j, clsid, :, :]
+
+ catid = clsid2catid[clsid]
+
+ w = xmax - xmin + 1
+ h = ymax - ymin + 1
+ w = np.maximum(w, 1)
+ h = np.maximum(h, 1)
+
+ resized_mask = cv2.resize(padded_mask, (w, h))
+ resized_mask = np.array(
+ resized_mask > thresh_binarize, dtype=np.uint8)
+ im_mask = np.zeros((im_h, im_w), dtype=np.uint8)
+
+ x0 = min(max(xmin, 0), im_w)
+ x1 = min(max(xmax + 1, 0), im_w)
+ y0 = min(max(ymin, 0), im_h)
+ y1 = min(max(ymax + 1, 0), im_h)
+
+ im_mask[y0:y1, x0:x1] = resized_mask[(y0 - ymin):(y1 - ymin), (
+ x0 - xmin):(x1 - xmin)]
+ segm = mask_util.encode(
+ np.array(
+ im_mask[:, :, np.newaxis], order='F'))[0]
+ catid = clsid2catid[clsid]
+ segm['counts'] = segm['counts'].decode('utf8')
+ coco_res = {
+ 'image_id': im_id,
+ 'category_id': catid,
+ 'segmentation': segm,
+ 'score': score
+ }
+ segm_res.append(coco_res)
+ return segm_res
+
+
+def expand_boxes(boxes, scale):
+ """
+ Expand an array of boxes by a given scale.
+ """
+ w_half = (boxes[:, 2] - boxes[:, 0]) * .5
+ h_half = (boxes[:, 3] - boxes[:, 1]) * .5
+ x_c = (boxes[:, 2] + boxes[:, 0]) * .5
+ y_c = (boxes[:, 3] + boxes[:, 1]) * .5
+
+ w_half *= scale
+ h_half *= scale
+
+ boxes_exp = np.zeros(boxes.shape)
+ boxes_exp[:, 0] = x_c - w_half
+ boxes_exp[:, 2] = x_c + w_half
+ boxes_exp[:, 1] = y_c - h_half
+ boxes_exp[:, 3] = y_c + h_half
+
+ return boxes_exp
+
+
+def get_category_info(anno_file=None,
+ with_background=True,
+ use_default_label=False):
+ if use_default_label or anno_file is None \
+ or not os.path.exists(anno_file):
+ logger.info("Not found annotation file {}, load "
+ "coco17 categories.".format(anno_file))
+ return coco17_category_info(with_background)
+ else:
+ logger.info("Load categories from {}".format(anno_file))
+ return get_category_info_from_anno(anno_file, with_background)
+
+
+def get_category_info_from_anno(anno_file, with_background=True):
+ """
+ Get class id to category id map and category id
+ to category name map from annotation file.
+
+ Args:
+ anno_file (str): annotation file path
+ with_background (bool, default True):
+ whether load background as class 0.
+ """
+ from pycocotools.coco import COCO
+ coco = COCO(anno_file)
+ cats = coco.loadCats(coco.getCatIds())
+ clsid2catid = {
+ i + int(with_background): cat['id']
+ for i, cat in enumerate(cats)
+ }
+ catid2name = {cat['id']: cat['name'] for cat in cats}
+
+ return clsid2catid, catid2name
+
+
+def coco17_category_info(with_background=True):
+ """
+ Get class id to category id map and category id
+ to category name map of COCO2017 dataset
+
+ Args:
+ with_background (bool, default True):
+ whether load background as class 0.
+ """
+ clsid2catid = {
+ 1: 1,
+ 2: 2,
+ 3: 3,
+ 4: 4,
+ 5: 5,
+ 6: 6,
+ 7: 7,
+ 8: 8,
+ 9: 9,
+ 10: 10,
+ 11: 11,
+ 12: 13,
+ 13: 14,
+ 14: 15,
+ 15: 16,
+ 16: 17,
+ 17: 18,
+ 18: 19,
+ 19: 20,
+ 20: 21,
+ 21: 22,
+ 22: 23,
+ 23: 24,
+ 24: 25,
+ 25: 27,
+ 26: 28,
+ 27: 31,
+ 28: 32,
+ 29: 33,
+ 30: 34,
+ 31: 35,
+ 32: 36,
+ 33: 37,
+ 34: 38,
+ 35: 39,
+ 36: 40,
+ 37: 41,
+ 38: 42,
+ 39: 43,
+ 40: 44,
+ 41: 46,
+ 42: 47,
+ 43: 48,
+ 44: 49,
+ 45: 50,
+ 46: 51,
+ 47: 52,
+ 48: 53,
+ 49: 54,
+ 50: 55,
+ 51: 56,
+ 52: 57,
+ 53: 58,
+ 54: 59,
+ 55: 60,
+ 56: 61,
+ 57: 62,
+ 58: 63,
+ 59: 64,
+ 60: 65,
+ 61: 67,
+ 62: 70,
+ 63: 72,
+ 64: 73,
+ 65: 74,
+ 66: 75,
+ 67: 76,
+ 68: 77,
+ 69: 78,
+ 70: 79,
+ 71: 80,
+ 72: 81,
+ 73: 82,
+ 74: 84,
+ 75: 85,
+ 76: 86,
+ 77: 87,
+ 78: 88,
+ 79: 89,
+ 80: 90
+ }
+
+ catid2name = {
+ 0: 'background',
+ 1: 'person',
+ 2: 'bicycle',
+ 3: 'car',
+ 4: 'motorcycle',
+ 5: 'airplane',
+ 6: 'bus',
+ 7: 'train',
+ 8: 'truck',
+ 9: 'boat',
+ 10: 'traffic light',
+ 11: 'fire hydrant',
+ 13: 'stop sign',
+ 14: 'parking meter',
+ 15: 'bench',
+ 16: 'bird',
+ 17: 'cat',
+ 18: 'dog',
+ 19: 'horse',
+ 20: 'sheep',
+ 21: 'cow',
+ 22: 'elephant',
+ 23: 'bear',
+ 24: 'zebra',
+ 25: 'giraffe',
+ 27: 'backpack',
+ 28: 'umbrella',
+ 31: 'handbag',
+ 32: 'tie',
+ 33: 'suitcase',
+ 34: 'frisbee',
+ 35: 'skis',
+ 36: 'snowboard',
+ 37: 'sports ball',
+ 38: 'kite',
+ 39: 'baseball bat',
+ 40: 'baseball glove',
+ 41: 'skateboard',
+ 42: 'surfboard',
+ 43: 'tennis racket',
+ 44: 'bottle',
+ 46: 'wine glass',
+ 47: 'cup',
+ 48: 'fork',
+ 49: 'knife',
+ 50: 'spoon',
+ 51: 'bowl',
+ 52: 'banana',
+ 53: 'apple',
+ 54: 'sandwich',
+ 55: 'orange',
+ 56: 'broccoli',
+ 57: 'carrot',
+ 58: 'hot dog',
+ 59: 'pizza',
+ 60: 'donut',
+ 61: 'cake',
+ 62: 'chair',
+ 63: 'couch',
+ 64: 'potted plant',
+ 65: 'bed',
+ 67: 'dining table',
+ 70: 'toilet',
+ 72: 'tv',
+ 73: 'laptop',
+ 74: 'mouse',
+ 75: 'remote',
+ 76: 'keyboard',
+ 77: 'cell phone',
+ 78: 'microwave',
+ 79: 'oven',
+ 80: 'toaster',
+ 81: 'sink',
+ 82: 'refrigerator',
+ 84: 'book',
+ 85: 'clock',
+ 86: 'vase',
+ 87: 'scissors',
+ 88: 'teddy bear',
+ 89: 'hair drier',
+ 90: 'toothbrush'
+ }
+
+ if not with_background:
+ clsid2catid = {k - 1: v for k, v in clsid2catid.items()}
+
+ return clsid2catid, catid2name
diff --git a/ppdet/utils/colormap.py b/ppdet/utils/colormap.py
new file mode 100644
index 0000000000000000000000000000000000000000..566185ef90390e2f45747bee48e3b008f7dfc0e9
--- /dev/null
+++ b/ppdet/utils/colormap.py
@@ -0,0 +1,56 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import numpy as np
+
+
+def colormap(rgb=False):
+ """
+ Get colormap
+ """
+ color_list = np.array([
+ 0.000, 0.447, 0.741, 0.850, 0.325, 0.098, 0.929, 0.694, 0.125, 0.494,
+ 0.184, 0.556, 0.466, 0.674, 0.188, 0.301, 0.745, 0.933, 0.635, 0.078,
+ 0.184, 0.300, 0.300, 0.300, 0.600, 0.600, 0.600, 1.000, 0.000, 0.000,
+ 1.000, 0.500, 0.000, 0.749, 0.749, 0.000, 0.000, 1.000, 0.000, 0.000,
+ 0.000, 1.000, 0.667, 0.000, 1.000, 0.333, 0.333, 0.000, 0.333, 0.667,
+ 0.000, 0.333, 1.000, 0.000, 0.667, 0.333, 0.000, 0.667, 0.667, 0.000,
+ 0.667, 1.000, 0.000, 1.000, 0.333, 0.000, 1.000, 0.667, 0.000, 1.000,
+ 1.000, 0.000, 0.000, 0.333, 0.500, 0.000, 0.667, 0.500, 0.000, 1.000,
+ 0.500, 0.333, 0.000, 0.500, 0.333, 0.333, 0.500, 0.333, 0.667, 0.500,
+ 0.333, 1.000, 0.500, 0.667, 0.000, 0.500, 0.667, 0.333, 0.500, 0.667,
+ 0.667, 0.500, 0.667, 1.000, 0.500, 1.000, 0.000, 0.500, 1.000, 0.333,
+ 0.500, 1.000, 0.667, 0.500, 1.000, 1.000, 0.500, 0.000, 0.333, 1.000,
+ 0.000, 0.667, 1.000, 0.000, 1.000, 1.000, 0.333, 0.000, 1.000, 0.333,
+ 0.333, 1.000, 0.333, 0.667, 1.000, 0.333, 1.000, 1.000, 0.667, 0.000,
+ 1.000, 0.667, 0.333, 1.000, 0.667, 0.667, 1.000, 0.667, 1.000, 1.000,
+ 1.000, 0.000, 1.000, 1.000, 0.333, 1.000, 1.000, 0.667, 1.000, 0.167,
+ 0.000, 0.000, 0.333, 0.000, 0.000, 0.500, 0.000, 0.000, 0.667, 0.000,
+ 0.000, 0.833, 0.000, 0.000, 1.000, 0.000, 0.000, 0.000, 0.167, 0.000,
+ 0.000, 0.333, 0.000, 0.000, 0.500, 0.000, 0.000, 0.667, 0.000, 0.000,
+ 0.833, 0.000, 0.000, 1.000, 0.000, 0.000, 0.000, 0.167, 0.000, 0.000,
+ 0.333, 0.000, 0.000, 0.500, 0.000, 0.000, 0.667, 0.000, 0.000, 0.833,
+ 0.000, 0.000, 1.000, 0.000, 0.000, 0.000, 0.143, 0.143, 0.143, 0.286,
+ 0.286, 0.286, 0.429, 0.429, 0.429, 0.571, 0.571, 0.571, 0.714, 0.714,
+ 0.714, 0.857, 0.857, 0.857, 1.000, 1.000, 1.000
+ ]).astype(np.float32)
+ color_list = color_list.reshape((-1, 3)) * 255
+ if not rgb:
+ color_list = color_list[:, ::-1]
+ return color_list
diff --git a/ppdet/utils/dist_utils.py b/ppdet/utils/dist_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..32eead4a797ba70cb6980e0368ff9873102680c2
--- /dev/null
+++ b/ppdet/utils/dist_utils.py
@@ -0,0 +1,41 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+
+import os
+
+import paddle.fluid as fluid
+
+
+def nccl2_prepare(trainer_id, startup_prog, main_prog):
+ config = fluid.DistributeTranspilerConfig()
+ config.mode = "nccl2"
+ t = fluid.DistributeTranspiler(config=config)
+ t.transpile(
+ trainer_id,
+ trainers=os.environ.get('PADDLE_TRAINER_ENDPOINTS'),
+ current_endpoint=os.environ.get('PADDLE_CURRENT_ENDPOINT'),
+ startup_program=startup_prog,
+ program=main_prog)
+
+
+def prepare_for_multi_process(exe, build_strategy, startup_prog, main_prog):
+ trainer_id = int(os.environ.get('PADDLE_TRAINER_ID', 0))
+ num_trainers = int(os.environ.get('PADDLE_TRAINERS_NUM', 1))
+ if num_trainers < 2:
+ return
+ build_strategy.num_trainers = num_trainers
+ build_strategy.trainer_id = trainer_id
+ nccl2_prepare(trainer_id, startup_prog, main_prog)
diff --git a/ppdet/utils/download.py b/ppdet/utils/download.py
new file mode 100644
index 0000000000000000000000000000000000000000..6de9138ec40e1ef29a473ef8354f778ec9260ef5
--- /dev/null
+++ b/ppdet/utils/download.py
@@ -0,0 +1,357 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import os.path as osp
+import shutil
+import requests
+import tqdm
+import hashlib
+import tarfile
+import zipfile
+
+from .voc_utils import create_list
+
+import logging
+logger = logging.getLogger(__name__)
+
+__all__ = ['get_weights_path', 'get_dataset_path']
+
+WEIGHTS_HOME = osp.expanduser("~/.cache/paddle/weights")
+DATASET_HOME = osp.expanduser("~/.cache/paddle/dataset")
+
+# dict of {dataset_name: (download_info, sub_dirs)}
+# download info: (url, md5sum)
+DATASETS = {
+ 'coco': ([
+ (
+ 'http://images.cocodataset.org/zips/train2017.zip',
+ 'cced6f7f71b7629ddf16f17bbcfab6b2', ),
+ (
+ 'http://images.cocodataset.org/zips/val2017.zip',
+ '442b8da7639aecaf257c1dceb8ba8c80', ),
+ (
+ 'http://images.cocodataset.org/annotations/annotations_trainval2017.zip',
+ 'f4bbac642086de4f52a3fdda2de5fa2c', ),
+ ], ["annotations", "train2017", "val2017"]),
+ 'voc': ([
+ (
+ 'http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar',
+ '6cd6e144f989b92b3379bac3b3de84fd', ),
+ (
+ 'http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtrainval_06-Nov-2007.tar',
+ 'c52e279531787c972589f7e41ab4ae64', ),
+ (
+ 'http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtest_06-Nov-2007.tar',
+ 'b6e924de25625d8de591ea690078ad9f', ),
+ ], ["VOCdevkit/VOC2012", "VOCdevkit/VOC2007"]),
+ 'wider_face': ([
+ (
+ 'https://dataset.bj.bcebos.com/wider_face/WIDER_train.zip',
+ '3fedf70df600953d25982bcd13d91ba2', ),
+ (
+ 'https://dataset.bj.bcebos.com/wider_face/WIDER_val.zip',
+ 'dfa7d7e790efa35df3788964cf0bbaea', ),
+ (
+ 'https://dataset.bj.bcebos.com/wider_face/wider_face_split.zip',
+ 'a4a898d6193db4b9ef3260a68bad0dc7', ),
+ ], ["WIDER_train", "WIDER_val", "wider_face_split"]),
+ 'fruit': ([
+ (
+ 'https://dataset.bj.bcebos.com/PaddleDetection_demo/fruit-detection.tar',
+ '374554a7633b1b68d6a5fbb7c061b8ba', ),
+ ], ["fruit-detection"]),
+}
+
+DOWNLOAD_RETRY_LIMIT = 3
+
+
+def get_weights_path(url):
+ """Get weights path from WEIGHT_HOME, if not exists,
+ download it from url.
+ """
+ path, _ = get_path(url, WEIGHTS_HOME)
+ return path
+
+
+def get_dataset_path(path, annotation, image_dir):
+ """
+ If path exists, return path.
+ Otherwise, get dataset path from DATASET_HOME, if not exists,
+ download it.
+ """
+ if _dataset_exists(path, annotation, image_dir):
+ return path
+
+ logger.info("Dataset {} is not valid for reason above, try searching {} or "
+ "downloading dataset...".format(
+ osp.realpath(path), DATASET_HOME))
+
+ for name, dataset in DATASETS.items():
+ if os.path.split(path.strip().lower())[-1] == name:
+ logger.info("Parse dataset_dir {} as dataset "
+ "{}".format(path, name))
+ data_dir = osp.join(DATASET_HOME, name)
+
+ # For voc, only check dir VOCdevkit/VOC2012, VOCdevkit/VOC2007
+ if name == 'voc':
+ exists = True
+ for sub_dir in dataset[1]:
+ check_dir = osp.join(data_dir, sub_dir)
+ if osp.exists(check_dir):
+ logger.info("Found {}".format(check_dir))
+ else:
+ exists = False
+ if exists:
+ return data_dir
+
+ # voc exist is checked above, voc is not exist here
+ check_exist = name != 'voc'
+ for url, md5sum in dataset[0]:
+ get_path(url, data_dir, md5sum, check_exist)
+
+ # voc should create list after download
+ if name == 'voc':
+ create_voc_list(data_dir)
+ return data_dir
+
+ # not match any dataset in DATASETS
+ raise ValueError("Dataset {} is not valid and cannot parse dataset type "
+ "'{}' for automaticly downloading, which only supports "
+ "'voc' and 'coco' currently".format(path,
+ osp.split(path)[-1]))
+
+
+def create_voc_list(data_dir, devkit_subdir='VOCdevkit'):
+ logger.info("Create voc file list...")
+ devkit_dir = osp.join(data_dir, devkit_subdir)
+ years = ['2007', '2012']
+
+ # NOTE: since using auto download VOC
+ # dataset, VOC default label list should be used,
+ # do not generate label_list.txt here. For default
+ # label, see ../data/source/voc_loader.py
+ create_list(devkit_dir, years, data_dir)
+ logger.info("Create voc file list finished")
+
+
+def map_path(url, root_dir):
+ # parse path after download to decompress under root_dir
+ fname = url.split('/')[-1]
+ zip_formats = ['.zip', '.tar', '.gz']
+ fpath = fname
+ for zip_format in zip_formats:
+ fpath = fpath.replace(zip_format, '')
+ return osp.join(root_dir, fpath)
+
+
+def get_path(url, root_dir, md5sum=None, check_exist=True):
+ """ Download from given url to root_dir.
+ if file or directory specified by url is exists under
+ root_dir, return the path directly, otherwise download
+ from url and decompress it, return the path.
+
+ url (str): download url
+ root_dir (str): root dir for downloading, it should be
+ WEIGHTS_HOME or DATASET_HOME
+ md5sum (str): md5 sum of download package
+ """
+ # parse path after download to decompress under root_dir
+ fullpath = map_path(url, root_dir)
+
+ # For same zip file, decompressed directory name different
+ # from zip file name, rename by following map
+ decompress_name_map = {
+ "VOCtrainval_11-May-2012": "VOCdevkit/VOC2012",
+ "VOCtrainval_06-Nov-2007": "VOCdevkit/VOC2007",
+ "VOCtest_06-Nov-2007": "VOCdevkit/VOC2007",
+ "annotations_trainval": "annotations"
+ }
+ for k, v in decompress_name_map.items():
+ if fullpath.find(k) >= 0:
+ fullpath = '/'.join(fullpath.split('/')[:-1] + [v])
+
+ exist_flag = False
+ if osp.exists(fullpath) and check_exist:
+ exist_flag = True
+ logger.info("Found {}".format(fullpath))
+ else:
+ exist_flag = False
+ fullname = _download(url, root_dir, md5sum)
+ _decompress(fullname)
+
+ return fullpath, exist_flag
+
+
+def download_dataset(path, dataset=None):
+ if dataset not in DATASETS.keys():
+ logger.error("Unknown dataset {}, it should be "
+ "{}".format(dataset, DATASETS.keys()))
+ return
+ dataset_info = DATASETS[dataset][0]
+ for info in dataset_info:
+ get_path(info[0], path, info[1], False)
+ logger.info("Download dataset {} finished.".format(dataset))
+
+
+def _dataset_exists(path, annotation, image_dir):
+ """
+ Check if user define dataset exists
+ """
+ if not osp.exists(path):
+ logger.info("Config dataset_dir {} is not exits, "
+ "dataset config is not valid".format(path))
+ return False
+
+ if annotation:
+ annotation_path = osp.join(path, annotation)
+ if not osp.isfile(annotation_path):
+ logger.info("Config annotation {} is not a "
+ "file, dataset config is not "
+ "valid".format(annotation_path))
+ return False
+ if image_dir:
+ image_path = osp.join(path, image_dir)
+ if not osp.isdir(image_path):
+ logger.info("Config image_dir {} is not a "
+ "directory, dataset config is not "
+ "valid".format(image_path))
+ return False
+ return True
+
+
+def _download(url, path, md5sum=None):
+ """
+ Download from url, save to path.
+
+ url (str): download url
+ path (str): download to given path
+ """
+ if not osp.exists(path):
+ os.makedirs(path)
+
+ fname = url.split('/')[-1]
+ fullname = osp.join(path, fname)
+ retry_cnt = 0
+
+ while not (osp.exists(fullname) and _md5check(fullname, md5sum)):
+ if retry_cnt < DOWNLOAD_RETRY_LIMIT:
+ retry_cnt += 1
+ else:
+ raise RuntimeError("Download from {} failed. "
+ "Retry limit reached".format(url))
+
+ logger.info("Downloading {} from {}".format(fname, url))
+
+ req = requests.get(url, stream=True)
+ if req.status_code != 200:
+ raise RuntimeError("Downloading from {} failed with code "
+ "{}!".format(url, req.status_code))
+
+ # For protecting download interupted, download to
+ # tmp_fullname firstly, move tmp_fullname to fullname
+ # after download finished
+ tmp_fullname = fullname + "_tmp"
+ total_size = req.headers.get('content-length')
+ with open(tmp_fullname, 'wb') as f:
+ if total_size:
+ for chunk in tqdm.tqdm(
+ req.iter_content(chunk_size=1024),
+ total=(int(total_size) + 1023) // 1024,
+ unit='KB'):
+ f.write(chunk)
+ else:
+ for chunk in req.iter_content(chunk_size=1024):
+ if chunk:
+ f.write(chunk)
+ shutil.move(tmp_fullname, fullname)
+
+ return fullname
+
+
+def _md5check(fullname, md5sum=None):
+ if md5sum is None:
+ return True
+
+ logger.info("File {} md5 checking...".format(fullname))
+ md5 = hashlib.md5()
+ with open(fullname, 'rb') as f:
+ for chunk in iter(lambda: f.read(4096), b""):
+ md5.update(chunk)
+ calc_md5sum = md5.hexdigest()
+
+ if calc_md5sum != md5sum:
+ logger.info("File {} md5 check failed, {}(calc) != "
+ "{}(base)".format(fullname, calc_md5sum, md5sum))
+ return False
+ return True
+
+
+def _decompress(fname):
+ """
+ Decompress for zip and tar file
+ """
+ logger.info("Decompressing {}...".format(fname))
+
+ # For protecting decompressing interupted,
+ # decompress to fpath_tmp directory firstly, if decompress
+ # successed, move decompress files to fpath and delete
+ # fpath_tmp and remove download compress file.
+ fpath = '/'.join(fname.split('/')[:-1])
+ fpath_tmp = osp.join(fpath, 'tmp')
+ if osp.isdir(fpath_tmp):
+ shutil.rmtree(fpath_tmp)
+ os.makedirs(fpath_tmp)
+
+ if fname.find('tar') >= 0:
+ with tarfile.open(fname) as tf:
+ tf.extractall(path=fpath_tmp)
+ elif fname.find('zip') >= 0:
+ with zipfile.ZipFile(fname) as zf:
+ zf.extractall(path=fpath_tmp)
+ else:
+ raise TypeError("Unsupport compress file type {}".format(fname))
+
+ for f in os.listdir(fpath_tmp):
+ src_dir = osp.join(fpath_tmp, f)
+ dst_dir = osp.join(fpath, f)
+ _move_and_merge_tree(src_dir, dst_dir)
+
+ shutil.rmtree(fpath_tmp)
+ os.remove(fname)
+
+
+def _move_and_merge_tree(src, dst):
+ """
+ Move src directory to dst, if dst is already exists,
+ merge src to dst
+ """
+ if not osp.exists(dst):
+ shutil.move(src, dst)
+ else:
+ for fp in os.listdir(src):
+ src_fp = osp.join(src, fp)
+ dst_fp = osp.join(dst, fp)
+ if osp.isdir(src_fp):
+ if osp.isdir(dst_fp):
+ _move_and_merge_tree(src_fp, dst_fp)
+ else:
+ shutil.move(src_fp, dst_fp)
+ elif osp.isfile(src_fp) and \
+ not osp.isfile(dst_fp):
+ shutil.move(src_fp, dst_fp)
diff --git a/ppdet/utils/eval_utils.py b/ppdet/utils/eval_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..dbded30197b46e12282d50991406a6585c0cb572
--- /dev/null
+++ b/ppdet/utils/eval_utils.py
@@ -0,0 +1,247 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import logging
+import numpy as np
+import os
+import time
+
+import paddle.fluid as fluid
+
+from ppdet.utils.voc_eval import bbox_eval as voc_bbox_eval
+from ppdet.utils.post_process import mstest_box_post_process, mstest_mask_post_process, box_flip
+
+__all__ = ['parse_fetches', 'eval_run', 'eval_results', 'json_eval_results']
+
+logger = logging.getLogger(__name__)
+
+
+def parse_fetches(fetches, prog=None, extra_keys=None):
+ """
+ Parse fetch variable infos from model fetches,
+ values for fetch_list and keys for stat
+ """
+ keys, values = [], []
+ cls = []
+ for k, v in fetches.items():
+ if hasattr(v, 'name'):
+ keys.append(k)
+ v.persistable = True
+ values.append(v.name)
+ else:
+ cls.append(v)
+
+ if prog is not None and extra_keys is not None:
+ for k in extra_keys:
+ try:
+ v = fluid.framework._get_var(k, prog)
+ keys.append(k)
+ values.append(v.name)
+ except Exception:
+ pass
+
+ return keys, values, cls
+
+
+def length2lod(length_lod):
+ offset_lod = [0]
+ for i in length_lod:
+ offset_lod.append(offset_lod[-1] + i)
+ return [offset_lod]
+
+
+def get_sub_feed(input, place):
+ new_dict = {}
+ res_feed = {}
+ key_name = ['bbox', 'im_info', 'im_id', 'im_shape', 'bbox_flip']
+ for k in key_name:
+ if k in input.keys():
+ new_dict[k] = input[k]
+ for k in input.keys():
+ if 'image' in k:
+ new_dict[k] = input[k]
+ for k, v in new_dict.items():
+ data_t = fluid.LoDTensor()
+ data_t.set(v[0], place)
+ if 'bbox' in k:
+ lod = length2lod(v[1][0])
+ data_t.set_lod(lod)
+ res_feed[k] = data_t
+ return res_feed
+
+
+def clean_res(result, keep_name_list):
+ clean_result = {}
+ for k in result.keys():
+ if k in keep_name_list:
+ clean_result[k] = result[k]
+ result.clear()
+ return clean_result
+
+
+def eval_run(exe,
+ compile_program,
+ pyreader,
+ keys,
+ values,
+ cls,
+ cfg=None,
+ sub_prog=None,
+ sub_keys=None,
+ sub_values=None):
+ """
+ Run evaluation program, return program outputs.
+ """
+ iter_id = 0
+ results = []
+ if len(cls) != 0:
+ values = []
+ for i in range(len(cls)):
+ _, accum_map = cls[i].get_map_var()
+ cls[i].reset(exe)
+ values.append(accum_map)
+
+ images_num = 0
+ start_time = time.time()
+ has_bbox = 'bbox' in keys
+
+ try:
+ pyreader.start()
+ while True:
+ outs = exe.run(compile_program,
+ fetch_list=values,
+ return_numpy=False)
+ res = {
+ k: (np.array(v), v.recursive_sequence_lengths())
+ for k, v in zip(keys, outs)
+ }
+ multi_scale_test = getattr(cfg, 'MultiScaleTEST', None)
+ mask_multi_scale_test = multi_scale_test and 'Mask' in cfg.architecture
+
+ if multi_scale_test:
+ post_res = mstest_box_post_process(res, cfg)
+ res.update(post_res)
+ if mask_multi_scale_test:
+ place = fluid.CUDAPlace(0) if cfg.use_gpu else fluid.CPUPlace()
+ sub_feed = get_sub_feed(res, place)
+ sub_prog_outs = exe.run(sub_prog,
+ feed=sub_feed,
+ fetch_list=sub_values,
+ return_numpy=False)
+ sub_prog_res = {
+ k: (np.array(v), v.recursive_sequence_lengths())
+ for k, v in zip(sub_keys, sub_prog_outs)
+ }
+ post_res = mstest_mask_post_process(sub_prog_res, cfg)
+ res.update(post_res)
+ if multi_scale_test:
+ res = clean_res(
+ res, ['im_info', 'bbox', 'im_id', 'im_shape', 'mask'])
+ results.append(res)
+ if iter_id % 100 == 0:
+ logger.info('Test iter {}'.format(iter_id))
+ iter_id += 1
+ images_num += len(res['bbox'][1][0]) if has_bbox else 1
+ except (StopIteration, fluid.core.EOFException):
+ pyreader.reset()
+ logger.info('Test finish iter {}'.format(iter_id))
+
+ end_time = time.time()
+ fps = images_num / (end_time - start_time)
+ if has_bbox:
+ logger.info('Total number of images: {}, inference time: {} fps.'.
+ format(images_num, fps))
+ else:
+ logger.info('Total iteration: {}, inference time: {} batch/s.'.format(
+ images_num, fps))
+
+ return results
+
+
+def eval_results(results,
+ feed,
+ metric,
+ num_classes,
+ resolution=None,
+ is_bbox_normalized=False,
+ output_directory=None,
+ map_type='11point'):
+ """Evaluation for evaluation program results"""
+ box_ap_stats = []
+ if metric == 'COCO':
+ from ppdet.utils.coco_eval import proposal_eval, bbox_eval, mask_eval
+ anno_file = getattr(feed.dataset, 'annotation', None)
+ with_background = getattr(feed, 'with_background', True)
+ if 'proposal' in results[0]:
+ output = 'proposal.json'
+ if output_directory:
+ output = os.path.join(output_directory, 'proposal.json')
+ proposal_eval(results, anno_file, output)
+ if 'bbox' in results[0]:
+ output = 'bbox.json'
+ if output_directory:
+ output = os.path.join(output_directory, 'bbox.json')
+
+ box_ap_stats = bbox_eval(
+ results,
+ anno_file,
+ output,
+ with_background,
+ is_bbox_normalized=is_bbox_normalized)
+
+ if 'mask' in results[0]:
+ output = 'mask.json'
+ if output_directory:
+ output = os.path.join(output_directory, 'mask.json')
+ mask_eval(results, anno_file, output, resolution)
+ else:
+ if 'accum_map' in results[-1]:
+ res = np.mean(results[-1]['accum_map'][0])
+ logger.info('mAP: {:.2f}'.format(res * 100.))
+ box_ap_stats.append(res * 100.)
+ elif 'bbox' in results[0]:
+ box_ap = voc_bbox_eval(
+ results,
+ num_classes,
+ is_bbox_normalized=is_bbox_normalized,
+ map_type=map_type)
+ box_ap_stats.append(box_ap)
+ return box_ap_stats
+
+
+def json_eval_results(feed, metric, json_directory=None):
+ """
+ cocoapi eval with already exists proposal.json, bbox.json or mask.json
+ """
+ assert metric == 'COCO'
+ from ppdet.utils.coco_eval import cocoapi_eval
+ anno_file = getattr(feed.dataset, 'annotation', None)
+ json_file_list = ['proposal.json', 'bbox.json', 'mask.json']
+ if json_directory:
+ assert os.path.exists(
+ json_directory), "The json directory:{} does not exist".format(
+ json_directory)
+ for k, v in enumerate(json_file_list):
+ json_file_list[k] = os.path.join(str(json_directory), v)
+
+ coco_eval_style = ['proposal', 'bbox', 'segm']
+ for i, v_json in enumerate(json_file_list):
+ if os.path.exists(v_json):
+ cocoapi_eval(v_json, coco_eval_style[i], anno_file=anno_file)
+ else:
+ logger.info("{} not exists!".format(v_json))
diff --git a/ppdet/utils/map_utils.py b/ppdet/utils/map_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe0530596bb54920a81235ee6716e2d43918899a
--- /dev/null
+++ b/ppdet/utils/map_utils.py
@@ -0,0 +1,214 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import sys
+import numpy as np
+import logging
+logger = logging.getLogger(__name__)
+
+__all__ = ['bbox_area', 'jaccard_overlap', 'DetectionMAP']
+
+
+def bbox_area(bbox, is_bbox_normalized):
+ """
+ Calculate area of a bounding box
+ """
+ norm = 1. - float(is_bbox_normalized)
+ width = bbox[2] - bbox[0] + norm
+ height = bbox[3] - bbox[1] + norm
+ return width * height
+
+
+def jaccard_overlap(pred, gt, is_bbox_normalized=False):
+ """
+ Calculate jaccard overlap ratio between two bounding box
+ """
+ if pred[0] >= gt[2] or pred[2] <= gt[0] or \
+ pred[1] >= gt[3] or pred[3] <= gt[1]:
+ return 0.
+ inter_xmin = max(pred[0], gt[0])
+ inter_ymin = max(pred[1], gt[1])
+ inter_xmax = min(pred[2], gt[2])
+ inter_ymax = min(pred[3], gt[3])
+ inter_size = bbox_area([inter_xmin, inter_ymin, inter_xmax, inter_ymax],
+ is_bbox_normalized)
+ pred_size = bbox_area(pred, is_bbox_normalized)
+ gt_size = bbox_area(gt, is_bbox_normalized)
+ overlap = float(inter_size) / (pred_size + gt_size - inter_size)
+ return overlap
+
+
+class DetectionMAP(object):
+ """
+ Calculate detection mean average precision.
+ Currently support two types: 11point and integral
+
+ Args:
+ class_num (int): the class number.
+ overlap_thresh (float): The threshold of overlap
+ ratio between prediction bounding box and
+ ground truth bounding box for deciding
+ true/false positive. Default 0.5.
+ map_type (str): calculation method of mean average
+ precision, currently support '11point' and
+ 'integral'. Default '11point'.
+ is_bbox_normalized (bool): whther bounding boxes
+ is normalized to range[0, 1]. Default False.
+ evaluate_difficult (bool): whether to evaluate
+ difficult bounding boxes. Default False.
+ """
+
+ def __init__(self,
+ class_num,
+ overlap_thresh=0.5,
+ map_type='11point',
+ is_bbox_normalized=False,
+ evaluate_difficult=False):
+ self.class_num = class_num
+ self.overlap_thresh = overlap_thresh
+ assert map_type in ['11point', 'integral'], \
+ "map_type currently only support '11point' "\
+ "and 'integral'"
+ self.map_type = map_type
+ self.is_bbox_normalized = is_bbox_normalized
+ self.evaluate_difficult = evaluate_difficult
+ self.reset()
+
+ def update(self, bbox, gt_box, gt_label, difficult=None):
+ """
+ Update metric statics from given prediction and ground
+ truth infomations.
+ """
+ if difficult is None:
+ difficult = np.zeros_like(gt_label)
+
+ # record class gt count
+ for gtl, diff in zip(gt_label, difficult):
+ if self.evaluate_difficult or int(diff) == 0:
+ self.class_gt_counts[int(np.array(gtl))] += 1
+
+ # record class score positive
+ visited = [False] * len(gt_label)
+ for b in bbox:
+ label, score, xmin, ymin, xmax, ymax = b.tolist()
+ pred = [xmin, ymin, xmax, ymax]
+ max_idx = -1
+ max_overlap = -1.0
+ for i, gl in enumerate(gt_label):
+ if int(gl) == int(label):
+ overlap = jaccard_overlap(pred, gt_box[i],
+ self.is_bbox_normalized)
+ if overlap > max_overlap:
+ max_overlap = overlap
+ max_idx = i
+
+ if max_overlap > self.overlap_thresh:
+ if self.evaluate_difficult or \
+ int(np.array(difficult[max_idx])) == 0:
+ if not visited[max_idx]:
+ self.class_score_poss[int(label)].append([score, 1.0])
+ visited[max_idx] = True
+ else:
+ self.class_score_poss[int(label)].append([score, 0.0])
+ else:
+ self.class_score_poss[int(label)].append([score, 0.0])
+
+ def reset(self):
+ """
+ Reset metric statics
+ """
+ self.class_score_poss = [[] for _ in range(self.class_num)]
+ self.class_gt_counts = [0] * self.class_num
+ self.mAP = None
+
+ def accumulate(self):
+ """
+ Accumulate metric results and calculate mAP
+ """
+ mAP = 0.
+ valid_cnt = 0
+ for score_pos, count in zip(self.class_score_poss,
+ self.class_gt_counts):
+ if count == 0 or len(score_pos) == 0:
+ continue
+
+ accum_tp_list, accum_fp_list = \
+ self._get_tp_fp_accum(score_pos)
+ precision = []
+ recall = []
+ for ac_tp, ac_fp in zip(accum_tp_list, accum_fp_list):
+ precision.append(float(ac_tp) / (ac_tp + ac_fp))
+ recall.append(float(ac_tp) / count)
+
+ if self.map_type == '11point':
+ max_precisions = [0.] * 11
+ start_idx = len(precision) - 1
+ for j in range(10, -1, -1):
+ for i in range(start_idx, -1, -1):
+ if recall[i] < float(j) / 10.:
+ start_idx = i
+ if j > 0:
+ max_precisions[j - 1] = max_precisions[j]
+ break
+ else:
+ if max_precisions[j] < precision[i]:
+ max_precisions[j] = precision[i]
+ mAP += sum(max_precisions) / 11.
+ valid_cnt += 1
+ elif self.map_type == 'integral':
+ import math
+ ap = 0.
+ prev_recall = 0.
+ for i in range(len(precision)):
+ recall_gap = math.fabs(recall[i] - prev_recall)
+ if recall_gap > 1e-6:
+ ap += precision[i] * recall_gap
+ prev_recall = recall[i]
+ mAP += ap
+ valid_cnt += 1
+ else:
+ logger.error("Unspported mAP type {}".format(self.map_type))
+ sys.exit(1)
+
+ self.mAP = mAP / float(valid_cnt) if valid_cnt > 0 else mAP
+
+ def get_map(self):
+ """
+ Get mAP result
+ """
+ if self.mAP is None:
+ logger.error("mAP is not calculated.")
+ return self.mAP
+
+ def _get_tp_fp_accum(self, score_pos_list):
+ """
+ Calculate accumulating true/false positive results from
+ [score, pos] records
+ """
+ sorted_list = sorted(score_pos_list, key=lambda s: s[0], reverse=True)
+ accum_tp = 0
+ accum_fp = 0
+ accum_tp_list = []
+ accum_fp_list = []
+ for (score, pos) in sorted_list:
+ accum_tp += int(pos)
+ accum_tp_list.append(accum_tp)
+ accum_fp += 1 - int(pos)
+ accum_fp_list.append(accum_fp)
+ return accum_tp_list, accum_fp_list
diff --git a/ppdet/utils/post_process.py b/ppdet/utils/post_process.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc80bc186626c4e983328ffd53f53d217230a244
--- /dev/null
+++ b/ppdet/utils/post_process.py
@@ -0,0 +1,212 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import logging
+import numpy as np
+
+import paddle.fluid as fluid
+
+__all__ = ['nms']
+
+logger = logging.getLogger(__name__)
+
+
+def box_flip(boxes, im_shape):
+ im_width = im_shape[0][1]
+ flipped_boxes = boxes.copy()
+
+ flipped_boxes[:, 0::4] = im_width - boxes[:, 2::4] - 1
+ flipped_boxes[:, 2::4] = im_width - boxes[:, 0::4] - 1
+ return flipped_boxes
+
+
+def nms(dets, thresh):
+ """Apply classic DPM-style greedy NMS."""
+ if dets.shape[0] == 0:
+ return []
+ scores = dets[:, 0]
+ x1 = dets[:, 1]
+ y1 = dets[:, 2]
+ x2 = dets[:, 3]
+ y2 = dets[:, 4]
+
+ areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+ order = scores.argsort()[::-1]
+
+ ndets = dets.shape[0]
+ suppressed = np.zeros((ndets), dtype=np.int)
+
+ # nominal indices
+ # _i, _j
+ # sorted indices
+ # i, j
+ # temp variables for box i's (the box currently under consideration)
+ # ix1, iy1, ix2, iy2, iarea
+
+ # variables for computing overlap with box j (lower scoring box)
+ # xx1, yy1, xx2, yy2
+ # w, h
+ # inter, ovr
+
+ for _i in range(ndets):
+ i = order[_i]
+ if suppressed[i] == 1:
+ continue
+ ix1 = x1[i]
+ iy1 = y1[i]
+ ix2 = x2[i]
+ iy2 = y2[i]
+ iarea = areas[i]
+ for _j in range(_i + 1, ndets):
+ j = order[_j]
+ if suppressed[j] == 1:
+ continue
+ xx1 = max(ix1, x1[j])
+ yy1 = max(iy1, y1[j])
+ xx2 = min(ix2, x2[j])
+ yy2 = min(iy2, y2[j])
+ w = max(0.0, xx2 - xx1 + 1)
+ h = max(0.0, yy2 - yy1 + 1)
+ inter = w * h
+ ovr = inter / (iarea + areas[j] - inter)
+ if ovr >= thresh:
+ suppressed[j] = 1
+
+ return np.where(suppressed == 0)[0]
+
+
+def bbox_area(box):
+ w = box[2] - box[0] + 1
+ h = box[3] - box[1] + 1
+ return w * h
+
+
+def bbox_overlaps(x, y):
+ N = x.shape[0]
+ K = y.shape[0]
+ overlaps = np.zeros((N, K), dtype=np.float32)
+ for k in range(K):
+ y_area = bbox_area(y[k])
+ for n in range(N):
+ iw = min(x[n, 2], y[k, 2]) - max(x[n, 0], y[k, 0]) + 1
+ if iw > 0:
+ ih = min(x[n, 3], y[k, 3]) - max(x[n, 1], y[k, 1]) + 1
+ if ih > 0:
+ x_area = bbox_area(x[n])
+ ua = x_area + y_area - iw * ih
+ overlaps[n, k] = iw * ih / ua
+ return overlaps
+
+
+def box_voting(nms_dets, dets, vote_thresh):
+ top_dets = nms_dets.copy()
+ top_boxes = nms_dets[:, 1:]
+ all_boxes = dets[:, 1:]
+ all_scores = dets[:, 0]
+ top_to_all_overlaps = bbox_overlaps(top_boxes, all_boxes)
+ for k in range(nms_dets.shape[0]):
+ inds_to_vote = np.where(top_to_all_overlaps[k] >= vote_thresh)[0]
+ boxes_to_vote = all_boxes[inds_to_vote, :]
+ ws = all_scores[inds_to_vote]
+ top_dets[k, 1:] = np.average(boxes_to_vote, axis=0, weights=ws)
+
+ return top_dets
+
+
+def get_nms_result(boxes, scores, cfg):
+ cls_boxes = [[] for _ in range(cfg.num_classes)]
+ for j in range(1, cfg.num_classes):
+ inds = np.where(scores[:, j] > cfg.MultiScaleTEST['score_thresh'])[0]
+ scores_j = scores[inds, j]
+ boxes_j = boxes[inds, j * 4:(j + 1) * 4]
+ dets_j = np.hstack((scores_j[:, np.newaxis], boxes_j)).astype(
+ np.float32, copy=False)
+ keep = nms(dets_j, cfg.MultiScaleTEST['nms_thresh'])
+ nms_dets = dets_j[keep, :]
+ if cfg.MultiScaleTEST['enable_voting']:
+ nms_dets = box_voting(nms_dets, dets_j,
+ cfg.MultiScaleTEST['vote_thresh'])
+ #add labels
+ label = np.array([j for _ in range(len(keep))])
+ nms_dets = np.hstack((label[:, np.newaxis], nms_dets)).astype(
+ np.float32, copy=False)
+ cls_boxes[j] = nms_dets
+ # Limit to max_per_image detections **over all classes**
+ image_scores = np.hstack(
+ [cls_boxes[j][:, 1] for j in range(1, cfg.num_classes)])
+ if len(image_scores) > cfg.MultiScaleTEST['detections_per_im']:
+ image_thresh = np.sort(image_scores)[-cfg.MultiScaleTEST[
+ 'detections_per_im']]
+ for j in range(1, cfg.num_classes):
+ keep = np.where(cls_boxes[j][:, 1] >= image_thresh)[0]
+ cls_boxes[j] = cls_boxes[j][keep, :]
+
+ im_results = np.vstack([cls_boxes[j] for j in range(1, cfg.num_classes)])
+ return im_results
+
+
+def mstest_box_post_process(result, cfg):
+ """
+ Multi-scale Test
+ Only available for batch_size=1 now.
+ """
+ post_bbox = {}
+ use_flip = False
+ ms_boxes = []
+ ms_scores = []
+ im_shape = result['im_shape'][0]
+ for k in result.keys():
+ if 'bbox' in k:
+ boxes = result[k][0]
+ boxes = np.reshape(boxes, (-1, 4 * cfg.num_classes))
+ scores = result['score' + k[4:]][0]
+ if 'flip' in k:
+ boxes = box_flip(boxes, im_shape)
+ use_flip = True
+ ms_boxes.append(boxes)
+ ms_scores.append(scores)
+
+ ms_boxes = np.concatenate(ms_boxes)
+ ms_scores = np.concatenate(ms_scores)
+ bbox_pred = get_nms_result(ms_boxes, ms_scores, cfg)
+ post_bbox.update({'bbox': (bbox_pred, [[len(bbox_pred)]])})
+ if use_flip:
+ bbox = bbox_pred[:, 2:]
+ bbox_flip = np.append(
+ bbox_pred[:, :2], box_flip(bbox, im_shape), axis=1)
+ post_bbox.update({'bbox_flip': (bbox_flip, [[len(bbox_flip)]])})
+ return post_bbox
+
+
+def mstest_mask_post_process(result, cfg):
+ mask_list = []
+ im_shape = result['im_shape'][0]
+ M = cfg.FPNRoIAlign['mask_resolution']
+ for k in result.keys():
+ if 'mask' in k:
+ masks = result[k][0]
+ if len(masks.shape) != 4:
+ masks = np.zeros((0, M, M))
+ mask_list.append(masks)
+ continue
+ if 'flip' in k:
+ masks = masks[:, :, :, ::-1]
+ mask_list.append(masks)
+
+ mask_pred = np.mean(mask_list, axis=0)
+ return {'mask': (mask_pred, [[len(mask_pred)]])}
diff --git a/ppdet/utils/stats.py b/ppdet/utils/stats.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d7e36babf8d53170162cfd5581f591e376ec8cd
--- /dev/null
+++ b/ppdet/utils/stats.py
@@ -0,0 +1,65 @@
+# Copyright (c) 2019 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 collections
+import numpy as np
+import datetime
+
+__all__ = ['TrainingStats', 'Time']
+
+
+class SmoothedValue(object):
+ """Track a series of values and provide access to smoothed values over a
+ window or the global series average.
+ """
+
+ def __init__(self, window_size):
+ self.deque = collections.deque(maxlen=window_size)
+
+ def add_value(self, value):
+ self.deque.append(value)
+
+ def get_median_value(self):
+ return np.median(self.deque)
+
+
+def Time():
+ return datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')
+
+
+class TrainingStats(object):
+ def __init__(self, window_size, stats_keys):
+ self.smoothed_losses_and_metrics = {
+ key: SmoothedValue(window_size)
+ for key in stats_keys
+ }
+
+ def update(self, stats):
+ for k, v in self.smoothed_losses_and_metrics.items():
+ v.add_value(stats[k])
+
+ def get(self, extras=None):
+ stats = collections.OrderedDict()
+ if extras:
+ for k, v in extras.items():
+ stats[k] = v
+ for k, v in self.smoothed_losses_and_metrics.items():
+ stats[k] = format(v.get_median_value(), '.6f')
+
+ return stats
+
+ def log(self, extras=None):
+ d = self.get(extras)
+ strs = ', '.join(str(dict({x: y})).strip('{}') for x, y in d.items())
+ return strs
diff --git a/ppdet/utils/visualizer.py b/ppdet/utils/visualizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..ff35dc2d577fcaff042583d63c709a498dadb1da
--- /dev/null
+++ b/ppdet/utils/visualizer.py
@@ -0,0 +1,110 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import numpy as np
+import pycocotools.mask as mask_util
+from PIL import Image, ImageDraw
+
+from .colormap import colormap
+
+__all__ = ['visualize_results']
+
+
+def visualize_results(image,
+ im_id,
+ catid2name,
+ threshold=0.5,
+ bbox_results=None,
+ mask_results=None):
+ """
+ Visualize bbox and mask results
+ """
+ if mask_results:
+ image = draw_mask(image, im_id, mask_results, threshold)
+ if bbox_results:
+ image = draw_bbox(image, im_id, catid2name, bbox_results,
+ threshold)
+ return image
+
+
+def draw_mask(image, im_id, segms, threshold, alpha=0.7):
+ """
+ Draw mask on image
+ """
+ mask_color_id = 0
+ w_ratio = .4
+ color_list = colormap(rgb=True)
+ img_array = np.array(image).astype('float32')
+ for dt in np.array(segms):
+ if im_id != dt['image_id']:
+ continue
+ segm, score = dt['segmentation'], dt['score']
+ if score < threshold:
+ continue
+ mask = mask_util.decode(segm) * 255
+ color_mask = color_list[mask_color_id % len(color_list), 0:3]
+ mask_color_id += 1
+ for c in range(3):
+ color_mask[c] = color_mask[c] * (1 - w_ratio) + w_ratio * 255
+ idx = np.nonzero(mask)
+ img_array[idx[0], idx[1], :] *= 1.0 - alpha
+ img_array[idx[0], idx[1], :] += alpha * color_mask
+ return Image.fromarray(img_array.astype('uint8'))
+
+
+def draw_bbox(image, im_id, catid2name, bboxes, threshold):
+ """
+ Draw bbox on image
+ """
+ draw = ImageDraw.Draw(image)
+
+ catid2color = {}
+ color_list = colormap(rgb=True)[:40]
+ for dt in np.array(bboxes):
+ if im_id != dt['image_id']:
+ continue
+ catid, bbox, score = dt['category_id'], dt['bbox'], dt['score']
+ if score < threshold:
+ continue
+
+ xmin, ymin, w, h = bbox
+ xmax = xmin + w
+ ymax = ymin + h
+
+ if catid not in catid2color:
+ idx = np.random.randint(len(color_list))
+ catid2color[catid] = color_list[idx]
+ color = tuple(catid2color[catid])
+
+ # draw bbox
+ draw.line(
+ [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin),
+ (xmin, ymin)],
+ width=2,
+ fill=color)
+
+ # draw label
+ text = "{} {:.2f}".format(catid2name[catid], score)
+ tw, th = draw.textsize(text)
+ draw.rectangle([(xmin + 1, ymin - th),
+ (xmin + tw + 1, ymin)],
+ fill=color)
+ draw.text((xmin + 1, ymin - th), text, fill=(255, 255, 255))
+
+ return image
diff --git a/ppdet/utils/voc_eval.py b/ppdet/utils/voc_eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..67e66e4c683aaf7d5af2fd352817daf1ad3576d4
--- /dev/null
+++ b/ppdet/utils/voc_eval.py
@@ -0,0 +1,186 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import os
+import sys
+import numpy as np
+
+from ..data.source.voc_loader import pascalvoc_label
+from .map_utils import DetectionMAP
+from .coco_eval import bbox2out
+
+import logging
+logger = logging.getLogger(__name__)
+
+__all__ = [
+ 'bbox_eval', 'bbox2out', 'get_category_info'
+]
+
+
+def bbox_eval(results,
+ class_num,
+ overlap_thresh=0.5,
+ map_type='11point',
+ is_bbox_normalized=False,
+ evaluate_difficult=False):
+ """
+ Bounding box evaluation for VOC dataset
+
+ Args:
+ results (list): prediction bounding box results.
+ class_num (int): evaluation class number.
+ overlap_thresh (float): the postive threshold of
+ bbox overlap
+ map_type (string): method for mAP calcualtion,
+ can only be '11point' or 'integral'
+ is_bbox_normalized (bool): whether bbox is normalized
+ to range [0, 1].
+ evaluate_difficult (bool): whether to evaluate
+ difficult gt bbox.
+ """
+ assert 'bbox' in results[0]
+ logger.info("Start evaluate...")
+
+ detection_map = DetectionMAP(class_num=class_num,
+ overlap_thresh=overlap_thresh,
+ map_type=map_type,
+ is_bbox_normalized=is_bbox_normalized,
+ evaluate_difficult=evaluate_difficult)
+
+ for t in results:
+ bboxes = t['bbox'][0]
+ bbox_lengths = t['bbox'][1][0]
+
+ if bboxes.shape == (1, 1) or bboxes is None:
+ continue
+
+ gt_boxes = t['gt_box'][0]
+ gt_labels = t['gt_label'][0]
+ difficults = t['is_difficult'][0] if not evaluate_difficult \
+ else None
+
+ if len(t['gt_box'][1]) == 0:
+ # gt_box, gt_label, difficult read as zero padded Tensor
+ bbox_idx = 0
+ for i in range(len(gt_boxes)):
+ gt_box = gt_boxes[i]
+ gt_label = gt_labels[i]
+ difficult = None if difficults is None \
+ else difficults[i]
+ bbox_num = bbox_lengths[i]
+ bbox = bboxes[bbox_idx: bbox_idx + bbox_num]
+ gt_box, gt_label, difficult = prune_zero_padding(
+ gt_box, gt_label, difficult)
+ detection_map.update(bbox, gt_box, gt_label, difficult)
+ bbox_idx += bbox_num
+ else:
+ # gt_box, gt_label, difficult read as LoDTensor
+ gt_box_lengths = t['gt_box'][1][0]
+ bbox_idx = 0
+ gt_box_idx = 0
+ for i in range(len(bbox_lengths)):
+ bbox_num = bbox_lengths[i]
+ gt_box_num = gt_box_lengths[i]
+ bbox = bboxes[bbox_idx: bbox_idx + bbox_num]
+ gt_box = gt_boxes[gt_box_idx: gt_box_idx + gt_box_num]
+ gt_label = gt_labels[gt_box_idx: gt_box_idx + gt_box_num]
+ difficult = None if difficults is None else \
+ difficults[gt_box_idx: gt_box_idx + gt_box_num]
+ detection_map.update(bbox, gt_box, gt_label, difficult)
+ bbox_idx += bbox_num
+ gt_box_idx += gt_box_num
+
+ logger.info("Accumulating evaluatation results...")
+ detection_map.accumulate()
+ map_stat = 100. * detection_map.get_map()
+ logger.info("mAP({:.2f}, {}) = {:.2f}".format(overlap_thresh,
+ map_type, map_stat))
+ return map_stat
+
+
+def prune_zero_padding(gt_box, gt_label, difficult=None):
+ valid_cnt = 0
+ for i in range(len(gt_box)):
+ if gt_box[i, 0] == 0 and gt_box[i, 1] == 0 and \
+ gt_box[i, 2] == 0 and gt_box[i, 3] == 0:
+ break
+ valid_cnt += 1
+ return (gt_box[:valid_cnt], gt_label[:valid_cnt],
+ difficult[:valid_cnt] if difficult is not None else None)
+
+
+def get_category_info(anno_file=None,
+ with_background=True,
+ use_default_label=False):
+ if use_default_label or anno_file is None \
+ or not os.path.exists(anno_file):
+ logger.info("Not found annotation file {}, load "
+ "voc2012 categories.".format(anno_file))
+ return vocall_category_info(with_background)
+ else:
+ logger.info("Load categories from {}".format(anno_file))
+ return get_category_info_from_anno(anno_file, with_background)
+
+
+def get_category_info_from_anno(anno_file, with_background=True):
+ """
+ Get class id to category id map and category id
+ to category name map from annotation file.
+
+ Args:
+ anno_file (str): annotation file path
+ with_background (bool, default True):
+ whether load background as class 0.
+ """
+ cats = []
+ with open(anno_file) as f:
+ for line in f.readlines():
+ cats.append(line.strip())
+
+ if cats[0] != 'background' and with_background:
+ cats.insert(0, 'background')
+ if cats[0] == 'background' and not with_background:
+ cats = cats[1:]
+
+ clsid2catid = {i: i for i in range(len(cats))}
+ catid2name = {i: name for i, name in enumerate(cats)}
+
+ return clsid2catid, catid2name
+
+
+def vocall_category_info(with_background=True):
+ """
+ Get class id to category id map and category id
+ to category name map of mixup voc dataset
+
+ Args:
+ with_background (bool, default True):
+ whether load background as class 0.
+ """
+ label_map = pascalvoc_label(with_background)
+ label_map = sorted(label_map.items(), key=lambda x: x[1])
+ cats = [l[0] for l in label_map]
+
+ if with_background:
+ cats.insert(0, 'background')
+
+ clsid2catid = {i: i for i in range(len(cats))}
+ catid2name = {i: name for i, name in enumerate(cats)}
+
+ return clsid2catid, catid2name
diff --git a/ppdet/utils/voc_utils.py b/ppdet/utils/voc_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..88252e2351164cf3402e94a2c0e6f49277d7736b
--- /dev/null
+++ b/ppdet/utils/voc_utils.py
@@ -0,0 +1,86 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import os.path as osp
+import re
+import random
+import shutil
+
+__all__ = ['create_list']
+
+
+def create_list(devkit_dir, years, output_dir):
+ """
+ create following list:
+ 1. trainval.txt
+ 2. test.txt
+ """
+ trainval_list = []
+ test_list = []
+ for year in years:
+ trainval, test = _walk_voc_dir(devkit_dir, year, output_dir)
+ trainval_list.extend(trainval)
+ test_list.extend(test)
+
+ random.shuffle(trainval_list)
+ with open(osp.join(output_dir, 'trainval.txt'), 'w') as ftrainval:
+ for item in trainval_list:
+ ftrainval.write(item[0] + ' ' + item[1] + '\n')
+
+ with open(osp.join(output_dir, 'test.txt'), 'w') as fval:
+ ct = 0
+ for item in test_list:
+ ct += 1
+ fval.write(item[0] + ' ' + item[1] + '\n')
+
+
+def _get_voc_dir(devkit_dir, year, type):
+ return osp.join(devkit_dir, 'VOC' + year, type)
+
+
+def _walk_voc_dir(devkit_dir, year, output_dir):
+ filelist_dir = _get_voc_dir(devkit_dir, year, 'ImageSets/Main')
+ annotation_dir = _get_voc_dir(devkit_dir, year, 'Annotations')
+ img_dir = _get_voc_dir(devkit_dir, year, 'JPEGImages')
+ trainval_list = []
+ test_list = []
+ added = set()
+
+ for _, _, files in os.walk(filelist_dir):
+ for fname in files:
+ img_ann_list = []
+ if re.match('[a-z]+_trainval\.txt', fname):
+ img_ann_list = trainval_list
+ elif re.match('[a-z]+_test\.txt', fname):
+ img_ann_list = test_list
+ else:
+ continue
+ fpath = osp.join(filelist_dir, fname)
+ for line in open(fpath):
+ name_prefix = line.strip().split()[0]
+ if name_prefix in added:
+ continue
+ added.add(name_prefix)
+ ann_path = osp.join(osp.relpath(annotation_dir, output_dir),
+ name_prefix + '.xml')
+ img_path = osp.join(osp.relpath(img_dir, output_dir),
+ name_prefix + '.jpg')
+ img_ann_list.append((img_path, ann_path))
+
+ return trainval_list, test_list
diff --git a/ppdet/utils/widerface_eval_utils.py b/ppdet/utils/widerface_eval_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..a19cd08350e7be9b3c7db8aa45e95f86b7088bf5
--- /dev/null
+++ b/ppdet/utils/widerface_eval_utils.py
@@ -0,0 +1,227 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import numpy as np
+
+from ppdet.data.source.widerface_loader import widerface_label
+from ppdet.utils.coco_eval import bbox2out
+
+import logging
+logger = logging.getLogger(__name__)
+
+__all__ = [
+ 'get_shrink', 'bbox_vote', 'save_widerface_bboxes', 'save_fddb_bboxes',
+ 'to_chw_bgr', 'bbox2out', 'get_category_info'
+]
+
+
+def to_chw_bgr(image):
+ """
+ Transpose image from HWC to CHW and from RBG to BGR.
+ Args:
+ image (np.array): an image with HWC and RBG layout.
+ """
+ # HWC to CHW
+ if len(image.shape) == 3:
+ image = np.swapaxes(image, 1, 2)
+ image = np.swapaxes(image, 1, 0)
+ # RBG to BGR
+ image = image[[2, 1, 0], :, :]
+ return image
+
+
+def bbox_vote(det):
+ order = det[:, 4].ravel().argsort()[::-1]
+ det = det[order, :]
+ if det.shape[0] == 0:
+ dets = np.array([[10, 10, 20, 20, 0.002]])
+ det = np.empty(shape=[0, 5])
+ while det.shape[0] > 0:
+ # IOU
+ area = (det[:, 2] - det[:, 0] + 1) * (det[:, 3] - det[:, 1] + 1)
+ xx1 = np.maximum(det[0, 0], det[:, 0])
+ yy1 = np.maximum(det[0, 1], det[:, 1])
+ xx2 = np.minimum(det[0, 2], det[:, 2])
+ yy2 = np.minimum(det[0, 3], det[:, 3])
+ w = np.maximum(0.0, xx2 - xx1 + 1)
+ h = np.maximum(0.0, yy2 - yy1 + 1)
+ inter = w * h
+ o = inter / (area[0] + area[:] - inter)
+
+ # nms
+ merge_index = np.where(o >= 0.3)[0]
+ det_accu = det[merge_index, :]
+ det = np.delete(det, merge_index, 0)
+ if merge_index.shape[0] <= 1:
+ if det.shape[0] == 0:
+ try:
+ dets = np.row_stack((dets, det_accu))
+ except:
+ dets = det_accu
+ continue
+ det_accu[:, 0:4] = det_accu[:, 0:4] * np.tile(det_accu[:, -1:], (1, 4))
+ max_score = np.max(det_accu[:, 4])
+ det_accu_sum = np.zeros((1, 5))
+ det_accu_sum[:, 0:4] = np.sum(det_accu[:, 0:4],
+ axis=0) / np.sum(det_accu[:, -1:])
+ det_accu_sum[:, 4] = max_score
+ try:
+ dets = np.row_stack((dets, det_accu_sum))
+ except:
+ dets = det_accu_sum
+ dets = dets[0:750, :]
+ # Only keep 0.3 or more
+ keep_index = np.where(dets[:, 4] >= 0.01)[0]
+ dets = dets[keep_index, :]
+ return dets
+
+
+def get_shrink(height, width):
+ """
+ Args:
+ height (int): image height.
+ width (int): image width.
+ """
+ # avoid out of memory
+ max_shrink_v1 = (0x7fffffff / 577.0 / (height * width))**0.5
+ max_shrink_v2 = ((678 * 1024 * 2.0 * 2.0) / (height * width))**0.5
+
+ def get_round(x, loc):
+ str_x = str(x)
+ if '.' in str_x:
+ str_before, str_after = str_x.split('.')
+ len_after = len(str_after)
+ if len_after >= 3:
+ str_final = str_before + '.' + str_after[0:loc]
+ return float(str_final)
+ else:
+ return x
+
+ max_shrink = get_round(min(max_shrink_v1, max_shrink_v2), 2) - 0.3
+ if max_shrink >= 1.5 and max_shrink < 2:
+ max_shrink = max_shrink - 0.1
+ elif max_shrink >= 2 and max_shrink < 3:
+ max_shrink = max_shrink - 0.2
+ elif max_shrink >= 3 and max_shrink < 4:
+ max_shrink = max_shrink - 0.3
+ elif max_shrink >= 4 and max_shrink < 5:
+ max_shrink = max_shrink - 0.4
+ elif max_shrink >= 5:
+ max_shrink = max_shrink - 0.5
+
+ shrink = max_shrink if max_shrink < 1 else 1
+ return shrink, max_shrink
+
+
+def save_widerface_bboxes(image_path, bboxes_scores, output_dir):
+ image_name = image_path.split('/')[-1]
+ image_class = image_path.split('/')[-2]
+ odir = os.path.join(output_dir, image_class)
+ if not os.path.exists(odir):
+ os.makedirs(odir)
+
+ ofname = os.path.join(odir, '%s.txt' % (image_name[:-4]))
+ f = open(ofname, 'w')
+ f.write('{:s}\n'.format(image_class + '/' + image_name))
+ f.write('{:d}\n'.format(bboxes_scores.shape[0]))
+ for box_score in bboxes_scores:
+ xmin, ymin, xmax, ymax, score = box_score
+ f.write('{:.1f} {:.1f} {:.1f} {:.1f} {:.3f}\n'.format(xmin, ymin, (
+ xmax - xmin + 1), (ymax - ymin + 1), score))
+ f.close()
+ logger.info("The predicted result is saved as {}".format(ofname))
+
+
+def save_fddb_bboxes(bboxes_scores,
+ output_dir,
+ output_fname='pred_fddb_res.txt'):
+ if not os.path.exists(output_dir):
+ os.makedirs(output_dir)
+ predict_file = os.path.join(output_dir, output_fname)
+ f = open(predict_file, 'w')
+ for image_path, dets in bboxes_scores.iteritems():
+ f.write('{:s}\n'.format(image_path))
+ f.write('{:d}\n'.format(dets.shape[0]))
+ for box_score in dets:
+ xmin, ymin, xmax, ymax, score = box_score
+ width, height = xmax - xmin, ymax - ymin
+ f.write('{:.1f} {:.1f} {:.1f} {:.1f} {:.3f}\n'
+ .format(xmin, ymin, width, height, score))
+ logger.info("The predicted result is saved as {}".format(predict_file))
+ return predict_file
+
+
+def get_category_info(anno_file=None,
+ with_background=True,
+ use_default_label=False):
+ if use_default_label or anno_file is None \
+ or not os.path.exists(anno_file):
+ logger.info("Not found annotation file {}, load "
+ "wider-face categories.".format(anno_file))
+ return widerfaceall_category_info(with_background)
+ else:
+ logger.info("Load categories from {}".format(anno_file))
+ return get_category_info_from_anno(anno_file, with_background)
+
+
+def get_category_info_from_anno(anno_file, with_background=True):
+ """
+ Get class id to category id map and category id
+ to category name map from annotation file.
+ Args:
+ anno_file (str): annotation file path
+ with_background (bool, default True):
+ whether load background as class 0.
+ """
+ cats = []
+ with open(anno_file) as f:
+ for line in f.readlines():
+ cats.append(line.strip())
+
+ if cats[0] != 'background' and with_background:
+ cats.insert(0, 'background')
+ if cats[0] == 'background' and not with_background:
+ cats = cats[1:]
+
+ clsid2catid = {i: i for i in range(len(cats))}
+ catid2name = {i: name for i, name in enumerate(cats)}
+
+ return clsid2catid, catid2name
+
+
+def widerfaceall_category_info(with_background=True):
+ """
+ Get class id to category id map and category id
+ to category name map of mixup wider_face dataset
+
+ Args:
+ with_background (bool, default True):
+ whether load background as class 0.
+ """
+ label_map = widerface_label(with_background)
+ label_map = sorted(label_map.items(), key=lambda x: x[1])
+ cats = [l[0] for l in label_map]
+
+ if with_background:
+ cats.insert(0, 'background')
+
+ clsid2catid = {i: i for i in range(len(cats))}
+ catid2name = {i: name for i, name in enumerate(cats)}
+
+ return clsid2catid, catid2name
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..798b006ad7baa3b4f24b4a7db15a63d6d2e533f4
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,5 @@
+tqdm
+docstring_parser @ http://github.com/willthefrog/docstring_parser/tarball/master
+typeguard ; python_version >= '3.4'
+tb-paddle
+tb-nightly
diff --git a/slim/distillation/README.md b/slim/distillation/README.md
new file mode 100755
index 0000000000000000000000000000000000000000..e970cc42b54c17a6131c4873662fb2be46767b60
--- /dev/null
+++ b/slim/distillation/README.md
@@ -0,0 +1,141 @@
+>运行该示例前请安装Paddle1.6或更高版本
+
+# 检测模型蒸馏示例
+
+## 概述
+
+该示例使用PaddleSlim提供的[蒸馏策略](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/tutorial.md#3-蒸馏)对检测库中的模型进行蒸馏训练。
+在阅读该示例前，建议您先了解以下内容：
+
+- [检测库的常规训练方法](https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/PaddleDetection)
+- [PaddleSlim使用文档](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md)
+
+
+## 配置文件说明
+
+关于配置文件如何编写您可以参考：
+
+- [PaddleSlim配置文件编写说明](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md#122-%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6%E7%9A%84%E4%BD%BF%E7%94%A8)
+- [蒸馏策略配置文件编写说明](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md#23-蒸馏)
+
+这里以ResNet34-YoloV3蒸馏MobileNetV1-YoloV3模型为例，首先，为了对`student model`和`teacher model`有个总体的认识，从而进一步确认蒸馏的对象，我们通过以下命令分别观察两个网络变量（Variable）的名称和形状：
+
+```python
+# 观察student model的Variable
+for v in fluid.default_main_program().list_vars():
+ if "py_reader" not in v.name and "double_buffer" not in v.name and "generated_var" not in v.name:
+ print(v.name, v.shape)
+# 观察teacher model的Variable
+for v in teacher_program.list_vars():
+ print(v.name, v.shape)
+```
+
+经过对比可以发现，`student model`和`teacher model`的部分中间结果分别为：
+
+```bash
+# student model
+conv2d_15.tmp_0
+# teacher model
+teacher_teacher_conv2d_1.tmp_0
+```
+
+
+所以，我们用`l2_distiller`对这两个特征图做蒸馏。在配置文件中进行如下配置：
+
+```yaml
+distillers:
+ l2_distiller:
+ class: 'L2Distiller'
+ teacher_feature_map: 'teacher_teacher_conv2d_1.tmp_0'
+ student_feature_map: 'conv2d_15.tmp_0'
+ distillation_loss_weight: 1
+strategies:
+ distillation_strategy:
+ class: 'DistillationStrategy'
+ distillers: ['l2_distiller']
+ start_epoch: 0
+ end_epoch: 270
+```
+
+我们也可以根据上述操作为蒸馏策略选择其他loss，PaddleSlim支持的有`FSP_loss`, `L2_loss`和`softmax_with_cross_entropy_loss` 。
+
+## 训练
+
+根据[PaddleDetection/tools/train.py](https://github.com/PaddlePaddle/models/blob/develop/PaddleCV/PaddleDetection/tools/train.py)编写压缩脚本compress.py。
+在该脚本中定义了Compressor对象，用于执行压缩任务。
+
+
+
+
+您可以通过运行脚本`run.sh`运行该示例。
+
+
+### 保存断点（checkpoint）
+
+如果在配置文件中设置了`checkpoint_path`, 则在蒸馏任务执行过程中会自动保存断点，当任务异常中断时，
+重启任务会自动从`checkpoint_path`路径下按数字顺序加载最新的checkpoint文件。如果不想让重启的任务从断点恢复，
+需要修改配置文件中的`checkpoint_path`，或者将`checkpoint_path`路径下文件清空。
+
+>注意：配置文件中的信息不会保存在断点中，重启前对配置文件的修改将会生效。
+
+
+## 评估
+
+如果在配置文件中设置了`checkpoint_path`，则每个epoch会保存一个压缩后的用于评估的模型，
+该模型会保存在`${checkpoint_path}/${epoch_id}/eval_model/`路径下，包含`__model__`和`__params__`两个文件。
+其中，`__model__`用于保存模型结构信息，`__params__`用于保存参数（parameters）信息。
+
+如果不需要保存评估模型，可以在定义Compressor对象时，将`save_eval_model`选项设置为False（默认为True）。
+
+运行命令为：
+```
+python ../eval.py \
+ --model_path ${checkpoint_path}/${epoch_id}/eval_model/ \
+ --model_name __model__ \
+ --params_name __params__ \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ -d "../../dataset/voc"
+```
+
+## 预测
+
+如果在配置文件中设置了`checkpoint_path`，并且在定义Compressor对象时指定了`prune_infer_model`选项，则每个epoch都会
+保存一个`inference model`。该模型是通过删除eval_program中多余的operators而得到的。
+
+该模型会保存在`${checkpoint_path}/${epoch_id}/eval_model/`路径下，包含`__model__.infer`和`__params__`两个文件。
+其中，`__model__.infer`用于保存模型结构信息，`__params__`用于保存参数（parameters）信息。
+
+更多关于`prune_infer_model`选项的介绍，请参考：[Compressor介绍](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md#121-%E5%A6%82%E4%BD%95%E6%94%B9%E5%86%99%E6%99%AE%E9%80%9A%E8%AE%AD%E7%BB%83%E8%84%9A%E6%9C%AC)
+
+### python预测
+
+在脚本slim/infer.py中展示了如何使用fluid python API加载使用预测模型进行预测。
+
+运行命令为：
+```
+python ../infer.py \
+ --model_path ${checkpoint_path}/${epoch_id}/eval_model/ \
+ --model_name __model__.infer \
+ --params_name __params__ \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ --infer_dir ../../demo
+```
+
+### PaddleLite
+
+该示例中产出的预测（inference）模型可以直接用PaddleLite进行加载使用。
+关于PaddleLite如何使用，请参考：[PaddleLite使用文档](https://github.com/PaddlePaddle/Paddle-Lite/wiki#%E4%BD%BF%E7%94%A8)
+
+## 示例结果
+
+>当前release的结果并非超参调优后的最好结果，仅做示例参考，后续我们会优化当前结果。
+
+### MobileNetV1-YOLO-V3
+
+| FLOPS |Box AP|
+|---|---|
+|baseline|76.2 |
+|蒸馏后|- |
+
+
+## FAQ
diff --git a/slim/distillation/compress.py b/slim/distillation/compress.py
new file mode 100644
index 0000000000000000000000000000000000000000..6dc4fff9742ec258b30cad4408b5e6f428273495
--- /dev/null
+++ b/slim/distillation/compress.py
@@ -0,0 +1,324 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import time
+import multiprocessing
+import numpy as np
+from collections import deque, OrderedDict
+from paddle.fluid.contrib.slim.core import Compressor
+from paddle.fluid.framework import IrGraph
+
+
+def set_paddle_flags(**kwargs):
+ for key, value in kwargs.items():
+ if os.environ.get(key, None) is None:
+ os.environ[key] = str(value)
+
+
+# NOTE(paddle-dev): All of these flags should be set before
+# `import paddle`. Otherwise, it would not take any effect.
+set_paddle_flags(
+ FLAGS_eager_delete_tensor_gb=0, # enable GC to save memory
+)
+
+from paddle import fluid
+
+import sys
+sys.path.append("../../")
+from ppdet.core.workspace import load_config, merge_config, create
+from ppdet.data.data_feed import create_reader
+from ppdet.utils.eval_utils import parse_fetches, eval_results
+from ppdet.utils.stats import TrainingStats
+from ppdet.utils.cli import ArgsParser
+from ppdet.utils.check import check_gpu
+import ppdet.utils.checkpoint as checkpoint
+from ppdet.modeling.model_input import create_feed
+
+import logging
+FORMAT = '%(asctime)s-%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.INFO, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+
+def eval_run(exe, compile_program, reader, keys, values, cls, test_feed):
+ """
+ Run evaluation program, return program outputs.
+ """
+ iter_id = 0
+ results = []
+ if len(cls) != 0:
+ values = []
+ for i in range(len(cls)):
+ _, accum_map = cls[i].get_map_var()
+ cls[i].reset(exe)
+ values.append(accum_map)
+
+ images_num = 0
+ start_time = time.time()
+ has_bbox = 'bbox' in keys
+ for data in reader():
+ data = test_feed.feed(data)
+ feed_data = {'image': data['image'], 'im_size': data['im_size']}
+ outs = exe.run(compile_program,
+ feed=feed_data,
+ fetch_list=[values[0]],
+ return_numpy=False)
+ outs.append(data['gt_box'])
+ outs.append(data['gt_label'])
+ outs.append(data['is_difficult'])
+ res = {
+ k: (np.array(v), v.recursive_sequence_lengths())
+ for k, v in zip(keys, outs)
+ }
+ results.append(res)
+ if iter_id % 100 == 0:
+ logger.info('Test iter {}'.format(iter_id))
+ iter_id += 1
+ images_num += len(res['bbox'][1][0]) if has_bbox else 1
+ logger.info('Test finish iter {}'.format(iter_id))
+
+ end_time = time.time()
+ fps = images_num / (end_time - start_time)
+ if has_bbox:
+ logger.info('Total number of images: {}, inference time: {} fps.'.
+ format(images_num, fps))
+ else:
+ logger.info('Total iteration: {}, inference time: {} batch/s.'.format(
+ images_num, fps))
+
+ return results
+
+
+def main():
+ cfg = load_config(FLAGS.config)
+ if 'architecture' in cfg:
+ main_arch = cfg.architecture
+ else:
+ raise ValueError("'architecture' not specified in config file.")
+
+ merge_config(FLAGS.opt)
+ if 'log_iter' not in cfg:
+ cfg.log_iter = 20
+
+ # check if set use_gpu=True in paddlepaddle cpu version
+ check_gpu(cfg.use_gpu)
+
+ if cfg.use_gpu:
+ devices_num = fluid.core.get_cuda_device_count()
+ else:
+ devices_num = int(
+ os.environ.get('CPU_NUM', multiprocessing.cpu_count()))
+
+ if 'train_feed' not in cfg:
+ train_feed = create(main_arch + 'TrainFeed')
+ else:
+ train_feed = create(cfg.train_feed)
+
+ if 'eval_feed' not in cfg:
+ eval_feed = create(main_arch + 'EvalFeed')
+ else:
+ eval_feed = create(cfg.eval_feed)
+
+ place = fluid.CUDAPlace(0) if cfg.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ lr_builder = create('LearningRate')
+ optim_builder = create('OptimizerBuilder')
+
+ # build program
+ model = create(main_arch)
+ _, train_feed_vars = create_feed(train_feed, False)
+ train_fetches = model.train(train_feed_vars)
+ loss = train_fetches['loss']
+ lr = lr_builder()
+ opt = optim_builder(lr)
+ opt.minimize(loss)
+ #for v in fluid.default_main_program().list_vars():
+ # if "py_reader" not in v.name and "double_buffer" not in v.name and "generated_var" not in v.name:
+ # print(v.name, v.shape)
+
+ cfg.max_iters = 258
+ train_reader = create_reader(train_feed, cfg.max_iters, FLAGS.dataset_dir)
+
+ exe.run(fluid.default_startup_program())
+
+ # parse train fetches
+ train_keys, train_values, _ = parse_fetches(train_fetches)
+ train_keys.append('lr')
+ train_values.append(lr.name)
+
+ train_fetch_list = []
+ for k, v in zip(train_keys, train_values):
+ train_fetch_list.append((k, v))
+ print("train_fetch_list: {}".format(train_fetch_list))
+
+ eval_prog = fluid.Program()
+ startup_prog = fluid.Program()
+ with fluid.program_guard(eval_prog, startup_prog):
+ with fluid.unique_name.guard():
+ model = create(main_arch)
+ _, test_feed_vars = create_feed(eval_feed, False)
+ fetches = model.eval(test_feed_vars)
+ eval_prog = eval_prog.clone(True)
+
+ eval_reader = create_reader(eval_feed, args_path=FLAGS.dataset_dir)
+ test_data_feed = fluid.DataFeeder(test_feed_vars.values(), place)
+
+ # parse eval fetches
+ extra_keys = []
+ if cfg.metric == 'COCO':
+ extra_keys = ['im_info', 'im_id', 'im_shape']
+ if cfg.metric == 'VOC':
+ extra_keys = ['gt_box', 'gt_label', 'is_difficult']
+ eval_keys, eval_values, eval_cls = parse_fetches(fetches, eval_prog,
+ extra_keys)
+
+ eval_fetch_list = []
+ for k, v in zip(eval_keys, eval_values):
+ eval_fetch_list.append((k, v))
+ print("eval_fetch_list: {}".format(eval_fetch_list))
+
+ exe.run(startup_prog)
+ checkpoint.load_params(exe,
+ fluid.default_main_program(), cfg.pretrain_weights)
+
+ best_box_ap_list = []
+
+ def eval_func(program, scope):
+ results = eval_run(exe, program, eval_reader, eval_keys, eval_values,
+ eval_cls, test_data_feed)
+
+ resolution = None
+ is_bbox_normalized = False
+ if 'mask' in results[0]:
+ resolution = model.mask_head.resolution
+ box_ap_stats = eval_results(results, eval_feed, cfg.metric,
+ cfg.num_classes, resolution,
+ is_bbox_normalized, FLAGS.output_eval)
+ if len(best_box_ap_list) == 0:
+ best_box_ap_list.append(box_ap_stats[0])
+ elif box_ap_stats[0] > best_box_ap_list[0]:
+ best_box_ap_list[0] = box_ap_stats[0]
+ logger.info("Best test box ap: {}".format(best_box_ap_list[0]))
+ return best_box_ap_list[0]
+
+ test_feed = [('image', test_feed_vars['image'].name),
+ ('im_size', test_feed_vars['im_size'].name)]
+
+ teacher_cfg = load_config(FLAGS.teacher_config)
+ teacher_arch = teacher_cfg.architecture
+ teacher_programs = []
+ teacher_program = fluid.Program()
+ teacher_startup_program = fluid.Program()
+ with fluid.program_guard(teacher_program, teacher_startup_program):
+ with fluid.unique_name.guard('teacher_'):
+ teacher_feed_vars = OrderedDict()
+ for name, var in train_feed_vars.items():
+ teacher_feed_vars[name] = teacher_program.global_block(
+ )._clone_variable(
+ var, force_persistable=False)
+ model = create(teacher_arch)
+ train_fetches = model.train(teacher_feed_vars)
+ #print("="*50+"teacher_model_params"+"="*50)
+ #for v in teacher_program.list_vars():
+ # print(v.name, v.shape)
+ #return
+
+ exe.run(teacher_startup_program)
+ assert FLAGS.teacher_pretrained and os.path.exists(
+ FLAGS.teacher_pretrained
+ ), "teacher_pretrained should be set when teacher_model is not None."
+
+ def if_exist(var):
+ return os.path.exists(os.path.join(FLAGS.teacher_pretrained, var.name))
+
+ fluid.io.load_vars(
+ exe,
+ FLAGS.teacher_pretrained,
+ main_program=teacher_program,
+ predicate=if_exist)
+
+ teacher_programs.append(teacher_program.clone(for_test=True))
+
+ com = Compressor(
+ place,
+ fluid.global_scope(),
+ fluid.default_main_program(),
+ train_reader=train_reader,
+ train_feed_list=[(key, value.name)
+ for key, value in train_feed_vars.items()],
+ train_fetch_list=train_fetch_list,
+ eval_program=eval_prog,
+ eval_reader=eval_reader,
+ eval_feed_list=test_feed,
+ eval_func={'map': eval_func},
+ eval_fetch_list=eval_fetch_list[0:1],
+ save_eval_model=True,
+ prune_infer_model=[["image", "im_size"], ["multiclass_nms_0.tmp_0"]],
+ teacher_programs=teacher_programs,
+ train_optimizer=None,
+ distiller_optimizer=opt,
+ log_period=20)
+ com.config(FLAGS.slim_file)
+ com.run()
+
+
+if __name__ == '__main__':
+ parser = ArgsParser()
+ parser.add_argument(
+ "-t",
+ "--teacher_config",
+ default=None,
+ type=str,
+ help="Config file of teacher architecture.")
+ parser.add_argument(
+ "-s",
+ "--slim_file",
+ default=None,
+ type=str,
+ help="Config file of PaddleSlim.")
+ parser.add_argument(
+ "-r",
+ "--resume_checkpoint",
+ default=None,
+ type=str,
+ help="Checkpoint path for resuming training.")
+ parser.add_argument(
+ "--eval",
+ action='store_true',
+ default=False,
+ help="Whether to perform evaluation in train")
+ parser.add_argument(
+ "--teacher_pretrained",
+ default=None,
+ type=str,
+ help="Whether to use pretrained model.")
+ parser.add_argument(
+ "--output_eval",
+ default=None,
+ type=str,
+ help="Evaluation directory, default is current directory.")
+ parser.add_argument(
+ "-d",
+ "--dataset_dir",
+ default=None,
+ type=str,
+ help="Dataset path, same as DataFeed.dataset.dataset_dir")
+ FLAGS = parser.parse_args()
+ main()
diff --git a/slim/distillation/run.sh b/slim/distillation/run.sh
new file mode 100644
index 0000000000000000000000000000000000000000..a5497bdce2464c72e14fa2168b87db60685e83e8
--- /dev/null
+++ b/slim/distillation/run.sh
@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+
+# download pretrain model
+root_url="https://paddlemodels.bj.bcebos.com/object_detection"
+yolov3_r34_voc="yolov3_r34_voc.tar"
+pretrain_dir='./pretrain'
+
+if [ ! -d ${pretrain_dir} ]; then
+ mkdir ${pretrain_dir}
+fi
+
+cd ${pretrain_dir}
+
+if [ ! -f ${yolov3_r34_voc} ]; then
+ wget ${root_url}/${yolov3_r34_voc}
+ tar xf ${yolov3_r34_voc}
+fi
+cd -
+
+# enable GC strategy
+export FLAGS_fast_eager_deletion_mode=1
+export FLAGS_eager_delete_tensor_gb=0.0
+
+# for distillation
+#-----------------
+export CUDA_VISIBLE_DEVICES=0,1,2,3
+
+
+# Fixing name conflicts in distillation
+cd ${pretrain_dir}/yolov3_r34_voc
+for files in $(ls teacher_*)
+ do mv $files ${files#*_}
+done
+for files in $(ls *)
+ do mv $files "teacher_"$files
+done
+cd -
+
+python -u compress.py \
+-c ../../configs/yolov3_mobilenet_v1_voc.yml \
+-t yolov3_resnet34.yml \
+-s yolov3_mobilenet_v1_yolov3_resnet34_distillation.yml \
+-o YoloTrainFeed.batch_size=64 \
+-d ../../dataset/voc \
+--teacher_pretrained ./pretrain/yolov3_r34_voc \
+> yolov3_distallation.log 2>&1 &
+tailf yolov3_distallation.log
diff --git a/slim/distillation/yolov3_mobilenet_v1_yolov3_resnet34_distillation.yml b/slim/distillation/yolov3_mobilenet_v1_yolov3_resnet34_distillation.yml
new file mode 100644
index 0000000000000000000000000000000000000000..6a2a5a2575b71563c557c528a4dc94f00dce73ca
--- /dev/null
+++ b/slim/distillation/yolov3_mobilenet_v1_yolov3_resnet34_distillation.yml
@@ -0,0 +1,18 @@
+version: 1.0
+distillers:
+ l2_distiller:
+ class: 'L2Distiller'
+ teacher_feature_map: 'teacher_teacher_conv2d_1.tmp_0'
+ student_feature_map: 'conv2d_15.tmp_0'
+ distillation_loss_weight: 1
+strategies:
+ distillation_strategy:
+ class: 'DistillationStrategy'
+ distillers: ['l2_distiller']
+ start_epoch: 0
+ end_epoch: 270
+compressor:
+ epoch: 271
+ checkpoint_path: './checkpoints/'
+ strategies:
+ - distillation_strategy
diff --git a/slim/distillation/yolov3_resnet34.yml b/slim/distillation/yolov3_resnet34.yml
new file mode 100644
index 0000000000000000000000000000000000000000..c04bdde9f6e35a1ce53231e3862a37364ff7dbb8
--- /dev/null
+++ b/slim/distillation/yolov3_resnet34.yml
@@ -0,0 +1,34 @@
+architecture: YOLOv3
+log_smooth_window: 20
+metric: VOC
+map_type: 11point
+num_classes: 20
+weight_prefix_name: teacher_
+
+YOLOv3:
+ backbone: ResNet
+ yolo_head: YOLOv3Head
+
+ResNet:
+ norm_type: sync_bn
+ freeze_at: 0
+ freeze_norm: false
+ norm_decay: 0.
+ depth: 34
+ feature_maps: [3, 4, 5]
+
+YOLOv3Head:
+ anchor_masks: [[6, 7, 8], [3, 4, 5], [0, 1, 2]]
+ anchors: [[10, 13], [16, 30], [33, 23],
+ [30, 61], [62, 45], [59, 119],
+ [116, 90], [156, 198], [373, 326]]
+ norm_decay: 0.
+ ignore_thresh: 0.7
+ label_smooth: false
+ nms:
+ background_label: -1
+ keep_top_k: 100
+ nms_threshold: 0.45
+ nms_top_k: 1000
+ normalized: false
+ score_threshold: 0.01
diff --git a/slim/eval.py b/slim/eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..579f58d2932e215362efa9e8864c16d1a451b26a
--- /dev/null
+++ b/slim/eval.py
@@ -0,0 +1,194 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import time
+import multiprocessing
+import numpy as np
+import datetime
+from collections import deque
+import sys
+sys.path.append("../../")
+from paddle.fluid.contrib.slim import Compressor
+from paddle.fluid.framework import IrGraph
+from paddle.fluid import core
+from paddle.fluid.contrib.slim.quantization import QuantizationTransformPass
+from paddle.fluid.contrib.slim.quantization import QuantizationFreezePass
+from paddle.fluid.contrib.slim.quantization import ConvertToInt8Pass
+from paddle.fluid.contrib.slim.quantization import TransformForMobilePass
+
+
+def set_paddle_flags(**kwargs):
+ for key, value in kwargs.items():
+ if os.environ.get(key, None) is None:
+ os.environ[key] = str(value)
+
+
+# NOTE(paddle-dev): All of these flags should be set before
+# `import paddle`. Otherwise, it would not take any effect.
+set_paddle_flags(
+ FLAGS_eager_delete_tensor_gb=0, # enable GC to save memory
+)
+
+from paddle import fluid
+
+from ppdet.core.workspace import load_config, merge_config, create
+from ppdet.data.data_feed import create_reader
+
+from ppdet.utils.eval_utils import parse_fetches, eval_results
+from ppdet.utils.stats import TrainingStats
+from ppdet.utils.cli import ArgsParser
+from ppdet.utils.check import check_gpu
+import ppdet.utils.checkpoint as checkpoint
+from ppdet.modeling.model_input import create_feed
+
+import logging
+FORMAT = '%(asctime)s-%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.INFO, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+
+def eval_run(exe, compile_program, reader, keys, values, cls, test_feed):
+ """
+ Run evaluation program, return program outputs.
+ """
+ iter_id = 0
+ results = []
+
+ images_num = 0
+ start_time = time.time()
+ has_bbox = 'bbox' in keys
+ for data in reader():
+ data = test_feed.feed(data)
+ feed_data = {'image': data['image'], 'im_size': data['im_size']}
+ outs = exe.run(compile_program,
+ feed=feed_data,
+ fetch_list=values[0],
+ return_numpy=False)
+ outs.append(data['gt_box'])
+ outs.append(data['gt_label'])
+ outs.append(data['is_difficult'])
+ res = {
+ k: (np.array(v), v.recursive_sequence_lengths())
+ for k, v in zip(keys, outs)
+ }
+ results.append(res)
+ if iter_id % 100 == 0:
+ logger.info('Test iter {}'.format(iter_id))
+ iter_id += 1
+ images_num += len(res['bbox'][1][0]) if has_bbox else 1
+ logger.info('Test finish iter {}'.format(iter_id))
+
+ end_time = time.time()
+ fps = images_num / (end_time - start_time)
+ if has_bbox:
+ logger.info('Total number of images: {}, inference time: {} fps.'.
+ format(images_num, fps))
+ else:
+ logger.info('Total iteration: {}, inference time: {} batch/s.'.format(
+ images_num, fps))
+
+ return results
+
+
+def main():
+ cfg = load_config(FLAGS.config)
+ if 'architecture' in cfg:
+ main_arch = cfg.architecture
+ else:
+ raise ValueError("'architecture' not specified in config file.")
+
+ merge_config(FLAGS.opt)
+ if 'log_iter' not in cfg:
+ cfg.log_iter = 20
+
+ # check if set use_gpu=True in paddlepaddle cpu version
+ check_gpu(cfg.use_gpu)
+
+ if cfg.use_gpu:
+ devices_num = fluid.core.get_cuda_device_count()
+ else:
+ devices_num = int(
+ os.environ.get('CPU_NUM', multiprocessing.cpu_count()))
+
+ if 'eval_feed' not in cfg:
+ eval_feed = create(main_arch + 'EvalFeed')
+ else:
+ eval_feed = create(cfg.eval_feed)
+
+ place = fluid.CUDAPlace(0) if cfg.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ _, test_feed_vars = create_feed(eval_feed, False)
+
+ eval_reader = create_reader(eval_feed, args_path=FLAGS.dataset_dir)
+ #eval_pyreader.decorate_sample_list_generator(eval_reader, place)
+ test_data_feed = fluid.DataFeeder(test_feed_vars.values(), place)
+
+ assert os.path.exists(FLAGS.model_path)
+ infer_prog, feed_names, fetch_targets = fluid.io.load_inference_model(
+ dirname=FLAGS.model_path,
+ executor=exe,
+ model_filename=FLAGS.model_name,
+ params_filename=FLAGS.params_name)
+
+ eval_keys = ['bbox', 'gt_box', 'gt_label', 'is_difficult']
+ eval_values = [
+ 'multiclass_nms_0.tmp_0', 'gt_box', 'gt_label', 'is_difficult'
+ ]
+ eval_cls = []
+ eval_values[0] = fetch_targets[0]
+
+ results = eval_run(exe, infer_prog, eval_reader, eval_keys, eval_values,
+ eval_cls, test_data_feed)
+
+ resolution = None
+ if 'mask' in results[0]:
+ resolution = model.mask_head.resolution
+ eval_results(results, eval_feed, cfg.metric, cfg.num_classes, resolution,
+ False, FLAGS.output_eval)
+
+
+if __name__ == '__main__':
+ parser = ArgsParser()
+ parser.add_argument(
+ "-m", "--model_path", default=None, type=str, help="path of checkpoint")
+ parser.add_argument(
+ "--output_eval",
+ default=None,
+ type=str,
+ help="Evaluation directory, default is current directory.")
+ parser.add_argument(
+ "-d",
+ "--dataset_dir",
+ default=None,
+ type=str,
+ help="Dataset path, same as DataFeed.dataset.dataset_dir")
+ parser.add_argument(
+ "--model_name",
+ default='model',
+ type=str,
+ help="model file name to load_inference_model")
+ parser.add_argument(
+ "--params_name",
+ default='params',
+ type=str,
+ help="params file name to load_inference_model")
+
+ FLAGS = parser.parse_args()
+ main()
diff --git a/slim/infer.py b/slim/infer.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5c00de983a15c40db60deb9097c3d8f92a557aa
--- /dev/null
+++ b/slim/infer.py
@@ -0,0 +1,300 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import sys
+import glob
+import time
+
+import numpy as np
+from PIL import Image
+sys.path.append("../../")
+
+
+def set_paddle_flags(**kwargs):
+ for key, value in kwargs.items():
+ if os.environ.get(key, None) is None:
+ os.environ[key] = str(value)
+
+
+# NOTE(paddle-dev): All of these flags should be set before
+# `import paddle`. Otherwise, it would not take any effect.
+set_paddle_flags(
+ FLAGS_eager_delete_tensor_gb=0, # enable GC to save memory
+)
+
+from paddle import fluid
+from ppdet.utils.cli import print_total_cfg
+from ppdet.core.workspace import load_config, merge_config, create
+from ppdet.modeling.model_input import create_feed
+from ppdet.data.data_feed import create_reader
+
+from ppdet.utils.eval_utils import parse_fetches
+from ppdet.utils.cli import ArgsParser
+from ppdet.utils.check import check_gpu
+from ppdet.utils.visualizer import visualize_results
+import ppdet.utils.checkpoint as checkpoint
+
+import logging
+FORMAT = '%(asctime)s-%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.INFO, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+
+def get_save_image_name(output_dir, image_path):
+ """
+ Get save image name from source image path.
+ """
+ if not os.path.exists(output_dir):
+ os.makedirs(output_dir)
+ image_name = os.path.split(image_path)[-1]
+ name, ext = os.path.splitext(image_name)
+ return os.path.join(output_dir, "{}".format(name)) + ext
+
+
+def get_test_images(infer_dir, infer_img):
+ """
+ Get image path list in TEST mode
+ """
+ assert infer_img is not None or infer_dir is not None, \
+ "--infer_img or --infer_dir should be set"
+ assert infer_img is None or os.path.isfile(infer_img), \
+ "{} is not a file".format(infer_img)
+ assert infer_dir is None or os.path.isdir(infer_dir), \
+ "{} is not a directory".format(infer_dir)
+ images = []
+
+ # infer_img has a higher priority
+ if infer_img and os.path.isfile(infer_img):
+ images.append(infer_img)
+ return images
+
+ infer_dir = os.path.abspath(infer_dir)
+ assert os.path.isdir(infer_dir), \
+ "infer_dir {} is not a directory".format(infer_dir)
+ exts = ['jpg', 'jpeg', 'png', 'bmp']
+ exts += [ext.upper() for ext in exts]
+ for ext in exts:
+ images.extend(glob.glob('{}/*.{}'.format(infer_dir, ext)))
+
+ assert len(images) > 0, "no image found in {}".format(infer_dir)
+ logger.info("Found {} inference images in total.".format(len(images)))
+
+ return images
+
+
+def main():
+ cfg = load_config(FLAGS.config)
+
+ if 'architecture' in cfg:
+ main_arch = cfg.architecture
+ else:
+ raise ValueError("'architecture' not specified in config file.")
+
+ merge_config(FLAGS.opt)
+
+ # check if set use_gpu=True in paddlepaddle cpu version
+ check_gpu(cfg.use_gpu)
+ # print_total_cfg(cfg)
+
+ if 'test_feed' not in cfg:
+ test_feed = create(main_arch + 'TestFeed')
+ else:
+ test_feed = create(cfg.test_feed)
+
+ test_images = get_test_images(FLAGS.infer_dir, FLAGS.infer_img)
+ test_feed.dataset.add_images(test_images)
+
+ place = fluid.CUDAPlace(0) if cfg.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ infer_prog, feed_var_names, fetch_list = fluid.io.load_inference_model(
+ dirname=FLAGS.model_path,
+ model_filename=FLAGS.model_name,
+ params_filename=FLAGS.params_name,
+ executor=exe)
+
+ reader = create_reader(test_feed)
+ feeder = fluid.DataFeeder(
+ place=place, feed_list=feed_var_names, program=infer_prog)
+
+ # parse infer fetches
+ assert cfg.metric in ['COCO', 'VOC'], \
+ "unknown metric type {}".format(cfg.metric)
+ extra_keys = []
+ if cfg['metric'] == 'COCO':
+ extra_keys = ['im_info', 'im_id', 'im_shape']
+ if cfg['metric'] == 'VOC':
+ extra_keys = ['im_id', 'im_shape']
+ keys, values, _ = parse_fetches({
+ 'bbox': fetch_list
+ }, infer_prog, extra_keys)
+
+ # parse dataset category
+ if cfg.metric == 'COCO':
+ from ppdet.utils.coco_eval import bbox2out, mask2out, get_category_info
+ if cfg.metric == "VOC":
+ from ppdet.utils.voc_eval import bbox2out, get_category_info
+
+ anno_file = getattr(test_feed.dataset, 'annotation', None)
+ with_background = getattr(test_feed, 'with_background', True)
+ use_default_label = getattr(test_feed, 'use_default_label', False)
+ clsid2catid, catid2name = get_category_info(anno_file, with_background,
+ use_default_label)
+
+ # whether output bbox is normalized in model output layer
+ is_bbox_normalized = False
+
+ # use tb-paddle to log image
+ if FLAGS.use_tb:
+ from tb_paddle import SummaryWriter
+ tb_writer = SummaryWriter(FLAGS.tb_log_dir)
+ tb_image_step = 0
+ tb_image_frame = 0 # each frame can display ten pictures at most.
+
+ imid2path = reader.imid2path
+ keys = ['bbox']
+ infer_time = True
+ compile_prog = fluid.compiler.CompiledProgram(infer_prog)
+
+ for iter_id, data in enumerate(reader()):
+ feed_data = [[d[0], d[1]] for d in data]
+ # for infer time
+ if infer_time:
+ warmup_times = 10
+ repeats_time = 100
+ feed_data_dict = feeder.feed(feed_data)
+ for i in range(warmup_times):
+ exe.run(compile_prog,
+ feed=feed_data_dict,
+ fetch_list=fetch_list,
+ return_numpy=False)
+ start_time = time.time()
+ for i in range(repeats_time):
+ exe.run(compile_prog,
+ feed=feed_data_dict,
+ fetch_list=fetch_list,
+ return_numpy=False)
+
+ print("infer time: {} ms/sample".format((time.time() - start_time) *
+ 1000 / repeats_time))
+ infer_time = False
+
+ outs = exe.run(compile_prog,
+ feed=feeder.feed(feed_data),
+ fetch_list=fetch_list,
+ return_numpy=False)
+ res = {
+ k: (np.array(v), v.recursive_sequence_lengths())
+ for k, v in zip(keys, outs)
+ }
+ res['im_id'] = [[d[2] for d in data]]
+ logger.info('Infer iter {}'.format(iter_id))
+
+ bbox_results = None
+ mask_results = None
+ if 'bbox' in res:
+ bbox_results = bbox2out([res], clsid2catid, is_bbox_normalized)
+ if 'mask' in res:
+ mask_results = mask2out([res], clsid2catid,
+ model.mask_head.resolution)
+
+ # visualize result
+ im_ids = res['im_id'][0]
+ for im_id in im_ids:
+ image_path = imid2path[int(im_id)]
+ image = Image.open(image_path).convert('RGB')
+
+ # use tb-paddle to log original image
+ if FLAGS.use_tb:
+ original_image_np = np.array(image)
+ tb_writer.add_image(
+ "original/frame_{}".format(tb_image_frame),
+ original_image_np,
+ tb_image_step,
+ dataformats='HWC')
+
+ image = visualize_results(image,
+ int(im_id), catid2name,
+ FLAGS.draw_threshold, bbox_results,
+ mask_results)
+
+ # use tb-paddle to log image with bbox
+ if FLAGS.use_tb:
+ infer_image_np = np.array(image)
+ tb_writer.add_image(
+ "bbox/frame_{}".format(tb_image_frame),
+ infer_image_np,
+ tb_image_step,
+ dataformats='HWC')
+ tb_image_step += 1
+ if tb_image_step % 10 == 0:
+ tb_image_step = 0
+ tb_image_frame += 1
+
+ save_name = get_save_image_name(FLAGS.output_dir, image_path)
+ logger.info("Detection bbox results save in {}".format(save_name))
+ image.save(save_name, quality=95)
+
+
+if __name__ == '__main__':
+ parser = ArgsParser()
+ parser.add_argument(
+ "--infer_dir",
+ type=str,
+ default=None,
+ help="Directory for images to perform inference on.")
+ parser.add_argument(
+ "--infer_img",
+ type=str,
+ default=None,
+ help="Image path, has higher priority over --infer_dir")
+ parser.add_argument(
+ "--output_dir",
+ type=str,
+ default="output",
+ help="Directory for storing the output visualization files.")
+ parser.add_argument(
+ "--draw_threshold",
+ type=float,
+ default=0.5,
+ help="Threshold to reserve the result for visualization.")
+ parser.add_argument(
+ "--use_tb",
+ type=bool,
+ default=False,
+ help="whether to record the data to Tensorboard.")
+ parser.add_argument(
+ '--tb_log_dir',
+ type=str,
+ default="tb_log_dir/image",
+ help='Tensorboard logging directory for image.')
+ parser.add_argument(
+ '--model_path', type=str, default=None, help="inference model path")
+ parser.add_argument(
+ '--model_name',
+ type=str,
+ default='__model__.infer',
+ help="model filename for inference model")
+ parser.add_argument(
+ '--params_name',
+ type=str,
+ default='__params__',
+ help="params filename for inference model")
+ FLAGS = parser.parse_args()
+ main()
diff --git a/slim/prune/README.md b/slim/prune/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..b06fdd2bdd6a3cd75eb00ab7952dfd546b2bfaad
--- /dev/null
+++ b/slim/prune/README.md
@@ -0,0 +1,221 @@
+>运行该示例前请安装Paddle1.6或更高版本
+
+# 检测模型卷积通道剪裁示例
+
+## 概述
+
+该示例使用PaddleSlim提供的[卷积通道剪裁压缩策略](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/tutorial.md#2-%E5%8D%B7%E7%A7%AF%E6%A0%B8%E5%89%AA%E8%A3%81%E5%8E%9F%E7%90%86)对检测库中的模型进行压缩。
+在阅读该示例前，建议您先了解以下内容：
+
+- 检测库的常规训练方法
+- [检测模型数据准备](https://github.com/PaddlePaddle/models/blob/develop/PaddleCV/PaddleDetection/docs/INSTALL_cn.md#%E6%95%B0%E6%8D%AE%E9%9B%86)
+- [PaddleSlim使用文档](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md)
+
+
+## 配置文件说明
+
+关于配置文件如何编写您可以参考：
+
+- [PaddleSlim配置文件编写说明](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md#122-%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6%E7%9A%84%E4%BD%BF%E7%94%A8)
+- [裁剪策略配置文件编写说明](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md#22-%E6%A8%A1%E5%9E%8B%E9%80%9A%E9%81%93%E5%89%AA%E8%A3%81)
+
+其中，配置文件中的`pruned_params`需要根据当前模型的网络结构特点设置，它用来指定要裁剪的parameters.
+
+这里以MobileNetV1-YoloV3模型为例，其卷积可以三种：主干网络中的普通卷积，主干网络中的`depthwise convolution`和`yolo block`里的普通卷积。PaddleSlim暂时无法对`depthwise convolution`直接进行剪裁， 因为`depthwise convolution`的`channel`的变化会同时影响到前后的卷积层。我们这里只对主干网络中的普通卷积和`yolo block`里的普通卷积做裁剪。
+
+通过以下方式可视化模型结构：
+
+```
+from paddle.fluid.framework import IrGraph
+from paddle.fluid import core
+
+graph = IrGraph(core.Graph(train_prog.desc), for_test=True)
+marked_nodes = set()
+for op in graph.all_op_nodes():
+ print(op.name())
+ if op.name().find('conv') > -1:
+ marked_nodes.add(op)
+graph.draw('.', 'forward', marked_nodes)
+```
+
+该示例中MobileNetV1-YoloV3模型结构的可视化结果：MobileNetV1-YoloV3.pdf
+
+同时通过以下命令观察目标卷积层的参数（parameters）的名称和shape:
+
+```
+for param in fluid.default_main_program().global_block().all_parameters():
+ if 'weights' in param.name:
+ print(param.name, param.shape)
+```
+
+
+从可视化结果，我们可以排除后续会做concat的卷积层，最终得到如下要裁剪的参数名称：
+
+```
+conv2_1_sep_weights
+conv2_2_sep_weights
+conv3_1_sep_weights
+conv4_1_sep_weights
+conv5_1_sep_weights
+conv5_2_sep_weights
+conv5_3_sep_weights
+conv5_4_sep_weights
+conv5_5_sep_weights
+conv5_6_sep_weights
+yolo_block.0.0.0.conv.weights
+yolo_block.0.0.1.conv.weights
+yolo_block.0.1.0.conv.weights
+yolo_block.0.1.1.conv.weights
+yolo_block.1.0.0.conv.weights
+yolo_block.1.0.1.conv.weights
+yolo_block.1.1.0.conv.weights
+yolo_block.1.1.1.conv.weights
+yolo_block.1.2.conv.weights
+yolo_block.2.0.0.conv.weights
+yolo_block.2.0.1.conv.weights
+yolo_block.2.1.1.conv.weights
+yolo_block.2.2.conv.weights
+yolo_block.2.tip.conv.weights
+```
+
+```
+(conv2_1_sep_weights)|(conv2_2_sep_weights)|(conv3_1_sep_weights)|(conv4_1_sep_weights)|(conv5_1_sep_weights)|(conv5_2_sep_weights)|(conv5_3_sep_weights)|(conv5_4_sep_weights)|(conv5_5_sep_weights)|(conv5_6_sep_weights)|(yolo_block.0.0.0.conv.weights)|(yolo_block.0.0.1.conv.weights)|(yolo_block.0.1.0.conv.weights)|(yolo_block.0.1.1.conv.weights)|(yolo_block.1.0.0.conv.weights)|(yolo_block.1.0.1.conv.weights)|(yolo_block.1.1.0.conv.weights)|(yolo_block.1.1.1.conv.weights)|(yolo_block.1.2.conv.weights)|(yolo_block.2.0.0.conv.weights)|(yolo_block.2.0.1.conv.weights)|(yolo_block.2.1.1.conv.weights)|(yolo_block.2.2.conv.weights)|(yolo_block.2.tip.conv.weights)
+```
+
+综上，我们将MobileNetV2配置文件中的`pruned_params`设置为以下正则表达式：
+
+```
+(conv2_1_sep_weights)|(conv2_2_sep_weights)|(conv3_1_sep_weights)|(conv4_1_sep_weights)|(conv5_1_sep_weights)|(conv5_2_sep_weights)|(conv5_3_sep_weights)|(conv5_4_sep_weights)|(conv5_5_sep_weights)|(conv5_6_sep_weights)|(yolo_block.0.0.0.conv.weights)|(yolo_block.0.0.1.conv.weights)|(yolo_block.0.1.0.conv.weights)|(yolo_block.0.1.1.conv.weights)|(yolo_block.1.0.0.conv.weights)|(yolo_block.1.0.1.conv.weights)|(yolo_block.1.1.0.conv.weights)|(yolo_block.1.1.1.conv.weights)|(yolo_block.1.2.conv.weights)|(yolo_block.2.0.0.conv.weights)|(yolo_block.2.0.1.conv.weights)|(yolo_block.2.1.1.conv.weights)|(yolo_block.2.2.conv.weights)|(yolo_block.2.tip.conv.weights)
+```
+
+我们可以用上述操作观察其它检测模型的参数名称规律，然后设置合适的正则表达式来剪裁合适的参数。
+
+## 训练
+
+根据PaddleDetection/tools/train.py编写压缩脚本compress.py。
+在该脚本中定义了Compressor对象，用于执行压缩任务。
+
+### 执行示例
+
+step1: 设置gpu卡
+```
+export CUDA_VISIBLE_DEVICES=0
+```
+step2: 开始训练
+
+使用PaddleDetection提供的配置文件在用8卡进行训练：
+
+```
+python compress.py \
+ -s yolov3_mobilenet_v1_slim.yaml \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ -o max_iters=258 \
+ YoloTrainFeed.batch_size=64 \
+ -d "../../dataset/voc"
+```
+
+>通过命令行覆盖设置max_iters选项，因为PaddleDetection中训练是以`batch`为单位迭代的，并没有涉及`epoch`的概念，但是PaddleSlim需要知道当前训练进行到第几个`epoch`, 所以需要将`max_iters`设置为一个`epoch`内的`batch`的数量。
+
+如果要调整训练卡数，需要调整配置文件`yolov3_mobilenet_v1_voc.yml`中的以下参数：
+
+- **max_iters:** 一个`epoch`中batch的数量，需要设置为`total_num / batch_size`, 其中`total_num`为训练样本总数量，`batch_size`为多卡上总的batch size.
+- **YoloTrainFeed.batch_size:** 当使用DataLoader时，表示单张卡上的batch size; 当使用普通reader时，则表示多卡上的总的`batch_size`。`batch_size`受限于显存大小。
+- **LeaningRate.base_lr:** 根据多卡的总`batch_size`调整`base_lr`，两者大小正相关，可以简单的按比例进行调整。
+- **LearningRate.schedulers.PiecewiseDecay.milestones：** 请根据batch size的变化对其调整。
+- **LearningRate.schedulers.PiecewiseDecay.LinearWarmup.steps：** 请根据batch size的变化对其进行调整。
+
+
+以下为4卡训练示例，通过命令行覆盖`yolov3_mobilenet_v1_voc.yml`中的参数：
+
+```
+python compress.py \
+ -s yolov3_mobilenet_v1_slim.yaml \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ -o max_iters=258 \
+ YoloTrainFeed.batch_size=64 \
+ -d "../../dataset/voc"
+```
+
+以下为2卡训练示例，受显存所制，单卡`batch_size`不变，总`batch_size`减小，`base_lr`减小，一个epoch内batch数量增加，同时需要调整学习率相关参数，如下：
+```
+python compress.py \
+ -s yolov3_mobilenet_v1_slim.yaml \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ -o max_iters=516 \
+ LeaningRate.base_lr=0.005 \
+ YoloTrainFeed.batch_size=32 \
+ LearningRate.schedulers='[!PiecewiseDecay {gamma: 0.1, milestones: [110000, 124000]}, !LinearWarmup {start_factor: 0., steps: 2000}]' \
+ -d "../../dataset/voc"
+```
+
+通过`python compress.py --help`查看可配置参数。
+通过`python ../../tools/configure.py ${option_name} help`查看如何通过命令行覆盖配置文件`yolov3_mobilenet_v1_voc.yml`中的参数。
+
+### 保存断点（checkpoint）
+
+如果在配置文件中设置了`checkpoint_path`, 则在压缩任务执行过程中会自动保存断点，当任务异常中断时，
+重启任务会自动从`checkpoint_path`路径下按数字顺序加载最新的checkpoint文件。如果不想让重启的任务从断点恢复，
+需要修改配置文件中的`checkpoint_path`，或者将`checkpoint_path`路径下文件清空。
+
+>注意：配置文件中的信息不会保存在断点中，重启前对配置文件的修改将会生效。
+
+
+## 评估
+
+如果在配置文件中设置了`checkpoint_path`，则每个epoch会保存一个压缩后的用于评估的模型，
+该模型会保存在`${checkpoint_path}/${epoch_id}/eval_model/`路径下，包含`__model__`和`__params__`两个文件。
+其中，`__model__`用于保存模型结构信息，`__params__`用于保存参数（parameters）信息。
+
+如果不需要保存评估模型，可以在定义Compressor对象时，将`save_eval_model`选项设置为False（默认为True）。
+
+运行命令为：
+```
+python ../eval.py \
+ --model_path ${checkpoint_path}/${epoch_id}/eval_model/ \
+ --model_name __model__ \
+ --params_name __params__ \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ -d "../../dataset/voc"
+```
+
+## 预测
+
+如果在配置文件中设置了`checkpoint_path`，并且在定义Compressor对象时指定了`prune_infer_model`选项，则每个epoch都会
+保存一个`inference model`。该模型是通过删除eval_program中多余的operators而得到的。
+
+该模型会保存在`${checkpoint_path}/${epoch_id}/eval_model/`路径下，包含`__model__.infer`和`__params__`两个文件。
+其中，`__model__.infer`用于保存模型结构信息，`__params__`用于保存参数（parameters）信息。
+
+更多关于`prune_infer_model`选项的介绍，请参考：[Compressor介绍](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md#121-%E5%A6%82%E4%BD%95%E6%94%B9%E5%86%99%E6%99%AE%E9%80%9A%E8%AE%AD%E7%BB%83%E8%84%9A%E6%9C%AC)
+
+### python预测
+
+在脚本PaddleDetection/tools/infer.py中展示了如何使用fluid python API加载使用预测模型进行预测。
+
+运行命令为：
+```
+python ../infer.py \
+ --model_path ${checkpoint_path}/${epoch_id}/eval_model/ \
+ --model_name __model__.infer \
+ --params_name __params__ \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ --infer_dir ../../demo
+```
+
+### PaddleLite
+
+该示例中产出的预测（inference）模型可以直接用PaddleLite进行加载使用。
+关于PaddleLite如何使用，请参考：[PaddleLite使用文档](https://github.com/PaddlePaddle/Paddle-Lite/wiki#%E4%BD%BF%E7%94%A8)
+
+## 示例结果
+
+> 当前release的结果并非超参调优后的最好结果，仅做示例参考，后续我们会优化当前结果。
+
+### MobileNetV1-YOLO-V3
+
+| FLOPS |Box AP| model_size |Paddle Fluid inference time(ms)| Paddle Lite inference time(ms)|
+|---|---|---|---|---|
+|baseline|76.2 |93M |- |-|
+|-50%|69.48 |51M |- |-|
+
+## FAQ
diff --git a/slim/prune/compress.py b/slim/prune/compress.py
new file mode 100644
index 0000000000000000000000000000000000000000..66f9a0cb50514bfbdf2964024064caf6702cfbc4
--- /dev/null
+++ b/slim/prune/compress.py
@@ -0,0 +1,255 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import time
+import multiprocessing
+import numpy as np
+import sys
+sys.path.append("../../")
+from paddle.fluid.contrib.slim import Compressor
+
+
+def set_paddle_flags(**kwargs):
+ for key, value in kwargs.items():
+ if os.environ.get(key, None) is None:
+ os.environ[key] = str(value)
+
+
+# NOTE(paddle-dev): All of these flags should be set before
+# `import paddle`. Otherwise, it would not take any effect.
+set_paddle_flags(
+ FLAGS_eager_delete_tensor_gb=0, # enable GC to save memory
+)
+
+from paddle import fluid
+from ppdet.core.workspace import load_config, merge_config, create
+from ppdet.data.data_feed import create_reader
+from ppdet.utils.eval_utils import parse_fetches, eval_results
+from ppdet.utils.cli import ArgsParser
+from ppdet.utils.check import check_gpu
+import ppdet.utils.checkpoint as checkpoint
+from ppdet.modeling.model_input import create_feed
+
+import logging
+FORMAT = '%(asctime)s-%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.INFO, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+
+def eval_run(exe, compile_program, reader, keys, values, cls, test_feed):
+ """
+ Run evaluation program, return program outputs.
+ """
+ iter_id = 0
+ results = []
+ if len(cls) != 0:
+ values = []
+ for i in range(len(cls)):
+ _, accum_map = cls[i].get_map_var()
+ cls[i].reset(exe)
+ values.append(accum_map)
+
+ images_num = 0
+ start_time = time.time()
+ has_bbox = 'bbox' in keys
+ for data in reader():
+ data = test_feed.feed(data)
+ feed_data = {'image': data['image'], 'im_size': data['im_size']}
+ outs = exe.run(compile_program,
+ feed=feed_data,
+ fetch_list=[values[0]],
+ return_numpy=False)
+ outs.append(data['gt_box'])
+ outs.append(data['gt_label'])
+ outs.append(data['is_difficult'])
+ res = {
+ k: (np.array(v), v.recursive_sequence_lengths())
+ for k, v in zip(keys, outs)
+ }
+ results.append(res)
+ if iter_id % 100 == 0:
+ logger.info('Test iter {}'.format(iter_id))
+ iter_id += 1
+ images_num += len(res['bbox'][1][0]) if has_bbox else 1
+ logger.info('Test finish iter {}'.format(iter_id))
+
+ end_time = time.time()
+ fps = images_num / (end_time - start_time)
+ if has_bbox:
+ logger.info('Total number of images: {}, inference time: {} fps.'.
+ format(images_num, fps))
+ else:
+ logger.info('Total iteration: {}, inference time: {} batch/s.'.format(
+ images_num, fps))
+
+ return results
+
+
+def main():
+ cfg = load_config(FLAGS.config)
+ if 'architecture' in cfg:
+ main_arch = cfg.architecture
+ else:
+ raise ValueError("'architecture' not specified in config file.")
+
+ merge_config(FLAGS.opt)
+ if 'log_iter' not in cfg:
+ cfg.log_iter = 20
+
+ # check if set use_gpu=True in paddlepaddle cpu version
+ check_gpu(cfg.use_gpu)
+
+ if cfg.use_gpu:
+ devices_num = fluid.core.get_cuda_device_count()
+ else:
+ devices_num = int(
+ os.environ.get('CPU_NUM', multiprocessing.cpu_count()))
+
+ if 'train_feed' not in cfg:
+ train_feed = create(main_arch + 'TrainFeed')
+ else:
+ train_feed = create(cfg.train_feed)
+
+ if 'eval_feed' not in cfg:
+ eval_feed = create(main_arch + 'EvalFeed')
+ else:
+ eval_feed = create(cfg.eval_feed)
+
+ place = fluid.CUDAPlace(0) if cfg.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ lr_builder = create('LearningRate')
+ optim_builder = create('OptimizerBuilder')
+
+ # build program
+ startup_prog = fluid.Program()
+ train_prog = fluid.Program()
+ with fluid.program_guard(train_prog, startup_prog):
+ with fluid.unique_name.guard():
+ model = create(main_arch)
+ _, feed_vars = create_feed(train_feed, False)
+ train_fetches = model.train(feed_vars)
+ loss = train_fetches['loss']
+ lr = lr_builder()
+ optimizer = optim_builder(lr)
+ optimizer.minimize(loss)
+
+ train_reader = create_reader(train_feed, cfg.max_iters, FLAGS.dataset_dir)
+
+ # parse train fetches
+ train_keys, train_values, _ = parse_fetches(train_fetches)
+ train_keys.append("lr")
+ train_values.append(lr.name)
+
+ train_fetch_list = []
+ for k, v in zip(train_keys, train_values):
+ train_fetch_list.append((k, v))
+
+ eval_prog = fluid.Program()
+ with fluid.program_guard(eval_prog, startup_prog):
+ with fluid.unique_name.guard():
+ model = create(main_arch)
+ _, test_feed_vars = create_feed(eval_feed, False)
+ fetches = model.eval(test_feed_vars)
+
+ eval_prog = eval_prog.clone(True)
+
+ eval_reader = create_reader(eval_feed, args_path=FLAGS.dataset_dir)
+ test_data_feed = fluid.DataFeeder(test_feed_vars.values(), place)
+
+ # parse eval fetches
+ extra_keys = []
+ if cfg.metric == 'COCO':
+ extra_keys = ['im_info', 'im_id', 'im_shape']
+ if cfg.metric == 'VOC':
+ extra_keys = ['gt_box', 'gt_label', 'is_difficult']
+ eval_keys, eval_values, eval_cls = parse_fetches(fetches, eval_prog,
+ extra_keys)
+ eval_fetch_list = []
+ for k, v in zip(eval_keys, eval_values):
+ eval_fetch_list.append((k, v))
+
+ exe.run(startup_prog)
+ checkpoint.load_params(exe, train_prog, cfg.pretrain_weights)
+
+ best_box_ap_list = []
+
+ def eval_func(program, scope):
+
+ #place = fluid.CPUPlace()
+ #exe = fluid.Executor(place)
+ results = eval_run(exe, program, eval_reader, eval_keys, eval_values,
+ eval_cls, test_data_feed)
+
+ resolution = None
+ if 'mask' in results[0]:
+ resolution = model.mask_head.resolution
+ box_ap_stats = eval_results(results, eval_feed, cfg.metric,
+ cfg.num_classes, resolution, False,
+ FLAGS.output_eval)
+ if len(best_box_ap_list) == 0:
+ best_box_ap_list.append(box_ap_stats[0])
+ elif box_ap_stats[0] > best_box_ap_list[0]:
+ best_box_ap_list[0] = box_ap_stats[0]
+ logger.info("Best test box ap: {}".format(best_box_ap_list[0]))
+ return best_box_ap_list[0]
+
+ test_feed = [('image', test_feed_vars['image'].name),
+ ('im_size', test_feed_vars['im_size'].name)]
+
+ com = Compressor(
+ place,
+ fluid.global_scope(),
+ train_prog,
+ train_reader=train_reader,
+ train_feed_list=[(key, value.name) for key, value in feed_vars.items()],
+ train_fetch_list=train_fetch_list,
+ eval_program=eval_prog,
+ eval_reader=eval_reader,
+ eval_feed_list=test_feed,
+ eval_func={'map': eval_func},
+ eval_fetch_list=[eval_fetch_list[0]],
+ save_eval_model=True,
+ prune_infer_model=[["image", "im_size"], ["multiclass_nms_0.tmp_0"]],
+ train_optimizer=None)
+ com.config(FLAGS.slim_file)
+ com.run()
+
+
+if __name__ == '__main__':
+ parser = ArgsParser()
+ parser.add_argument(
+ "-s",
+ "--slim_file",
+ default=None,
+ type=str,
+ help="Config file of PaddleSlim.")
+ parser.add_argument(
+ "--output_eval",
+ default=None,
+ type=str,
+ help="Evaluation directory, default is current directory.")
+ parser.add_argument(
+ "-d",
+ "--dataset_dir",
+ default=None,
+ type=str,
+ help="Dataset path, same as DataFeed.dataset.dataset_dir")
+ FLAGS = parser.parse_args()
+ main()
diff --git a/slim/prune/images/MobileNetV1-YoloV3.pdf b/slim/prune/images/MobileNetV1-YoloV3.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..f5d3a22db5030ffc6beb1e7f8c92bddd61e366e6
Binary files /dev/null and b/slim/prune/images/MobileNetV1-YoloV3.pdf differ
diff --git a/slim/prune/yolov3_mobilenet_v1_slim.yaml b/slim/prune/yolov3_mobilenet_v1_slim.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..ff9859eafe5872dee13f33a3703502e334d1c85e
--- /dev/null
+++ b/slim/prune/yolov3_mobilenet_v1_slim.yaml
@@ -0,0 +1,23 @@
+version: 1.0
+pruners:
+ pruner_1:
+ class: 'StructurePruner'
+ pruning_axis:
+ '*': 0
+ criterions:
+ '*': 'l1_norm'
+strategies:
+ uniform_pruning_strategy:
+ class: 'UniformPruneStrategy'
+ pruner: 'pruner_1'
+ start_epoch: 0
+ target_ratio: 0.5
+ pruned_params: '(conv2_1_sep_weights)|(conv2_2_sep_weights)|(conv3_1_sep_weights)|(conv4_1_sep_weights)|(conv5_1_sep_weights)|(conv5_2_sep_weights)|(conv5_3_sep_weights)|(conv5_4_sep_weights)|(conv5_5_sep_weights)|(conv5_6_sep_weights)|(yolo_block.0.0.0.conv.weights)|(yolo_block.0.0.1.conv.weights)|(yolo_block.0.1.0.conv.weights)|(yolo_block.0.1.1.conv.weights)|(yolo_block.1.0.0.conv.weights)|(yolo_block.1.0.1.conv.weights)|(yolo_block.1.1.0.conv.weights)|(yolo_block.1.1.1.conv.weights)|(yolo_block.1.2.conv.weights)|(yolo_block.2.0.0.conv.weights)|(yolo_block.2.0.1.conv.weights)|(yolo_block.2.1.1.conv.weights)|(yolo_block.2.2.conv.weights)|(yolo_block.2.tip.conv.weights)'
+ metric_name: 'acc_top1'
+compressor:
+ epoch: 271
+ eval_epoch: 10
+ #init_model: './checkpoints/0' # Please enable this option for loading checkpoint.
+ checkpoint_path: './checkpoints/'
+ strategies:
+ - uniform_pruning_strategy
diff --git a/slim/quantization/README.md b/slim/quantization/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..acb4c9efcbd49bccc4682c7eb7af294885e5d42a
--- /dev/null
+++ b/slim/quantization/README.md
@@ -0,0 +1,241 @@
+>运行该示例前请安装Paddle1.6或更高版本
+
+# 检测模型量化压缩示例
+
+## 概述
+
+该示例使用PaddleSlim提供的[量化压缩策略](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/tutorial.md#1-quantization-aware-training%E9%87%8F%E5%8C%96%E4%BB%8B%E7%BB%8D)对分类模型进行压缩。
+在阅读该示例前，建议您先了解以下内容：
+
+- [检测模型的常规训练方法](https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/PaddleDetection)
+- [PaddleSlim使用文档](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md)
+
+
+## 配置文件说明
+
+关于配置文件如何编写您可以参考：
+
+- [PaddleSlim配置文件编写说明](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md#122-%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6%E7%9A%84%E4%BD%BF%E7%94%A8)
+- [量化策略配置文件编写说明](https://github.com/PaddlePaddle/models/blob/develop/PaddleSlim/docs/usage.md#21-%E9%87%8F%E5%8C%96%E8%AE%AD%E7%BB%83)
+
+其中save_out_nodes需要得到检测结果的Variable的名称，下面介绍如何确定save_out_nodes的参数
+以MobileNet V1为例，可在compress.py中构建好网络之后，直接打印Variable得到Variable的名称信息。
+代码示例：
+```
+ eval_keys, eval_values, eval_cls = parse_fetches(fetches, eval_prog,
+ extra_keys)
+ # print(eval_values)
+```
+根据运行结果可看到Variable的名字为：`multiclass_nms_0.tmp_0`。
+## 训练
+
+根据 [PaddleCV/PaddleDetection/tools/train.py](https://github.com/PaddlePaddle/models/blob/develop/PaddleCV/PaddleDetection/tools/train.py) 编写压缩脚本compress.py。
+在该脚本中定义了Compressor对象，用于执行压缩任务。
+
+通过`python compress.py --help`查看可配置参数，简述如下：
+
+- config: 检测库的配置，其中配置了训练超参数、数据集信息等。
+- slim_file: PaddleSlim的配置文件，参见[配置文件说明](#配置文件说明)。
+
+您可以通过运行以下命令运行该示例。
+
+step1: 设置gpu卡
+```
+export CUDA_VISIBLE_DEVICES=0
+```
+step2: 开始训练
+使用PaddleDetection提供的配置文件在用8卡进行训练：
+
+```
+python compress.py \
+ -s yolov3_mobilenet_v1_slim.yaml \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ -d "../../dataset/voc" \
+ -o max_iters=258 \
+ LearningRate.base_lr=0.0001 \
+ LearningRate.schedulers="[!PiecewiseDecay {gamma: 0.1, milestones: [258, 516]}]" \
+ pretrain_weights=https://paddlemodels.bj.bcebos.com/object_detection/yolov3_mobilenet_v1_voc.tar \
+ YoloTrainFeed.batch_size=64
+```
+
+>通过命令行覆盖设置max_iters选项，因为PaddleDetection中训练是以`batch`为单位迭代的，并没有涉及`epoch`的概念，但是PaddleSlim需要知道当前训练进行到第几个`epoch`, 所以需要将`max_iters`设置为一个`epoch`内的`batch`的数量。
+
+如果要调整训练卡数，需要调整配置文件`yolov3_mobilenet_v1_voc.yml`中的以下参数：
+
+- **max_iters:** 一个`epoch`中batch的数量，需要设置为`total_num / batch_size`, 其中`total_num`为训练样本总数量，`batch_size`为多卡上总的batch size.
+- **YoloTrainFeed.batch_size:** 当使用DataLoader时，表示单张卡上的batch size; 当使用普通reader时，则表示多卡上的总的batch_size。batch_size受限于显存大小。
+- **LeaningRate.base_lr:** 根据多卡的总`batch_size`调整`base_lr`，两者大小正相关，可以简单的按比例进行调整。
+- **LearningRate.schedulers.PiecewiseDecay.milestones：** 请根据batch size的变化对其调整。
+- **LearningRate.schedulers.PiecewiseDecay.LinearWarmup.steps：** 请根据batch size的变化对其进行调整。
+
+
+以下为4卡训练示例，通过命令行覆盖`yolov3_mobilenet_v1_voc.yml`中的参数：
+
+```
+python compress.py \
+ -s yolov3_mobilenet_v1_slim.yaml \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ -d "../../dataset/voc" \
+ -o max_iters=258 \
+ LearningRate.base_lr=0.0001 \
+ LearningRate.schedulers="[!PiecewiseDecay {gamma: 0.1, milestones: [258, 516]}]" \
+ pretrain_weights=https://paddlemodels.bj.bcebos.com/object_detection/yolov3_mobilenet_v1_voc.tar \
+ YoloTrainFeed.batch_size=64
+
+```
+
+以下为2卡训练示例，受显存所制，单卡`batch_size`不变, 总`batch_size`减小，`base_lr`减小，一个epoch内batch数量增加，同时需要调整学习率相关参数，如下：
+
+```
+python compress.py \
+ -s yolov3_mobilenet_v1_slim.yaml \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ -d "../../dataset/voc" \
+ -o max_iters=516 \
+ LearningRate.base_lr=0.00005 \
+ LearningRate.schedulers="[!PiecewiseDecay {gamma: 0.1, milestones: [516, 1012]}]" \
+ pretrain_weights=https://paddlemodels.bj.bcebos.com/object_detection/yolov3_mobilenet_v1_voc.tar \
+ YoloTrainFeed.batch_size=32
+```
+
+通过`python compress.py --help`查看可配置参数。
+通过`python ../../tools/configure.py ${option_name} help`查看如何通过命令行覆盖配置文件`yolov3_mobilenet_v1_voc.yml`中的参数。
+
+
+
+### 训练时的模型结构
+这部分介绍来源于[量化low-level API介绍](https://github.com/PaddlePaddle/models/tree/develop/PaddleSlim/quant_low_level_api#1-%E9%87%8F%E5%8C%96%E8%AE%AD%E7%BB%83low-level-apis%E4%BB%8B%E7%BB%8D)。
+
+PaddlePaddle框架中和量化相关的IrPass, 分别有QuantizationTransformPass、QuantizationFreezePass、ConvertToInt8Pass。在训练时，对网络应用了QuantizationTransformPass，作用是在网络中的conv2d、depthwise_conv2d、mul等算子的各个输入前插入连续的量化op和反量化op，并改变相应反向算子的某些输入。示例图如下：
+
+
+
+图1：应用QuantizationTransformPass后的结果
+
+
+### 保存断点（checkpoint）
+
+如果在配置文件中设置了`checkpoint_path`, 则在压缩任务执行过程中会自动保存断点，当任务异常中断时，
+重启任务会自动从`checkpoint_path`路径下按数字顺序加载最新的checkpoint文件。如果不想让重启的任务从断点恢复，
+需要修改配置文件中的`checkpoint_path`，或者将`checkpoint_path`路径下文件清空。
+
+>注意：配置文件中的信息不会保存在断点中，重启前对配置文件的修改将会生效。
+
+
+### 保存评估和预测模型
+
+如果在配置文件的量化策略中设置了`float_model_save_path`, `int8_model_save_path` 在训练结束后，会保存模型量化压缩之后用于预测的模型。接下来介绍这2种预测模型的区别。
+
+#### FP32模型
+在介绍量化训练时的模型结构时介绍了PaddlePaddle框架中和量化相关的IrPass, 分别是QuantizationTransformPass、QuantizationFreezePass、ConvertToInt8Pass。FP32模型是在应用QuantizationFreezePass并删除eval_program中多余的operators之后，保存的模型。
+
+QuantizationFreezePass主要用于改变IrGraph中量化op和反量化op的顺序，即将类似图1中的量化op和反量化op顺序改变为图2中的布局。除此之外，QuantizationFreezePass还会将`conv2d`、`depthwise_conv2d`、`mul`等算子的权重离线量化为int8_t范围内的值(但数据类型仍为float32)，以减少预测过程中对权重的量化操作，示例如图2：
+
+
+
+图2：应用QuantizationFreezePass后的结果
+
+
+#### 8-bit模型
+在对训练网络进行QuantizationFreezePass之后，执行ConvertToInt8Pass，
+其主要目的是将执行完QuantizationFreezePass后输出的权重类型由`FP32`更改为`INT8`。换言之，用户可以选择将量化后的权重保存为float32类型（不执行ConvertToInt8Pass）或者int8_t类型（执行ConvertToInt8Pass），示例如图3：
+
+
+
+图3：应用ConvertToInt8Pass后的结果
+
+
+> 综上，可得在量化过程中有以下几种模型结构：
+
+1. 原始模型
+2. 经QuantizationTransformPass之后得到的适用于训练的量化模型结构，在${checkpoint_path}下保存的`eval_model`是这种结构，在训练过程中每个epoch结束时也使用这个网络结构进行评估，虽然这个模型结构不是最终想要的模型结构，但是每个epoch的评估结果可用来挑选模型。
+3. 经QuantizationFreezePass之后得到的FP32模型结构，具体结构已在上面进行介绍。本文档中列出的数据集的评估结果是对FP32模型结构进行评估得到的结果。这种模型结构在训练过程中只会保存一次，也就是在量化配置文件中设置的`end_epoch`结束时进行保存，如果想将其他epoch的训练结果转化成FP32模型，可使用脚本 PaddleSlim/classification/quantization/freeze.py进行转化，具体使用方法在[评估](#评估)中介绍。
+4. 经ConvertToInt8Pass之后得到的8-bit模型结构，具体结构已在上面进行介绍。这种模型结构在训练过程中只会保存一次，也就是在量化配置文件中设置的`end_epoch`结束时进行保存，如果想将其他epoch的训练结果转化成8-bit模型，可使用脚本 slim/quantization/freeze.py进行转化，具体使用方法在[评估](#评估)中介绍。
+
+
+## 评估
+
+### 每个epoch保存的评估模型
+因为量化的最终模型只有在end_epoch时保存一次，不能保证保存的模型是最好的，因此
+如果在配置文件中设置了`checkpoint_path`，则每个epoch会保存一个量化后的用于评估的模型，
+该模型会保存在`${checkpoint_path}/${epoch_id}/eval_model/`路径下，包含`__model__`和`__params__`两个文件。
+其中，`__model__`用于保存模型结构信息，`__params__`用于保存参数（parameters）信息。模型结构和训练时一样。
+
+如果不需要保存评估模型，可以在定义Compressor对象时，将`save_eval_model`选项设置为False（默认为True）。
+
+脚本slim/eval.py中为使用该模型在评估数据集上做评估的示例。
+运行命令为：
+```
+python ../eval.py \
+ --model_path ${checkpoint_path}/${epoch_id}/eval_model/ \
+ --model_name __model__ \
+ --params_name __params__ \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ -d "../../dataset/voc"
+```
+
+在评估之后，选取效果最好的epoch的模型，可使用脚本 slim/quantization/freeze.py将该模型转化为以上介绍的2种模型：FP32模型，int8模型，需要配置的参数为：
+
+- model_path, 加载的模型路径，`为${checkpoint_path}/${epoch_id}/eval_model/`
+- weight_quant_type 模型参数的量化方式，和配置文件中的类型保持一致
+- save_path `FP32`, `8-bit` 模型的保存路径，分别为 `${save_path}/float/`, `${save_path}/int8/`
+
+运行命令示例：
+```
+python freeze.py \
+ --model_path ${checkpoint_path}/${epoch_id}/eval_model/ \
+ --weight_quant_type ${weight_quant_type} \
+ --save_path ${any path you want} \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ -d "../../dataset/voc"
+```
+
+### 最终评估模型
+最终使用的评估模型是FP32模型，使用脚本slim/eval.py中为使用该模型在评估数据集上做评估的示例。
+运行命令为：
+```
+python ../eval.py \
+ --model_path ${float_model_path}
+ --model_name model \
+ --params_name weights \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ -d "../../dataset/voc"
+```
+
+## 预测
+
+### python预测
+FP32模型可直接使用原生PaddlePaddle Fluid预测方法进行预测。
+
+在脚本slim/infer.py中展示了如何使用fluid python API加载使用预测模型进行预测。
+
+运行命令示例:
+```
+python ../infer.py \
+ --model_path ${save_path}/float \
+ --model_name model \
+ --params_name weights \
+ -c ../../configs/yolov3_mobilenet_v1_voc.yml \
+ --infer_dir ../../demo
+```
+
+
+### PaddleLite预测
+FP32模型可使用PaddleLite进行加载预测，可参见教程[Paddle-Lite如何加载运行量化模型](https://github.com/PaddlePaddle/Paddle-Lite/wiki/model_quantization)
+
+
+## 示例结果
+
+>当前release的结果并非超参调优后的最好结果，仅做示例参考，后续我们会优化当前结果。
+
+### MobileNetV1-YOLO-V3
+
+| weight量化方式 | activation量化方式| Box ap |Paddle Fluid inference time(ms)| Paddle Lite inference time(ms)|
+|---|---|---|---|---|
+|baseline|- |76.2%|- |-|
+|abs_max|abs_max|- |- |-|
+|abs_max|moving_average_abs_max|- |- |-|
+|channel_wise_abs_max|abs_max|- |- |-|
+
+
+## FAQ
diff --git a/slim/quantization/compress.py b/slim/quantization/compress.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4a5553cf46eabcd25f7cc1ce6c50fccefd2e5df
--- /dev/null
+++ b/slim/quantization/compress.py
@@ -0,0 +1,267 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import time
+import multiprocessing
+import numpy as np
+import datetime
+from collections import deque
+import sys
+sys.path.append("../../")
+from paddle.fluid.contrib.slim import Compressor
+from paddle.fluid.framework import IrGraph
+from paddle.fluid import core
+
+
+def set_paddle_flags(**kwargs):
+ for key, value in kwargs.items():
+ if os.environ.get(key, None) is None:
+ os.environ[key] = str(value)
+
+
+# NOTE(paddle-dev): All of these flags should be set before
+# `import paddle`. Otherwise, it would not take any effect.
+set_paddle_flags(
+ FLAGS_eager_delete_tensor_gb=0, # enable GC to save memory
+)
+
+from paddle import fluid
+
+from ppdet.core.workspace import load_config, merge_config, create
+from ppdet.data.data_feed import create_reader
+
+from ppdet.utils.eval_utils import parse_fetches, eval_results
+from ppdet.utils.stats import TrainingStats
+from ppdet.utils.cli import ArgsParser, print_total_cfg
+from ppdet.utils.check import check_gpu, check_version
+import ppdet.utils.checkpoint as checkpoint
+from ppdet.modeling.model_input import create_feed
+
+import logging
+FORMAT = '%(asctime)s-%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.INFO, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+
+def eval_run(exe, compile_program, reader, keys, values, cls, test_feed):
+ """
+ Run evaluation program, return program outputs.
+ """
+ iter_id = 0
+ results = []
+ if len(cls) != 0:
+ values = []
+ for i in range(len(cls)):
+ _, accum_map = cls[i].get_map_var()
+ cls[i].reset(exe)
+ values.append(accum_map)
+
+ images_num = 0
+ start_time = time.time()
+ has_bbox = 'bbox' in keys
+ for data in reader():
+ data = test_feed.feed(data)
+ feed_data = {'image': data['image'], 'im_size': data['im_size']}
+ outs = exe.run(compile_program,
+ feed=feed_data,
+ fetch_list=[values[0]],
+ return_numpy=False)
+ outs.append(data['gt_box'])
+ outs.append(data['gt_label'])
+ outs.append(data['is_difficult'])
+ res = {
+ k: (np.array(v), v.recursive_sequence_lengths())
+ for k, v in zip(keys, outs)
+ }
+ results.append(res)
+ if iter_id % 100 == 0:
+ logger.info('Test iter {}'.format(iter_id))
+ iter_id += 1
+ images_num += len(res['bbox'][1][0]) if has_bbox else 1
+ logger.info('Test finish iter {}'.format(iter_id))
+
+ end_time = time.time()
+ fps = images_num / (end_time - start_time)
+ if has_bbox:
+ logger.info('Total number of images: {}, inference time: {} fps.'.
+ format(images_num, fps))
+ else:
+ logger.info('Total iteration: {}, inference time: {} batch/s.'.format(
+ images_num, fps))
+
+ return results
+
+
+def main():
+ cfg = load_config(FLAGS.config)
+ if 'architecture' in cfg:
+ main_arch = cfg.architecture
+ else:
+ raise ValueError("'architecture' not specified in config file.")
+
+ merge_config(FLAGS.opt)
+ if 'log_iter' not in cfg:
+ cfg.log_iter = 20
+
+ # check if set use_gpu=True in paddlepaddle cpu version
+ check_gpu(cfg.use_gpu)
+ # print_total_cfg(cfg)
+ #check_version()
+ if cfg.use_gpu:
+ devices_num = fluid.core.get_cuda_device_count()
+ else:
+ devices_num = int(
+ os.environ.get('CPU_NUM', multiprocessing.cpu_count()))
+
+ if 'train_feed' not in cfg:
+ train_feed = create(main_arch + 'TrainFeed')
+ else:
+ train_feed = create(cfg.train_feed)
+
+ if 'eval_feed' not in cfg:
+ eval_feed = create(main_arch + 'EvalFeed')
+ else:
+ eval_feed = create(cfg.eval_feed)
+
+ place = fluid.CUDAPlace(0) if cfg.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ lr_builder = create('LearningRate')
+ optim_builder = create('OptimizerBuilder')
+
+ # build program
+ startup_prog = fluid.Program()
+ train_prog = fluid.Program()
+ with fluid.program_guard(train_prog, startup_prog):
+ with fluid.unique_name.guard():
+ model = create(main_arch)
+ _, feed_vars = create_feed(train_feed, False)
+ train_fetches = model.train(feed_vars)
+ loss = train_fetches['loss']
+ lr = lr_builder()
+ optimizer = optim_builder(lr)
+ optimizer.minimize(loss)
+
+ train_reader = create_reader(train_feed, cfg.max_iters, FLAGS.dataset_dir)
+
+ # parse train fetches
+ train_keys, train_values, _ = parse_fetches(train_fetches)
+ train_values.append(lr)
+
+ train_fetch_list = []
+ for k, v in zip(train_keys, train_values):
+ train_fetch_list.append((k, v))
+ print("train_fetch_list: {}".format(train_fetch_list))
+
+ eval_prog = fluid.Program()
+ with fluid.program_guard(eval_prog, startup_prog):
+ with fluid.unique_name.guard():
+ model = create(main_arch)
+ _, test_feed_vars = create_feed(eval_feed, False)
+ fetches = model.eval(test_feed_vars)
+ eval_prog = eval_prog.clone(True)
+
+ eval_reader = create_reader(eval_feed, args_path=FLAGS.dataset_dir)
+ #eval_pyreader.decorate_sample_list_generator(eval_reader, place)
+ test_data_feed = fluid.DataFeeder(test_feed_vars.values(), place)
+
+ # parse eval fetches
+ extra_keys = []
+ if cfg.metric == 'COCO':
+ extra_keys = ['im_info', 'im_id', 'im_shape']
+ if cfg.metric == 'VOC':
+ extra_keys = ['gt_box', 'gt_label', 'is_difficult']
+ eval_keys, eval_values, eval_cls = parse_fetches(fetches, eval_prog,
+ extra_keys)
+ # print(eval_values)
+
+ eval_fetch_list = []
+ for k, v in zip(eval_keys, eval_values):
+ eval_fetch_list.append((k, v))
+
+ exe.run(startup_prog)
+
+ start_iter = 0
+
+ checkpoint.load_params(exe, train_prog, cfg.pretrain_weights)
+
+ best_box_ap_list = []
+
+ def eval_func(program, scope):
+
+ #place = fluid.CPUPlace()
+ #exe = fluid.Executor(place)
+ results = eval_run(exe, program, eval_reader, eval_keys, eval_values,
+ eval_cls, test_data_feed)
+
+ resolution = None
+ if 'mask' in results[0]:
+ resolution = model.mask_head.resolution
+ box_ap_stats = eval_results(results, eval_feed, cfg.metric,
+ cfg.num_classes, resolution, False,
+ FLAGS.output_eval)
+ if len(best_box_ap_list) == 0:
+ best_box_ap_list.append(box_ap_stats[0])
+ elif box_ap_stats[0] > best_box_ap_list[0]:
+ best_box_ap_list[0] = box_ap_stats[0]
+ logger.info("Best test box ap: {}".format(best_box_ap_list[0]))
+ return best_box_ap_list[0]
+
+ test_feed = [('image', test_feed_vars['image'].name),
+ ('im_size', test_feed_vars['im_size'].name)]
+
+ com = Compressor(
+ place,
+ fluid.global_scope(),
+ train_prog,
+ train_reader=train_reader,
+ train_feed_list=[(key, value.name) for key, value in feed_vars.items()],
+ train_fetch_list=train_fetch_list,
+ eval_program=eval_prog,
+ eval_reader=eval_reader,
+ eval_feed_list=test_feed,
+ eval_func={'map': eval_func},
+ eval_fetch_list=[eval_fetch_list[0]],
+ prune_infer_model=[["image", "im_size"], ["multiclass_nms_0.tmp_0"]],
+ train_optimizer=None)
+ com.config(FLAGS.slim_file)
+ com.run()
+
+
+if __name__ == '__main__':
+ parser = ArgsParser()
+ parser.add_argument(
+ "-s",
+ "--slim_file",
+ default=None,
+ type=str,
+ help="Config file of PaddleSlim.")
+ parser.add_argument(
+ "--output_eval",
+ default=None,
+ type=str,
+ help="Evaluation directory, default is current directory.")
+ parser.add_argument(
+ "-d",
+ "--dataset_dir",
+ default=None,
+ type=str,
+ help="Dataset path, same as DataFeed.dataset.dataset_dir")
+ FLAGS = parser.parse_args()
+ main()
diff --git a/slim/quantization/freeze.py b/slim/quantization/freeze.py
new file mode 100644
index 0000000000000000000000000000000000000000..38c06578e3d22e1cc4f2bdcc933298553c1c1f37
--- /dev/null
+++ b/slim/quantization/freeze.py
@@ -0,0 +1,239 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import time
+import multiprocessing
+import numpy as np
+import datetime
+from collections import deque
+import sys
+sys.path.append("../../")
+from paddle.fluid.contrib.slim import Compressor
+from paddle.fluid.framework import IrGraph
+from paddle.fluid import core
+from paddle.fluid.contrib.slim.quantization import QuantizationTransformPass
+from paddle.fluid.contrib.slim.quantization import QuantizationFreezePass
+from paddle.fluid.contrib.slim.quantization import ConvertToInt8Pass
+from paddle.fluid.contrib.slim.quantization import TransformForMobilePass
+
+
+def set_paddle_flags(**kwargs):
+ for key, value in kwargs.items():
+ if os.environ.get(key, None) is None:
+ os.environ[key] = str(value)
+
+
+# NOTE(paddle-dev): All of these flags should be set before
+# `import paddle`. Otherwise, it would not take any effect.
+set_paddle_flags(
+ FLAGS_eager_delete_tensor_gb=0, # enable GC to save memory
+)
+
+from paddle import fluid
+
+from ppdet.core.workspace import load_config, merge_config, create
+from ppdet.data.data_feed import create_reader
+
+from ppdet.utils.eval_utils import parse_fetches, eval_results
+from ppdet.utils.stats import TrainingStats
+from ppdet.utils.cli import ArgsParser
+from ppdet.utils.check import check_gpu
+import ppdet.utils.checkpoint as checkpoint
+from ppdet.modeling.model_input import create_feed
+
+import logging
+FORMAT = '%(asctime)s-%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.INFO, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+
+def eval_run(exe, compile_program, reader, keys, values, cls, test_feed):
+ """
+ Run evaluation program, return program outputs.
+ """
+ iter_id = 0
+ results = []
+
+ images_num = 0
+ start_time = time.time()
+ has_bbox = 'bbox' in keys
+ for data in reader():
+ data = test_feed.feed(data)
+ feed_data = {'image': data['image'], 'im_size': data['im_size']}
+ outs = exe.run(compile_program,
+ feed=feed_data,
+ fetch_list=values[0],
+ return_numpy=False)
+ outs.append(data['gt_box'])
+ outs.append(data['gt_label'])
+ outs.append(data['is_difficult'])
+ res = {
+ k: (np.array(v), v.recursive_sequence_lengths())
+ for k, v in zip(keys, outs)
+ }
+ results.append(res)
+ if iter_id % 100 == 0:
+ logger.info('Test iter {}'.format(iter_id))
+ iter_id += 1
+ images_num += len(res['bbox'][1][0]) if has_bbox else 1
+ logger.info('Test finish iter {}'.format(iter_id))
+
+ end_time = time.time()
+ fps = images_num / (end_time - start_time)
+ if has_bbox:
+ logger.info('Total number of images: {}, inference time: {} fps.'.
+ format(images_num, fps))
+ else:
+ logger.info('Total iteration: {}, inference time: {} batch/s.'.format(
+ images_num, fps))
+
+ return results
+
+
+def main():
+ cfg = load_config(FLAGS.config)
+ if 'architecture' in cfg:
+ main_arch = cfg.architecture
+ else:
+ raise ValueError("'architecture' not specified in config file.")
+
+ merge_config(FLAGS.opt)
+ if 'log_iter' not in cfg:
+ cfg.log_iter = 20
+
+ # check if set use_gpu=True in paddlepaddle cpu version
+ check_gpu(cfg.use_gpu)
+
+ if cfg.use_gpu:
+ devices_num = fluid.core.get_cuda_device_count()
+ else:
+ devices_num = int(
+ os.environ.get('CPU_NUM', multiprocessing.cpu_count()))
+
+ if 'eval_feed' not in cfg:
+ eval_feed = create(main_arch + 'EvalFeed')
+ else:
+ eval_feed = create(cfg.eval_feed)
+
+ place = fluid.CUDAPlace(0) if cfg.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ _, test_feed_vars = create_feed(eval_feed, False)
+
+ eval_reader = create_reader(eval_feed, args_path=FLAGS.dataset_dir)
+ #eval_pyreader.decorate_sample_list_generator(eval_reader, place)
+ test_data_feed = fluid.DataFeeder(test_feed_vars.values(), place)
+
+ assert os.path.exists(FLAGS.model_path)
+ infer_prog, feed_names, fetch_targets = fluid.io.load_inference_model(
+ dirname=FLAGS.model_path,
+ executor=exe,
+ model_filename='__model__.infer',
+ params_filename='__params__')
+
+ eval_keys = ['bbox', 'gt_box', 'gt_label', 'is_difficult']
+ eval_values = [
+ 'multiclass_nms_0.tmp_0', 'gt_box', 'gt_label', 'is_difficult'
+ ]
+ eval_cls = []
+ eval_values[0] = fetch_targets[0]
+
+ results = eval_run(exe, infer_prog, eval_reader, eval_keys, eval_values,
+ eval_cls, test_data_feed)
+
+ resolution = None
+ if 'mask' in results[0]:
+ resolution = model.mask_head.resolution
+ box_ap_stats = eval_results(results, eval_feed, cfg.metric, cfg.num_classes,
+ resolution, False, FLAGS.output_eval)
+
+ logger.info("freeze the graph for inference")
+ test_graph = IrGraph(core.Graph(infer_prog.desc), for_test=True)
+
+ freeze_pass = QuantizationFreezePass(
+ scope=fluid.global_scope(),
+ place=place,
+ weight_quantize_type=FLAGS.weight_quant_type)
+ freeze_pass.apply(test_graph)
+ server_program = test_graph.to_program()
+ fluid.io.save_inference_model(
+ dirname=os.path.join(FLAGS.save_path, 'float'),
+ feeded_var_names=feed_names,
+ target_vars=fetch_targets,
+ executor=exe,
+ main_program=server_program,
+ model_filename='model',
+ params_filename='weights')
+
+ logger.info("convert the weights into int8 type")
+ convert_int8_pass = ConvertToInt8Pass(
+ scope=fluid.global_scope(), place=place)
+ convert_int8_pass.apply(test_graph)
+ server_int8_program = test_graph.to_program()
+ fluid.io.save_inference_model(
+ dirname=os.path.join(FLAGS.save_path, 'int8'),
+ feeded_var_names=feed_names,
+ target_vars=fetch_targets,
+ executor=exe,
+ main_program=server_int8_program,
+ model_filename='model',
+ params_filename='weights')
+
+ logger.info("convert the freezed pass to paddle-lite execution")
+ mobile_pass = TransformForMobilePass()
+ mobile_pass.apply(test_graph)
+ mobile_program = test_graph.to_program()
+ fluid.io.save_inference_model(
+ dirname=os.path.join(FLAGS.save_path, 'mobile'),
+ feeded_var_names=feed_names,
+ target_vars=fetch_targets,
+ executor=exe,
+ main_program=mobile_program,
+ model_filename='model',
+ params_filename='weights')
+
+
+if __name__ == '__main__':
+ parser = ArgsParser()
+ parser.add_argument(
+ "-m", "--model_path", default=None, type=str, help="path of checkpoint")
+ parser.add_argument(
+ "--output_eval",
+ default=None,
+ type=str,
+ help="Evaluation directory, default is current directory.")
+ parser.add_argument(
+ "-d",
+ "--dataset_dir",
+ default=None,
+ type=str,
+ help="Dataset path, same as DataFeed.dataset.dataset_dir")
+ parser.add_argument(
+ "--weight_quant_type",
+ default='abs_max',
+ type=str,
+ help="quantization type for weight")
+ parser.add_argument(
+ "--save_path",
+ default='./output',
+ type=str,
+ help="path to save quantization inference model")
+
+ FLAGS = parser.parse_args()
+ main()
diff --git a/slim/quantization/images/ConvertToInt8Pass.png b/slim/quantization/images/ConvertToInt8Pass.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b5849819c0bc8e592dc8f864d8945330df85ab1
Binary files /dev/null and b/slim/quantization/images/ConvertToInt8Pass.png differ
diff --git a/slim/quantization/images/FreezePass.png b/slim/quantization/images/FreezePass.png
new file mode 100644
index 0000000000000000000000000000000000000000..acd2b0a890a8af85bec6eecdb22e47ad386a178c
Binary files /dev/null and b/slim/quantization/images/FreezePass.png differ
diff --git a/slim/quantization/images/TransformForMobilePass.png b/slim/quantization/images/TransformForMobilePass.png
new file mode 100644
index 0000000000000000000000000000000000000000..4104cacc67af0be1c7bc152696e2ae544127aace
Binary files /dev/null and b/slim/quantization/images/TransformForMobilePass.png differ
diff --git a/slim/quantization/images/TransformPass.png b/slim/quantization/images/TransformPass.png
new file mode 100644
index 0000000000000000000000000000000000000000..f29ab62753e0e6ddf28d0c1dda7139705fc24b18
Binary files /dev/null and b/slim/quantization/images/TransformPass.png differ
diff --git a/slim/quantization/yolov3_mobilenet_v1_slim.yaml b/slim/quantization/yolov3_mobilenet_v1_slim.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..60a66f656f9e419cd862231654ab4eaca6057ea2
--- /dev/null
+++ b/slim/quantization/yolov3_mobilenet_v1_slim.yaml
@@ -0,0 +1,20 @@
+version: 1.0
+strategies:
+ quantization_strategy:
+ class: 'QuantizationStrategy'
+ start_epoch: 0
+ end_epoch: 4
+ float_model_save_path: './output/yolov3/float'
+ mobile_model_save_path: './output/yolov3/mobile'
+ int8_model_save_path: './output/yolov3/int8'
+ weight_bits: 8
+ activation_bits: 8
+ weight_quantize_type: 'abs_max'
+ activation_quantize_type: 'moving_average_abs_max'
+ save_in_nodes: ['image', 'im_size']
+ save_out_nodes: ['multiclass_nms_0.tmp_0']
+compressor:
+ epoch: 5
+ checkpoint_path: './checkpoints/yolov3/'
+ strategies:
+ - quantization_strategy
diff --git a/tools/__init__.py b/tools/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0c32e26092f6ea25771279418582a24ea449ab2
--- /dev/null
+++ b/tools/__init__.py
@@ -0,0 +1,13 @@
+# Copyright (c) 2019 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.
diff --git a/tools/configure.py b/tools/configure.py
new file mode 100644
index 0000000000000000000000000000000000000000..560d161513ae8f0115d8d3d5f97f6a0695642015
--- /dev/null
+++ b/tools/configure.py
@@ -0,0 +1,202 @@
+# Copyright (c) 2019 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.
+
+from __future__ import print_function
+
+import sys
+from argparse import ArgumentParser, RawDescriptionHelpFormatter
+
+import yaml
+
+from ppdet.core.workspace import get_registered_modules, load_config, dump_value
+from ppdet.utils.cli import ColorTTY, print_total_cfg
+
+color_tty = ColorTTY()
+
+MISC_CONFIG = {
+ "architecture": "",
+ "max_iters": "",
+ "train_feed": "",
+ "eval_feed": "",
+ "test_feed": "",
+ "pretrain_weights": "",
+ "save_dir": "",
+ "weights": "",
+ "metric": "",
+ "map_type": "11point",
+ "log_smooth_window": 20,
+ "snapshot_iter": 10000,
+ "log_iter": 20,
+ "use_gpu": True,
+ "finetune_exclude_pretrained_params": "",
+}
+
+
+def dump_config(module, minimal=False):
+ args = module.schema.values()
+ if minimal:
+ args = [arg for arg in args if not arg.has_default()]
+ return yaml.dump(
+ {
+ module.name: {
+ arg.name: arg.default if arg.has_default() else ""
+ for arg in args
+ }
+ },
+ default_flow_style=False,
+ default_style='')
+
+
+def list_modules(**kwargs):
+ target_category = kwargs['category']
+ module_schema = get_registered_modules()
+ module_by_category = {}
+
+ for schema in module_schema.values():
+ category = schema.category
+ if target_category is not None and schema.category != target_category:
+ continue
+ if category not in module_by_category:
+ module_by_category[category] = [schema]
+ else:
+ module_by_category[category].append(schema)
+
+ for cat, modules in module_by_category.items():
+ print("Available modules in the category '{}':".format(cat))
+ print("")
+ max_len = max([len(mod.name) for mod in modules])
+ for mod in modules:
+ print(color_tty.green(mod.name.ljust(max_len)),
+ mod.doc.split('\n')[0])
+ print("")
+
+
+def help_module(**kwargs):
+ schema = get_registered_modules()[kwargs['module']]
+
+ doc = schema.doc is None and "Not documented" or "{}".format(schema.doc)
+ func_args = {arg.name: arg.doc for arg in schema.schema.values()}
+ max_len = max([len(k) for k in func_args.keys()])
+ opts = "\n".join([
+ "{} {}".format(color_tty.green(k.ljust(max_len)), v)
+ for k, v in func_args.items()
+ ])
+ template = dump_config(schema)
+ print("{}\n\n{}\n\n{}\n\n{}\n\n{}\n\n{}\n{}\n".format(
+ color_tty.bold(color_tty.blue("MODULE DESCRIPTION:")),
+ doc,
+ color_tty.bold(color_tty.blue("MODULE OPTIONS:")),
+ opts,
+ color_tty.bold(color_tty.blue("CONFIGURATION TEMPLATE:")),
+ template,
+ color_tty.bold(color_tty.blue("COMMAND LINE OPTIONS:")), ))
+ for arg in schema.schema.values():
+ print("--opt {}.{}={}".format(schema.name, arg.name,
+ dump_value(arg.default)
+ if arg.has_default() else ""))
+
+
+def generate_config(**kwargs):
+ minimal = kwargs['minimal']
+ modules = kwargs['modules']
+ module_schema = get_registered_modules()
+ visited = []
+ schema = []
+
+ def walk(m):
+ if m in visited:
+ return
+ s = module_schema[m]
+ schema.append(s)
+ visited.append(m)
+
+ for mod in modules:
+ walk(mod)
+
+ # XXX try to be smart about when to add header,
+ # if any "architecture" module, is included, head will be added as well
+ if any([getattr(m, 'category', None) == 'architecture' for m in schema]):
+ # XXX for ordered printing
+ header = ""
+ for k, v in MISC_CONFIG.items():
+ header += yaml.dump(
+ {
+ k: v
+ }, default_flow_style=False, default_style='')
+ print(header)
+
+ for s in schema:
+ print(dump_config(s, minimal))
+
+
+# FIXME this is pretty hackish, maybe implement a custom YAML printer?
+def analyze_config(**kwargs):
+ config = load_config(kwargs['file'])
+ print_total_cfg(config)
+
+
+if __name__ == '__main__':
+ argv = sys.argv[1:]
+
+ parser = ArgumentParser(formatter_class=RawDescriptionHelpFormatter)
+ subparsers = parser.add_subparsers(help='Supported Commands')
+ list_parser = subparsers.add_parser("list", help="list available modules")
+ help_parser = subparsers.add_parser(
+ "help", help="show detail options for module")
+ generate_parser = subparsers.add_parser(
+ "generate", help="generate configuration template")
+ analyze_parser = subparsers.add_parser(
+ "analyze", help="analyze configuration file")
+
+ list_parser.set_defaults(func=list_modules)
+ help_parser.set_defaults(func=help_module)
+ generate_parser.set_defaults(func=generate_config)
+ analyze_parser.set_defaults(func=analyze_config)
+
+ list_group = list_parser.add_mutually_exclusive_group()
+ list_group.add_argument(
+ "-c",
+ "--category",
+ type=str,
+ default=None,
+ help="list modules for ")
+
+ help_parser.add_argument(
+ "module",
+ help="module to show info for",
+ choices=list(get_registered_modules().keys()))
+
+ generate_parser.add_argument(
+ "modules",
+ nargs='+',
+ help="include these module in generated configuration template",
+ choices=list(get_registered_modules().keys()))
+ generate_group = generate_parser.add_mutually_exclusive_group()
+ generate_group.add_argument(
+ "--minimal", action='store_true', help="only include required options")
+ generate_group.add_argument(
+ "--full",
+ action='store_false',
+ dest='minimal',
+ help="include all options")
+
+ analyze_parser.add_argument("file", help="configuration file to analyze")
+
+ if len(sys.argv) < 2:
+ parser.print_help()
+ sys.exit(1)
+
+ args = parser.parse_args(argv)
+ if hasattr(args, 'func'):
+ args.func(**vars(args))
diff --git a/tools/eval.py b/tools/eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..15692d3dd8b13789faaaa6a9a0bb3ed9385f37a6
--- /dev/null
+++ b/tools/eval.py
@@ -0,0 +1,183 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+
+
+def set_paddle_flags(**kwargs):
+ for key, value in kwargs.items():
+ if os.environ.get(key, None) is None:
+ os.environ[key] = str(value)
+
+
+# NOTE(paddle-dev): All of these flags should be set before
+# `import paddle`. Otherwise, it would not take any effect.
+set_paddle_flags(
+ FLAGS_eager_delete_tensor_gb=0, # enable GC to save memory
+)
+
+import paddle.fluid as fluid
+
+from ppdet.utils.eval_utils import parse_fetches, eval_run, eval_results, json_eval_results
+import ppdet.utils.checkpoint as checkpoint
+from ppdet.utils.check import check_gpu
+from ppdet.modeling.model_input import create_feed
+from ppdet.data.data_feed import create_reader
+from ppdet.core.workspace import load_config, merge_config, create
+from ppdet.utils.cli import print_total_cfg
+from ppdet.utils.cli import ArgsParser
+
+import logging
+FORMAT = '%(asctime)s-%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.INFO, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+
+def main():
+ """
+ Main evaluate function
+ """
+ cfg = load_config(FLAGS.config)
+ if 'architecture' in cfg:
+ main_arch = cfg.architecture
+ else:
+ raise ValueError("'architecture' not specified in config file.")
+
+ merge_config(FLAGS.opt)
+ # check if set use_gpu=True in paddlepaddle cpu version
+ check_gpu(cfg.use_gpu)
+ print_total_cfg(cfg)
+
+ if 'eval_feed' not in cfg:
+ eval_feed = create(main_arch + 'EvalFeed')
+ else:
+ eval_feed = create(cfg.eval_feed)
+
+ multi_scale_test = getattr(cfg, 'MultiScaleTEST', None)
+
+ # define executor
+ place = fluid.CUDAPlace(0) if cfg.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ # build program
+ model = create(main_arch)
+ startup_prog = fluid.Program()
+ eval_prog = fluid.Program()
+ with fluid.program_guard(eval_prog, startup_prog):
+ with fluid.unique_name.guard():
+ pyreader, feed_vars = create_feed(eval_feed)
+ if multi_scale_test is None:
+ fetches = model.eval(feed_vars)
+ else:
+ fetches = model.eval(feed_vars, multi_scale_test)
+ eval_prog = eval_prog.clone(True)
+ reader = create_reader(eval_feed, args_path=FLAGS.dataset_dir)
+ pyreader.decorate_sample_list_generator(reader, place)
+
+ # eval already exists json file
+ if FLAGS.json_eval:
+ logger.info(
+ "In json_eval mode, PaddleDetection will evaluate json files in "
+ "output_eval directly. And proposal.json, bbox.json and mask.json "
+ "will be detected by default.")
+ json_eval_results(
+ eval_feed, cfg.metric, json_directory=FLAGS.output_eval)
+ return
+
+ compile_program = fluid.compiler.CompiledProgram(
+ eval_prog).with_data_parallel()
+
+ # load model
+ exe.run(startup_prog)
+ if 'weights' in cfg:
+ checkpoint.load_params(exe, eval_prog, cfg.weights)
+
+ assert cfg.metric in ['COCO', 'VOC'], \
+ "unknown metric type {}".format(cfg.metric)
+ extra_keys = []
+ if cfg.metric == 'COCO':
+ extra_keys = ['im_info', 'im_id', 'im_shape']
+ if cfg.metric == 'VOC':
+ extra_keys = ['gt_box', 'gt_label', 'is_difficult']
+
+ keys, values, cls = parse_fetches(fetches, eval_prog, extra_keys)
+
+ # whether output bbox is normalized in model output layer
+ is_bbox_normalized = False
+ if hasattr(model, 'is_bbox_normalized') and \
+ callable(model.is_bbox_normalized):
+ is_bbox_normalized = model.is_bbox_normalized()
+
+ sub_eval_prog = None
+ sub_keys = None
+ sub_values = None
+ # build sub-program
+ if 'Mask' in main_arch and multi_scale_test:
+ sub_eval_prog = fluid.Program()
+ with fluid.program_guard(sub_eval_prog, startup_prog):
+ with fluid.unique_name.guard():
+ _, feed_vars = create_feed(
+ eval_feed, use_pyreader=False, sub_prog_feed=True)
+ sub_fetches = model.eval(
+ feed_vars, multi_scale_test, mask_branch=True)
+ extra_keys = []
+ if cfg.metric == 'COCO':
+ extra_keys = ['im_id', 'im_shape']
+ if cfg.metric == 'VOC':
+ extra_keys = ['gt_box', 'gt_label', 'is_difficult']
+ sub_keys, sub_values, _ = parse_fetches(sub_fetches, sub_eval_prog,
+ extra_keys)
+ sub_eval_prog = sub_eval_prog.clone(True)
+
+ if 'weights' in cfg:
+ checkpoint.load_params(exe, sub_eval_prog, cfg.weights)
+
+ results = eval_run(exe, compile_program, pyreader, keys, values, cls, cfg,
+ sub_eval_prog, sub_keys, sub_values)
+
+ # evaluation
+ resolution = None
+ if 'mask' in results[0]:
+ resolution = model.mask_head.resolution
+ # if map_type not set, use default 11point, only use in VOC eval
+ map_type = cfg.map_type if 'map_type' in cfg else '11point'
+ eval_results(results, eval_feed, cfg.metric, cfg.num_classes, resolution,
+ is_bbox_normalized, FLAGS.output_eval, map_type)
+
+
+if __name__ == '__main__':
+ parser = ArgsParser()
+ parser.add_argument(
+ "--json_eval",
+ action='store_true',
+ default=False,
+ help="Whether to re eval with already exists bbox.json or mask.json")
+ parser.add_argument(
+ "-d",
+ "--dataset_dir",
+ default=None,
+ type=str,
+ help="Dataset path, same as DataFeed.dataset.dataset_dir")
+ parser.add_argument(
+ "-f",
+ "--output_eval",
+ default=None,
+ type=str,
+ help="Evaluation file directory, default is current directory.")
+ FLAGS = parser.parse_args()
+ main()
diff --git a/tools/export_model.py b/tools/export_model.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0c9edac316220ca2b752fad05eec5437f698de8
--- /dev/null
+++ b/tools/export_model.py
@@ -0,0 +1,118 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+
+from paddle import fluid
+
+from ppdet.core.workspace import load_config, merge_config, create
+from ppdet.modeling.model_input import create_feed
+from ppdet.utils.cli import ArgsParser
+import ppdet.utils.checkpoint as checkpoint
+
+import logging
+FORMAT = '%(asctime)s-%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.INFO, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+
+def prune_feed_vars(feeded_var_names, target_vars, prog):
+ """
+ Filter out feed variables which are not in program,
+ pruned feed variables are only used in post processing
+ on model output, which are not used in program, such
+ as im_id to identify image order, im_shape to clip bbox
+ in image.
+ """
+ exist_var_names = []
+ prog = prog.clone()
+ prog = prog._prune(targets=target_vars)
+ global_block = prog.global_block()
+ for name in feeded_var_names:
+ try:
+ v = global_block.var(name)
+ exist_var_names.append(str(v.name))
+ except Exception:
+ logger.info('save_inference_model pruned unused feed '
+ 'variables {}'.format(name))
+ pass
+ return exist_var_names
+
+
+def save_infer_model(FLAGS, exe, feed_vars, test_fetches, infer_prog):
+ cfg_name = os.path.basename(FLAGS.config).split('.')[0]
+ save_dir = os.path.join(FLAGS.output_dir, cfg_name)
+ feed_var_names = [var.name for var in feed_vars.values()]
+ target_vars = list(test_fetches.values())
+ feed_var_names = prune_feed_vars(feed_var_names, target_vars, infer_prog)
+ logger.info("Export inference model to {}, input: {}, output: "
+ "{}...".format(save_dir, feed_var_names,
+ [str(var.name) for var in target_vars]))
+ fluid.io.save_inference_model(
+ save_dir,
+ feeded_var_names=feed_var_names,
+ target_vars=target_vars,
+ executor=exe,
+ main_program=infer_prog,
+ params_filename="__params__")
+
+
+def main():
+ cfg = load_config(FLAGS.config)
+
+ if 'architecture' in cfg:
+ main_arch = cfg.architecture
+ else:
+ raise ValueError("'architecture' not specified in config file.")
+
+ merge_config(FLAGS.opt)
+
+ if 'test_feed' not in cfg:
+ test_feed = create(main_arch + 'TestFeed')
+ else:
+ test_feed = create(cfg.test_feed)
+
+ # Use CPU for exporting inference model instead of GPU
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ model = create(main_arch)
+
+ startup_prog = fluid.Program()
+ infer_prog = fluid.Program()
+ with fluid.program_guard(infer_prog, startup_prog):
+ with fluid.unique_name.guard():
+ _, feed_vars = create_feed(test_feed, use_pyreader=False)
+ test_fetches = model.test(feed_vars)
+ infer_prog = infer_prog.clone(True)
+
+ exe.run(startup_prog)
+ checkpoint.load_params(exe, infer_prog, cfg.weights)
+
+ save_infer_model(FLAGS, exe, feed_vars, test_fetches, infer_prog)
+
+
+if __name__ == '__main__':
+ parser = ArgsParser()
+ parser.add_argument(
+ "--output_dir",
+ type=str,
+ default="output",
+ help="Directory for storing the output model files.")
+ FLAGS = parser.parse_args()
+ main()
diff --git a/tools/face_eval.py b/tools/face_eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..f74d5ba431e2933e346d8430e9ba9b2ad20af170
--- /dev/null
+++ b/tools/face_eval.py
@@ -0,0 +1,298 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+
+import paddle.fluid as fluid
+import numpy as np
+from PIL import Image
+from collections import OrderedDict
+
+import ppdet.utils.checkpoint as checkpoint
+from ppdet.utils.cli import ArgsParser
+from ppdet.utils.check import check_gpu
+from ppdet.utils.widerface_eval_utils import get_shrink, bbox_vote, \
+ save_widerface_bboxes, save_fddb_bboxes, to_chw_bgr
+from ppdet.core.workspace import load_config, merge_config, create
+from ppdet.modeling.model_input import create_feed
+
+import logging
+FORMAT = '%(asctime)s-%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.INFO, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+
+def face_img_process(image,
+ mean=[104., 117., 123.],
+ std=[127.502231, 127.502231, 127.502231]):
+ img = np.array(image)
+ img = to_chw_bgr(img)
+ img = img.astype('float32')
+ img -= np.array(mean)[:, np.newaxis, np.newaxis].astype('float32')
+ img /= np.array(std)[:, np.newaxis, np.newaxis].astype('float32')
+ img = [img]
+ img = np.array(img)
+ return img
+
+
+def face_eval_run(exe,
+ compile_program,
+ fetches,
+ img_root_dir,
+ gt_file,
+ pred_dir='output/pred',
+ eval_mode='widerface',
+ multi_scale=False):
+ # load ground truth files
+ with open(gt_file, 'r') as f:
+ gt_lines = f.readlines()
+ imid2path = []
+ pos_gt = 0
+ while pos_gt < len(gt_lines):
+ name_gt = gt_lines[pos_gt].strip('\n\t').split()[0]
+ imid2path.append(name_gt)
+ pos_gt += 1
+ n_gt = int(gt_lines[pos_gt].strip('\n\t').split()[0])
+ pos_gt += 1 + n_gt
+ logger.info('The ground truth file load {} images'.format(len(imid2path)))
+
+ dets_dist = OrderedDict()
+ for iter_id, im_path in enumerate(imid2path):
+ image_path = os.path.join(img_root_dir, im_path)
+ if eval_mode == 'fddb':
+ image_path += '.jpg'
+ image = Image.open(image_path).convert('RGB')
+ if multi_scale:
+ shrink, max_shrink = get_shrink(image.size[1], image.size[0])
+ det0 = detect_face(exe, compile_program, fetches, image, shrink)
+ det1 = flip_test(exe, compile_program, fetches, image, shrink)
+ [det2, det3] = multi_scale_test(exe, compile_program, fetches, image,
+ max_shrink)
+ det4 = multi_scale_test_pyramid(exe, compile_program, fetches, image,
+ max_shrink)
+ det = np.row_stack((det0, det1, det2, det3, det4))
+ dets = bbox_vote(det)
+ else:
+ dets = detect_face(exe, compile_program, fetches, image, 1)
+ if eval_mode == 'widerface':
+ save_widerface_bboxes(image_path, dets, pred_dir)
+ else:
+ dets_dist[im_path] = dets
+ if iter_id % 100 == 0:
+ logger.info('Test iter {}'.format(iter_id))
+ if eval_mode == 'fddb':
+ save_fddb_bboxes(dets_dist, pred_dir)
+ logger.info("Finish evaluation.")
+
+
+def detect_face(exe, compile_program, fetches, image, shrink):
+ image_shape = [3, image.size[1], image.size[0]]
+ if shrink != 1:
+ h, w = int(image_shape[1] * shrink), int(image_shape[2] * shrink)
+ image = image.resize((w, h), Image.ANTIALIAS)
+ image_shape = [3, h, w]
+
+ img = face_img_process(image)
+ detection, = exe.run(compile_program,
+ feed={'image': img},
+ fetch_list=[fetches['bbox']],
+ return_numpy=False)
+ detection = np.array(detection)
+ # layout: xmin, ymin, xmax. ymax, score
+ if np.prod(detection.shape) == 1:
+ logger.info("No face detected")
+ return np.array([[0, 0, 0, 0, 0]])
+ det_conf = detection[:, 1]
+ det_xmin = image_shape[2] * detection[:, 2] / shrink
+ det_ymin = image_shape[1] * detection[:, 3] / shrink
+ det_xmax = image_shape[2] * detection[:, 4] / shrink
+ det_ymax = image_shape[1] * detection[:, 5] / shrink
+
+ det = np.column_stack((det_xmin, det_ymin, det_xmax, det_ymax, det_conf))
+ return det
+
+
+def flip_test(exe, compile_program, fetches, image, shrink):
+ img = image.transpose(Image.FLIP_LEFT_RIGHT)
+ det_f = detect_face(exe, compile_program, fetches, img, shrink)
+ det_t = np.zeros(det_f.shape)
+ # image.size: [width, height]
+ det_t[:, 0] = image.size[0] - det_f[:, 2]
+ det_t[:, 1] = det_f[:, 1]
+ det_t[:, 2] = image.size[0] - det_f[:, 0]
+ det_t[:, 3] = det_f[:, 3]
+ det_t[:, 4] = det_f[:, 4]
+ return det_t
+
+
+def multi_scale_test(exe, compile_program, fetches, image, max_shrink):
+ # Shrink detecting is only used to detect big faces
+ st = 0.5 if max_shrink >= 0.75 else 0.5 * max_shrink
+ det_s = detect_face(exe, compile_program, fetches, image, st)
+ index = np.where(
+ np.maximum(det_s[:, 2] - det_s[:, 0] + 1, det_s[:, 3] - det_s[:, 1] + 1)
+ > 30)[0]
+ det_s = det_s[index, :]
+ # Enlarge one times
+ bt = min(2, max_shrink) if max_shrink > 1 else (st + max_shrink) / 2
+ det_b = detect_face(exe, compile_program, fetches, image, bt)
+
+ # Enlarge small image x times for small faces
+ if max_shrink > 2:
+ bt *= 2
+ while bt < max_shrink:
+ det_b = np.row_stack((det_b, detect_face(exe, compile_program,
+ fetches, image, bt)))
+ bt *= 2
+ det_b = np.row_stack((det_b, detect_face(exe, compile_program, fetches,
+ image, max_shrink)))
+
+ # Enlarged images are only used to detect small faces.
+ if bt > 1:
+ index = np.where(
+ np.minimum(det_b[:, 2] - det_b[:, 0] + 1,
+ det_b[:, 3] - det_b[:, 1] + 1) < 100)[0]
+ det_b = det_b[index, :]
+ # Shrinked images are only used to detect big faces.
+ else:
+ index = np.where(
+ np.maximum(det_b[:, 2] - det_b[:, 0] + 1,
+ det_b[:, 3] - det_b[:, 1] + 1) > 30)[0]
+ det_b = det_b[index, :]
+ return det_s, det_b
+
+
+def multi_scale_test_pyramid(exe, compile_program, fetches, image, max_shrink):
+ # Use image pyramids to detect faces
+ det_b = detect_face(exe, compile_program, fetches, image, 0.25)
+ index = np.where(
+ np.maximum(det_b[:, 2] - det_b[:, 0] + 1, det_b[:, 3] - det_b[:, 1] + 1)
+ > 30)[0]
+ det_b = det_b[index, :]
+
+ st = [0.75, 1.25, 1.5, 1.75]
+ for i in range(len(st)):
+ if st[i] <= max_shrink:
+ det_temp = detect_face(exe, compile_program, fetches, image, st[i])
+ # Enlarged images are only used to detect small faces.
+ if st[i] > 1:
+ index = np.where(
+ np.minimum(det_temp[:, 2] - det_temp[:, 0] + 1,
+ det_temp[:, 3] - det_temp[:, 1] + 1) < 100)[0]
+ det_temp = det_temp[index, :]
+ # Shrinked images are only used to detect big faces.
+ else:
+ index = np.where(
+ np.maximum(det_temp[:, 2] - det_temp[:, 0] + 1,
+ det_temp[:, 3] - det_temp[:, 1] + 1) > 30)[0]
+ det_temp = det_temp[index, :]
+ det_b = np.row_stack((det_b, det_temp))
+ return det_b
+
+
+def main():
+ """
+ Main evaluate function
+ """
+ cfg = load_config(FLAGS.config)
+ if 'architecture' in cfg:
+ main_arch = cfg.architecture
+ else:
+ raise ValueError("'architecture' not specified in config file.")
+
+ merge_config(FLAGS.opt)
+
+ # check if set use_gpu=True in paddlepaddle cpu version
+ check_gpu(cfg.use_gpu)
+
+ if 'eval_feed' not in cfg:
+ eval_feed = create(main_arch + 'EvalFeed')
+ else:
+ eval_feed = create(cfg.eval_feed)
+
+ # define executor
+ place = fluid.CUDAPlace(0) if cfg.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ # build program
+ model = create(main_arch)
+ startup_prog = fluid.Program()
+ eval_prog = fluid.Program()
+ with fluid.program_guard(eval_prog, startup_prog):
+ with fluid.unique_name.guard():
+ _, feed_vars = create_feed(eval_feed, use_pyreader=False)
+ fetches = model.eval(feed_vars)
+
+ eval_prog = eval_prog.clone(True)
+
+ # load model
+ exe.run(startup_prog)
+ if 'weights' in cfg:
+ checkpoint.load_params(exe, eval_prog, cfg.weights)
+
+ assert cfg.metric in ['WIDERFACE'], \
+ "unknown metric type {}".format(cfg.metric)
+
+ annotation_file = getattr(eval_feed.dataset, 'annotation', None)
+ dataset_dir = FLAGS.dataset_dir if FLAGS.dataset_dir else \
+ getattr(eval_feed.dataset, 'dataset_dir', None)
+ img_root_dir = dataset_dir
+ if FLAGS.eval_mode == "widerface":
+ image_dir = getattr(eval_feed.dataset, 'image_dir', None)
+ img_root_dir = os.path.join(dataset_dir, image_dir)
+ gt_file = os.path.join(dataset_dir, annotation_file)
+ pred_dir = FLAGS.output_eval if FLAGS.output_eval else 'output/pred'
+ face_eval_run(
+ exe,
+ eval_prog,
+ fetches,
+ img_root_dir,
+ gt_file,
+ pred_dir=pred_dir,
+ eval_mode=FLAGS.eval_mode,
+ multi_scale=FLAGS.multi_scale)
+
+
+if __name__ == '__main__':
+ parser = ArgsParser()
+ parser.add_argument(
+ "-d",
+ "--dataset_dir",
+ default=None,
+ type=str,
+ help="Dataset path, same as DataFeed.dataset.dataset_dir")
+ parser.add_argument(
+ "-f",
+ "--output_eval",
+ default=None,
+ type=str,
+ help="Evaluation file directory, default is current directory.")
+ parser.add_argument(
+ "-e",
+ "--eval_mode",
+ default="widerface",
+ type=str,
+ help="Evaluation mode, include `widerface` and `fddb`, default is `widerface`."
+ )
+ parser.add_argument(
+ "--multi_scale",
+ action='store_true',
+ default=False,
+ help="If True it will select `multi_scale` evaluation. Default is `False`, it will select `single-scale` evaluation.")
+ FLAGS = parser.parse_args()
+ main()
diff --git a/tools/infer.py b/tools/infer.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed10814846037dcabdb301e244370848c647a61b
--- /dev/null
+++ b/tools/infer.py
@@ -0,0 +1,269 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import glob
+
+import numpy as np
+from PIL import Image
+
+
+def set_paddle_flags(**kwargs):
+ for key, value in kwargs.items():
+ if os.environ.get(key, None) is None:
+ os.environ[key] = str(value)
+
+
+# NOTE(paddle-dev): All of these flags should be set before
+# `import paddle`. Otherwise, it would not take any effect.
+set_paddle_flags(
+ FLAGS_eager_delete_tensor_gb=0, # enable GC to save memory
+)
+
+from paddle import fluid
+
+from ppdet.utils.cli import print_total_cfg
+from ppdet.core.workspace import load_config, merge_config, create
+from ppdet.modeling.model_input import create_feed
+from ppdet.data.data_feed import create_reader
+
+from ppdet.utils.eval_utils import parse_fetches
+from ppdet.utils.cli import ArgsParser
+from ppdet.utils.check import check_gpu
+from ppdet.utils.visualizer import visualize_results
+import ppdet.utils.checkpoint as checkpoint
+
+import logging
+FORMAT = '%(asctime)s-%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.INFO, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+
+def get_save_image_name(output_dir, image_path):
+ """
+ Get save image name from source image path.
+ """
+ if not os.path.exists(output_dir):
+ os.makedirs(output_dir)
+ image_name = os.path.split(image_path)[-1]
+ name, ext = os.path.splitext(image_name)
+ return os.path.join(output_dir, "{}".format(name)) + ext
+
+
+def get_test_images(infer_dir, infer_img):
+ """
+ Get image path list in TEST mode
+ """
+ assert infer_img is not None or infer_dir is not None, \
+ "--infer_img or --infer_dir should be set"
+ assert infer_img is None or os.path.isfile(infer_img), \
+ "{} is not a file".format(infer_img)
+ assert infer_dir is None or os.path.isdir(infer_dir), \
+ "{} is not a directory".format(infer_dir)
+ images = []
+
+ # infer_img has a higher priority
+ if infer_img and os.path.isfile(infer_img):
+ images.append(infer_img)
+ return images
+
+ infer_dir = os.path.abspath(infer_dir)
+ assert os.path.isdir(infer_dir), \
+ "infer_dir {} is not a directory".format(infer_dir)
+ exts = ['jpg', 'jpeg', 'png', 'bmp']
+ exts += [ext.upper() for ext in exts]
+ for ext in exts:
+ images.extend(glob.glob('{}/*.{}'.format(infer_dir, ext)))
+
+ assert len(images) > 0, "no image found in {}".format(infer_dir)
+ logger.info("Found {} inference images in total.".format(len(images)))
+
+ return images
+
+
+def main():
+ cfg = load_config(FLAGS.config)
+
+ if 'architecture' in cfg:
+ main_arch = cfg.architecture
+ else:
+ raise ValueError("'architecture' not specified in config file.")
+
+ merge_config(FLAGS.opt)
+
+ # check if set use_gpu=True in paddlepaddle cpu version
+ check_gpu(cfg.use_gpu)
+ print_total_cfg(cfg)
+
+ if 'test_feed' not in cfg:
+ test_feed = create(main_arch + 'TestFeed')
+ else:
+ test_feed = create(cfg.test_feed)
+
+ test_images = get_test_images(FLAGS.infer_dir, FLAGS.infer_img)
+ test_feed.dataset.add_images(test_images)
+
+ place = fluid.CUDAPlace(0) if cfg.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ model = create(main_arch)
+
+ startup_prog = fluid.Program()
+ infer_prog = fluid.Program()
+ with fluid.program_guard(infer_prog, startup_prog):
+ with fluid.unique_name.guard():
+ _, feed_vars = create_feed(test_feed, use_pyreader=False)
+ test_fetches = model.test(feed_vars)
+ infer_prog = infer_prog.clone(True)
+
+ reader = create_reader(test_feed)
+ feeder = fluid.DataFeeder(place=place, feed_list=feed_vars.values())
+
+ exe.run(startup_prog)
+ if cfg.weights:
+ checkpoint.load_params(exe, infer_prog, cfg.weights)
+
+ # parse infer fetches
+ assert cfg.metric in ['COCO', 'VOC', 'WIDERFACE'], \
+ "unknown metric type {}".format(cfg.metric)
+ extra_keys = []
+ if cfg['metric'] == 'COCO':
+ extra_keys = ['im_info', 'im_id', 'im_shape']
+ if cfg['metric'] == 'VOC' or cfg['metric'] == 'WIDERFACE':
+ extra_keys = ['im_id', 'im_shape']
+ keys, values, _ = parse_fetches(test_fetches, infer_prog, extra_keys)
+
+ # parse dataset category
+ if cfg.metric == 'COCO':
+ from ppdet.utils.coco_eval import bbox2out, mask2out, get_category_info
+ if cfg.metric == "VOC":
+ from ppdet.utils.voc_eval import bbox2out, get_category_info
+ if cfg.metric == "WIDERFACE":
+ from ppdet.utils.widerface_eval_utils import bbox2out, get_category_info
+
+ anno_file = getattr(test_feed.dataset, 'annotation', None)
+ with_background = getattr(test_feed, 'with_background', True)
+ use_default_label = getattr(test_feed, 'use_default_label', False)
+ clsid2catid, catid2name = get_category_info(anno_file, with_background,
+ use_default_label)
+
+ # whether output bbox is normalized in model output layer
+ is_bbox_normalized = False
+ if hasattr(model, 'is_bbox_normalized') and \
+ callable(model.is_bbox_normalized):
+ is_bbox_normalized = model.is_bbox_normalized()
+
+ # use tb-paddle to log image
+ if FLAGS.use_tb:
+ from tb_paddle import SummaryWriter
+ tb_writer = SummaryWriter(FLAGS.tb_log_dir)
+ tb_image_step = 0
+ tb_image_frame = 0 # each frame can display ten pictures at most.
+
+ imid2path = reader.imid2path
+ for iter_id, data in enumerate(reader()):
+ outs = exe.run(infer_prog,
+ feed=feeder.feed(data),
+ fetch_list=values,
+ return_numpy=False)
+ res = {
+ k: (np.array(v), v.recursive_sequence_lengths())
+ for k, v in zip(keys, outs)
+ }
+ logger.info('Infer iter {}'.format(iter_id))
+
+ bbox_results = None
+ mask_results = None
+ if 'bbox' in res:
+ bbox_results = bbox2out([res], clsid2catid, is_bbox_normalized)
+ if 'mask' in res:
+ mask_results = mask2out([res], clsid2catid,
+ model.mask_head.resolution)
+
+ # visualize result
+ im_ids = res['im_id'][0]
+ for im_id in im_ids:
+ image_path = imid2path[int(im_id)]
+ image = Image.open(image_path).convert('RGB')
+
+ # use tb-paddle to log original image
+ if FLAGS.use_tb:
+ original_image_np = np.array(image)
+ tb_writer.add_image(
+ "original/frame_{}".format(tb_image_frame),
+ original_image_np,
+ tb_image_step,
+ dataformats='HWC')
+
+ image = visualize_results(image,
+ int(im_id), catid2name,
+ FLAGS.draw_threshold, bbox_results,
+ mask_results)
+
+ # use tb-paddle to log image with bbox
+ if FLAGS.use_tb:
+ infer_image_np = np.array(image)
+ tb_writer.add_image(
+ "bbox/frame_{}".format(tb_image_frame),
+ infer_image_np,
+ tb_image_step,
+ dataformats='HWC')
+ tb_image_step += 1
+ if tb_image_step % 10 == 0:
+ tb_image_step = 0
+ tb_image_frame += 1
+
+ save_name = get_save_image_name(FLAGS.output_dir, image_path)
+ logger.info("Detection bbox results save in {}".format(save_name))
+ image.save(save_name, quality=95)
+
+
+if __name__ == '__main__':
+ parser = ArgsParser()
+ parser.add_argument(
+ "--infer_dir",
+ type=str,
+ default=None,
+ help="Directory for images to perform inference on.")
+ parser.add_argument(
+ "--infer_img",
+ type=str,
+ default=None,
+ help="Image path, has higher priority over --infer_dir")
+ parser.add_argument(
+ "--output_dir",
+ type=str,
+ default="output",
+ help="Directory for storing the output visualization files.")
+ parser.add_argument(
+ "--draw_threshold",
+ type=float,
+ default=0.5,
+ help="Threshold to reserve the result for visualization.")
+ parser.add_argument(
+ "--use_tb",
+ type=bool,
+ default=False,
+ help="whether to record the data to Tensorboard.")
+ parser.add_argument(
+ '--tb_log_dir',
+ type=str,
+ default="tb_log_dir/image",
+ help='Tensorboard logging directory for image.')
+ FLAGS = parser.parse_args()
+ main()
diff --git a/tools/train.py b/tools/train.py
new file mode 100644
index 0000000000000000000000000000000000000000..08e1fc63437c78722e11429d94468dcf2e5eee2c
--- /dev/null
+++ b/tools/train.py
@@ -0,0 +1,338 @@
+# Copyright (c) 2019 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.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import time
+import numpy as np
+import datetime
+from collections import deque
+
+
+def set_paddle_flags(**kwargs):
+ for key, value in kwargs.items():
+ if os.environ.get(key, None) is None:
+ os.environ[key] = str(value)
+
+
+# NOTE(paddle-dev): All of these flags should be set before
+# `import paddle`. Otherwise, it would not take any effect.
+set_paddle_flags(
+ FLAGS_eager_delete_tensor_gb=0, # enable GC to save memory
+)
+
+from paddle import fluid
+
+from ppdet.experimental import mixed_precision_context
+from ppdet.core.workspace import load_config, merge_config, create
+from ppdet.data.data_feed import create_reader
+
+from ppdet.utils.cli import print_total_cfg
+from ppdet.utils import dist_utils
+from ppdet.utils.eval_utils import parse_fetches, eval_run, eval_results
+from ppdet.utils.stats import TrainingStats
+from ppdet.utils.cli import ArgsParser
+from ppdet.utils.check import check_gpu
+import ppdet.utils.checkpoint as checkpoint
+from ppdet.modeling.model_input import create_feed
+
+import logging
+FORMAT = '%(asctime)s-%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.INFO, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+
+def main():
+ env = os.environ
+ FLAGS.dist = 'PADDLE_TRAINER_ID' in env and 'PADDLE_TRAINERS_NUM' in env
+ if FLAGS.dist:
+ trainer_id = int(env['PADDLE_TRAINER_ID'])
+ import random
+ local_seed = (99 + trainer_id)
+ random.seed(local_seed)
+ np.random.seed(local_seed)
+
+ cfg = load_config(FLAGS.config)
+ if 'architecture' in cfg:
+ main_arch = cfg.architecture
+ else:
+ raise ValueError("'architecture' not specified in config file.")
+
+ merge_config(FLAGS.opt)
+
+ if 'log_iter' not in cfg:
+ cfg.log_iter = 20
+
+ # check if set use_gpu=True in paddlepaddle cpu version
+ check_gpu(cfg.use_gpu)
+ if not FLAGS.dist or trainer_id == 0:
+ print_total_cfg(cfg)
+
+ if cfg.use_gpu:
+ devices_num = fluid.core.get_cuda_device_count()
+ else:
+ devices_num = int(os.environ.get('CPU_NUM', 1))
+
+ if 'train_feed' not in cfg:
+ train_feed = create(main_arch + 'TrainFeed')
+ else:
+ train_feed = create(cfg.train_feed)
+
+ if FLAGS.eval:
+ if 'eval_feed' not in cfg:
+ eval_feed = create(main_arch + 'EvalFeed')
+ else:
+ eval_feed = create(cfg.eval_feed)
+
+ if 'FLAGS_selected_gpus' in env:
+ device_id = int(env['FLAGS_selected_gpus'])
+ else:
+ device_id = 0
+ place = fluid.CUDAPlace(device_id) if cfg.use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ lr_builder = create('LearningRate')
+ optim_builder = create('OptimizerBuilder')
+
+ # build program
+ startup_prog = fluid.Program()
+ train_prog = fluid.Program()
+ with fluid.program_guard(train_prog, startup_prog):
+ with fluid.unique_name.guard():
+ model = create(main_arch)
+ train_pyreader, feed_vars = create_feed(train_feed)
+
+ if FLAGS.fp16:
+ assert (getattr(model.backbone, 'norm_type', None)
+ != 'affine_channel'), \
+ '--fp16 currently does not support affine channel, ' \
+ ' please modify backbone settings to use batch norm'
+
+ with mixed_precision_context(FLAGS.loss_scale, FLAGS.fp16) as ctx:
+ train_fetches = model.train(feed_vars)
+
+ loss = train_fetches['loss']
+ if FLAGS.fp16:
+ loss *= ctx.get_loss_scale_var()
+ lr = lr_builder()
+ optimizer = optim_builder(lr)
+ optimizer.minimize(loss)
+ if FLAGS.fp16:
+ loss /= ctx.get_loss_scale_var()
+
+ # parse train fetches
+ train_keys, train_values, _ = parse_fetches(train_fetches)
+ train_values.append(lr)
+
+ if FLAGS.eval:
+ eval_prog = fluid.Program()
+ with fluid.program_guard(eval_prog, startup_prog):
+ with fluid.unique_name.guard():
+ model = create(main_arch)
+ eval_pyreader, feed_vars = create_feed(eval_feed)
+ fetches = model.eval(feed_vars)
+ eval_prog = eval_prog.clone(True)
+
+ eval_reader = create_reader(eval_feed, args_path=FLAGS.dataset_dir)
+ eval_pyreader.decorate_sample_list_generator(eval_reader, place)
+
+ # parse eval fetches
+ extra_keys = []
+ if cfg.metric == 'COCO':
+ extra_keys = ['im_info', 'im_id', 'im_shape']
+ if cfg.metric == 'VOC':
+ extra_keys = ['gt_box', 'gt_label', 'is_difficult']
+ if cfg.metric == 'WIDERFACE':
+ extra_keys = ['im_id', 'im_shape', 'gt_box']
+ eval_keys, eval_values, eval_cls = parse_fetches(fetches, eval_prog,
+ extra_keys)
+
+ # compile program for multi-devices
+ build_strategy = fluid.BuildStrategy()
+ build_strategy.fuse_all_optimizer_ops = False
+ build_strategy.fuse_elewise_add_act_ops = True
+ # only enable sync_bn in multi GPU devices
+ sync_bn = getattr(model.backbone, 'norm_type', None) == 'sync_bn'
+ build_strategy.sync_batch_norm = sync_bn and devices_num > 1 \
+ and cfg.use_gpu
+
+ exec_strategy = fluid.ExecutionStrategy()
+ # iteration number when CompiledProgram tries to drop local execution scopes.
+ # Set it to be 1 to save memory usages, so that unused variables in
+ # local execution scopes can be deleted after each iteration.
+ exec_strategy.num_iteration_per_drop_scope = 1
+ if FLAGS.dist:
+ dist_utils.prepare_for_multi_process(exe, build_strategy, startup_prog,
+ train_prog)
+ exec_strategy.num_threads = 1
+
+ exe.run(startup_prog)
+ compiled_train_prog = fluid.CompiledProgram(train_prog).with_data_parallel(
+ loss_name=loss.name,
+ build_strategy=build_strategy,
+ exec_strategy=exec_strategy)
+
+ if FLAGS.eval:
+ compiled_eval_prog = fluid.compiler.CompiledProgram(eval_prog)
+
+ fuse_bn = getattr(model.backbone, 'norm_type', None) == 'affine_channel'
+
+ ignore_params = cfg.finetune_exclude_pretrained_params \
+ if 'finetune_exclude_pretrained_params' in cfg else []
+
+ start_iter = 0
+ if FLAGS.resume_checkpoint:
+ checkpoint.load_checkpoint(exe, train_prog, FLAGS.resume_checkpoint)
+ start_iter = checkpoint.global_step()
+ elif cfg.pretrain_weights and fuse_bn and not ignore_params:
+ checkpoint.load_and_fusebn(exe, train_prog, cfg.pretrain_weights)
+ elif cfg.pretrain_weights:
+ checkpoint.load_params(
+ exe, train_prog, cfg.pretrain_weights, ignore_params=ignore_params)
+
+ train_reader = create_reader(train_feed, (cfg.max_iters - start_iter) *
+ devices_num, FLAGS.dataset_dir)
+ train_pyreader.decorate_sample_list_generator(train_reader, place)
+
+ # whether output bbox is normalized in model output layer
+ is_bbox_normalized = False
+ if hasattr(model, 'is_bbox_normalized') and \
+ callable(model.is_bbox_normalized):
+ is_bbox_normalized = model.is_bbox_normalized()
+
+ # if map_type not set, use default 11point, only use in VOC eval
+ map_type = cfg.map_type if 'map_type' in cfg else '11point'
+
+ train_stats = TrainingStats(cfg.log_smooth_window, train_keys)
+ train_pyreader.start()
+ start_time = time.time()
+ end_time = time.time()
+
+ cfg_name = os.path.basename(FLAGS.config).split('.')[0]
+ save_dir = os.path.join(cfg.save_dir, cfg_name)
+ time_stat = deque(maxlen=cfg.log_smooth_window)
+ best_box_ap_list = [0.0, 0] #[map, iter]
+
+ # use tb-paddle to log data
+ if FLAGS.use_tb:
+ from tb_paddle import SummaryWriter
+ tb_writer = SummaryWriter(FLAGS.tb_log_dir)
+ tb_loss_step = 0
+ tb_mAP_step = 0
+
+ for it in range(start_iter, cfg.max_iters):
+ start_time = end_time
+ end_time = time.time()
+ time_stat.append(end_time - start_time)
+ time_cost = np.mean(time_stat)
+ eta_sec = (cfg.max_iters - it) * time_cost
+ eta = str(datetime.timedelta(seconds=int(eta_sec)))
+ outs = exe.run(compiled_train_prog, fetch_list=train_values)
+ stats = {k: np.array(v).mean() for k, v in zip(train_keys, outs[:-1])}
+
+ # use tb-paddle to log loss
+ if FLAGS.use_tb:
+ if it % cfg.log_iter == 0:
+ for loss_name, loss_value in stats.items():
+ tb_writer.add_scalar(loss_name, loss_value, tb_loss_step)
+ tb_loss_step += 1
+
+ train_stats.update(stats)
+ logs = train_stats.log()
+ if it % cfg.log_iter == 0 and (not FLAGS.dist or trainer_id == 0):
+ strs = 'iter: {}, lr: {:.6f}, {}, time: {:.3f}, eta: {}'.format(
+ it, np.mean(outs[-1]), logs, time_cost, eta)
+ logger.info(strs)
+
+ if (it > 0 and it % cfg.snapshot_iter == 0 or it == cfg.max_iters - 1) \
+ and (not FLAGS.dist or trainer_id == 0):
+ save_name = str(it) if it != cfg.max_iters - 1 else "model_final"
+ checkpoint.save(exe, train_prog, os.path.join(save_dir, save_name))
+
+ if FLAGS.eval:
+ # evaluation
+ results = eval_run(exe, compiled_eval_prog, eval_pyreader,
+ eval_keys, eval_values, eval_cls)
+ resolution = None
+ if 'mask' in results[0]:
+ resolution = model.mask_head.resolution
+ box_ap_stats = eval_results(
+ results, eval_feed, cfg.metric, cfg.num_classes, resolution,
+ is_bbox_normalized, FLAGS.output_eval, map_type)
+
+ # use tb_paddle to log mAP
+ if FLAGS.use_tb:
+ tb_writer.add_scalar("mAP", box_ap_stats[0], tb_mAP_step)
+ tb_mAP_step += 1
+
+ if box_ap_stats[0] > best_box_ap_list[0]:
+ best_box_ap_list[0] = box_ap_stats[0]
+ best_box_ap_list[1] = it
+ checkpoint.save(exe, train_prog,
+ os.path.join(save_dir, "best_model"))
+ logger.info("Best test box ap: {}, in iter: {}".format(
+ best_box_ap_list[0], best_box_ap_list[1]))
+
+ train_pyreader.reset()
+
+
+if __name__ == '__main__':
+ parser = ArgsParser()
+ parser.add_argument(
+ "-r",
+ "--resume_checkpoint",
+ default=None,
+ type=str,
+ help="Checkpoint path for resuming training.")
+ parser.add_argument(
+ "--fp16",
+ action='store_true',
+ default=False,
+ help="Enable mixed precision training.")
+ parser.add_argument(
+ "--loss_scale",
+ default=8.,
+ type=float,
+ help="Mixed precision training loss scale.")
+ parser.add_argument(
+ "--eval",
+ action='store_true',
+ default=False,
+ help="Whether to perform evaluation in train")
+ parser.add_argument(
+ "--output_eval",
+ default=None,
+ type=str,
+ help="Evaluation directory, default is current directory.")
+ parser.add_argument(
+ "-d",
+ "--dataset_dir",
+ default=None,
+ type=str,
+ help="Dataset path, same as DataFeed.dataset.dataset_dir")
+ parser.add_argument(
+ "--use_tb",
+ type=bool,
+ default=False,
+ help="whether to record the data to Tensorboard.")
+ parser.add_argument(
+ '--tb_log_dir',
+ type=str,
+ default="tb_log_dir/scalar",
+ help='Tensorboard logging directory for scalar.')
+ FLAGS = parser.parse_args()
+ main()
+
+
+
+
+
+
+
+ 
+