MXNet之网络结构搭建

1.卷积层(Convolution)

import mxnet as mx

input_data = mx.nd.arange(1, 51).reshape((1,2,5,5))
print(input_data)

weight = mx.nd.arange(1, 37).reshape((2,2,3,3))
print(weight)

bias = mx.nd.ones(2)
print(bias)

#dilate>1时,表示执行空洞卷积num_proup>1时,表示执行分组卷积操作
output_data = mx.nd.Convolution(data=input_data, weight=weight, bias=bias,
                                kernel=(3,3), stride=(1,1), pad=(0,0),
                                dilate=(1,1), num_filter=2, num_group=1
                               ) 
print(output_data)

计算过程如图:

output_data = mx.nd.Convolution(data=input_data, weight=weight, bias=bias,
                                kernel=(3,3), stride=(1,1), pad=(0,0),
                                dilate=(2,2), num_filter=2, num_group=1
                               ) #dilate=(2,2),实际kernel_size=(5,5)
print(output_data)

#此处卷积核的channel与input_data的channel不一样了,但数量是2个,可对input_data做group卷积操作
weight = mx.nd.arange(1,19).reshape((2,1,3,3)) 
print(weight)

#进行group卷积操作,将输入特征图和卷积核分成两个组,分别做卷积,的到2通道的输出特征图
output_data_group = mx.nd.Convolution(data=input_data, weight=weight, bias=bias,
                                      kernel=(3,3), stride=(1,1), pad=(0,0),
                                      dilate=(1,1), num_filter=2, num_group=2,
                                     )
print(output_data_group)

2.BN层(Batch Normalization)

BN(Batch Normalization)层主要对网络层输入做归一化和线性变换的层,能够加快模型收敛.

import mxnet as mx

input_data = mx.nd.arange(1,9).reshape(1,2,2,2)
print(input_data)

#初始化BN层的gamma参数[1,1]
#gamma参数用来对归一化的特征图做变换操作,模型在训练中不断学习该参数
gamma = mx.nd.ones(2)

#初始化BN层的beta参数[1,1]
#beta参数是一个偏移参数
beta  =  mx.nd.ones(2)

#初始化全局均值[3,3]
#基于整个数据集集算出的均值
moving_mean = mx.nd.ones(2) * 3

#初始化全局方差[2,2]
#基于整个数据集集算出的方差
moving_var = mx.nd.ones(2) * 2 

#计算BN层结果; momentum:类似于优化函数的动量参数,默认0.9; fix_gamma设置为1;
#则gammam参数固定不变,设置为0,网络学习gamma参数;
#use_global_stats:表示是否用moving_mean替换mean,设置为0代表不替换,一般用于训练,设置为1代表替换,用于测试.

"""
#data_mean,data_var计算的是当前批次的输入特征图数据,在通道维度上的均值和方差
#moving_mean,moving_var计算的是整个数据集的均值和方差
moving_mean = moving_mean * momentum + data_mean * (1 - momentum)
moving_var = moving_var * momentum + data_var * (1 - momentum)
"""
out_data = mx.nd.BatchNorm(data=input_data, gamma=gamma, beta=beta,
                           moving_mean=moving_mean, moving_var=moving_var,
                           momentum=0.9, fix_gamma=1, use_global_stats=1)
print(out_data)

3.激活层(Activation)

import mxnet as mx
input_data = mx.nd.arange(-8,8).reshape(1,1,4,4)
print(input_data)

#调用relu激活函数
out_data_relu = mx.nd.Activation(data=input_data,act_type="relu")
print(out_data_relu)

#调用sigmoid激活函数
out_data_sigmoid = mx.nd.Activation(data=input_data, act_type="sigmoid")
print(out_data_sigmoid)

#调用softrelu
out_data_softrelu = mx.nd.Activation(data=input_data, act_type="softrelu")
print(out_data_softrelu)

4.池化层(Pooling)

