devbox
算法编织者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

用PaddleDetection做上班摸鱼神器（完整教程）_paddledetection github

作者：算法编织者 | 2024-01-31 20:54:54

赞

踩

paddledetection github

来源：转载 作者：livingbody
编辑：学姐

还记得小时候爸妈不偷看电视的你吗？

还记得高中时代看小说防着老师的你吗？

还记得上班打游戏防着领导的你吗？

有了这个你将能安心摸鱼

介绍

本文使用PaddleDetection自制数据集，做人脸分类，调用本地电脑的前置摄像头识别出现在屏幕前的人脸，根据不同的人脸切换本地电脑的窗口，实现偷懒神器~

效果

演示项目效果地址：

https://www.bilibili.com/video/BV1ni4y1V7TT

百度推广视频演示地址：

https://www.bilibili.com/video/BV1kC4y1t7s1

实现的效果截图：

百度推广视频效果图：

PaddleDetection介绍

目标检测是机器视觉领域的核心问题之一。7月3日百度AI开发者大会，飞桨核心框架Paddle Fluid v1.5宣布开源了PaddleDetection物体检测统一框架，用户可以非常方便、快速的搭建出各种检测框架，构建强大的各类应用。

PaddleDetection物体检测统一框架，覆盖主流的检测算法，即具备高精度模型、也具备高速推理模型，并提供丰富的预训练模型，具有工业化、模块化、高性能的优势。

  • 工业化：结合飞桨核心框架的高速推理引擎，训练到部署无缝衔接
  • 模块化：提供模块化设计，模型网络结构和数据处理均可定制
  • 高性能：基于高效的核心框架，训练速度和显存占用上有一定的优势，例如，YOLO v3训练速度相比同类框架快1.6倍。

现有的模型

用PaddleDetection实现本项目

PaddleDetection下载地址：

https://github.com/PaddlePaddle/PaddleDetection

或者

