AIHGF

YOLOV3 - 基于百度 PaddlePaddle 的实现[转]
原文:快到没朋友的YOLO v3有了PaddlePaddle实现 - 2019.05.21出处:PaddlePad...
扫描右侧二维码阅读全文
01
2019/06

YOLOV3 - 基于百度 PaddlePaddle 的实现[转]

原文:快到没朋友的YOLO v3有了PaddlePaddle实现 - 2019.05.21

出处:PaddlePaddle - 微信公众号

项目路径:Github - PaddlePaddle/models/PaddleCV/yolov3/

现在,快到没朋友的YOLO v3有PaddlePaddle实现了。相比原作者在 Darknet 实现的模型,PaddlePaddle 添加了其它一些模块,且精度提高了 5.9个绝对百分点。

YOLO作为目标检测领域的创新技术,一经推出就受到开发者的广泛关注。值得一提的是,基于百度自研的开源深度学习平台PaddlePaddle的YOLO v3实现,参考了论文【Bag of Tricks for Image Classification with Convolutional NeuralNetworks】,增加了mixup,label_smooth等处理,精度(mAP(0.5:0.95))相比于原作者的实现提高了4.7个绝对百分点,在此基础上加入synchronize batchnormalization, 最终精度相比原作者提高5.9个绝对百分点。我们将在下文中为大家详解实现的具体过程。

CV领域的核心问题之一就是目标检测(object detection),它的任务是找出图像当中所有感兴趣的目标(物体),确定其位置和大小(包含目标的矩形框)并识别出具体是哪个对象。Faster R-CNN及在其基础上改进的Mask R-CNN在实例分割、目标检测、人体关键点检测等任务上都取得了很好的效果,但通常较慢。YOLO 创造性的提出one-stage,就是目标定位和目标识别在一个步骤中完成。

由于整个检测流水线是单个网络,因此可以直接在检测性能上进行端到端优化,使得基础YOLO模型能以每秒45帧的速度实时处理图像,较小网络的Fast YOLO每秒处理图像可达到惊人的155帧。YOLO有让人惊艳的速度,同时也有让人止步的缺陷:不擅长小目标检测。而YOLO v3保持了YOLO的速度优势,提升了模型精度,尤其加强了小目标、重叠遮挡目标的识别,补齐了YOLO的短板,是目前速度和精度均衡的目标检测网络

中文文档:https://github.com/PaddlePaddle/models/blob/v1.4/PaddleCV/yolov3/README_cn.md

1. YOLOv3 检测原理

YOLO v3 是一阶段End2End的目标检测器。

YOLO v3将输入图像分成SxS个格子,每个格子预测B个bounding box,每个boundingbox预测内容包括: Location(x, y, w, h)、Confidence Score和C个类别的概率,因此YOLO v3输出层的channel数为SxSxBx(5+C)。

YOLO v3的loss函数也有三部分组成:Location误差,Confidence误差和分类误差。

2. YOLOv3 网络结构

YOLO v3 的网络结构由基础特征提取网络multi-scale特征融合层输出层组成。

[1] - 特征提取网络。YOLO v3使用 DarkNet53作为特征提取网络:DarkNet53 基本采用了全卷积网络,用步长为2的卷积操作替代了池化层,同时添加了 Residual 单元,避免在网络层数过深时发生梯度弥散。

[2] - 特征融合层。为了解决之前YOLO版本对小目标不敏感的问题,YOLO v3采用了3个不同尺度的特征图来进行目标检测,分别为13x13, 26x26, 52x52,用来检测大、中、小三种目标。特征融合层选取 DarkNet产出的三种尺度特征图作为输入,借鉴了FPN(feature pyramid networks)的思想,通过一系列的卷积层和上采样对各尺度的特征图进行融合。

[3] - 输出层。同样使用了全卷积结构,其中最后一个卷积层的卷积核个数是255:3x(80+4+1)=255,3表示一个grid cell包含3个boundingbox,4表示框的4个坐标信息,1表示Confidence Score,80表示COCO数据集中80个类别的概率。

3. PaddlePaddle简介

PaddlePaddle是百度自研的集深度学习框架、工具组件和服务平台为一体的技术领先、功能完备的开源深度学习平台,有全面的官方支持的工业级应用模型,涵盖自然语言处理、计算机视觉、推荐引擎等多个领域,并开放多个领先的预训练中文模型。目前,已经被中国企业广泛使用,并拥有活跃的开发者社区。

