init model

README.md

@@ -0,0 +1,90 @@
+---
+license: apache-2.0
+datasets:
+- wider_face
+tags:
+- RyzenAI
+- Object Detection
+- Computer Vision
+- Face
+- WiderFace
+- MobileNet
+- RetinaNet
+- ONNX
+---
+
+# Retinaface model trained on WiderFace
+
+Retinaface trained on WiderFace dataset at resolution 640x640, when Retinaface use mobilenet0.25 as backbone net. 
+It was introduced in the paper [RetinaFace: Single-stage Dense Face Localisation in the Wild](https://arxiv.org/abs/1905.00641) by Jiankang Deng et al. 
+The code version we use from [this repository](https://github.com/biubug6/Pytorch_Retinaface.git).
+
+We develop a modified version that could be supported by [AMD Ryzen AI](https://ryzenai.docs.amd.com).
+
+
+## Model description
+
+Retinaface is an advanced algorithm used for face detection and facial keypoint localization. It is based on deep learning techniques and is capable of accurately detecting faces in images and providing precise positioning of facial landmarks.
+
+
+## Intended uses & limitations
+
+You can use the raw model for Face detection. See the [model hub](https://huggingface.co/models?sort=trending&search=amd%2FRetinaface) to look for all available Retinaface models.
+
+
+## How to use
+
+### Installation
+
+   Follow [Ryzen AI Installation](https://ryzenai.docs.amd.com/en/latest/inst.html) to prepare the environment for Ryzen AI.
+   Run the following script to install pre-requisites for this model.
+   ```bash
+   pip install -r requirements.txt 
+   ```
+
+
+### Data Preparation (optional: for accuracy evaluation)
+1. Download the [WIDERFACE](http://shuoyang1213.me/WIDERFACE/index.html) dataset.
+2. Organise the dataset directory as follows:
+(Note: `train` and `test` are not necessary for accuracy evaluation on validation set. wider_val.txt only include val file names but not label information.)
+```Shell
+  ./data/widerface/
+    val/
+      images/
+      wider_val.txt
+```
+
+### Test & Evaluation
+ - Run inference for a single image
+  ```python
+  python widerface_onnx_inference.py  -m .\weights\RetinaFace_int.onnx --image_path \WIDERFACE_VAL_IMAGE_PAT --ipu --provider_config Path\To\vaip_config.json
+  #return three lists: boxes, confs, landms 
+  #if you want to change the image path, please select another image from widerface val dataset, set --image_path  new_image_path
+  ```
+*Note: __vaip_config.json__ is located at the setup package of Ryzen AI (refer to [Installation](#installation))*
+
+ - Test accuracy of the quantized model
+  1. Generate txt file
+  ```python
+  python widerface_onnx_evalute.py --ipu --provider_config Path\To\vaip_config.json
+  ```
+  2. Evaluate txt results. Demo come from [Here](https://github.com/wondervictor/WiderFace-Evaluation)
+  ```Shell
+  cd ./widerface_evaluate
+  python setup.py build_ext --inplace
+  python evaluation.py #please modify the evaluation path
+  ```
+
+### Performance
+| Model | easy | medium | hard |
+|:-|:-:|:-:|:-:|
+| RetinaFace_onnx_model (608x640) | 88.67% | 82.10% | 52.16% |
+
+
+```bibtex
+@inproceedings{deng2019retinaface,
+title={RetinaFace: Single-stage Dense Face Localisation in the Wild},
+author={Deng, Jiankang and Guo, Jia and Yuxiang, Zhou and Jinke Yu and Irene Kotsia and Zafeiriou, Stefanos},
+booktitle={arxiv},
+year={2019}
+```

requirements.txt

@@ -0,0 +1,14 @@
+torch==1.9.1
+torchvision==0.10.1
+opencv-python
+Cython
+IPython
+scipy
+tqdm
+argparse
+#numpy
+#onnxruntime
+#random
+#math
+#itertools
+#time

utils.py

@@ -0,0 +1,243 @@
+import numpy as np
+import cv2
+from itertools import product as product
+from math import ceil
+
+import torch
+import torch.nn.functional as F
+
+
+class PriorBox(object):
+    def __init__(self, cfg, image_size=None, phase="train"):
+        super(PriorBox, self).__init__()
+        self.min_sizes = cfg["min_sizes"]
+        self.steps = cfg["steps"]
+        self.clip = cfg["clip"]
+        self.image_size = image_size
+        self.feature_maps = [
+            [ceil(self.image_size[0] / step), ceil(self.image_size[1] / step)]
+            for step in self.steps
+        ]
+
+    def forward(self):
+        anchors = []
+        for k, f in enumerate(self.feature_maps):
+            min_sizes = self.min_sizes[k]
+            for i, j in product(range(f[0]), range(f[1])):
+                for min_size in min_sizes:
+                    s_kx = min_size / self.image_size[1]
+                    s_ky = min_size / self.image_size[0]
+                    dense_cx = [
+                        x * self.steps[k] / self.image_size[1] for x in [j + 0.5]
+                    ]
+                    dense_cy = [
+                        y * self.steps[k] / self.image_size[0] for y in [i + 0.5]
+                    ]
+                    for cy, cx in product(dense_cy, dense_cx):
+                        anchors += [cx, cy, s_kx, s_ky]
+        # back to torch land
+        output = torch.Tensor(anchors).view(-1, 4)
+        if self.clip:
+            output.clamp_(max=1, min=0)
+        return output
+
+
+def py_cpu_nms(dets, thresh):
+    """Pure Python NMS baseline.
+    Args:
+        dets: detections before nms
+        thresh: nms threshold
+    Return:
+        keep: index after nms
+    """
+    x1 = dets[:, 0]
+    y1 = dets[:, 1]
+    x2 = dets[:, 2]
+    y2 = dets[:, 3]
+    scores = dets[:, 4]
+    areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+    order = scores.argsort()[::-1]
+
+    keep = []
+    while order.size > 0:
+        i = order[0]
+        keep.append(i)
+        xx1 = np.maximum(x1[i], x1[order[1:]])
+        yy1 = np.maximum(y1[i], y1[order[1:]])
+        xx2 = np.minimum(x2[i], x2[order[1:]])
+        yy2 = np.minimum(y2[i], y2[order[1:]])
+
+        w = np.maximum(0.0, xx2 - xx1 + 1)
+        h = np.maximum(0.0, yy2 - yy1 + 1)
+        inter = w * h
+        ovr = inter / (areas[i] + areas[order[1:]] - inter)
+
+        inds = np.where(ovr <= thresh)[0]
+        order = order[inds + 1]
+    return keep
+
+
+def decode(loc, priors, variances):
+    """Decode locations from predictions using priors to undo
+    the encoding we did for offset regression at train time.
+    Args:
+        loc (tensor): location predictions for loc layers,
+            Shape: [num_priors,4]
+        priors (tensor): Prior boxes in center-offset form.
+            Shape: [num_priors,4].
+        variances: (list[float]) Variances of priorboxes
+    Return:
+        decoded bounding box predictions
+    """
+
+    boxes = torch.cat(
+        (
+            priors[:, :2] + loc[:, :2] * variances[0] * priors[:, 2:],
+            priors[:, 2:] * torch.exp(loc[:, 2:] * variances[1]),
+        ),
+        1,
+    )
+    boxes[:, :2] -= boxes[:, 2:] / 2
+    boxes[:, 2:] += boxes[:, :2]
+    return boxes
+
+
+def decode_landm(pre, priors, variances):
+    """Decode landm from predictions using priors to undo
+    the encoding we did for offset regression at train time.
+    Args:
+        pre (tensor): landm predictions for loc layers,
+            Shape: [num_priors,10]
+        priors (tensor): Prior boxes in center-offset form.
+            Shape: [num_priors,4].
+        variances: (list[float]) Variances of priorboxes
+    Return:
+        decoded landm predictions
+    """
+    landms = torch.cat(
+        (
+            priors[:, :2] + pre[:, :2] * variances[0] * priors[:, 2:],
+            priors[:, :2] + pre[:, 2:4] * variances[0] * priors[:, 2:],
+            priors[:, :2] + pre[:, 4:6] * variances[0] * priors[:, 2:],
+            priors[:, :2] + pre[:, 6:8] * variances[0] * priors[:, 2:],
+            priors[:, :2] + pre[:, 8:10] * variances[0] * priors[:, 2:],
+        ),
+        dim=1,
+    )
+    return landms
+
+
+def pad_image(image, h, w, size, padvalue):
+    pad_image = image.copy()
+    pad_h = max(size[0] - h, 0)
+    pad_w = max(size[1] - w, 0)
+    if pad_h > 0 or pad_w > 0:
+        pad_image = cv2.copyMakeBorder(image, 0, pad_h, 0,
+                                    pad_w, cv2.BORDER_CONSTANT,
+                                    value=padvalue)
+    return pad_image
+
+
+def resize_image(image, re_size, keep_ratio=True):
+    """Resize image
+    Args: 
+        image: origin image
+        re_size: resize scale
+        keep_ratio: keep aspect ratio. Default is set to true.
+    Returns:
+        re_image: resized image
+        resize_ratio: resize ratio
+    """
+    if not keep_ratio:
+        re_image = cv2.resize(image, (re_size[0], re_size[1])).astype('float32')                                             
+        return re_image, 0, 0 
+    ratio = re_size[0] * 1.0 / re_size[1] 
+    h, w = image.shape[0:2]
+    if h * 1.0 / w <= ratio:
+        resize_ratio = re_size[1] * 1.0 / w
+        re_h, re_w = int(h * resize_ratio), re_size[1] 
+    else:
+        resize_ratio = re_size[0] * 1.0 / h
+        re_h, re_w = re_size[0], int(w * resize_ratio)
+    
+    re_image = cv2.resize(image, (re_w, re_h)).astype('float32')                                              
+    re_image = pad_image(re_image, re_h, re_w, re_size, (0.0, 0.0, 0.0))
+    return re_image, resize_ratio
+
+
+def preprocess(img_raw, input_size, device):
+    """preprocess
+    Args:
+        img_raw: origin image 
+    Returns: 
+        img: resized image
+        scale: resized image scale
+        resize: resize ratio
+    """
+    img = np.float32(img_raw)
+    # resize image
+    img, resize = resize_image(img, input_size)
+    scale = torch.Tensor([img.shape[1], img.shape[0], img.shape[1], img.shape[0]])
+    img -= (104, 117, 123)
+    img = img.transpose(2, 0, 1)
+    img = torch.from_numpy(img).unsqueeze(0)
+    img = img.numpy()
+    scale = scale.to(device)
+    return img, scale, resize
+
+
+def postprocess(cfg, img, outputs, scale, resize, confidence_threshold, nms_threshold, device):
+    """post_process
+    Args:
+        img: resized image
+        outputs: forward outputs
+        scale: resized image scale
+        resize: resize ratio
+        confidence_threshold: confidence threshold
+        nms_threshold: non-maximum suppression threshold
+    Returns: 
+        detetcion results
+    """
+    _, _, im_height, im_width= img.shape
+    loc = torch.from_numpy(outputs[0])
+    conf = torch.from_numpy(outputs[1])
+    landms = torch.from_numpy(outputs[2])
+    # softmax
+    conf = F.softmax(conf, dim=-1)
+
+    priorbox = PriorBox(cfg, image_size=(im_height, im_width))
+    priors = priorbox.forward()
+    priors = priors.to(device)
+    prior_data = priors.data
+    boxes = decode(loc.squeeze(0), prior_data, cfg["variance"])
+    boxes = boxes * scale / resize 
+    boxes = boxes.cpu().numpy()
+    scores = conf.squeeze(0).data.cpu().numpy()[:, 1]
+    landms = decode_landm(landms.squeeze(0), prior_data, cfg["variance"])
+    scale1 = torch.Tensor(
+        [img.shape[3], img.shape[2], img.shape[3], img.shape[2], img.shape[3],
+         img.shape[2], img.shape[3], img.shape[2], img.shape[3], img.shape[2],]
+    )
+    scale1 = scale1.to(device)
+    landms = landms * scale1 / resize 
+    landms = landms.cpu().numpy()
+
+    # ignore low scores
+    inds = np.where(scores > confidence_threshold)[0]
+    boxes = boxes[inds]
+    landms = landms[inds]
+    scores = scores[inds]
+
+    # keep top-K before NMS
+    order = scores.argsort()[::-1]
+    boxes = boxes[order]
+    landms = landms[order]
+    scores = scores[order]
+
+    # do NMS
+    dets = np.hstack((boxes, scores[:, np.newaxis])).astype(np.float32, copy=False)
+    keep = py_cpu_nms(dets, nms_threshold)
+    dets = dets[keep, :]
+    landms = landms[keep]
+    dets = np.concatenate((dets, landms), axis=1)
+    return dets

weights/RetinaFace_int.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7377847aafa8aece44f06a6acb6e48e7810e9b2057a599ef0a896c1b726f35b9
+size 1767381

widerface_evaluate/README.md

@@ -0,0 +1,27 @@
+# WiderFace-Evaluation
+Python Evaluation Code for [Wider Face Dataset](http://mmlab.ie.cuhk.edu.hk/projects/WIDERFace/)
+
+
+## Usage
+
+
+##### before evaluating ....
+
+````
+python3 setup.py build_ext --inplace
+````
+
+##### evaluating
+
+**GroungTruth:** `wider_face_val.mat`, `wider_easy_val.mat`, `wider_medium_val.mat`,`wider_hard_val.mat`
+
+````
+python3 evaluation.py -p <your prediction dir> -g <groud truth dir>
+````
+
+## Bugs & Problems
+please issue
+
+## Acknowledgements
+
+some code borrowed from Sergey Karayev

widerface_evaluate/box_overlaps.pyx

@@ -0,0 +1,55 @@
+# --------------------------------------------------------
+# Fast R-CNN
+# Copyright (c) 2015 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Written by Sergey Karayev
+# --------------------------------------------------------
+
+cimport cython
+import numpy as np
+cimport numpy as np
+
+DTYPE = np.float64
+ctypedef np.float_t DTYPE_t
+
+def bbox_overlaps(
+        np.ndarray[DTYPE_t, ndim=2] boxes,
+        np.ndarray[DTYPE_t, ndim=2] query_boxes):
+    """
+    Parameters
+    ----------
+    boxes: (N, 4) ndarray of float
+    query_boxes: (K, 4) ndarray of float
+    Returns
+    -------
+    overlaps: (N, K) ndarray of overlap between boxes and query_boxes
+    """
+    cdef unsigned int N = boxes.shape[0]
+    cdef unsigned int K = query_boxes.shape[0]
+    cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE)
+    cdef DTYPE_t iw, ih, box_area
+    cdef DTYPE_t ua
+    cdef unsigned int k, n
+    for k in range(K):
+        box_area = (
+            (query_boxes[k, 2] - query_boxes[k, 0] + 1) *
+            (query_boxes[k, 3] - query_boxes[k, 1] + 1)
+        )
+        for n in range(N):
+            iw = (
+                min(boxes[n, 2], query_boxes[k, 2]) -
+                max(boxes[n, 0], query_boxes[k, 0]) + 1
+            )
+            if iw > 0:
+                ih = (
+                    min(boxes[n, 3], query_boxes[k, 3]) -
+                    max(boxes[n, 1], query_boxes[k, 1]) + 1
+                )
+                if ih > 0:
+                    ua = float(
+                        (boxes[n, 2] - boxes[n, 0] + 1) *
+                        (boxes[n, 3] - boxes[n, 1] + 1) +
+                        box_area - iw * ih
+                    )
+                    overlaps[n, k] = iw * ih / ua
+    return overlaps

widerface_evaluate/evaluation.py

@@ -0,0 +1,311 @@
+"""
+WiderFace evaluation code
+author: wondervictor
+mail: [email protected]
+copyright@wondervictor
+"""
+
+import os
+import tqdm
+import pickle
+import argparse
+import numpy as np
+from scipy.io import loadmat
+from bbox import bbox_overlaps
+from IPython import embed
+
+
+def get_gt_boxes(gt_dir):
+    """gt dir: (wider_face_val.mat, wider_easy_val.mat, wider_medium_val.mat, wider_hard_val.mat)"""
+
+    gt_mat = loadmat(os.path.join(gt_dir, "wider_face_val.mat"))
+    hard_mat = loadmat(os.path.join(gt_dir, "wider_hard_val.mat"))
+    medium_mat = loadmat(os.path.join(gt_dir, "wider_medium_val.mat"))
+    easy_mat = loadmat(os.path.join(gt_dir, "wider_easy_val.mat"))
+
+    facebox_list = gt_mat["face_bbx_list"]
+    event_list = gt_mat["event_list"]
+    file_list = gt_mat["file_list"]
+
+    hard_gt_list = hard_mat["gt_list"]
+    medium_gt_list = medium_mat["gt_list"]
+    easy_gt_list = easy_mat["gt_list"]
+
+    return (
+        facebox_list,
+        event_list,
+        file_list,
+        hard_gt_list,
+        medium_gt_list,
+        easy_gt_list,
+    )
+
+
+def get_gt_boxes_from_txt(gt_path, cache_dir):
+    cache_file = os.path.join(cache_dir, "gt_cache.pkl")
+    if os.path.exists(cache_file):
+        f = open(cache_file, "rb")
+        boxes = pickle.load(f)
+        f.close()
+        return boxes
+
+    f = open(gt_path, "r")
+    state = 0
+    lines = f.readlines()
+    lines = list(map(lambda x: x.rstrip("\r\n"), lines))
+    boxes = {}
+    print(len(lines))
+    f.close()
+    current_boxes = []
+    current_name = None
+    for line in lines:
+        if state == 0 and "--" in line:
+            state = 1
+            current_name = line
+            continue
+        if state == 1:
+            state = 2
+            continue
+
+        if state == 2 and "--" in line:
+            state = 1
+            boxes[current_name] = np.array(current_boxes).astype("float32")
+            current_name = line
+            current_boxes = []
+            continue
+
+        if state == 2:
+            box = [float(x) for x in line.split(" ")[:4]]
+            current_boxes.append(box)
+            continue
+
+    f = open(cache_file, "wb")
+    pickle.dump(boxes, f)
+    f.close()
+    return boxes
+
+
+def read_pred_file(filepath):
+    with open(filepath, "r") as f:
+        lines = f.readlines()
+        img_file = lines[0].rstrip("\n\r")
+        lines = lines[2:]
+
+    # b = lines[0].rstrip('\r\n').split(' ')[:-1]
+    # c = float(b)
+    # a = map(lambda x: [[float(a[0]), float(a[1]), float(a[2]), float(a[3]), float(a[4])] for a in x.rstrip('\r\n').split(' ')], lines)
+    boxes = []
+    for line in lines:
+        line = line.rstrip("\r\n").split(" ")
+        if line[0] == "":
+            continue
+        # a = float(line[4])
+        boxes.append(
+            [
+                float(line[0]),
+                float(line[1]),
+                float(line[2]),
+                float(line[3]),
+                float(line[4]),
+            ]
+        )
+    boxes = np.array(boxes)
+    # boxes = np.array(list(map(lambda x: [float(a) for a in x.rstrip('\r\n').split(' ')], lines))).astype('float')
+    return img_file.split("/")[-1], boxes
+
+
+def get_preds(pred_dir):
+    events = os.listdir(pred_dir)
+    boxes = dict()
+    pbar = tqdm.tqdm(events)
+
+    for event in pbar:
+        pbar.set_description("Reading Predictions ")
+        event_dir = os.path.join(pred_dir, event)
+        event_images = os.listdir(event_dir)
+        current_event = dict()
+        for imgtxt in event_images:
+            imgname, _boxes = read_pred_file(os.path.join(event_dir, imgtxt))
+            current_event[imgname.rstrip(".jpg")] = _boxes
+        boxes[event] = current_event
+    return boxes
+
+
+def norm_score(pred):
+    """norm score
+    pred {key: [[x1,y1,x2,y2,s]]}
+    """
+
+    max_score = 0
+    min_score = 1
+
+    for _, k in pred.items():
+        for _, v in k.items():
+            if len(v) == 0:
+                continue
+            _min = np.min(v[:, -1])
+            _max = np.max(v[:, -1])
+            max_score = max(_max, max_score)
+            min_score = min(_min, min_score)
+
+    diff = max_score - min_score
+    for _, k in pred.items():
+        for _, v in k.items():
+            if len(v) == 0:
+                continue
+            v[:, -1] = (v[:, -1] - min_score) / diff
+
+
+def image_eval(pred, gt, ignore, iou_thresh):
+    """single image evaluation
+    pred: Nx5
+    gt: Nx4
+    ignore:
+    """
+
+    _pred = pred.copy()
+    _gt = gt.copy()
+    pred_recall = np.zeros(_pred.shape[0])
+    recall_list = np.zeros(_gt.shape[0])
+    proposal_list = np.ones(_pred.shape[0])
+
+    _pred[:, 2] = _pred[:, 2] + _pred[:, 0]
+    _pred[:, 3] = _pred[:, 3] + _pred[:, 1]
+    _gt[:, 2] = _gt[:, 2] + _gt[:, 0]
+    _gt[:, 3] = _gt[:, 3] + _gt[:, 1]
+
+    overlaps = bbox_overlaps(_pred[:, :4], _gt)
+
+    for h in range(_pred.shape[0]):
+        gt_overlap = overlaps[h]
+        max_overlap, max_idx = gt_overlap.max(), gt_overlap.argmax()
+        if max_overlap >= iou_thresh:
+            if ignore[max_idx] == 0:
+                recall_list[max_idx] = -1
+                proposal_list[h] = -1
+            elif recall_list[max_idx] == 0:
+                recall_list[max_idx] = 1
+
+        r_keep_index = np.where(recall_list == 1)[0]
+        pred_recall[h] = len(r_keep_index)
+    return pred_recall, proposal_list
+
+
+def img_pr_info(thresh_num, pred_info, proposal_list, pred_recall):
+    pr_info = np.zeros((thresh_num, 2)).astype("float")
+    for t in range(thresh_num):
+        thresh = 1 - (t + 1) / thresh_num
+        r_index = np.where(pred_info[:, 4] >= thresh)[0]
+        if len(r_index) == 0:
+            pr_info[t, 0] = 0
+            pr_info[t, 1] = 0
+        else:
+            r_index = r_index[-1]
+            p_index = np.where(proposal_list[: r_index + 1] == 1)[0]
+            pr_info[t, 0] = len(p_index)
+            pr_info[t, 1] = pred_recall[r_index]
+    return pr_info
+
+
+def dataset_pr_info(thresh_num, pr_curve, count_face):
+    _pr_curve = np.zeros((thresh_num, 2))
+    for i in range(thresh_num):
+        _pr_curve[i, 0] = pr_curve[i, 1] / pr_curve[i, 0]
+        _pr_curve[i, 1] = pr_curve[i, 1] / count_face
+    return _pr_curve
+
+
+def voc_ap(rec, prec):
+    # correct AP calculation
+    # first append sentinel values at the end
+    mrec = np.concatenate(([0.0], rec, [1.0]))
+    mpre = np.concatenate(([0.0], prec, [0.0]))
+
+    # compute the precision envelope
+    for i in range(mpre.size - 1, 0, -1):
+        mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])
+
+    # to calculate area under PR curve, look for points
+    # where X axis (recall) changes value
+    i = np.where(mrec[1:] != mrec[:-1])[0]
+
+    # and sum (\Delta recall) * prec
+    ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
+    return ap
+
+
+def evaluation(pred, gt_path, iou_thresh=0.5):
+    pred = get_preds(pred)
+    norm_score(pred)
+    (
+        facebox_list,
+        event_list,
+        file_list,
+        hard_gt_list,
+        medium_gt_list,
+        easy_gt_list,
+    ) = get_gt_boxes(gt_path)
+    event_num = len(event_list)
+    thresh_num = 1000
+    settings = ["easy", "medium", "hard"]
+    setting_gts = [easy_gt_list, medium_gt_list, hard_gt_list]
+    aps = []
+    for setting_id in range(3):
+        # different setting
+        gt_list = setting_gts[setting_id]
+        count_face = 0
+        pr_curve = np.zeros((thresh_num, 2)).astype("float")
+        # [hard, medium, easy]
+        pbar = tqdm.tqdm(range(event_num))
+        for i in pbar:
+            pbar.set_description("Processing {}".format(settings[setting_id]))
+            event_name = str(event_list[i][0][0])
+            img_list = file_list[i][0]
+            pred_list = pred[event_name]
+            sub_gt_list = gt_list[i][0]
+            # img_pr_info_list = np.zeros((len(img_list), thresh_num, 2))
+            gt_bbx_list = facebox_list[i][0]
+
+            for j in range(len(img_list)):
+                pred_info = pred_list[str(img_list[j][0][0])]
+
+                gt_boxes = gt_bbx_list[j][0].astype("float")
+                keep_index = sub_gt_list[j][0]
+                count_face += len(keep_index)
+
+                if len(gt_boxes) == 0 or len(pred_info) == 0:
+                    continue
+                ignore = np.zeros(gt_boxes.shape[0])
+                if len(keep_index) != 0:
+                    ignore[keep_index - 1] = 1
+                pred_recall, proposal_list = image_eval(
+                    pred_info, gt_boxes, ignore, iou_thresh
+                )
+
+                _img_pr_info = img_pr_info(
+                    thresh_num, pred_info, proposal_list, pred_recall
+                )
+
+                pr_curve += _img_pr_info
+        pr_curve = dataset_pr_info(thresh_num, pr_curve, count_face)
+
+        propose = pr_curve[:, 0]
+        recall = pr_curve[:, 1]
+
+        ap = voc_ap(recall, propose)
+        aps.append(ap)
+
+    print("==================== Results ====================")
+    print("Easy   Val AP: {}".format(aps[0]))
+    print("Medium Val AP: {}".format(aps[1]))
+    print("Hard   Val AP: {}".format(aps[2]))
+    print("=================================================")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-p", "--pred", default="./widerface_txt/")
+    parser.add_argument("-g", "--gt", default="./ground_truth/")
+
+    args = parser.parse_args()
+    evaluation(args.pred, args.gt)

widerface_evaluate/setup.py

@@ -0,0 +1,13 @@
+"""
+WiderFace evaluation code
+author: wondervictor
+mail: [email protected]
+copyright@wondervictor
+"""
+
+from distutils.core import setup, Extension
+from Cython.Build import cythonize
+import numpy
+
+package = Extension("bbox", ["box_overlaps.pyx"], include_dirs=[numpy.get_include()])
+setup(ext_modules=cythonize([package]))

widerface_onnx_evalute.py

@@ -0,0 +1,136 @@
+import os
+import argparse
+
+import onnxruntime as ort
+from utils import *
+
+
+CFG = {
+    "name": "mobilenet0.25",
+    "min_sizes": [[16, 32], [64, 128], [256, 512]],
+    "steps": [8, 16, 32],
+    "variance": [0.1, 0.2],
+    "clip": False,
+}
+INPUT_SIZE = [608, 640]   #resize scale
+DEVICE = torch.device("cpu")
+
+
+def save_result(img_name, dets, save_folder):
+    """Save detection results
+    Args:
+        img_name: origin image name
+        dets: detection results
+        save_folder: results path
+    """
+    if not os.path.exists(save_folder):
+        os.makedirs(save_folder)
+    save_name = save_folder + img_name[:-4] + ".txt"
+    dirname = os.path.dirname(save_name)
+    if not os.path.isdir(dirname):
+        os.makedirs(dirname)
+    with open(save_name, "w") as fw:
+        bboxs = dets
+        file_name = os.path.basename(save_name)[:-4] + "\n"
+        bboxs_num = str(len(bboxs)) + "\n"
+        fw.write(file_name)
+        fw.write(bboxs_num)
+        for box in bboxs:
+            x = int(box[0])
+            y = int(box[1])
+            w = int(box[2]) - int(box[0])
+            h = int(box[3]) - int(box[1])
+            confidence = str(box[4])
+            line = (str(x) + " " + str(y) + " " + str(w) + " " + str(h) + " " + confidence + " \n")
+            fw.write(line)
+
+
+def Retinaface_evalute(run_ort, args):
+    """Retinaface_evalute function
+    Args:
+        run_ort : run_ort to evaluate.
+        args : parser parameter.
+    Returns:
+        predict result : under "--save_folder" path.
+    """
+    # testing dataset
+    testset_folder = args.dataset_folder
+    testset_list = args.dataset_folder[:-7] + "wider_val.txt"
+
+    with open(testset_list, "r") as fr:
+        test_dataset = fr.read().split()
+    num_images = len(test_dataset)
+    
+    # testing begin
+    for i, img_name in enumerate(test_dataset):
+        image_path = testset_folder + img_name
+        img_raw = cv2.imread(image_path, cv2.IMREAD_COLOR)
+        # preprocess
+        img, scale, resize = preprocess(img_raw, INPUT_SIZE, DEVICE)
+        # forward 
+        outputs = run_ort.run(None, {run_ort.get_inputs()[0].name: img})
+        # postprocess
+        dets = postprocess(CFG, img, outputs, scale, resize, args.confidence_threshold, args.nms_threshold, DEVICE)
+
+        # save predict result
+        save_result(img_name, dets, args.save_folder)
+        print("im_detect: {:d}/{:d}".format(i + 1, num_images))
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="Retinaface")
+    parser.add_argument(
+        "-m",
+        "--trained_model",
+        default="./weights/RetinaFace_int.onnx",
+        type=str,
+        help="Trained state_dict file path to open",
+    )
+    parser.add_argument(
+        "--save_folder",
+        default="./widerface_evaluate/widerface_txt/",
+        type=str,
+        help="Dir to save txt results",
+    )
+    parser.add_argument(
+        "--dataset_folder",
+        default="./data/widerface/val/images/",
+        type=str,
+        help="dataset path",
+    )
+    parser.add_argument(
+        "--confidence_threshold",
+        default=0.02,
+        type=float,
+        help="confidence_threshold",
+    )
+    parser.add_argument(
+        "--nms_threshold",
+        default=0.4,
+        type=float,
+        help="nms_threshold",
+    )
+    parser.add_argument(
+        "--ipu",
+        action="store_true",
+        help="Use IPU for inference.",
+    )
+    parser.add_argument(
+        "--provider_config",
+        type=str,
+        default="vaip_config.json",
+        help="Path of the config file for seting provider_options.",
+    )
+
+    args = parser.parse_args()
+    if args.ipu:
+        providers = ["VitisAIExecutionProvider"]
+        provider_options = [{"config_file": args.provider_config}]
+    else:
+        providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+        provider_options = None
+        
+    print("Loading pretrained model from {}".format(args.trained_model))
+    run_ort = ort.InferenceSession(args.trained_model, providers=providers, provider_options=provider_options)
+    
+    Retinaface_evalute(run_ort, args)

widerface_onnx_inference.py

@@ -0,0 +1,151 @@
+import os
+import argparse
+
+import onnxruntime as ort
+from utils import *
+
+
+CFG = {
+    "name": "mobilenet0.25",
+    "min_sizes": [[16, 32], [64, 128], [256, 512]],
+    "steps": [8, 16, 32],
+    "variance": [0.1, 0.2],
+    "clip": False,
+}
+INPUT_SIZE = [608, 640]   #resize scale
+DEVICE = torch.device("cpu")
+
+
+def vis(img_raw, dets, vis_thres):
+    """Visualization original image
+    Args:
+        img_raw: origin image
+        dets: detections
+        vis_thres: visualization threshold
+    Returns: 
+        visualization results
+    """
+    for b in dets:
+        if b[4] < vis_thres:
+            continue
+        text = "{:.4f}".format(b[4])
+        b = list(map(int, b))
+        cv2.rectangle(img_raw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255), 2)
+        cx = b[0]
+        cy = b[1] + 12
+        cv2.putText(img_raw, text, (cx, cy), cv2.FONT_HERSHEY_DUPLEX, 0.5, (255, 255, 255),)
+
+        # landms
+        cv2.circle(img_raw, (b[5], b[6]), 1, (0, 0, 255), 4)
+        cv2.circle(img_raw, (b[7], b[8]), 1, (0, 255, 255), 4)
+        cv2.circle(img_raw, (b[9], b[10]), 1, (255, 0, 255), 4)
+        cv2.circle(img_raw, (b[11], b[12]), 1, (0, 255, 0), 4)
+        cv2.circle(img_raw, (b[13], b[14]), 1, (255, 0, 0), 4)
+    # save image
+    if not os.path.exists("./results/"):
+        os.makedirs("./results/")
+    name = "./results/" + 'result' + ".jpg"
+    cv2.imwrite(name, img_raw)
+
+
+def Retinaface_inference(run_ort, args):
+    """Infer an image with onnx seession
+    Args:
+        run_ort: Onnx session
+        args: including image path and hyperparameters
+    Returns: boxes_list, confidence_list, landm_list
+        boxes_list = [[left, top, right, bottom]...]
+        confidence_list = [[confidence]...]
+        landm_list = [[landms(dim=10)]...]
+    """
+    img_raw = cv2.imread(args.image_path, cv2.IMREAD_COLOR)
+    # preprocess
+    img, scale, resize = preprocess(img_raw, INPUT_SIZE, DEVICE)
+    # forward 
+    outputs = run_ort.run(None, {run_ort.get_inputs()[0].name: img})
+    # postprocess
+    dets = postprocess(CFG, img, outputs, scale, resize, args.confidence_threshold, args.nms_threshold, DEVICE)
+    
+    # result list
+    boxes = dets[:, :4]
+    confidences = dets[:, 4:5]
+    landms = dets[:, 5:]
+    boxes_list = [box.tolist() for box in boxes]
+    confidence_list = [confidence.tolist() for confidence in confidences]
+    landm_list = [landm.tolist() for landm in landms]
+
+    # save image
+    if args.save_image:
+        vis(img_raw, dets, args.vis_thres)
+
+    return boxes_list, confidence_list, landm_list
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="Retinaface")
+    parser.add_argument(
+        "-m",
+        "--trained_model",
+        default="./weights/RetinaFace_int.onnx",
+        type=str,
+        help="Trained state_dict file path to open",
+    )
+    parser.add_argument(
+        "--image_path",
+        default="./data/widerface/val/images/18--Concerts/18_Concerts_Concerts_18_38.jpg",
+        type=str,
+        help="image path",
+    )
+    parser.add_argument(
+        "--confidence_threshold", 
+        default=0.4, 
+        type=float, 
+        help="confidence_threshold" 
+    )
+    parser.add_argument(
+        "--nms_threshold", 
+        default=0.4, 
+        type=float, 
+        help="nms_threshold"
+    )
+    parser.add_argument(
+        "-s",
+        "--save_image",
+        action="store_true",
+        default=False, 
+        help="show detection results",
+    )
+    parser.add_argument(
+        "--vis_thres", 
+        default=0.5, 
+        type=float, 
+        help="visualization_threshold"
+    )
+    parser.add_argument(
+        "--ipu",
+        action="store_true",
+        help="Use IPU for inference.",
+    )
+    parser.add_argument(
+        "--provider_config",
+        type=str,
+        default="vaip_config.json",
+        help="Path of the config file for seting provider_options.",
+    )
+    
+    args = parser.parse_args()
+
+    if args.ipu:
+        providers = ["VitisAIExecutionProvider"]
+        provider_options = [{"config_file": args.provider_config}]
+    else:
+        providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+        provider_options = None
+        
+    print("Loading pretrained model from {}".format(args.trained_model))
+    run_ort = ort.InferenceSession(args.trained_model, providers=providers, provider_options=provider_options)
+
+    boxes_list, confidence_list, landm_list = Retinaface_inference(run_ort, args)
+    print('inference done!')
+    print(boxes_list, confidence_list, landm_list)
+