https://gitee.com/paddlepaddle/PaddleDetection

  1. # git下载最新版本
  2. !git clone https://gitee.com/paddlepaddle/PaddleDetection.git --depth=1
  1.    Cloning into 'PaddleDetection'...
  2.     remote: Enumerating objects: 1870, done.[K
  3.     remote: Counting objects: 100% (1870/1870), done.[K
  4.     remote: Compressing objects: 100% (1438/1438), done.[K
  5.     remote: Total 1870 (delta 617), reused 1061 (delta 368), pack-reused 0[K
  6.     Receiving objects: 100% (1870/1870), 175.31 MiB | 15.71 MiB/s, done.
  7.     Resolving deltas: 100% (617/617), done.
  8.     Checking connectivity... done.

01本地制作数据集

实现本项目,最好用打算实验的相机拍摄数据集,就比如我想在自己的笔记本电脑上实现,那么可以直接调用本地电脑的前置相机来采集人脸照片,调用本地电脑拍照储存代码如会自动调用摄像头，按 S 按键，保存捕获的图像， ESC 退出。

  1. ####### 本地运行!!!!!!!!!
  2. import cv2
  3. import os
  4.  
  5.  
  6. path = "./pictures/" # 图片保存路径
  7. if not os.path.exists(path):
  8.     os.makedirs(path)
  9. cap = cv2.VideoCapture(0)
  10. i = 0
  11. while (1):
  12.     ret, frame = cap.read()
  13.     k = cv2.waitKey(1)
  14.     if k == 27:
  15.         break
  16.     elif k == ord('s'):
  17.         cv2.imwrite(path + str(i) + '.jpg', frame)
  18.         print("save" + str(i) + ".jpg")
  19.         i += 1
  20.     cv2.imshow("capture", frame)
  21. cap.release()
  22. cv2.destroyAllWindows()

02数据标注

上述代码执行完后会在本地这段代码所在路径创建pictures文件夹存放图片,接下来下载labelImg工具进行数据标注参考教程:

[labelImg在Python3 linux环境下安装]

(https://blog.csdn.net/weixin_40745291/article/details/85775708)

~ 安装完成后在本地执行以下命令打开labelImg：

  1. ##### 本地执行,不可在aistudio执行!!!!
  2. cd 你的path/labelImg
  3. python labelImg.py
  4.

打开图片路径：

选择框选,并给人脸标注名字(这里我用红绿灯的图为例保护隐私):

标注完成：

03训练模型

  1. # 解压照片,aistudio上执行
  2. %mkdir -p PaddleDetection/dataset/faces
  3. %mv pictures.zip PaddleDetection/dataset/faces  
  4. %cd PaddleDetection/dataset/faces 
  5. !unzip pictures.zip
  1. /home/aistudio/PaddleDetection-release-0.3/dataset
  2.

现在的路径应该是这样的：

pictures下放着我们的图片和xml文件。

3.1 生成图片和xmls关系的描述文件

  1. #### 在aistudio上执行
  2. %cd PaddleDetection/dataset/faces
  3. %mkdir xmls
  4. %cd ./pictures/
  5. %mv *.xml ../xmls
  1. # 记录train图片
  2. import os
  3. import random
  4.  
  5. path = "PaddleDetection/dataset/faces/"
  6. total_red = os.listdir(path + "pictures/")
  7.  
  8. num = len(total_red)
  9. list=range(num)
  10.  
  11. ftrain = open('PaddleDetection/dataset/faces/train.txt', 'w')
  12. fval = open('PaddleDetection/dataset/faces/val.txt', 'w')
  13.  
  14. for i  in list:
  15.     if i % 9 != 0:
  16.         name=total_red[i].split(".")[0]
  17.         writeName = "pictures/" + total_red[i] + " xmls/" + name + ".xml\n"
  18.         ftrain.write(writeName)
  19.     else:
  20.         name=total_red[i].split(".")[0]
  21.         writeName = "pictures/" + total_red[i] + " xmls/" + name + ".xml\n"
  22.         fval.write(writeName)
  23.  
  24.  
  25. ftrain.close()
  26. fval.close()
  27.  
  1. # 记录了label,记得修改label的列表!!!!!
  2. import os
  3. flabel = open('PaddleDetection/dataset/faces/label_list.txt', 'w')
  4. label = ['张三','李四']
  5. for _label in label:
  6.     flabel.write(_label + "\n")
  7.  
  8. flabel.close()
  9.

上面两段代码执行完后会生成三个文件：

3.2修改配置文件

修改这个文件:PaddleDetection/configs/ssd/ssd_mobilenet_v1_voc.yml

主要修改就是改动了dataset_dir和anno_path和use_default_label,本项目的ssd_mobilenet_v1_voc.yml文件已经修改了。

内容如下:

  1. #### 只是用来看的,不要运行!!!!!
  2. architecture: SSD
  3. pretrain_weights: https://paddlemodels.bj.bcebos.com/object_detection/ssd_mobilenet_v1_coco_pretrained.tar
  4. use_gpu: true
  5. max_iters: 28000
  6. snapshot_iter: 2000
  7. log_smooth_window: 1
  8. metric: VOC
  9. map_type: 11point
  10. save_dir: output
  11. weights: output/ssd_mobilenet_v1_voc/model_final
  12. # 20(label_class) + 1(background)
  13. num_classes: 21
  14.  
  15. SSD:
  16.   backbone: MobileNet
  17.   multi_box_head: MultiBoxHead
  18.   output_decoder:
  19.     background_label: 0
  20.     keep_top_k: 200
  21.     nms_eta: 1.0
  22.     nms_threshold: 0.45
  23.     nms_top_k: 400
  24.     score_threshold: 0.01
  25.  
  26. MobileNet:
  27.   norm_decay: 0.
  28.   conv_group_scale: 1
  29.   conv_learning_rate: 0.1
  30.   extra_block_filters: [[256, 512], [128, 256], [128, 256], [64, 128]]
  31.   with_extra_blocks: true
  32.  
  33. MultiBoxHead:
  34.   aspect_ratios: [[2.], [2., 3.], [2., 3.], [2., 3.], [2., 3.], [2., 3.]]
  35.   base_size: 300
  36.   flip: true
  37.   max_ratio: 90
  38.   max_sizes: [[], 150.0, 195.0, 240.0, 285.0, 300.0]
  39.   min_ratio: 20
  40.   min_sizes: [60.0, 105.0, 150.0, 195.0, 240.0, 285.0]
  41.   offset: 0.5
  42.  
  43. LearningRate:
  44.   schedulers:
  45.   - !PiecewiseDecay
  46.     milestones: [10000, 15000, 20000, 25000]
  47.     values: [0.001, 0.0005, 0.00025, 0.0001, 0.00001]
  48.  
  49. OptimizerBuilder:
  50.   optimizer:
  51.     momentum: 0.0
  52.     type: RMSPropOptimizer
  53.   regularizer:
  54.     factor: 0.00005
  55.     type: L2
  56.  
  57. TrainReader:
  58.   inputs_def:
  59.     image_shape: [3, 300, 300]
  60.     fields: ['image', 'gt_bbox', 'gt_class']
  61.   dataset:
  62.     !VOCDataSet
  63.     anno_path: train.txt
  64.     dataset_dir: dataset/faces
  65.     use_default_label: false
  66.   sample_transforms:
  67.   - !DecodeImage
  68.     to_rgb: true
  69.   - !RandomDistort
  70.     brightness_lower: 0.875
  71.     brightness_upper: 1.125
  72.     is_order: true
  73.   - !RandomExpand
  74.     fill_value: [127.5, 127.5, 127.5]
  75.   - !RandomCrop
  76.     allow_no_crop: false
  77.   - !NormalizeBox {}
  78.   - !ResizeImage
  79.     interp: 1
  80.     target_size: 300
  81.     use_cv2: false
  82.   - !RandomFlipImage
  83.     is_normalized: true
  84.   - !Permute {}
  85.   - !NormalizeImage
  86.     is_scale: false
  87.     mean: [127.5, 127.5, 127.5]
  88.     std: [127.502231, 127.502231, 127.502231]
  89.   batch_size: 32
  90.   shuffle: true
  91.   drop_last: true
  92.   worker_num: 8
  93.   bufsize: 16
  94.   use_process: true
  95.  
  96. EvalReader:
  97.   inputs_def:
  98.     image_shape: [3, 300, 300]
  99.     fields: ['image', 'gt_bbox', 'gt_class', 'im_shape', 'im_id', 'is_difficult']
  100.   dataset:
  101.     !VOCDataSet
  102.     anno_path: val.txt
  103.     dataset_dir: dataset/faces
  104.     use_default_label: false
  105.   sample_transforms:
  106.   - !DecodeImage
  107.     to_rgb: true
  108.   - !NormalizeBox {}
  109.   - !ResizeImage
  110.     interp: 1
  111.     target_size: 300
  112.     use_cv2: false
  113.   - !Permute {}
  114.   - !NormalizeImage
  115.     is_scale: false
  116.     mean: [127.5, 127.5, 127.5]
  117.     std: [127.502231, 127.502231, 127.502231]
  118.   batch_size: 32
  119.   worker_num: 8
  120.   bufsize: 16
  121.   use_process: false
  122.  
  123. TestReader:
  124.   inputs_def:
  125.     image_shape: [3,300,300]
  126.     fields: ['image', 'im_id', 'im_shape']
  127.   dataset:
  128.     !ImageFolder
  129.     dataset_dir: dataset/faces
  130.     anno_path: label_list.txt
  131.     use_default_label: false
  132.   sample_transforms:
  133.   - !DecodeImage
  134.     to_rgb: true
  135.   - !ResizeImage
  136.     interp: 1
  137.     max_size: 0
  138.     target_size: 300
  139.     use_cv2: false
  140.   - !Permute {}
  141.   - !NormalizeImage
  142.     is_scale: false
  143.     mean: [127.5, 127.5, 127.5]
  144.     std: [127.502231, 127.502231, 127.502231]
  145.   batch_size: 1

开始训练

  1. %cd ~/PaddleDetection/
  2. !pip install -r requirements.txt
  1. #测试项目环境
  2. %cd ~/PaddleDetection/
  3. !export PYTHONPATH=`pwd`:$PYTHONPATH
  4. !python ppdet/modeling/tests/test_architectures.py
  5.  
  1. #训练模型
  2. %cd ~/PaddleDetection/
  3. # ssd训练
  4. !python -u tools/train.py -c configs/ssd/ssd_mobilenet_v1_voc.yml -o --eval
  1. #转换模型
  2. %cd ~/PaddleDetection/
  3. !python -u tools/export_model.py -c configs/ssd/ssd_mobilenet_v1_voc.yml --output_dir=./inference_model

本地部署

转换模型后,这个路径下:

~/PaddleDetection-release/inference_model/ssd_mobilenet_v1_voc会有__params__ model infer_cfg.yml

三个文件,下载到本地。

本地在python环境下下载PaddleDetection的包,将模型的三个文件放到PaddleDetection目录下的output目录下:

安装工具wmctrl 在linux的终端下执行：

sudo apt-get install wmctrl

修改本地PaddleDetection包中的这个文件:

/PaddleDetection-release-0.3/deploy/python/infer.py

内容如下:

  1. # Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
  2. #
  3. # Licensed under the Apache License, Version 2.0 (the "License");
  4. # you may not use this file except in compliance with the License.
  5. # You may obtain a copy of the License at
  6. #
  7. #     http://www.apache.org/licenses/LICENSE-2.0
  8. #
  9. # Unless required by applicable law or agreed to in writing, software
  10. # distributed under the License is distributed on an "AS IS" BASIS,
  11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. # See the License for the specific language governing permissions and
  13. # limitations under the License.
  14. # python -u deploy/python/infer.py --model_dir output/light/mobilnet_best_model
  15. import os
  16. import argparse
  17. import threading
  18. import time
  19. import yaml
  20. import ast
  21. from functools import reduce
  22.  
  23. from PIL import Image
  24. import cv2
  25. import numpy as np
  26. import paddle.fluid as fluid
  27. from visualize import visualize_box_mask
  28.  
  29.  
  30.  
  31. def decode_image(im_file, im_info):
  32.     """read rgb image
  33.     Args:
  34.         im_file (str/np.ndarray): path of image/ np.ndarray read by cv2
  35.         im_info (dict): info of image
  36.     Returns:
  37.         im (np.ndarray):  processed image (np.ndarray)
  38.         im_info (dict): info of processed image
  39.     """
  40.     if isinstance(im_file, str):
  41.         with open(im_file, 'rb') as f:
  42.             im_read = f.read()
  43.         data = np.frombuffer(im_read, dtype='uint8')
  44.         im = cv2.imdecode(data, 1)  # BGR mode, but need RGB mode
  45.         im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)
  46.         im_info['origin_shape'] = im.shape[:2]
  47.         im_info['resize_shape'] = im.shape[:2]
  48.     else:
  49.         im = im_file
  50.         im_info['origin_shape'] = im.shape[:2]
  51.         im_info['resize_shape'] = im.shape[:2]
  52.     return im, im_info
  53.  
  54.  
  55. class Resize(object):
  56.     """resize image by target_size and max_size
  57.     Args:
  58.         arch (str): model type
  59.         target_size (int): the target size of image
  60.         max_size (int): the max size of image
  61.         use_cv2 (bool): whether us cv2
  62.         image_shape (list): input shape of model
  63.         interp (int): method of resize
  64.     """
  65.  
  66.     def __init__(self,
  67.                  arch,
  68.                  target_size,
  69.                  max_size,
  70.                  use_cv2=True,
  71.                  image_shape=None,
  72.                  interp=cv2.INTER_LINEAR):
  73.         self.target_size = target_size
  74.         self.max_size = max_size
  75.         self.image_shape = image_shape,
  76.         self.arch = arch
  77.         self.use_cv2 = use_cv2
  78.         self.interp = interp
  79.         self.scale_set = {'RCNN', 'RetinaNet'}
  80.  
  81.     def __call__(self, im, im_info):
  82.         """
  83.         Args:
  84.             im (np.ndarray): image (np.ndarray)
  85.             im_info (dict): info of image
  86.         Returns:
  87.             im (np.ndarray):  processed image (np.ndarray)
  88.             im_info (dict): info of processed image
  89.         """
  90.         im_channel = im.shape[2]
  91.         im_scale_x, im_scale_y = self.generate_scale(im)
  92.         if self.use_cv2:
  93.             im = cv2.resize(
  94.                 im,
  95.                 None,
  96.                 None,
  97.                 fx=im_scale_x,
  98.                 fy=im_scale_y,
  99.                 interpolation=self.interp)
  100.         else:
  101.             resize_w = int(im_scale_x * float(im.shape[1]))
  102.             resize_h = int(im_scale_y * float(im.shape[0]))
  103.             if self.max_size != 0:
  104.                 raise TypeError(
  105.                     'If you set max_size to cap the maximum size of image,'
  106.                     'please set use_cv2 to True to resize the image.')
  107.             im = im.astype('uint8')
  108.             im = Image.fromarray(im)
  109.             im = im.resize((int(resize_w), int(resize_h)), self.interp)
  110.             im = np.array(im)
  111.  
  112.         # padding im when image_shape fixed by infer_cfg.yml
  113.         if self.max_size != 0 and self.image_shape is not None:
  114.             padding_im = np.zeros(
  115.                 (self.max_size, self.max_size, im_channel), dtype=np.float32)
  116.             im_h, im_w = im.shape[:2]
  117.             padding_im[:im_h, :im_w, :] = im
  118.             im = padding_im
  119.  
  120.         if self.arch in self.scale_set:
  121.             im_info['scale'] = im_scale_x
  122.         im_info['resize_shape'] = im.shape[:2]
  123.         return im, im_info
  124.  
  125.     def generate_scale(self, im):
  126.         """
  127.         Args:
  128.             im (np.ndarray): image (np.ndarray)
  129.         Returns:
  130.             im_scale_x: the resize ratio of X 
  131.             im_scale_y: the resize ratio of Y 
  132.         """
  133.         origin_shape = im.shape[:2]
  134.         im_c = im.shape[2]
  135.         if self.max_size != 0 and self.arch in self.scale_set:
  136.             im_size_min = np.min(origin_shape[0:2])
  137.             im_size_max = np.max(origin_shape[0:2])
  138.             im_scale = float(self.target_size) / float(im_size_min)
  139.             if np.round(im_scale * im_size_max) > self.max_size:
  140.                 im_scale = float(self.max_size) / float(im_size_max)
  141.             im_scale_x = im_scale
  142.             im_scale_y = im_scale
  143.         else:
  144.             im_scale_x = float(self.target_size) / float(origin_shape[1])
  145.             im_scale_y = float(self.target_size) / float(origin_shape[0])
  146.         return im_scale_x, im_scale_y
  147.  
  148.  
  149. class Normalize(object):
  150.     """normalize image
  151.     Args:
  152.         mean (list): im - mean
  153.         std (list): im / std
  154.         is_scale (bool): whether need im / 255
  155.         is_channel_first (bool): if True: image shape is CHW, else: HWC
  156.     """
  157.  
  158.     def __init__(self, mean, std, is_scale=True, is_channel_first=False):
  159.         self.mean = mean
  160.         self.std = std
  161.         self.is_scale = is_scale
  162.         self.is_channel_first = is_channel_first
  163.  
  164.     def __call__(self, im, im_info):
  165.         """
  166.         Args:
  167.             im (np.ndarray): image (np.ndarray)
  168.             im_info (dict): info of image
  169.         Returns:
  170.             im (np.ndarray):  processed image (np.ndarray)
  171.             im_info (dict): info of processed image
  172.         """
  173.         im = im.astype(np.float32, copy=False)
  174.         if self.is_channel_first:
  175.             mean = np.array(self.mean)[:, np.newaxis, np.newaxis]
  176.             std = np.array(self.std)[:, np.newaxis, np.newaxis]
  177.         else:
  178.             mean = np.array(self.mean)[np.newaxis, np.newaxis, :]
  179.             std = np.array(self.std)[np.newaxis, np.newaxis, :]
  180.         if self.is_scale:
  181.             im = im / 255.0
  182.         im -= mean
  183.         im /= std
  184.         return im, im_info
  185.  
  186.  
  187. class Permute(object):
  188.     """permute image
  189.     Args:
  190.         to_bgr (bool): whether convert RGB to BGR 
  191.         channel_first (bool): whether convert HWC to CHW
  192.     """
  193.  
  194.     def __init__(self, to_bgr=False, channel_first=True):
  195.         self.to_bgr = to_bgr
  196.         self.channel_first = channel_first
  197.  
  198.     def __call__(self, im, im_info):
  199.         """
  200.         Args:
  201.             im (np.ndarray): image (np.ndarray)
  202.             im_info (dict): info of image
  203.         Returns:
  204.             im (np.ndarray):  processed image (np.ndarray)
  205.             im_info (dict): info of processed image
  206.         """
  207.         if self.channel_first:
  208.             im = im.transpose((2, 0, 1)).copy()
  209.         if self.to_bgr:
  210.             im = im[[2, 1, 0], :, :]
  211.         return im, im_info
  212.  
  213.  
  214. class PadStride(object):
  215.     """ padding image for model with FPN 
  216.     Args:
  217.         stride (bool): model with FPN need image shape % stride == 0 
  218.     """
  219.  
  220.     def __init__(self, stride=0):
  221.         self.coarsest_stride = stride
  222.  
  223.     def __call__(self, im, im_info):
  224.         """
  225.         Args:
  226.             im (np.ndarray): image (np.ndarray)
  227.             im_info (dict): info of image
  228.         Returns:
  229.             im (np.ndarray):  processed image (np.ndarray)
  230.             im_info (dict): info of processed image
  231.         """
  232.         coarsest_stride = self.coarsest_stride
  233.         if coarsest_stride == 0:
  234.             return im
  235.         im_c, im_h, im_w = im.shape
  236.         pad_h = int(np.ceil(float(im_h) / coarsest_stride) * coarsest_stride)
  237.         pad_w = int(np.ceil(float(im_w) / coarsest_stride) * coarsest_stride)
  238.         padding_im = np.zeros((im_c, pad_h, pad_w), dtype=np.float32)
  239.         padding_im[:, :im_h, :im_w] = im
  240.         im_info['resize_shape'] = padding_im.shape[1:]
  241.         return padding_im, im_info
  242.  
  243.  
  244. def create_inputs(im, im_info, model_arch='YOLO'):
  245.     """generate input for different model type
  246.     Args:
  247.         im (np.ndarray): image (np.ndarray)
  248.         im_info (dict): info of image
  249.         model_arch (str): model type
  250.     Returns:
  251.         inputs (dict): input of model
  252.     """
  253.     inputs = {}
  254.     inputs['image'] = im
  255.     origin_shape = list(im_info['origin_shape'])
  256.     resize_shape = list(im_info['resize_shape'])
  257.     scale = im_info['scale']
  258.     if 'YOLO' in model_arch:
  259.         im_size = np.array([origin_shape]).astype('int32')
  260.         inputs['im_size'] = im_size
  261.     elif 'RetinaNet' in model_arch:
  262.         im_info = np.array([resize_shape + [scale]]).astype('float32')
  263.         inputs['im_info'] = im_info
  264.     elif 'RCNN' in model_arch:
  265.         im_info = np.array([resize_shape + [scale]]).astype('float32')
  266.         im_shape = np.array([origin_shape + [1.]]).astype('float32')
  267.         inputs['im_info'] = im_info
  268.         inputs['im_shape'] = im_shape
  269.     return inputs
  270.  
  271.  
  272. class Config():
  273.     """set config of preprocess, postprocess and visualize
  274.     Args:
  275.         model_dir (str): root path of model.yml
  276.     """
  277.     support_models = ['YOLO', 'SSD', 'RetinaNet', 'RCNN', 'Face']
  278.  
  279.     def __init__(self, model_dir):
  280.         # parsing Yaml config for Preprocess
  281.         deploy_file = os.path.join(model_dir, 'infer_cfg.yml')
  282.         with open(deploy_file) as f:
  283.             yml_conf = yaml.safe_load(f)
  284.         self.check_model(yml_conf)
  285.         self.arch = yml_conf['arch']
  286.         self.preprocess_infos = yml_conf['Preprocess']
  287.         self.use_python_inference = yml_conf['use_python_inference']
  288.         self.min_subgraph_size = yml_conf['min_subgraph_size']
  289.         self.labels = yml_conf['label_list']
  290.         self.mask_resolution = None
  291.         if 'mask_resolution' in yml_conf:
  292.             self.mask_resolution = yml_conf['mask_resolution']
  293.         self.print_config()
  294.  
  295.     def check_model(self, yml_conf):
  296.         """
  297.         Raises:
  298.             ValueError: loaded model not in supported model type 
  299.         """
  300.         for support_model in self.support_models:
  301.             if support_model in yml_conf['arch']:
  302.                 return True
  303.         raise ValueError(
  304.             "Unsupported arch: {}, expect SSD, YOLO, RetinaNet, RCNN and Face".
  305.             format(yml_conf['arch']))
  306.  
  307.     def print_config(self):
  308.         print('-----------  Model Configuration -----------')
  309.         print('%s: %s' % ('Model Arch', self.arch))
  310.         print('%s: %s' % ('Use Padddle Executor', self.use_python_inference))
  311.         print('%s: ' % ('Transform Order'))
  312.         for op_info in self.preprocess_infos:
  313.             print('--%s: %s' % ('transform op', op_info['type']))
  314.         print('--------------------------------------------')
  315.  
  316.  
  317. def load_predictor(model_dir,
  318.                    run_mode='fluid',
  319.                    batch_size=1,
  320.                    use_gpu=False,
  321.                    min_subgraph_size=3):
  322.     """set AnalysisConfig, generate AnalysisPredictor
  323.     Args:
  324.         model_dir (str): root path of __model__ and __params__
  325.         use_gpu (bool): whether use gpu
  326.     Returns:
  327.         predictor (PaddlePredictor): AnalysisPredictor
  328.     Raises:
  329.         ValueError: predict by TensorRT need use_gpu == True.
  330.     """
  331.     if not use_gpu and not run_mode == 'fluid':
  332.         raise ValueError(
  333.             "Predict by TensorRT mode: {}, expect use_gpu==True, but use_gpu == {}"
  334.             .format(run_mode, use_gpu))
  335.     if run_mode == 'trt_int8':
  336.         raise ValueError("TensorRT int8 mode is not supported now, "
  337.                          "please use trt_fp32 or trt_fp16 instead.")
  338.     precision_map = {
  339.         'trt_int8': fluid.core.AnalysisConfig.Precision.Int8,
  340.         'trt_fp32': fluid.core.AnalysisConfig.Precision.Float32,
  341.         'trt_fp16': fluid.core.AnalysisConfig.Precision.Half
  342.     }
  343.     config = fluid.core.AnalysisConfig(
  344.         os.path.join(model_dir, '__model__'),
  345.         os.path.join(model_dir, '__params__'))
  346.     if use_gpu:
  347.         # initial GPU memory(M), device ID
  348.         config.enable_use_gpu(100, 0)
  349.         # optimize graph and fuse op
  350.         config.switch_ir_optim(True)
  351.     else:
  352.         config.disable_gpu()
  353.  
  354.     if run_mode in precision_map.keys():
  355.         config.enable_tensorrt_engine(
  356.             workspace_size=1 << 10,
  357.             max_batch_size=batch_size,
  358.             min_subgraph_size=min_subgraph_size,
  359.             precision_mode=precision_map[run_mode],
  360.             use_static=False,
  361.             use_calib_mode=False)
  362.  
  363.     # disable print log when predict
  364.     config.disable_glog_info()
  365.     # enable shared memory
  366.     config.enable_memory_optim()
  367.     # disable feed, fetch OP, needed by zero_copy_run
  368.     config.switch_use_feed_fetch_ops(False)
  369.     predictor = fluid.core.create_paddle_predictor(config)
  370.     return predictor
  371.  
  372.  
  373. def load_executor(model_dir, use_gpu=False):
  374.     if use_gpu:
  375.         place = fluid.CUDAPlace(0)
  376.     else:
  377.         place = fluid.CPUPlace()
  378.     exe = fluid.Executor(place)
  379.     program, feed_names, fetch_targets = fluid.io.load_inference_model(
  380.         dirname=model_dir,
  381.         executor=exe,
  382.         model_filename='__model__',
  383.         params_filename='__params__')
  384.     return exe, program, fetch_targets
  385.  
  386.  
  387. def visualize(image_file,
  388.               results,
  389.               labels,
  390.               mask_resolution=14,
  391.               output_dir='output/'):
  392.     # visualize the predict result
  393.     im = visualize_box_mask(
  394.         image_file, results, labels, mask_resolution=mask_resolution)
  395.     img_name = os.path.split(image_file)[-1]
  396.     if not os.path.exists(output_dir):
  397.         os.makedirs(output_dir)
  398.     out_path = os.path.join(output_dir, img_name)
  399.     im.save(out_path, quality=95)
  400.     print("save result to: " + out_path)
  401.  
  402.  
  403. class Detector():
  404.     """
  405.     Args:
  406.         model_dir (str): root path of __model__, __params__ and infer_cfg.yml
  407.         use_gpu (bool): whether use gpu
  408.     """
  409.  
  410.     def __init__(self,
  411.                  model_dir,
  412.                  use_gpu=False,
  413.                  run_mode='fluid',
  414.                  threshold=0.5):
  415.         self.config = Config(model_dir)
  416.         if self.config.use_python_inference:
  417.             self.executor, self.program, self.fecth_targets = load_executor(
  418.                 model_dir, use_gpu=use_gpu)
  419.         else:
  420.             self.predictor = load_predictor(
  421.                 model_dir,
  422.                 run_mode=run_mode,
  423.                 min_subgraph_size=self.config.min_subgraph_size,
  424.                 use_gpu=use_gpu)
  425.         self.preprocess_ops = []
  426.         for op_info in self.config.preprocess_infos:
  427.             op_type = op_info.pop('type')
  428.             if op_type == 'Resize':
  429.                 op_info['arch'] = self.config.arch
  430.             self.preprocess_ops.append(eval(op_type)(**op_info))
  431.  
  432.     def preprocess(self, im):
  433.         # process image by preprocess_ops
  434.         im_info = {
  435.             'scale': 1.,
  436.             'origin_shape': None,
  437.             'resize_shape': None,
  438.         }
  439.         im, im_info = decode_image(im, im_info)
  440.         for operator in self.preprocess_ops:
  441.             im, im_info = operator(im, im_info)
  442.         im = np.array((im, )).astype('float32')
  443.         inputs = create_inputs(im, im_info, self.config.arch)
  444.         return inputs, im_info
  445.  
  446.     def postprocess(self, np_boxes, np_masks, im_info, threshold=0.5):
  447.         # postprocess output of predictor
  448.         results = {}
  449.         if self.config.arch in ['SSD', 'Face']:
  450.             w, h = im_info['origin_shape']
  451.             np_boxes[:, 2] *= h
  452.             np_boxes[:, 3] *= w
  453.             np_boxes[:, 4] *= h
  454.             np_boxes[:, 5] *= w
  455.         expect_boxes = np_boxes[:, 1] > threshold
  456.         np_boxes = np_boxes[expect_boxes, :]
  457.         for box in np_boxes:
  458.             print('class_id:{:d}, confidence:{:.2f},'
  459.                   'left_top:[{:.2f},{:.2f}],'
  460.                   ' right_bottom:[{:.2f},{:.2f}]'.format(
  461.                       int(box[0]), box[1], box[2], box[3], box[4], box[5]))
  462.         results['boxes'] = np_boxes
  463.         if np_masks is not None:
  464.             np_masks = np_masks[expect_boxes, :, :, :]
  465.             results['masks'] = np_masks
  466.         return results
  467.  
  468.     def predict(self, image, threshold=0.5, warmup=0, repeats=1):
  469.         '''
  470.         Args:
  471.             image (str/np.ndarray): path of image/ np.ndarray read by cv2
  472.             threshold (float): threshold of predicted box' score
  473.         Returns:
  474.             results (dict): include 'boxes': np.ndarray: shape:[N,6], N: number of box,
  475.                             matix element:[class, score, x_min, y_min, x_max, y_max]
  476.                             MaskRCNN's results include 'masks': np.ndarray:
  477.                             shape:[N, class_num, mask_resolution, mask_resolution]
  478.         '''
  479.         inputs, im_info = self.preprocess(image)
  480.         np_boxes, np_masks = None, None
  481.         if self.config.use_python_inference:
  482.             for i in range(warmup):
  483.                 outs = self.executor.run(self.program,
  484.                                          feed=inputs,
  485.                                          fetch_list=self.fecth_targets,
  486.                                          return_numpy=False)
  487.             t1 = time.time()
  488.             for i in range(repeats):
  489.                 outs = self.executor.run(self.program,
  490.                                          feed=inputs,
  491.                                          fetch_list=self.fecth_targets,
  492.                                          return_numpy=False)
  493.             t2 = time.time()
  494.             ms = (t2 - t1) * 1000.0 / repeats
  495.             print("Inference: {} ms per batch image".format(ms))
  496.  
  497.             np_boxes = np.array(outs[0])
  498.             if self.config.mask_resolution is not None:
  499.                 np_masks = np.array(outs[1])
  500.         else:
  501.             input_names = self.predictor.get_input_names()
  502.             for i in range(len(inputs)):
  503.                 input_tensor = self.predictor.get_input_tensor(input_names[i])
  504.                 input_tensor.copy_from_cpu(inputs[input_names[i]])
  505.  
  506.             for i in range(warmup):
  507.                 self.predictor.zero_copy_run()
  508.                 output_names = self.predictor.get_output_names()
  509.                 boxes_tensor = self.predictor.get_output_tensor(output_names[0])
  510.                 np_boxes = boxes_tensor.copy_to_cpu()
  511.                 if self.config.mask_resolution is not None:
  512.                     masks_tensor = self.predictor.get_output_tensor(
  513.                         output_names[1])
  514.                     np_masks = masks_tensor.copy_to_cpu()
  515.  
  516.             t1 = time.time()
  517.             for i in range(repeats):
  518.                 self.predictor.zero_copy_run()
  519.                 output_names = self.predictor.get_output_names()
  520.                 boxes_tensor = self.predictor.get_output_tensor(output_names[0])
  521.                 np_boxes = boxes_tensor.copy_to_cpu()
  522.                 if self.config.mask_resolution is not None:
  523.                     masks_tensor = self.predictor.get_output_tensor(
  524.                         output_names[1])
  525.                     np_masks = masks_tensor.copy_to_cpu()
  526.             t2 = time.time()
  527.             ms = (t2 - t1) * 1000.0 / repeats
  528.             print("Inference: {} ms per batch image".format(ms))
  529.  
  530.         if reduce(lambda x, y: x * y, np_boxes.shape) < 6:
  531.             print('[WARNNING] No object detected.')
  532.             results = {'boxes': np.array([])}
  533.         else:
  534.             results = self.postprocess(
  535.                 np_boxes, np_masks, im_info, threshold=threshold)
  536.  
  537.         return results
  538.  
  539.  
  540. def predict_image():
  541.     detector = Detector(
  542.         FLAGS.model_dir, use_gpu=FLAGS.use_gpu, run_mode=FLAGS.run_mode)
  543.     if FLAGS.run_benchmark:
  544.         detector.predict(
  545.             FLAGS.image_file, FLAGS.threshold, warmup=100, repeats=100)
  546.     else:
  547.         results = detector.predict(FLAGS.image_file, FLAGS.threshold)
  548.         visualize(
  549.             FLAGS.image_file,
  550.             results,
  551.             detector.config.labels,
  552.             mask_resolution=detector.config.mask_resolution,
  553.             output_dir=FLAGS.output_dir)
  554.  
  555.  
  556.  
  557.  
  558.  
  559. def predict_video():
  560.     detector = Detector(
  561.         FLAGS.model_dir, use_gpu=FLAGS.use_gpu, run_mode=FLAGS.run_mode)
  562.     capture = cv2.VideoCapture(0)
  563.     fps = 30
  564.     width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
  565.     height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
  566.     fourcc = cv2.VideoWriter_fourcc(*'mp4v')
  567.     video_name = os.path.split(FLAGS.video_file)[-1]
  568.     if not os.path.exists(FLAGS.output_dir):
  569.         os.makedirs(FLAGS.output_dir)
  570.     out_path = os.path.join(FLAGS.output_dir, video_name)
  571.     writer = cv2.VideoWriter(out_path, fourcc, fps, (width, height))
  572.     index = 1
  573.     while (1):
  574.         ret, frame = capture.read()
  575.         if not ret:
  576.             break
  577.         print('detect frame:%d' % (index))
  578.         index += 1
  579.         results = detector.predict(frame, FLAGS.threshold)
  580.         if len(results['boxes']) != 0:
  581.             for box in results['boxes']:
  582.                 x1, y1, x2, y2 = box[2:]
  583.                 font = cv2.FONT_HERSHEY_SIMPLEX
  584.                 flag = 0
  585.                 # 这里两个人脸的话box[0]的值就是1.0和2.0,如果是三个人就是1.0和2.0和3.0,所以我这里两个人脸我就写了小于1.5来判断是谁
  586.                 if box[0] < 1.5:
  587.                     flag = 1
  588.                     cv2.putText(frame, 'wyj', (int(x1-5), int(y1-5)), font, 1.2, (255, 255, 0), 2)
  589.                 else:
  590.                     cv2.putText(frame, 'xmy', (int(x1 - 5), int(y1 - 5)), font, 1.2, (255, 255, 0), 2)
  591.                 cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 5)
  592.                 if flag == 1:
  593.                     os.system("wmctrl -a \"pycharm\"") #检测到妹妹的脸 命令行打开pycharm
  594.         cv2.imshow("1",frame)
  595.         cv2.waitKey(3)
  596.     writer.release()
  597.     cv2.destroyAllWindows()
  598.  
  599.  
  600. def print_arguments(args):
  601.     print('-----------  Running Arguments -----------')
  602.     for arg, value in sorted(vars(args).items()):
  603.         print('%s: %s' % (arg, value))
  604.     print('------------------------------------------')
  605.  
  606.  
  607. flag = 0
  608.  
  609. def showImg():
  610.     global flag
  611.     cap = cv2.VideoCapture(0)
  612.     while 1:
  613.         ret,frame = cap.read()
  614.         #cv2.imshow("cap",frame)
  615.  
  616.         if flag is 0:
  617.             cv2.imwrite("temp.jpg",frame)
  618.             flag = 1
  619.  
  620.         if cv2.waitKey(100) & 0xff == ord('q'):
  621.             break
  622.     cap.release()
  623.     cv2.destroyAllWindows()
  624.  
  625.  
  626. if __name__ == '__main__':
  627.  
  628.  
  629.     parser = argparse.ArgumentParser(description=__doc__)
  630.     parser.add_argument(
  631.         "--model_dir",
  632.         type=str,
  633.         default="",
  634.         help=("Directory include:'__model__', '__params__', "
  635.               "'infer_cfg.yml', created by tools/export_model.py."),
  636.         required=True)
  637.     parser.add_argument(
  638.         "--image_file", type=str, default='', help="Path of image file.")
  639.     parser.add_argument(
  640.         "--video_file", type=str, default='', help="Path of video file.")
  641.     parser.add_argument(
  642.         "--run_mode",
  643.         type=str,
  644.         default='fluid',
  645.         help="mode of running(fluid/trt_fp32/trt_fp16)")
  646.     parser.add_argument(
  647.         "--use_gpu",
  648.         type=ast.literal_eval,
  649.         default=False,
  650.         help="Whether to predict with GPU.")
  651.     parser.add_argument(
  652.         "--run_benchmark",
  653.         type=ast.literal_eval,
  654.         default=False,
  655.         help="Whether to predict a image_file repeatedly for benchmark")
  656.     parser.add_argument(
  657.         "--threshold", type=float, default=0.5, help="Threshold of score.")
  658.     parser.add_argument(
  659.         "--output_dir",
  660.         type=str,
  661.         default="output",
  662.         help="Directory of output visualization files.")
  663.  
  664.     FLAGS = parser.parse_args()
  665.     print_arguments(FLAGS)
  666.  
  667.     if FLAGS.image_file != '' and FLAGS.video_file != '':
  668.         assert "Cannot predict image and video at the same time"
  669.     if FLAGS.image_file != '':
  670.         predict_image()
  671.     predict_video()

上面代码的核心代码，根据个人使用一点修改，核心代码在585行，其他不用改动，内容如下:

  1. # 启动识别,本地运行不可以在aistudio运行!!!!!
  2. 在pychram中可打开终端,输入:
  3. python -u deploy/python/infer.py --model_dir output/face

总结

PaddleDetection可以帮助我们很好的实现各种目标检测任务，不需要用户写大量的代码，只需要简单的配置

使用PaddleDetection也可以很轻松的实现本地的部署

如果项目有任何问题，欢迎在评论区留言指出

关注下方《学姐带你玩AI》

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/52184
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。