4.4. 自定义层

深度学习的一个魅力在于神经网络中各式各样的层，例如全连接层和后面章节中将要介绍的卷积层、池化层与循环层。虽然Gluon提供了大量常用的层，但有时候我们依然希望自定义层。本节将介绍如何使用NDArray来自定义一个Gluon的层，从而可以被重复调用。

4.4.1. 不含模型参数的自定义层

我们先介绍如何定义一个不含模型参数的自定义层。事实上，这和“模型构造”一节中介绍的使用Block类构造模型类似。下面的CenteredLayer类通过继承Block类自定义了一个将输入减掉均值后输出的层，并将层的计算定义在了forward函数里。这个层里不含模型参数。

  1. In [1]:
  1. from mxnet import gluon, nd
  2. from mxnet.gluon import nn
  3.  
  4. class CenteredLayer(nn.Block):
  5.     def __init__(self, **kwargs):
  6.         super(CenteredLayer, self).__init__(**kwargs)
  7.  
  8.     def forward(self, x):
  9.         return x - x.mean()

我们可以实例化这个层，然后做前向计算。

  1. In [2]:
  1. layer = CenteredLayer()
  2. layer(nd.array([1, 2, 3, 4, 5]))
  1. Out[2]:
  1. [-2. -1.  0.  1.  2.]
  2. <NDArray 5 @cpu(0)>

我们也可以用它来构造更复杂的模型。

  1. In [3]:
  1. net = nn.Sequential()
  2. net.add(nn.Dense(128),
  3.         CenteredLayer())

下面打印自定义层各个输出的均值。因为均值是浮点数，所以它的值是一个很接近0的数。

  1. In [4]:
  1. net.initialize()
  2. y = net(nd.random.uniform(shape=(4, 8)))
  3. y.mean().asscalar()
  1. Out[4]:
  1. -7.212293e-10

4.4.2. 含模型参数的自定义层

我们还可以自定义含模型参数的自定义层。其中的模型参数可以通过训练学出。

“模型参数的访问、初始化和共享”一节分别介绍了Parameter类和ParameterDict类。在自定义含模型参数的层时，我们可以利用Block类自带的ParameterDict类型的成员变量params。它是一个由字符串类型的参数名字映射到Parameter类型的模型参数的字典。我们可以通过get函数从ParameterDict创建Parameter实例。

  1. In [5]:
  1. params = gluon.ParameterDict()
  2. params.get('param2', shape=(2, 3))
  3. params
  1. Out[5]:
  1. (
  2.   Parameter param2 (shape=(2, 3), dtype=<class 'numpy.float32'>)
  3. )

现在我们尝试实现一个含权重参数和偏差参数的全连接层。它使用ReLU函数作为激活函数。其中in_units和units分别代表输入个数和输出个数。

  1. In [6]:
  1. class MyDense(nn.Block):
  2.     # units为该层的输出个数，in_units为该层的输入个数
  3.     def __init__(self, units, in_units, **kwargs):
  4.         super(MyDense, self).__init__(**kwargs)
  5.         self.weight = self.params.get('weight', shape=(in_units, units))
  6.         self.bias = self.params.get('bias', shape=(units,))
  7.  
  8.     def forward(self, x):
  9.         linear = nd.dot(x, self.weight.data()) + self.bias.data()
  10.         return nd.relu(linear)

下面，我们实例化MyDense类并访问它的模型参数。

  1. In [7]:
  1. dense = MyDense(units=3, in_units=5)
  2. dense.params
  1. Out[7]:
  1. mydense0_ (
  2.   Parameter mydense0_weight (shape=(5, 3), dtype=<class 'numpy.float32'>)
  3.   Parameter mydense0_bias (shape=(3,), dtype=<class 'numpy.float32'>)
  4. )

我们可以直接使用自定义层做前向计算。

  1. In [8]:
  1. dense.initialize()
  2. dense(nd.random.uniform(shape=(2, 5)))
  1. Out[8]:
  1. [[0.06917784 0.01627153 0.01029644]
  2.  [0.02602214 0.0453731  0.        ]]
  3. <NDArray 2x3 @cpu(0)>

我们也可以使用自定义层构造模型。它和Gluon的其他层在使用上很类似。

  1. In [9]:
  1. net = nn.Sequential()
  2. net.add(MyDense(8, in_units=64),
  3.         MyDense(1, in_units=8))
  4. net.initialize()
  5. net(nd.random.uniform(shape=(2, 64)))
  1. Out[9]:
  1. [[0.03820474]
  2.  [0.04035058]]
  3. <NDArray 2x1 @cpu(0)>

4.4.3. 小结

  • 可以通过Block类自定义神经网络中的层，从而可以被重复调用。

4.4.4. 练习

  • 自定义一个层，使用它做一次前向计算。