import mxnet as mx
input_data = mx.nd.arange(1,51).reshape((1,2,5,5))
print(input_data)

#最大值池化
#pooling_convention住要与输出特征图尺寸计算相关;'valid'代表向下取整,'full'代表向上取整.
out_data = mx.nd.Pooling(data=input_data, kernel=(2,2),pool_type="max",
                        global_pool=0, pooling_convention='valid',
                        stride=(1,1), pad=(0,0) )
print(out_data)

#均值池化
out_data = mx.nd.Pooling(data=input_data, kernel=(2,2),pool_type="avg",
                        global_pool=0, pooling_convention='valid',
                        stride=(1,1), pad=(0,0) )
print(out_data)

#全局最大值池化
out_data = mx.nd.Pooling(data=input_data, kernel=(2,2),pool_type="max",
                        global_pool=1, pooling_convention='valid',
                        stride=(1,1), pad=(0,0) )
print(out_data)

5.全连接层(FullyConnected)

import mxnet as mx
input_data = mx.nd.arange(1,19).reshape(1,2,3,3)
print(input_data)

#将input_data进行flatten后2*3*3=18,假设最后输出4类,所以reshape成(4,18)
bias = mx.nd.ones(4)
weight = mx.nd.arange(1,73).reshape((4,18))
print(weight)

out_data = mx.nd.FullyConnected(data=input_data, weight=weight, bias=bias,
                               num_hidden=4, flatten=1)
print(out_data)

6. 损失函数层

#input_data代表5个样本,4个类别
import mxnet as mx
input_data = mx.nd.cast(mx.nd.arange(0.1,2.1,0.1).reshape((5,4)),'float16')
print(input_data)

#进行softmax层操作,每一行相加=1
out_data = mx.nd.softmax(data=input_data,axis=-1)
print(out_data)

#假设5个样本真实标签都是0,从`上面结果可知,预测标签都是3,所以全预测错了
label = mx.nd.array([0,0,0,0,0], dtype='float16')
ce_loss = mx.nd.softmax_cross_entropy(data=input_data,label=label)
print(ce_loss)

#预测对了2个
label = mx.nd.array([1,0,3,3,0],dtype='float16')
ce_loss = mx.nd.softmax_cross_entropy(data=input_data,label=label)
print(ce_loss)

#全预测对了
label = mx.nd.array([3,3,3,3,3],dtype='float16')
ce_loss = mx.nd.softmax_cross_entropy(data=input_data,label=label)
print(ce_loss)

因为在这个例子中,没个样本4个类别之间其概率值相差不大,因此预测全对和全错的损失值差别也不大.

#目标检测算法常用的损失函数--Smooth L1
smoothl1_loss = mx.nd.smooth_l1(data=input_data, scalar=1)
print(smoothl1_loss)

7.通道合并层(concat)

通道合并层通过将输入特征图在通道维度上做合并,以达到特征融合的目的,目前在多种图像任务中都有广泛应用.

import mxnet as mx
#初始化第一张特征图
input_data1 = mx.nd.arange(1,51).reshape((1,2,5,5))
print(input_data1)
#初始化第二张特征图
input_data2 = mx.nd.arange(5,31).reshape((1,1,5,5))
print(input_data2)
#执行通道融合,合并后通道数是3;dim默认为1,代表通道这个维度.
out_data = mx.nd.concat(input_data1,input_data2,dim=1)
print(out_data)

8.逐点相加层(element-wise-sum)

逐点相加层,是对输入特征图在宽,高纬度做逐点相加得到输出特征图的网络层,也是一种特征融合操作.

• mxnet.symbol.ElementWiseSum()接口进行逐点相加操作

import mxnet as mx
input_data1 = mx.nd.arange(1,51).reshape((1,2,5,5))
input_data2 = mx.nd.arange(2,52).reshape((1,2,5,5))
out_data = mx.nd.ElementWiseSum(input_data1,input_data2)
print(out_data)