PaddlePaddle官网:http://www.paddlepaddle.org/

PaddlePaddle 文档:http://paddlepaddle.org/documentation/docs/zh/1.4/beginners_guide/install/index_cn.html

3.1. 应用案例—AI识虫

红脂大小蠹是危害超过 35 种松科植物的蛀干害虫,自 1998 年首次发现到 2004 年,发生面积超过 52.7 万平方公里 , 枯死松树达600 多万株。且在持续扩散,给我国林业经济带来巨大损失。传统监测方式依赖具有专业识别能力的工作人员进行实地检查,专业要求高,工作周期长。

北京林业大学、百度、嘉楠、软通智慧合作面向信息素诱捕器的智能虫情监测系统,通过PaddlePaddle训练得到目标检测模型YOLO v3,识别红脂大小蠹虫,远程监测病虫害情况,识别准确率达到90%,与专业人士水平相当,并将原本需要两周才能完成的检查任务,缩短至1小时就能完成。

4. YOLOv3 PaddlePaddle实战

运行样例代码需要Paddle Fluid的v 1.4或以上的版本。

4.1. 数据准备

在MS-COCO数据集上进行训练,通过如下方式下载数据集。

coco datasets - download.sh:

DIR="$( cd "$(dirname "$0")" ; pwd -P )"
cd "$DIR"

# Download the data.
echo "Downloading..."
wget http://images.cocodataset.org/zips/train2014.zip
wget http://images.cocodataset.org/zips/val2014.zip
wget http://images.cocodataset.org/zips/train2017.zip
wget http://images.cocodataset.org/zips/val2017.zip
wget http://images.cocodataset.org/annotations/annotations_trainval2014.zip
wget http://images.cocodataset.org/annotations/annotations_trainval2017.zip
# Extract the data.
echo "Extracting..."
unzip train2014.zip
unzip val2014.zip
unzip train2017.zip
unzip val2017.zip
unzip annotations_trainval2014.zip
unzip annotations_trainval2017.zip

下载数据集:

cd dataset/coco
./download.sh

得到的数据目录结构如下:

dataset/coco/
├── annotations
│   ├──instances_train2014.json
│   ├──instances_train2017.json
│   ├── instances_val2014.json
│   ├──instances_val2017.json
|   ...

├── train2017
│   ├──000000000009.jpg
│   ├──000000580008.jpg
|   ...

├── val2017
│   ├──000000000139.jpg
│   ├──000000000285.jpg
|   ...

4.2. 模型训练

[1] - 安装cocoapi:训练前需要首先下载cocoapi。

git clone https://github.com/cocodataset/cocoapi.git
cd cocoapi/PythonAPI

#if cython is not installed
pip install Cython

#Install into global site-packages
make install

#Alternatively, if you do not have permissions or prefer
#not to install the COCO API into global site-packages
python2 setup.py install --user

[2] - 下载预训练模型: 本示例提供darknet53预训练模型,该模型转换自作者提供的darknet53在ImageNet上预训练的权重,采用如下命令下载预训练模型。

model - download.sh

DIR="$( cd "$(dirname "$0")" ; pwd -P )"
cd "$DIR"

# Download the pretrain weights.
echo "Downloading..."
wget https://paddlemodels.bj.bcebos.com/yolo/darknet53.tar.gz
wget https://paddlemodels.bj.bcebos.com/yolo/yolov3.tar.gz
echo "Extracting..."
tar -xf darknet53.tar.gz
tar -xf yolov3.tar.gz

下载预训练模型:

sh./weights/download.sh

通过初始化 --pretrain 加载预训练模型。同时在参数微调时也采用该设置加载已训练模型。请在训练前确认预训练模型下载与加载正确,否则训练过程中损失可能会出现NAN。

[3] - 开始训练: 数据准备完毕后,可以通过如下的方式启动训练。

python train.py \
   --model_save_dir=output/ \
   --pretrain=${path_to_pretrain_model}
   --data_dir=${path_to_data}

通过设置 export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7 指定8卡GPU训练。

可选参数见:python train.py --help.

数据读取器说明

  • 数据读取器定义在reader.py中。

