mxnet 常用层，卷积激活损失

MXNet之网络结构搭建
网络结构搭建
1.卷积层(Convolution)
2.BN层(Batch Normalization)
3.激活层(Activation)
4.池化层(Pooling)
5.全连接层(FullyConnected)
6. 损失函数层
7.通道合并层(concat)
8.逐点相加层(element-wise-sum)
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)
  
 

文章来源: blog.csdn.net，作者：网奇，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/jacke121/article/details/115627971