MXNet的Faster R-CNN(基于区域提议网络的实时目标检测)《10》(尾)

MXNet的Faster R-CNN(基于区域提议网络的实时目标检测)《1》:论文源地址,克隆MXNet版本的源码,安装环境与测试,以及对下载的源码的每个目录做什么用的,做个解释。

MXNet的Faster R-CNN(基于区域提议网络的实时目标检测)《2》:对论文中的区域提议、平移不变锚、多尺度预测等概念的了解,对损失函数、边界框回归的公式的了解,以及共享特征的训练网络的方法。

MXNet的Faster R-CNN(基于区域提议网络的实时目标检测)《3》:加载模型参数,对参数文件的了解,以及感兴趣区域ROI和泛洪填充的方法(FLOODFILL_FIXED_RANGE,FLOODFILL_MASK_ONLY)

MXNet的Faster R-CNN(基于区域提议网络的实时目标检测)《4》:下载与熟悉Pascal VOC2007,2012语义分割数据集,明白实例分割除了分类之外,还可以细分到像素级别的所属类别。

MXNet的Faster R-CNN(基于区域提议网络的实时目标检测)《5》:主要就是熟悉转置卷积与大家所熟知的卷积有什么区别,作用是什么,以及双线性插值等相关知识

MXNet的Faster R-CNN(基于区域提议网络的实时目标检测)《6》:主要讲解关于参数解析的安全执行(ast.literal_eval),ROI池化以及计算图的可视化的处理

MXNet的Faster R-CNN(基于区域提议网络的实时目标检测)《7》:打印内容(比如参数文件里的东西)的三种方式以及对奇异值分解(SVD,Singular Value Decomposition)的熟悉,了解SVD的作用和运用

MXNet的Faster R-CNN(基于区域提议网络的实时目标检测)《8》:主要是通过参数的设置进一步熟悉模型,以及对于符号式编程的复习,另外关于损失函数之类,这里用到了自定义评价函数,然后通过自带的mx.metric来做,有示例让大家熟悉。

MXNet的Faster R-CNN(基于区域提议网络的实时目标检测)《9》:从测试模型了解有哪些知识点,张量的垂直叠加,然后从单个文件细读,有哪些关键点,交并比的计算、裁剪掉超出图像部分区域的锚框、边界框回归方法以及非极大值抑制的实现(并画出边界框图形)

这是第十篇继续来拆解学习Faster RCNN,也是最后一篇,知识点比较多,另外在文章末尾附上最终加上了注释的源码,有兴趣的伙伴们可以Clone一个看看。

我们继续对每个文件的代码进行阅读,有些我就直接在源码中做了注释,没有贴代码了,另外coco与restnet相关的代码跟voc的都差不多,只是数据集与网络结构不一样,整体的思路是一样的。这里还是以voc数据集为主来熟悉,来到这个symimdb目录,主要是图像数据的处理。

错误与断言assert

在代码中可以看到很多地方有断言与错误等处理,我们来熟悉下:

def _load_gt_roidb(self):
        raise NotImplementedError

出现raise NotImplementedError这个错误,就是说如果这个方法没有被重写就报错,我们看下这个方法是属于哪个类的,class IMDB(object) 然后我们搜索IMDB查看相关调用,我们发现在pascal_voc.py中有调用:class PascalVOC(IMDB)

那么在这个PascalVOC类里面肯定需要重写_load_gt_roidb这个方法,我们往下查看

def _load_gt_roidb(self):
    image_index = self._load_image_index()
    gt_roidb = [self._load_annotation(index) for index in image_index]
    return gt_roidb

没错,代码中确实做了重写,如果没有重写这个方法那就会触发NotImplementedError这个错误

另外断言出现的频率也很高,比如下面:

assert ex_rois.shape[0] == gt_rois.shape[0], 'inconsistent rois number'

如果两者的样本数不一样,那就会报inconsistent rois number这样的错误,当然这个错误的信息显示是自定义的,比如:

assert 1==2,'1不等于2'

源码中还有一种值错误处理,比如:

networks = {
        'vgg16': get_vgg16_train,
        'resnet50': get_resnet50_train,
        'resnet101': get_resnet101_train
    }
    if network not in networks:
        raise ValueError("network {} not supported".format(network))

这样的处理就是说网络只能是指定的这三者中的一种,如果是其他的就会报错,比如如果输入不存在的get_vgg18_train,将出现如下错误:

ValueError: network get_vgg18_train not supported

这些错误与断言,只要出现都将终止程序,不会继续往下执行,这个在平时自己写代码的时候需要注意,提高代码的严谨性。

推断形状infer_shape

我们来到symnet/model.py文件,其中关于推断形状,有必要介绍下,因为形状在神经网络中是非常非常重要的概念,先来看下源码中实现的方法infer_param_shape

def infer_param_shape(symbol, data_shapes):
    arg_shape, _, aux_shape = symbol.infer_shape(**dict(data_shapes))
    arg_shape_dict = dict(zip(symbol.list_arguments(), arg_shape))
    aux_shape_dict = dict(zip(symbol.list_auxiliary_states(), aux_shape))
    return arg_shape_dict, aux_shape_dict

主要关注infer_shape这个方法,其中的参数data_shapes,假如类似下面这样的形状,由元组组成的列表:

data_shapes = [('data', (1, 3, 800, 800)), ('im_info', (1, 3))]

这里通过字典的类型转换:dict(data_shapes),变成字典类型:

{'data': (1, 3, 800, 800), 'im_info': (1, 3)}

对于前面两个星号**的用法,如果不了解的伙伴们可以查阅:Python中*args和**kwargs的解释

如果有符号式编程的经验,那对于形状的推断就会很熟悉,如果是第一次接触,没关系,这里再次复习一遍。

通俗简单来说,符号式编程就是先将整个计算流程给设计出来,最后需要使用的时候,进行绑定与计算操作,就好比建房子之前先将图纸画好,然后我们只需要按照图纸来执行相关操作。

为了快速熟悉它,这里我用一个特别简单的示例来说明:

a = mx.sym.Variable('A')
b = mx.sym.Variable('B')
c = (a + b) / 10

这里定义了两个Symbol,A和B,然后将两者相加再除以10,这个时候的A和B是个未知变量,或说是个符号变量。那如果场景是在深度卷积网络中呢?整个流程我们需要正确执行,形状是关键,不然会因为形状不符合,就没法计算,所以这里就出现了推断形状的方法,然后可以做一些前面介绍的断言,确保形状一样,这样就可以确保顺畅的向下执行了。

我们来看个具体的示例,假如输入的形状如下:

input_shapes = {'A':(10,2), 'B':(10,2)}#这里我们就直接使用字典类型
c.infer_shape(**input_shapes)#这里会返回三个形状,arg_shapes,out_shapes,aux_shapes

接收返回值,打印看下结果:

arg_shapes,out_shapes,aux_shapes=c.infer_shape(**input_shapes)
#arg_shapes:[(10, 2), (10, 2)]
#out_shapes:[(10, 2)]
#aux_shapes:[]

也就是说在符号式编程中只需要指定形状,我们就可以通过“计算图”推断出每层输出的形状。

如何在实践中得到实际的结果,通过bind绑定和forward计算即可。

executor=c.bind(ctx=mx.cpu(),args={'A':nd.array([[2,3],[4,5]]),'B':nd.array([[11,10],[1,8]])})
executor.arg_dict
'''
{'A':
[[2. 3.]
 [4. 5.]]
, 'B':
[[11. 10.]
 [ 1.  8.]]
}
'''
executor.forward()
executor.outputs[0]
'''
[[1.3 1.3]
 [0.5 1.3]]

'''

计算结果没有问题,两者相加之后除以10,想了解更多关于符号式编程的伙伴们可以查阅:

MXNet中的命令式编程和符号式编程的优缺点

计算性能的提升之混合式编程(MXNet)

MXNet的Faster R-CNN(基于区域提议网络的实时目标检测)《6》

MakeLoss计算损失函数

我们在symnet/symbol_vgg.py的边界框回归的源码中,使用了平滑L1损失函数

