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