init

app.py

@@ -0,0 +1,31 @@
+import gradio as gr
+import os
+from src.detection import Detector
+
+
+# UGC: Define the inference fn() for your models
+def model_inference(image):
+    image, json_out = Detector('BlazeFace')(image)
+    return image
+
+
+def clear_all():
+    return None, None, None
+
+
+# 下载模型
+os.system("wget -c https://huggingface.co/yangcsu/facialdetection-vgg/resolve/main/vgg.pdparams -P ./configs")
+os.system("wget -c https://huggingface.co/yangcsu/facialdetection-vgg/resolve/main/model.pdiparams -P ./configs")
+os.system("wget -c https://huggingface.co/yangcsu/facialdetection-vgg/resolve/main/model.pdmodel -P ./configs")
+
+examples = [
+    "https://s3.tebi.io/oss.haust.ml/images/face1.jpg"
+]
+title = "人脸识别，表情分析"
+description = "使用BlazeFace模型识别图片中的人脸，并使用VGG16模型分析其表情"
+
+demo = gr.Interface(fn=model_inference, inputs="image", outputs="image", title=title, description=description,
+                    examples=examples)
+
+# 启动Gradio
+demo.launch()

configs/BlazeFace.yml

@@ -0,0 +1,22 @@
+mode: paddle
+draw_threshold: 0.5
+metric: WiderFace
+use_dynamic_shape: true
+arch: Face
+min_subgraph_size: 3
+param_path: configs/model.pdiparams
+model_path: configs/model.pdmodel
+Preprocess:
+- is_scale: false
+  mean:
+  - 123
+  - 117
+  - 104
+  std:
+  - 127.502231
+  - 127.502231
+  - 127.502231
+  type: NormalizeImage
+- type: Permute
+label_list:
+- face

requirements.txt

@@ -0,0 +1,10 @@
+gradio
+opencv-python
+paddlepaddle
+PyYAML
+shapely
+scipy
+Cython
+numpy
+setuptools
+pillow

src/NetWork.py

