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

Author： AIHGF
发布时间：June 1, 2019
6204views
No comments
18949 words
Categories：目标检测

原文：快到没朋友的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 size	mAP(IoU=0.50:0.95)	mAP(IoU=0.50)	mAP(IoU=0.75)
608x608	37.7	59.8	40.8
416x416	36.5	58.2	39.1
320x320	34.1	55.4	36.3

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

input size	mAP(IoU=0.50:0.95)	mAP(IoU=0.50)	mAP(IoU=0.75)
608x608	38.9	61.1	42.0
416x416	37.5	59.6	40.2
320x320	34.8	56.4	36.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 size	608x608	416x416	320x320
infer speed	48 ms/frame	29 ms/frame	24 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

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

AIHGF • 2019 年 06 月 01 日

原文：快到没朋友的YOLO v3有了PaddlePaddle实现 - 2019.05.21
出处：PaddlePaddle - 微信公众号
项目路径：Github - PaddlePaddle/models/PaddleCV/yolov3/

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

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

1. YOLOv3 检测原理

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

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

2. YOLOv3 网络结构

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

3. PaddlePaddle简介

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

3.1. 应用案例—AI识虫

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

[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 size	mAP(IoU=0.50:0.95)	mAP(IoU=0.50)	mAP(IoU=0.75)
608x608	37.7	59.8	40.8
416x416	36.5	58.2	39.1
320x320	34.1	55.4	36.3

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

input size	mAP(IoU=0.50:0.95)	mAP(IoU=0.50)	mAP(IoU=0.75)
608x608	38.9	61.1	42.0
416x416	37.5	59.6	40.2
320x320	34.8	56.4	36.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 size	608x608	416x416	320x320
infer speed	48 ms/frame	29 ms/frame	24 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")

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

1. YOLOv3 检测原理

2. YOLOv3 网络结构

3. PaddlePaddle简介

3.1. 应用案例—AI识虫

4. YOLOv3 PaddlePaddle实战

4.1. 数据准备

4.2. 模型训练

4.3. 模型评估

4.4. 模型推断

5. YOLOV3 模型定义 PaddlePaddle

5.1. darkent

5.2. yolov3

※相关文章推荐※

※最新文章推荐※

Leave a Comment Cancel reply

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

1. YOLOv3 检测原理

2. YOLOv3 网络结构

3. PaddlePaddle简介

3.1. 应用案例—AI识虫

4. YOLOv3 PaddlePaddle实战

4.1. 数据准备

4.2. 模型训练

4.3. 模型评估

4.4. 模型推断

5. YOLOV3 模型定义 PaddlePaddle

5.1. darkent

5.2. yolov3