在命令式编程中我们知道,nd有自带的L1平滑损失直接可以求出:

print(nd.smooth_l1(nd.array([0.5, 0.9, 1, 2, 3]), scalar=1))
'''
[0.125      0.40499997 0.5        1.5        2.5       ]

这里顺带将L1平滑损失函数的公式再次贴出来:

那么在符号式编程中,所以如何使用呢?我们看下源码中是怎么样的:

bbox_pred = mx.symbol.FullyConnected(name='bbox_pred', data=top_feat, num_hidden=num_classes * 4)
bbox_loss_ = bbox_weight * mx.symbol.smooth_l1(name='bbox_loss_', scalar=1.0, data=(bbox_pred - bbox_target))
bbox_loss = mx.sym.MakeLoss(name='bbox_loss', data=bbox_loss_, grad_scale=1.0 / rcnn_batch_rois)

照葫芦画瓢,这个symbol模块也自带有smooth_l1(平滑L1损失函数),指定需要的参数data(Symbol类型),然后通过MakeLoss去执行即可

data = mx.sym.Variable('data')
sl1_loss_ = mx.sym.smooth_l1(data=data, name='bbox_loss_', scalar=1)
m_loss = mx.sym.MakeLoss(data=sl1_loss_)
EX = m_loss.bind(ctx=mx.cpu(), args={'data': nd.array([0.5, 0.9, 1, 2, 3])})
EX.forward()
'''
[0.125      0.40499997 0.5        1.5        2.5       ]
]
'''

跟前面命令行编程的结果是一样的,当然自己使用公式计算也是这样的结果,其中0.40499997本来是0.41,这个属浮点数的误差。

这里需要注意的是,参数是scalar而不是源码中示例的sigma,如果写成sigma在VSCode中就会报错,命令行却没有问题,这里比较奇怪:

Exception has occurred: OSError
[WinError -529697949] Windows Error 0xe06d7363

以方法的参数为准:

def smooth_l1(data=None, scalar=_Null, name=None, attr=None, out=None, **kwargs)

示例中的公式是sigma,所以例子中的参数误写成了sigma,这里的细节需要注意下。

BlockGrad阻塞梯度的反向传播

Block是阻塞的意思,Grad是表示梯度Gradient,含义就是阻止梯度的反向传播。

我们在symnet/symbol_vgg.py的代码get_vgg_train训练方法中看到有这个方法的调用:

group = mx.symbol.Group([rpn_cls_prob, rpn_bbox_loss, cls_prob, bbox_loss, mx.symbol.BlockGrad(label)])

mx.symbol.BlockGrad(label)那意思就是说label在反向传播时的梯度在这里终止

我们来看个具体的示例:

from mxnet import nd
import mxnet as mx

x1 = nd.array([[1, 2]])
x2 = nd.array([[3, 4]])

a = mx.sym.Variable('a')
b = mx.sym.Variable('b')
a_grad = 5*a
b_grad = 10*b
m_loss = mx.sym.MakeLoss(a_grad+b_grad)
EX = m_loss.simple_bind(ctx=mx.cpu(), a=(1, 2), b=(1, 2))
print(EX.forward(a=x1, b=x2)[0])  # [[35. 50.]]

EX.backward()
print(EX.grad_arrays)
'''
[
[[5. 5.]]
,
[[10. 10.]]
]
'''

我们可以看到前向传播的结果是正确的,再观察这个5a和10b的梯度分别是5和10,反向传播的结果也没有问题。

现在我们阻止这个10b的梯度传播,看下会是什么情况:

x1 = nd.array([[1, 2]])
x2 = nd.array([[3, 4]])

a = mx.sym.Variable('a')
b = mx.sym.Variable('b')
a_grad = 5*a
b_grad = 10*b
# 这个位置我们添加一个阻止b_grad的反向传播
b_grad_stop = mx.sym.BlockGrad(b_grad)

m_loss = mx.sym.MakeLoss(a_grad+b_grad_stop)
EX = m_loss.simple_bind(ctx=mx.cpu(), a=(1, 2), b=(1, 2))
print(EX.forward(a=x1, b=x2)[0])  # [[35. 50.]]

EX.backward()
print(EX.grad_arrays)
'''
[
[[5. 5.]]
,
[[0. 0.]]
]
'''

5a的反向传播是正常的,求出的梯度是5没有问题,10b的梯度全部变为了0,说明成功阻止了它的反向传播,我们也可以可视化下这个小型的“计算图”:

digraph = mx.viz.plot_network(m_loss)
digraph.view()

如图:

MXNet的Faster R-CNN(基于区域提议网络的实时目标检测)《10》(尾)_第1张图片

可以看到a和b的区别,b这个分支多了一个blockgrad0,然后再相加,这里需要注意的是,前向传播是不影响的,还是正常的相乘之后两者相加,只是在反向传播求梯度的时候做一个阻塞,终止10b的传播。

自定义操作符operator

我们在symnet/proposal_target.py源码发现在类的上面出现这样一个装饰@mx.operator.register('proposal_target'),它的作用就是将名称proposal_target注册到自定义操作符中。

@mx.operator.register('proposal_target')
class ProposalTargetProp(mx.operator.CustomOpProp):
    def __init__(self, num_classes='21', batch_images='1', batch_rois='128', fg_fraction='0.25',
                 fg_overlap='0.5', box_stds='(0.1, 0.1, 0.2, 0.2)'):
        super(ProposalTargetProp, self).__init__(need_top_grad=False)#False:此层不需要传来的梯度
        self._num_classes = int(num_classes)
        self._batch_images = int(batch_images)
        self._batch_rois = int(batch_rois)
        self._fg_fraction = float(fg_fraction)
        self._fg_overlap = float(fg_overlap)
        self._box_stds = tuple(np.fromstring(box_stds[1:-1], dtype=float, sep=','))

先看下这个类的基类mx.operator.CustomOpProp,我们可以转到定义可以知道这个是自定义操作符属性类的基类。CustomOpProp最后创建操作符是返回CustomOp(),然后转到定义发现这个是python中实现的操作符的真正基类了,其他还有NumpyOp,NDArrayOp这样的操作都在operator.py文件定义

symnet/symbol_vgg.py中的调用:

group = mx.symbol.Custom(rois=rois, gt_boxes=gt_boxes, op_type='proposal_target',
                         num_classes=num_classes, batch_images=rcnn_batch_size,
                         batch_rois=rcnn_batch_rois, fg_fraction=rcnn_fg_fraction,
                         fg_overlap=rcnn_fg_overlap, box_stds=rcnn_bbox_stds)

op_type='proposal_target'这个操作符的名称就是来自前面声明的装饰@mx.operator.register('proposal_target')注册中的名称。

这样注册了之后,在这个类里面可以重写方法,比如说

def list_arguments(self):
    return ['rois', 'gt_boxes']

def list_outputs(self):
    return ['rois_output', 'label', 'bbox_target', 'bbox_weight']

这个list_arguments输入的参数就是由op_type绑定的自定义操作符决定了,同样的list_outputs输出参数也是的,这里其实是后缀形式,输出形式是name_后缀这样的输出。

当然这里还是围绕着这个源码来熟悉这个知识点,我们来看个具体的示例(输出是Softmax层,对官方示例有所改动),一个多层感知机的网络:

import mxnet as mx
from mxnet import nd
import numpy as np

class TestLayer(mx.operator.CustomOp):
    def forward(self, is_train, req, in_data, out_data, aux):
        x = in_data[0].asnumpy()
        y = np.exp(x - x.max(axis=1).reshape((x.shape[0], 1)))
        y /= y.sum(axis=1).reshape((x.shape[0], 1))
        self.assign(out_data[0], req[0], mx.nd.array(y))

    def backward(self, req, out_grad, in_data, out_data, in_grad, aux):
        l = in_data[1].asnumpy().ravel().astype(np.int32)
        y = out_data[0].asnumpy()
        y[np.arange(l.shape[0]), l] -= 1.0
        self.assign(in_grad[0], req[0], mx.nd.array(y))


@mx.operator.register('Tony')  # 注册名称将在调用的时候作为操作符名称
class TestProp(mx.operator.CustomOpProp):
    def __init__(self):
        super(TestProp, self).__init__(need_top_grad=False)

    def list_arguments(self):
        return ['data', 'label']

    def list_outputs(self):
        return ['output']

    def infer_shape(self, in_shape):
        data_shape = in_shape[0]
        label_shape = (in_shape[0][0],)
        output_shape = in_shape[0]
        return [data_shape, label_shape], [output_shape], []

    def infer_type(self, in_type):
        return in_type, [in_type[0]], []

    def create_operator(self, ctx, shapes, dtypes):
        return TestLayer()


net = mx.sym.Variable('data')
net = mx.sym.FullyConnected(net, name='fc', num_hidden=10)
net = mx.sym.Activation(net, name='relu', act_type="relu")
mlp = mx.sym.Custom(data=net, name='MySoftmax', op_type='Tony')

print(mlp.list_arguments(), mlp.list_outputs())
#['data', 'fc_weight', 'fc_bias', 'MySoftmax_label'] ['MySoftmax_output']

# 推断形状
input_shapes = {'data': (5, 28*28)}
print(mlp.infer_shape(**input_shapes))
#([(5, 784), (10, 784), (10,), (5,)], [(5, 10)], [])

#绑定做反向传播
args = {'data': nd.ones((1, 4)), 'fc_weight': nd.ones((10, 4)),
        'fc_bias': nd.ones((10,)), 'MySoftmax_label': nd.ones((1))}
args_grad = {'fc_weight': nd.zeros((10, 4)), 'fc_bias': nd.zeros((10))}

executor = mlp.bind(ctx=mx.cpu(0), args=args,args_grad=args_grad, grad_req='write')
print("executor.arg_dict 初始值\n", executor.arg_dict)
'''
executor.arg_dict 初始值
 {'data':
[[1. 1. 1. 1.]]
, 'fc_weight':
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
, 'fc_bias':
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
, 'MySoftmax_label':
[1.]
}
'''

print("executor.grad_dict 初始值\n", executor.grad_dict)
'''
executor.grad_dict 初始值
 {'data': None, 'fc_weight':
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]
, 'fc_bias':
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
, 'MySoftmax_label': None}
'''
executor.backward()
print(executor.grad_arrays)
'''
[None,
[[-2.144862e-15 -2.144862e-15 -2.144862e-15 -2.144862e-15]
 [-1.000000e+00 -1.000000e+00 -1.000000e+00 -1.000000e+00]
 [ 0.000000e+00  0.000000e+00  0.000000e+00  0.000000e+00]
 [ 4.591214e-41  4.591214e-41  4.591214e-41  4.591214e-41]
 [ 0.000000e+00  0.000000e+00  0.000000e+00  0.000000e+00]
 [ 0.000000e+00  0.000000e+00  0.000000e+00  0.000000e+00]
 [ 4.203895e-45  4.203895e-45  4.203895e-45  4.203895e-45]
 [ 0.000000e+00  0.000000e+00  0.000000e+00  0.000000e+00]
 [ 0.000000e+00  0.000000e+00  0.000000e+00  0.000000e+00]
 [ 5.044674e-43  5.044674e-43  5.044674e-43  5.044674e-43]]
,
[-2.144862e-15 -1.000000e+00  0.000000e+00  4.591214e-41  0.000000e+00
  0.000000e+00  4.203895e-45  0.000000e+00  0.000000e+00  5.044674e-43]
, None]
'''

十连载将Faster-RCNN全部梳理了一遍,尤其是对于源码中出现的知识点都单独挑出来进行了示例演示,希望能够帮助到大家更快的理解这个网络模型,由于水平有限,错误难免,还望留言指正!

其中对于源码的理解,做了一些注释,有兴趣的可以clone一个来看看,github地址如下:

https://github.com/yihangzhao/NewMXRCNN

你可能感兴趣的:(深度学习框架(MXNet),assert断言,infer_shape推断形状,MakeLoss,BlockGrad阻塞梯度反向,自定义操作符)