@@ -0,0 +1,98 @@
+# -*- coding:utf-8 -*-
+# VGG模型代码
+import numpy as np
+import paddle
+# from paddle.nn import Conv2D, MaxPool2D, BatchNorm, Linear
+from paddle.nn import Conv2D, MaxPool2D, BatchNorm2D, Linear
+
+
+# 定义vgg网络
+class VGG(paddle.nn.Layer):
+    def __init__(self, num_class):
+        super(VGG, self).__init__()
+
+        in_channels = [3, 64, 128, 256, 512, 512]
+        # 定义第一个卷积块，包含两个卷积 输入通道数是图片通道数即3 输出通道数即out_channels=in_channels[1]=64
+        self.conv1_1 = Conv2D(in_channels=in_channels[0], out_channels=in_channels[1], kernel_size=3, padding=1,
+                              stride=1)
+        self.conv1_2 = Conv2D(in_channels=in_channels[1], out_channels=in_channels[1], kernel_size=3, padding=1,
+                              stride=1)
+        # 定义第二个卷积块，包含两个卷积 输入通道数是上一个卷积块的输出通道数即64 输出通道数即out_channels=in_channels[2]=128
+        self.conv2_1 = Conv2D(in_channels=in_channels[1], out_channels=in_channels[2], kernel_size=3, padding=1,
+                              stride=1)
+        self.conv2_2 = Conv2D(in_channels=in_channels[2], out_channels=in_channels[2], kernel_size=3, padding=1,
+                              stride=1)
+        # 定义第三个卷积块，包含三个卷积 输入通道数是上一个卷积块的输出通道数即128 输出通道数即out_channels=in_channels[3]=256
+        self.conv3_1 = Conv2D(in_channels=in_channels[2], out_channels=in_channels[3], kernel_size=3, padding=1,
+                              stride=1)
+        self.conv3_2 = Conv2D(in_channels=in_channels[3], out_channels=in_channels[3], kernel_size=3, padding=1,
+                              stride=1)
+        self.conv3_3 = Conv2D(in_channels=in_channels[3], out_channels=in_channels[3], kernel_size=3, padding=1,
+                              stride=1)
+        # 定义第四个卷积块，包含三个卷积 输入通道数是上一个卷积块的输出通道数即256 输出通道数即out_channels=in_channels[4]=512
+        self.conv4_1 = Conv2D(in_channels=in_channels[3], out_channels=in_channels[4], kernel_size=3, padding=1,
+                              stride=1)
+        self.conv4_2 = Conv2D(in_channels=in_channels[4], out_channels=in_channels[4], kernel_size=3, padding=1,
+                              stride=1)
+        self.conv4_3 = Conv2D(in_channels=in_channels[4], out_channels=in_channels[4], kernel_size=3, padding=1,
+                              stride=1)
+        # 定义第五个卷积块，包含三个卷积 输入通道数是上一个卷积块的输出通道数即512 输出通道数即out_channels=in_channels[5]=512
+        self.conv5_1 = Conv2D(in_channels=in_channels[4], out_channels=in_channels[5], kernel_size=3, padding=1,
+                              stride=1)
+        self.conv5_2 = Conv2D(in_channels=in_channels[5], out_channels=in_channels[5], kernel_size=3, padding=1,
+                              stride=1)
+        self.conv5_3 = Conv2D(in_channels=in_channels[5], out_channels=in_channels[5], kernel_size=3, padding=1,
+                              stride=1)
+
+        # VGG网络的设计严格使用3*3的卷积层和池化层来提取特征，并在网络的最后面使用三层全连接层，将最后一层全连接层的输出作为分类的预测。
+        # 使用Sequential 将全连接层和relu组成一个线性结构（fc + relu）
+        # 当输入为224x224时，经过五个卷积块和池化层后，特征维度变为[512x7x7]
+        self.fc1 = paddle.nn.Sequential(paddle.nn.Linear(512 * 7 * 7, 4096), paddle.nn.ReLU())
+
+        self.drop1_ratio = 0.5
+        self.dropout1 = paddle.nn.Dropout(self.drop1_ratio, mode='upscale_in_train')
+        # 使用Sequential 将全连接层和relu组成一个线性结构（fc + relu）
+        self.fc2 = paddle.nn.Sequential(paddle.nn.Linear(4096, 4096), paddle.nn.ReLU())
+
+        self.drop2_ratio = 0.5
+        self.dropout2 = paddle.nn.Dropout(self.drop2_ratio, mode='upscale_in_train')
+
+        # 全连接层的输出
+        # paddle.nn.Linear(in_features, out_features, weight_attr=None, bias_attr=None, name=None)
+        # out_features 由输出标签的个数决定 本案例识别的7种表情，对应了3种标签。 因此 out_features = 3
+        self.fc3 = paddle.nn.Linear(4096, num_class)
+
+        self.relu = paddle.nn.ReLU()
+        self.pool = MaxPool2D(stride=2, kernel_size=2)
+
+    def forward(self, x):
+        # 激活函数用relu
+        x = self.relu(self.conv1_1(x))
+        x = self.relu(self.conv1_2(x))
+        x = self.pool(x)
+
+        x = self.relu(self.conv2_1(x))
+        x = self.relu(self.conv2_2(x))
+        x = self.pool(x)
+
+        x = self.relu(self.conv3_1(x))
+        x = self.relu(self.conv3_2(x))
+        x = self.relu(self.conv3_3(x))
+        x = self.pool(x)
+
+        x = self.relu(self.conv4_1(x))
+        x = self.relu(self.conv4_2(x))
+        x = self.relu(self.conv4_3(x))
+        x = self.pool(x)
+
+        x = self.relu(self.conv5_1(x))
+        x = self.relu(self.conv5_2(x))
+        x = self.relu(self.conv5_3(x))
+        x = self.pool(x)
+
+        x = paddle.flatten(x, 1, -1)
+        # 添加dropout抑制过拟合
+        x = self.dropout1(self.relu(self.fc1(x)))
+        x = self.dropout2(self.relu(self.fc2(x)))
+        x = self.fc3(x)
+        return x

src/detection.py