模型设置:

  • 模型使用了基于COCO数据集生成的9个先验框:10x13,16x30,33x23,30x61,62x45,59x119,116x90,156x198,373x326
  • 检测过程中,nms_topk=400, nms_posk=100,nms_thresh=0.45

训练策略:

  • 采用momentum优化算法训练YOLO v3,momentum=0.9。
  • 学习率采用warmup算法,前4000轮学习率从0.0线性增加至0.001。在400000,450000轮时使用0.1, 0.01乘子进行学习率衰减,最大训练500000轮。

下图为模型训练结果Train Loss。

4.3. 模型评估

模型评估是指对训练完毕的模型评估各类性能指标。本示例采用COCO官方评估。

eval.py 是评估模块的主要执行程序,调用示例如下:

python eval.py \
    --dataset=coco2017 \
    --weights=${path_to_weights} \

通过设置 export CUDA_VISIBLE_DEVICES=0 指定单卡GPU评估。

若训练时指定 --syncbn=False, 模型评估精度如下:

input sizemAP(IoU=0.50:0.95)mAP(IoU=0.50)mAP(IoU=0.75)
608x60837.759.840.8
416x41636.558.239.1
320x32034.155.436.3

若训练时指定 --syncbn=True, 模型评估精度如下。

input sizemAP(IoU=0.50:0.95)mAP(IoU=0.50)mAP(IoU=0.75)
608x60838.961.142.0
416x41637.559.640.2
320x32034.856.436.9

: 评估结果基于pycocotools评估器,没有滤除score < 0.05的预测框,其他框架有此滤除操作会导致精度下降。

4.4. 模型推断

模型推断可以获取图像中的物体及其对应的类别,infer.py是主要执行程序,调用示例如下。

pythoninfer.py \
    --dataset=coco2017 \
    --weights=${path_to_weights}  \
    --image_path=data/COCO17/val2017/  \
    --image_name=000000000139.jpg \
    --draw_thresh=0.5

通过设置 export CUDA_VISIBLE_DEVICES=0 指定单卡GPU预测。

模型预测速度(Tesla P40):

input size608x608416x416320x320
infer speed48 ms/frame29 ms/frame24 ms/frame

5. YOLOV3 模型定义 PaddlePaddle

darknet: https://github.com/PaddlePaddle/models/blob/v1.4/PaddleCV/yolov3/models/darknet.py

yolov3: https://github.com/PaddlePaddle/models/blob/v1.4/PaddleCV/yolov3/models/yolov3.py

5.1. darkent

import paddle.fluid as fluid
from paddle.fluid.param_attr import ParamAttr
from paddle.fluid.initializer import Constant
from paddle.fluid.regularizer import L2Decay

def conv_bn_layer(input,
                  ch_out,
                  filter_size,
                  stride,
                  padding,
                  act='leaky',
                  is_test=True,
                  name=None):
    conv1 = fluid.layers.conv2d(
        input=input,
        num_filters=ch_out,
        filter_size=filter_size,
        stride=stride,
        padding=padding,
        act=None,
        param_attr=ParamAttr(
            initializer=fluid.initializer.Normal(0., 0.02),
            name=name+".conv.weights"),
        bias_attr=False)

    bn_name = name + ".bn"
    out = fluid.layers.batch_norm(
        input=conv1,
        act=None,
        is_test=is_test,
        param_attr=ParamAttr(
                initializer=fluid.initializer.Normal(0., 0.02),
                regularizer=L2Decay(0.),
                name=bn_name + '.scale'),
        bias_attr=ParamAttr(
                initializer=fluid.initializer.Constant(0.0),
                regularizer=L2Decay(0.),
                name=bn_name + '.offset'),
        moving_mean_name=bn_name + '.mean',
        moving_variance_name=bn_name + '.var')
    if act == 'leaky':
        out = fluid.layers.leaky_relu(x=out, alpha=0.1)
    return out

def downsample(input, 
               ch_out, 
               filter_size=3, 
               stride=2, 
               padding=1, 
               is_test=True, 
               name=None):
    return conv_bn_layer(input, 
            ch_out=ch_out, 
            filter_size=filter_size, 
            stride=stride, 
            padding=padding, 
            is_test=is_test,
            name=name)

