上一节我们已经谈到了计算节点，但是即使是官方文档介绍里面相关内容也过于简略，我们使用Faster-RCNN代码中的新建节点为例，重新介绍一下新建节点的调用栈。
1、调用新建节点
参数分为三部分，op_type是节点名称，对应于辅助class的装饰器的输入；其他参数一部分传递给辅助class的初始化函数（这部分参数的虚参名和初始化函数的需参名要对应上），一部分直接作为一个list传给节点定义class的forward函数的in_data参数。
group = mx.symbol.Custom(rois=rois, # 2000*5的roi信息，CustomOpProp无此参数
gt_boxes=gt_boxes, # n*5的ground truth信息，n表示object数量，CustomOpProp无此参数
op_type='proposal_target', # <-----对应辅助节点装饰器参数
# CustomOp，CustomOpProp初始化参数
num_classes=num_classes, # num_classes是实际要分类的类别数加上背景类
batch_images=rcnn_batch_size, # 1
batch_rois=rcnn_batch_rois, # 128
fg_fraction=rcnn_fg_fraction, #s 0.25，正样本所占的比例
fg_overlap=rcnn_fg_overlap, # 0.5
box_stds=rcnn_bbox_stds # (0.1, 0.1, 0.2, 0.2)
)
2、建立辅助class：CustomOpProp
本部分的class方法参数固定，不可以随意修改
@mx.operator.register('proposal_target') # <-----对应调用的op_type
class ProposalTargetProp(mx.operator.CustomOpProp):
def __init__(self, num_classes='21', batch_images='1', batch_rois='128', fg_fraction='0.25', # 接受上面调用的后5个参数
fg_overlap='0.5', box_stds='(0.1, 0.1, 0.2, 0.2)'):
super(ProposalTargetProp, self).__init__(need_top_grad=False) # <-----本节点是否需要后面的梯度
self._num_classes = int(num_classes) # num_classes是实际要分类的类别数加上背景类
self._batch_images = int(batch_images) # 1
self._batch_rois = int(batch_rois) # 128
self._fg_fraction = float(fg_fraction) # 0.25，正样本所占的比例
self._fg_overlap = float(fg_overlap) # 0.5
self._box_stds = tuple(np.fromstring(box_stds[1:-1], dtype=float, sep=',')) # (0.1, 0.1, 0.2, 0.2)
def list_arguments(self):
return ['rois', 'gt_boxes'] # 向前传播需要的参数
def list_outputs(self):
return ['rois_output', 'label', 'bbox_target', 'bbox_weight'] # 向前传播输出参数名
def infer_shape(self, in_shape):
assert self._batch_rois % self._batch_images == 0,
'BATCHIMAGES {} must devide BATCH_ROIS {}'.format(self._batch_images, self._batch_rois)
rpn_rois_shape = in_shape[0]
gt_boxes_shape = in_shape[1]
output_rois_shape = (self._batch_rois, 5)
label_shape = (self._batch_rois, )
bbox_target_shape = (self._batch_rois, self._num_classes * 4)
bbox_weight_shape = (self._batch_rois, self._num_classes * 4)
return [rpn_rois_shape, gt_boxes_shape],
[output_rois_shape, label_shape, bbox_target_shape, bbox_weight_shape]
def create_operator(self, ctx, shapes, dtypes): # 返回初始化了的自定义节点类
return ProposalTargetOperator(self._num_classes, self._batch_images, self._batch_rois, self._fg_fraction,
self._fg_overlap, self._box_stds)
def declare_backward_dependency(self, out_grad, in_data, out_data):
return []
__init__
初始化方法会首先从调用位置接收参数，调用位置的op_type参数用于指定选用哪个辅助class，然后其他参数优先传入本初的__init__方法，剩下的没有和本方法参数对应上的参数会做为节点class的forward方法的in_data参数。
下面一行表示本节点不需要接收后面层的梯度，对应到节点定义class的backward方法，out_grad参数就不应在函数体内调用了，in_grad（向前传播回去的梯度）计算完全依赖本层的参数。
super(ProposalTargetProp, self).__init__(need_top_grad=False)
list_arguments
使用list_arguments()方法返回时，输出并不直接就是上述代码list_arguments方法的return列表，实际上会将整个net结构截至的本节点为止，全部的variable变量名称输入。
对于本节点group，定义输入有两个：
rois=rois # 2000*5的roi信息，CustomOpProp无此参数
gt_boxes=gt_boxes
其中gt_boxes变量本身是个variable（定义为gt_boxes = mx.symbol.Variable(name="gt_boxes")），但是rois为symbol，是之前网络的输出symbol，所以实际输出的arguments为gt_boxes本身，以及rois所依赖的全部variables，包含认为定义的占位符variable和网络层自带的参数variable。
['data', 'conv1_1_weight', 'conv1_1_bias', 'conv1_2_weight', 'conv1_2_bias', 'conv2_1_weight', 'conv2_1_bias', 'conv2_2_weight', 'conv2_2_bias', 'conv3_1_weight', 'conv3_1_bias', 'conv3_2_weight', 'conv3_2_bias', 'conv3_3_weight', 'conv3_3_bias', 'conv4_1_weight', 'conv4_1_bias', 'conv4_2_weight', 'conv4_2_bias', 'conv4_3_weight', 'conv4_3_bias', 'conv5_1_weight', 'conv5_1_bias', 'conv5_2_weight', 'conv5_2_bias', 'conv5_3_weight', 'conv5_3_bias', 'rpn_conv_3x3_weight', 'rpn_conv_3x3_bias', 'rpn_cls_score_weight', 'rpn_cls_score_bias', 'rpn_bbox_pred_weight', 'rpn_bbox_pred_bias', 'im_info',
'gt_boxes']
infer_shape
其输入参数in_shape就是list_arguments中return的那几个变量的shape，对于本例，就是rois和gtboxes的shape，本方法用于推断输出symbol和梯度symbol的shape是否正确。
3、实现节点class
节点class的初始化和调用部分的参数完全无关，是由辅助节点来进行传参调用的。但是其forward方法的in_data参数其值接收是从调用初进行的，in_data中的参数就是上面list_arguments方法的return结果（['rois', 'gt_boxes']），实际传参可以有空缺（例如第一小节可以删掉gt_boxes），缺省参数视为定义了一个Variable占位。
class ProposalTargetOperator(mx.operator.CustomOp):
def __init__(self, num_classes, batch_images, batch_rois, fg_fraction, fg_overlap, box_stds):
super(ProposalTargetOperator, self).__init__()
self._num_classes = num_classes # num_classes是实际要分类的类别数加上背景类
self._batch_images = batch_images # 1
self._batch_rois = batch_rois # 128
self._rois_per_image = int(batch_rois / batch_images)
self._fg_rois_per_image = int(round(fg_fraction * self._rois_per_image))
self._fg_overlap = fg_overlap # 0.5
self._box_stds = box_stds # (0.1, 0.1, 0.2, 0.2)
def forward(self, is_train, req, in_data, out_data, aux):
"""Forward interface. Can override when creating new operators.
Parameters
----------
is_train : bool
whether this is for training
req : list of str
how to assign to out_data. can be 'null', 'write', or 'add'.
You can optionally use self.assign(dst, req, src) to handle this.
in_data, out_data, aux: list of NDArrays
input, output, and auxiliary states for forward. See document for
corresponding arguments of Operator::Forward
"""
assert self._batch_images == in_data[1].shape[0], 'check batch size of gt_boxes'
all_rois = in_data[0].asnumpy() # [2000, 5]
all_gt_boxes = in_data[1].asnumpy() # [n, 5]
rois = np.empty((0, 5), dtype=np.float32)
labels = np.empty((0, ), dtype=np.float32)
bbox_targets = np.empty((0, 4 * self._num_classes), dtype=np.float32)
bbox_weights = np.empty((0, 4 * self._num_classes), dtype=np.float32)
for batch_idx in range(self._batch_images):
b_rois = all_rois[np.where(all_rois[:, 0] == batch_idx)[0]]
b_gt_boxes = all_gt_boxes[batch_idx]
b_gt_boxes = b_gt_boxes[np.where(b_gt_boxes[:, -1] > 0)[0]]
# Include ground-truth boxes in the set of candidate rois
batch_pad = batch_idx * np.ones((b_gt_boxes.shape[0], 1), dtype=b_gt_boxes.dtype)
b_rois = np.vstack((b_rois, np.hstack((batch_pad, b_gt_boxes[:, :-1]))))
b_rois, b_labels, b_bbox_targets, b_bbox_weights =
sample_rois(b_rois, b_gt_boxes, num_classes=self._num_classes, rois_per_image=self._rois_per_image,
fg_rois_per_image=self._fg_rois_per_image, fg_overlap=self._fg_overlap, box_stds=self._box_stds)
rois = np.vstack((rois, b_rois))
labels = np.hstack((labels, b_labels))
bbox_targets = np.vstack((bbox_targets, b_bbox_targets))
bbox_weights = np.vstack((bbox_weights, b_bbox_weights))
self.assign(out_data[0], req[0], rois)
self.assign(out_data[1], req[1], labels)
self.assign(out_data[2], req[2], bbox_targets)
self.assign(out_data[3], req[3], bbox_weights)
def backward(self, req, out_grad, in_data, out_data, in_grad, aux):
"""Backward interface. Can override when creating new operators.
Parameters
----------
req : list of str
how to assign to in_grad. can be 'null', 'write', or 'add'.
You can optionally use self.assign(dst, req, src) to handle this.
out_grad, in_data, out_data, in_grad, aux : list of NDArrays
input and output for backward. See document for
corresponding arguments of Operator::Backward
"""
self.assign(in_grad[0], req[0], 0)
self.assign(in_grad[1], req[1], 0)
介绍完辅助节点，本部分的介绍就不太多了，注意的就是向前向后两个方法没有返回值，使用assign来给symbol赋值，数量顺序要和辅助class的argument、output对应上，具体实现因为没有研究C++源码，没办法更详细介绍了，不过不影响使用（大概）。
另外，辅助节点class是会在python解释器里直接执行的，也就是说我们添加在函数体中的print什么的能够得到输出，但是在本class中，添加的中间输出不会被print出来，应该是建立符号图时被略去了（有关C++优化计算图的机理，李沐博士有介绍，不过我的C++功底不够，没有看过源码，仍旧觉得符号式编程的运行过程很神奇……），另外，我们在bind等操作做检查时，仅仅会运行辅助节点，不到真实的数据流入，这个class是不会运行乃至报错的，所以辅助节点的设计真的很重要。