@@ -0,0 +1,123 @@
+import cv2
+import os
+import numpy as np
+import yaml
+from paddle.inference import Config, create_predictor, PrecisionType
+from PIL import Image
+
+from .download import get_model_path
+from .preprocess import preprocess, Resize, NormalizeImage, Permute, PadStride, decode_image
+from .visualize import draw_det
+
+class Detector(object):
+    def __init__(self, model_name):
+        parent_path = os.path.abspath(os.path.join(__file__, *(['..'] * 2)))
+        yml_file = os.path.join(parent_path, 'configs/{}.yml'.format(model_name))
+        with open(yml_file, 'r') as f:
+            yml_conf = yaml.safe_load(f)
+        
+        infer_model = get_model_path(yml_conf['model_path'])
+        infer_params = get_model_path(yml_conf['param_path'])
+        config = Config(infer_model, infer_params)
+        device = yml_conf.get('device', 'CPU')
+        run_mode = yml_conf.get('mode', 'paddle')
+        cpu_threads = yml_conf.get('cpu_threads', 1)
+        if device == 'CPU':
+            config.disable_gpu()
+            config.set_cpu_math_library_num_threads(cpu_threads)
+        elif device == 'GPU':
+            # initial GPU memory(M), device ID
+            config.enable_use_gpu(200, 0)
+            # optimize graph and fuse op
+            config.switch_ir_optim(True)
+
+        precision_map = {
+            'trt_int8': Config.Precision.Int8,
+            'trt_fp32': Config.Precision.Float32,
+            'trt_fp16': Config.Precision.Half
+        }
+
+
+        if run_mode in precision_map.keys():
+            config.enable_tensorrt_engine(
+                workspace_size=(1 << 25) * batch_size,
+                max_batch_size=batch_size,
+                min_subgraph_size=yml_conf['min_subgraph_size'],
+                precision_mode=precision_map[run_mode],
+                use_static=True,
+                use_calib_mode=False)
+
+            if yml_conf['use_dynamic_shape']:
+                min_input_shape = {
+                    'image': [batch_size, 3, 640, 640],
+                    'scale_factor': [batch_size, 2]
+                }
+                max_input_shape = {
+                    'image': [batch_size, 3, 1280, 1280],
+                    'scale_factor': [batch_size, 2]
+                }
+                opt_input_shape = {
+                    'image': [batch_size, 3, 1024, 1024],
+                    'scale_factor': [batch_size, 2]
+                }
+                config.set_trt_dynamic_shape_info(min_input_shape, max_input_shape,
+                                                opt_input_shape)
+        
+        # disable print log when predict
+        config.disable_glog_info()
+        # enable shared memory
+        config.enable_memory_optim()
+        # disable feed, fetch OP, needed by zero_copy_run
+        config.switch_use_feed_fetch_ops(False)
+        self.predictor = create_predictor(config)
+        self.yml_conf = yml_conf
+        self.preprocess_ops = self.create_preprocess_ops(yml_conf)
+        self.input_names = self.predictor.get_input_names()
+        self.output_names = self.predictor.get_output_names()
+        self.draw_threshold = yml_conf.get('draw_threshold', 0.5)
+        self.class_names = yml_conf['label_list']
+
+    
+    def create_preprocess_ops(self, yml_conf):
+        preprocess_ops = []
+        for op_info in yml_conf['Preprocess']:
+            new_op_info = op_info.copy()
+            op_type = new_op_info.pop('type')
+            preprocess_ops.append(eval(op_type)(**new_op_info))
+        return preprocess_ops
+    
+    def create_inputs(self, image_files):
+        inputs = dict()
+        im_list, im_info_list = [], []
+        for im_path in image_files:
+            im, im_info = preprocess(im_path, self.preprocess_ops)
+            im_list.append(im)
+            im_info_list.append(im_info)
+
+        inputs['im_shape'] = np.stack([e['im_shape'] for e in im_info_list], axis=0).astype('float32')
+        inputs['scale_factor'] = np.stack([e['scale_factor'] for e in im_info_list], axis=0).astype('float32')
+        inputs['image'] = np.stack(im_list, axis=0).astype('float32')
+        return inputs
+    
+    def __call__(self, image_file):
+        inputs = self.create_inputs([image_file])
+        for name in self.input_names:
+            input_tensor = self.predictor.get_input_handle(name)
+            input_tensor.copy_from_cpu(inputs[name])
+        
+        self.predictor.run()
+        boxes_tensor = self.predictor.get_output_handle(self.output_names[0])
+        np_boxes = boxes_tensor.copy_to_cpu()
+        boxes_num = self.predictor.get_output_handle(self.output_names[1])
+        np_boxes_num = boxes_num.copy_to_cpu()
+        if np_boxes_num.sum() <= 0:
+            np_boxes = np.zeros([0, 6])
+        
+        if isinstance(image_file, str):
+            image = Image.open(image_file).convert('RGB')
+        elif isinstance(image_file, np.ndarray):
+            image = image_file
+        expect_boxes = (np_boxes[:, 1] > self.draw_threshold) & (np_boxes[:, 0] > -1)
+        np_boxes = np_boxes[expect_boxes, :]
+        image = draw_det(image, np_boxes, self.class_names)
+        return image, {'bboxes': np_boxes.tolist()}