def basicblock(input, ch_out, is_test=True, name=None):
    conv1 = conv_bn_layer(input, ch_out, 1, 1, 0, 
                          is_test=is_test, name=name+".0")
    conv2 = conv_bn_layer(conv1, ch_out*2, 3, 1, 1, 
                          is_test=is_test, name=name+".1")
    out = fluid.layers.elementwise_add(x=input, y=conv2, act=None)
    return out

def layer_warp(block_func, input, ch_out, count, is_test=True, name=None):
    res_out = block_func(input, ch_out, is_test=is_test, 
                         name='{}.0'.format(name))
    for j in range(1, count):
        res_out = block_func(res_out, ch_out, is_test=is_test, 
                             name='{}.{}'.format(name, j))
    return res_out


DarkNet_cfg = {53: ([1,2,8,8,4],basicblock)}


def add_DarkNet53_conv_body(body_input, is_test=True):
    stages, block_func = DarkNet_cfg[53]
    stages = stages[0:5]
    conv1 = conv_bn_layer(body_input, ch_out=32, filter_size=3, 
                          stride=1, padding=1, is_test=is_test, 
                          name="yolo_input")
    downsample_ = downsample(conv1, ch_out=conv1.shape[1]*2, 
                             is_test=is_test, 
                             name="yolo_input.downsample")
    blocks = []
    for i, stage in enumerate(stages):
        block = layer_warp(block_func, downsample_, 32 *(2**i), 
                           stage, is_test=is_test, 
                           name="stage.{}".format(i))
        blocks.append(block)
        if i < len(stages) - 1: # do not downsaple in the last stage
            downsample_ = downsample(
                block, 
                ch_out=block.shape[1]*2, 
                is_test=is_test, 
                name="stage.{}.downsample".format(i))
            
    return blocks[-1:-4:-1]

5.2. yolov3

from __future__ import division
from __future__ import print_function

import paddle.fluid as fluid
from paddle.fluid.param_attr import ParamAttr
from paddle.fluid.initializer import Constant
from paddle.fluid.initializer import Normal
from paddle.fluid.regularizer import L2Decay

from config import cfg

from .darknet import add_DarkNet53_conv_body
from .darknet import conv_bn_layer

def yolo_detection_block(input, channel, is_test=True, name=None):
    assert channel % 2 == 0, \
            "channel {} cannot be divided by 2".format(channel)
    conv = input
    for j in range(2):
        conv = conv_bn_layer(conv, channel, filter_size=1, 
                             stride=1, padding=0, is_test=is_test, 
                             name='{}.{}.0'.format(name, j))
        conv = conv_bn_layer(conv, channel*2, filter_size=3, 
                             stride=1, padding=1, is_test=is_test, 
                             name='{}.{}.1'.format(name, j))
    route = conv_bn_layer(conv, channel, filter_size=1, stride=1, 
                          padding=0, is_test=is_test, 
                          name='{}.2'.format(name))
    tip = conv_bn_layer(route,channel*2, filter_size=3, stride=1, 
                        padding=1, is_test=is_test, 
                        name='{}.tip'.format(name))
    return route, tip

def upsample(input, scale=2,name=None):
    # get dynamic upsample output shape
    shape_nchw = fluid.layers.shape(input)
    shape_hw = fluid.layers.slice(shape_nchw, axes=[0], starts=[2], ends=[4])
    shape_hw.stop_gradient = True
    in_shape = fluid.layers.cast(shape_hw, dtype='int32')
    out_shape = in_shape * scale
    out_shape.stop_gradient = True

    # reisze by actual_shape
    out = fluid.layers.resize_nearest(
        input=input,
        scale=scale,
        actual_shape=out_shape,
        name=name)
    return out