src/download.py

@@ -0,0 +1,218 @@
+#   Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import os.path as osp
+import sys
+import yaml
+import time
+import shutil
+import requests
+import tqdm
+import hashlib
+import base64
+import binascii
+import tarfile
+import zipfile
+
+__all__ = [
+    'get_model_path',
+    'get_config_path',
+    'get_dict_path',
+]
+
+WEIGHTS_HOME = osp.expanduser("~/.cache/paddlecv/models")
+CONFIGS_HOME = osp.expanduser("~/.cache/paddlecv/configs")
+DICTS_HOME = osp.expanduser("~/.cache/paddlecv/dicts")
+
+# dict of {dataset_name: (download_info, sub_dirs)}
+# download info: [(url, md5sum)]
+
+DOWNLOAD_RETRY_LIMIT = 3
+
+PMP_DOWNLOAD_URL_PREFIX = 'https://bj.bcebos.com/v1/paddle-model-ecology/paddlecv/'
+
+
+def is_url(path):
+    """
+    Whether path is URL.
+    Args:
+        path (string): URL string or not.
+    """
+    return path.startswith('http://') \
+            or path.startswith('https://') \
+            or path.startswith('paddlecv://')
+
+
+def parse_url(url):
+    url = url.replace("paddlecv://", PMP_DOWNLOAD_URL_PREFIX)
+    return url
+
+
+def get_model_path(path):
+    """Get model path from WEIGHTS_HOME, if not exists,
+    download it from url.
+    """
+    if not is_url(path):
+        return path
+    url = parse_url(path)
+    path, _ = get_path(url, WEIGHTS_HOME, path_depth=2)
+    return path
+
+
+def get_config_path(path):
+    """Get config path from CONFIGS_HOME, if not exists,
+    download it from url.
+    """
+    if not is_url(path):
+        return path
+    url = parse_url(path)
+    path, _ = get_path(url, CONFIGS_HOME)
+    return path
+
+
+def get_dict_path(path):
+    """Get config path from CONFIGS_HOME, if not exists,
+    download it from url.
+    """
+    if not is_url(path):
+        return path
+    url = parse_url(path)
+    path, _ = get_path(url, DICTS_HOME)
+    return path
+
+
+def map_path(url, root_dir, path_depth=1):
+    # parse path after download to decompress under root_dir
+    assert path_depth > 0, "path_depth should be a positive integer"
+    dirname = url
+    for _ in range(path_depth):
+        dirname = osp.dirname(dirname)
+    fpath = osp.relpath(url, dirname)
+    path = osp.join(root_dir, fpath)
+    dirname = osp.dirname(path)
+    return path, dirname
+
+
+def get_path(url, root_dir, md5sum=None, check_exist=True, path_depth=1):
+    """ 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, return the path.
+    url (str): download url
+    root_dir (str): root dir for downloading, it should be
+                    WEIGHTS_HOME
+    md5sum (str): md5 sum of download package
+    """
+    # parse path after download to decompress under root_dir
+    fullpath, dirname = map_path(url, root_dir, path_depth)
+
+    if osp.exists(fullpath) and check_exist:
+        if not osp.isfile(fullpath) or \
+                _check_exist_file_md5(fullpath, md5sum, url):
+            return fullpath, True
+        else:
+            os.remove(fullpath)
+
+    fullname = _download(url, dirname, md5sum)
+    return fullpath, False
+
+
+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 = osp.split(url)[-1]
+    fullname = osp.join(path, fname)
+    retry_cnt = 0
+
+    while not (osp.exists(fullname) and _check_exist_file_md5(fullname, md5sum,
+                                                              url)):
+        if retry_cnt < DOWNLOAD_RETRY_LIMIT:
+            retry_cnt += 1
+        else:
+            raise RuntimeError("Download from {} failed. "
+                               "Retry limit reached".format(url))
+
+
+        # NOTE: windows path join may incur \, which is invalid in url
+        if sys.platform == "win32":
+            url = url.replace('\\', '/')
+
+        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 _check_exist_file_md5(filename, md5sum, url):
+    # if md5sum is None, and file to check is model file, 
+    # read md5um from url and check, else check md5sum directly
+    return _md5check_from_url(filename, url) if md5sum is None \
+            and filename.endswith('pdparams') \
+            else _md5check(filename, md5sum)
+
+
+def _md5check_from_url(filename, url):
+    # For model in bcebos URLs, MD5 value is contained
+    # in request header as 'content_md5'
+    req = requests.get(url, stream=True)
+    content_md5 = req.headers.get('content-md5')
+    req.close()
+    if not content_md5 or _md5check(
+            filename,
+            binascii.hexlify(base64.b64decode(content_md5.strip('"'))).decode(
+            )):
+        return True
+    else:
+        return False
+
+
+def _md5check(fullname, md5sum=None):
+    if md5sum is None:
+        return True
+
+    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:
+        return False
+    return True

src/preprocess.py

@@ -0,0 +1,208 @@
+# Copyright (c) 2020 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 cv2
+import numpy as np
+
+
+def decode_image(im_file, im_info):
+    """read rgb image
+    Args:
+        im_file (str|np.ndarray): input can be image path or np.ndarray
+        im_info (dict): info of image
+    Returns:
+        im (np.ndarray):  processed image (np.ndarray)
+        im_info (dict): info of processed image
+    """
+    if isinstance(im_file, str):
+        with open(im_file, 'rb') as f:
+            im_read = f.read()
+        data = np.frombuffer(im_read, dtype='uint8')
+        im = cv2.imdecode(data, 1)  # BGR mode, but need RGB mode
+        im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)
+    else:
+        im = im_file
+    im_info['im_shape'] = np.array(im.shape[:2], dtype=np.float32)
+    im_info['scale_factor'] = np.array([1., 1.], dtype=np.float32)
+    return im, im_info
+
+
+class Resize(object):
+    """resize image by target_size and max_size
+    Args:
+        target_size (int): the target size of image
+        keep_ratio (bool): whether keep_ratio or not, default true
+        interp (int): method of resize
+    """
+
+    def __init__(self, target_size, keep_ratio=True, interp=cv2.INTER_LINEAR):
+        if isinstance(target_size, int):
+            target_size = [target_size, target_size]
+        self.target_size = target_size
+        self.keep_ratio = keep_ratio
+        self.interp = interp
+
+    def __call__(self, im, im_info):
+        """
+        Args:
+            im (np.ndarray): image (np.ndarray)
+            im_info (dict): info of image
+        Returns:
+            im (np.ndarray):  processed image (np.ndarray)
+            im_info (dict): info of processed image
+        """
+        assert len(self.target_size) == 2
+        assert self.target_size[0] > 0 and self.target_size[1] > 0
+        im_channel = im.shape[2]
+        im_scale_y, im_scale_x = self.generate_scale(im)
+        im = cv2.resize(
+            im,
+            None,
+            None,
+            fx=im_scale_x,
+            fy=im_scale_y,
+            interpolation=self.interp)
+        im_info['im_shape'] = np.array(im.shape[:2]).astype('float32')
+        im_info['scale_factor'] = np.array(
+            [im_scale_y, im_scale_x]).astype('float32')
+        return im, im_info
+
+    def generate_scale(self, im):
+        """
+        Args:
+            im (np.ndarray): image (np.ndarray)
+        Returns:
+            im_scale_x: the resize ratio of X
+            im_scale_y: the resize ratio of Y
+        """
+        origin_shape = im.shape[:2]
+        im_c = im.shape[2]
+        if self.keep_ratio:
+            im_size_min = np.min(origin_shape)
+            im_size_max = np.max(origin_shape)
+            target_size_min = np.min(self.target_size)
+            target_size_max = np.max(self.target_size)
+            im_scale = float(target_size_min) / float(im_size_min)
+            if np.round(im_scale * im_size_max) > target_size_max:
+                im_scale = float(target_size_max) / float(im_size_max)
+            im_scale_x = im_scale
+            im_scale_y = im_scale
+        else:
+            resize_h, resize_w = self.target_size
+            im_scale_y = resize_h / float(origin_shape[0])
+            im_scale_x = resize_w / float(origin_shape[1])
+        return im_scale_y, im_scale_x
+
+
+
+class NormalizeImage(object):
+    """normalize image
+    Args:
+        mean (list): im - mean
+        std (list): im / std
+        is_scale (bool): whether need im / 255
+        norm_type (str): type in ['mean_std', 'none']
+    """
+
+    def __init__(self, mean, std, is_scale=True, norm_type='mean_std'):
+        self.mean = mean
+        self.std = std
+        self.is_scale = is_scale
+        self.norm_type = norm_type
+
+    def __call__(self, im, im_info):
+        """
+        Args:
+            im (np.ndarray): image (np.ndarray)
+            im_info (dict): info of image
+        Returns:
+            im (np.ndarray):  processed image (np.ndarray)
+            im_info (dict): info of processed image
+        """
+        im = im.astype(np.float32, copy=False)
+        if self.is_scale:
+            scale = 1.0 / 255.0
+            im *= scale
+
+        if self.norm_type == 'mean_std':
+            mean = np.array(self.mean)[np.newaxis, np.newaxis, :]
+            std = np.array(self.std)[np.newaxis, np.newaxis, :]
+            im -= mean
+            im /= std
+        return im, im_info
+
+
+class Permute(object):
+    """permute image
+    Args:
+        to_bgr (bool): whether convert RGB to BGR 
+        channel_first (bool): whether convert HWC to CHW
+    """
+
+    def __init__(self, ):
+        super(Permute, self).__init__()
+
+    def __call__(self, im, im_info):
+        """
+        Args:
+            im (np.ndarray): image (np.ndarray)
+            im_info (dict): info of image
+        Returns:
+            im (np.ndarray):  processed image (np.ndarray)
+            im_info (dict): info of processed image
+        """
+        im = im.transpose((2, 0, 1)).copy()
+        return im, im_info
+
+
+class PadStride(object):
+    """ padding image for model with FPN, instead PadBatch(pad_to_stride) in original config
+    Args:
+        stride (bool): model with FPN need image shape % stride == 0
+    """
+
+    def __init__(self, stride=0):
+        self.coarsest_stride = stride
+
+    def __call__(self, im, im_info):
+        """
+        Args:
+            im (np.ndarray): image (np.ndarray)
+            im_info (dict): info of image
+        Returns:
+            im (np.ndarray):  processed image (np.ndarray)
+            im_info (dict): info of processed image
+        """
+        coarsest_stride = self.coarsest_stride
+        if coarsest_stride <= 0:
+            return im, im_info
+        im_c, im_h, im_w = im.shape
+        pad_h = int(np.ceil(float(im_h) / coarsest_stride) * coarsest_stride)
+        pad_w = int(np.ceil(float(im_w) / coarsest_stride) * coarsest_stride)
+        padding_im = np.zeros((im_c, pad_h, pad_w), dtype=np.float32)
+        padding_im[:, :im_h, :im_w] = im
+        return padding_im, im_info
+
+
+def preprocess(im, preprocess_ops):
+    # process image by preprocess_ops
+    im_info = {
+        'scale_factor': np.array(
+            [1., 1.], dtype=np.float32),
+        'im_shape': None,
+    }
+    im, im_info = decode_image(im, im_info)
+    for operator in preprocess_ops:
+        im, im_info = operator(im, im_info)
+    return im, im_info