class YOLOv3(object):
    def __init__(self, 
                is_train=True,
                use_random=True):
        self.is_train = is_train
        self.use_random = use_random
        self.outputs = []
        self.losses = []
        self.downsample = 32

    def build_input(self):
        self.image_shape = [3, cfg.input_size, cfg.input_size]
        if self.is_train:
            self.py_reader = fluid.layers.py_reader(
                capacity=64,
                shapes = [[-1] + self.image_shape, 
                          [-1, cfg.max_box_num, 4], 
                          [-1, cfg.max_box_num], 
                          [-1, cfg.max_box_num]],
                lod_levels=[0, 0, 0, 0],
                dtypes=['float32'] * 2 + ['int32'] + ['float32'],
                use_double_buffer=True)
            self.image, self.gtbox, self.gtlabel, self.gtscore = \
                    fluid.layers.read_file(self.py_reader)
        else:
            self.image = fluid.layers.data(
                name='image', 
                shape=self.image_shape, 
                dtype='float32')
            self.im_shape = fluid.layers.data(
                name="im_shape", 
                dtype='int32')
            self.im_id = fluid.layers.data(
                name="im_id", 
                shape=[1], 
                dtype='int32')
    
    def feeds(self):
        if not self.is_train:
            return [self.image, self.im_id, self.im_shape]
        return [self.image, self.gtbox, self.gtlabel, self.gtscore]

    def build_model(self):
        self.build_input()

        self.outputs = []
        self.boxes = []
        self.scores = []

        blocks = add_DarkNet53_conv_body(self.image, not self.is_train)
        for i, block in enumerate(blocks):
            if i > 0:
                block = fluid.layers.concat(
                    input=[route, block],
                    axis=1)
            route, tip = yolo_detection_block(
                block, 
                channel=512//(2**i), 
                is_test=(not self.is_train),
                name="yolo_block.{}".format(i))

            # out channel number = mask_num * (5 + class_num)
            num_filters = len(cfg.anchor_masks[i]) * (cfg.class_num + 5)
            block_out = fluid.layers.conv2d(
                input=tip,
                num_filters=num_filters,
                filter_size=1,
                stride=1,
                padding=0,
                act=None,
                param_attr=ParamAttr(
                    initializer=fluid.initializer.Normal(0., 0.02),
                    name="yolo_output.{}.conv.weights".format(i)),
                bias_attr=ParamAttr(
                    initializer=fluid.initializer.Constant(0.0),
                    regularizer=L2Decay(0.),
                    name="yolo_output.{}.conv.bias".format(i)))
            self.outputs.append(block_out)

            if i < len(blocks) - 1:
                route = conv_bn_layer(
                    input=route,
                    ch_out=256//(2**i),
                    filter_size=1,
                    stride=1,
                    padding=0,
                    is_test=(not self.is_train),
                    name="yolo_transition.{}".format(i))
                # upsample
                route = upsample(route)

        for i, out in enumerate(self.outputs):
            anchor_mask = cfg.anchor_masks[i]

            if self.is_train:
                loss = fluid.layers.yolov3_loss(
                        x=out,
                        gt_box=self.gtbox,
                        gt_label=self.gtlabel,
                        gt_score=self.gtscore,
                        anchors=cfg.anchors,
                        anchor_mask=anchor_mask,
                        class_num=cfg.class_num,
                        ignore_thresh=cfg.ignore_thresh,
                        downsample_ratio=self.downsample,
                        use_label_smooth=cfg.label_smooth,
                        name="yolo_loss"+str(i))
                self.losses.append(fluid.layers.reduce_mean(loss))
            else:
                mask_anchors=[]
                for m in anchor_mask:
                    mask_anchors.append(cfg.anchors[2 * m])
                    mask_anchors.append(cfg.anchors[2 * m + 1])
                boxes, scores = fluid.layers.yolo_box(
                        x=out,
                        img_size=self.im_shape,
                        anchors=mask_anchors,
                        class_num=cfg.class_num,
                        conf_thresh=cfg.valid_thresh,
                        downsample_ratio=self.downsample,
                        name="yolo_box"+str(i))
                self.boxes.append(boxes)
                self.scores.append(
                    fluid.layers.transpose(scores, perm=[0, 2, 1]))
                
            self.downsample //= 2


    def loss(self):
        return sum(self.losses)

    def get_pred(self):
        yolo_boxes = fluid.layers.concat(self.boxes, axis=1)
        yolo_scores = fluid.layers.concat(self.scores, axis=2)
        return fluid.layers.multiclass_nms(
                bboxes=yolo_boxes,
                scores=yolo_scores,
                score_threshold=cfg.valid_thresh,
                nms_top_k=cfg.nms_topk,
                keep_top_k=cfg.nms_posk,
                nms_threshold=cfg.nms_thresh,
                background_label=-1,
                name="multiclass_nms")
Last modification:June 12th, 2019 at 09:38 am

Leave a Comment