src/visualize.py

@@ -0,0 +1,103 @@
+import numpy as np
+from PIL import Image, ImageDraw, ImageFile
+from .NetWork import VGG
+import paddle
+import cv2
+
+def get_color_map_list(num_classes):
+    """
+    Args:
+        num_classes (int): number of class
+    Returns:
+        color_map (list): RGB color list
+    """
+    color_map = num_classes * [0, 0, 0]
+    for i in range(0, num_classes):
+        j = 0
+        lab = i
+        while lab:
+            color_map[i * 3] |= (((lab >> 0) & 1) << (7 - j))
+            color_map[i * 3 + 1] |= (((lab >> 1) & 1) << (7 - j))
+            color_map[i * 3 + 2] |= (((lab >> 2) & 1) << (7 - j))
+            j += 1
+            lab >>= 3
+    color_map = [color_map[i:i + 3] for i in range(0, len(color_map), 3)]
+    return color_map
+
+
+def draw_det(image, dt_bboxes, name_set):
+    im = Image.fromarray(image)
+    draw_thickness = min(im.size) // 320
+    draw = ImageDraw.Draw(im)
+    clsid2color = {}
+    color_list = get_color_map_list(len(name_set))
+
+    for (cls_id, score, xmin, ymin, xmax, ymax) in dt_bboxes:
+        image_box = im.crop(tuple([xmin, ymin, xmax, ymax]))
+        label = emotic(image_box)
+        cls_id = int(cls_id)
+        color = tuple(color_list[cls_id])
+        # draw bbox
+        draw.line(
+            [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin),
+             (xmin, ymin)],
+            width=draw_thickness,
+            fill=color)
+
+        # draw label
+        text = "{} {:.4f}".format(label, score)
+        box = draw.textbbox((xmin, ymin), text, anchor='lt')
+        draw.rectangle(box, fill=color)
+        draw.text((box[0], box[1]), text, fill=(255, 255, 255))
+    image = np.array(im)
+    return image
+
+
+def emotic(image):
+    def load_image(img):
+        # 将图片尺寸缩放道 224x224
+        img = cv2.resize(img, (224, 224))
+        # 读入的图像数据格式是[H, W, C]
+        # 使用转置操作将其变成[C, H, W]
+        img = np.transpose(img, (2, 0, 1))
+        img = img.astype('float32')
+        # 将数据范围调整到[-1.0, 1.0]之间
+        img = img / 255.
+        img = img * 2.0 - 1.0
+        return img
+
+    model = VGG(num_class=7)
+    params_file_path = r'configs/vgg.pdparams'
+    img = np.array(image)
+    # plt.imshow(img)
+    # plt.axis('off')
+    # plt.show()
+
+    param_dict = paddle.load(params_file_path)
+    model.load_dict(param_dict)
+    # 灌入数据
+    # model.eval()
+    tensor_img = load_image(img)
+    tensor_img = np.expand_dims(tensor_img, 0)
+
+    results = model(paddle.to_tensor(tensor_img))
+    # 取概率最大的标签作为预测输出
+    lab = np.argsort(results.numpy())
+    tap = lab[0][-1]
+
+    if tap == 0:
+        return 'SAD'
+    elif tap == 1:
+        return 'DISGUST'
+    elif tap == 2:
+        return 'HAPPY'
+    elif tap == 3:
+        return 'FEAR'
+    elif tap == 4:
+        return 'SUPERISE'
+    elif tap == 5:
+        return 'NATUREAL'
+    elif tap == 6:
+        return 'ANGRY'
+    else:
+        raise ('Not excepted file name')