5.4. 自定义层¶ Open the notebook in SageMaker Studio Lab
深度学习成功背后的一个因素是神经网络的灵活性： 我们可以用创造性的方式组合不同的层，从而设计出适用于各种任务的架构。 例如，研究人员发明了专门用于处理图像、文本、序列数据和执行动态规划的层。 有时我们会遇到或要自己发明一个现在在深度学习框架中还不存在的层。 在这些情况下，必须构建自定义层。本节将展示如何构建自定义层。
5.4.1. 不带参数的层¶
首先，我们构造一个没有任何参数的自定义层。 回忆一下在
5.1节对块的介绍， 这应该看起来很眼熟。
下面的CenteredLayer类要从其输入中减去均值。
要构建它，我们只需继承基础层类并实现前向传播功能。
from mxnet import np, npx
from mxnet.gluon import nn
npx.set_np()
class CenteredLayer(nn.Block):
def __init__(self, **kwargs):
super().__init__(**kwargs)
def forward(self, X):
return X - X.mean()
import torch
import torch.nn.functional as F
from torch import nn
class CenteredLayer(nn.Module):
def __init__(self):
super().__init__()
def forward(self, X):
return X - X.mean()
import tensorflow as tf
class CenteredLayer(tf.keras.Model):
def __init__(self):
super().__init__()
def call(self, inputs):
return inputs - tf.reduce_mean(inputs)
import warnings
warnings.filterwarnings(action='ignore')
import paddle
import paddle.nn.functional as F
from paddle import nn
class CenteredLayer(nn.Layer):
def __init__(self):
super().__init__()
def forward(self, X):
return X - X.mean()
让我们向该层提供一些数据，验证它是否能按预期工作。
layer = CenteredLayer()
layer(np.array([1, 2, 3, 4, 5]))
array([-2., -1., 0., 1., 2.])
layer = CenteredLayer()
layer(torch.FloatTensor([1, 2, 3, 4, 5]))
tensor([-2., -1., 0., 1., 2.])
layer = CenteredLayer()
layer(tf.constant([1, 2, 3, 4, 5]))
<tf.Tensor: shape=(5,), dtype=int32, numpy=array([-2, -1, 0, 1, 2], dtype=int32)>
layer = CenteredLayer()
layer(paddle.to_tensor([1, 2, 3, 4, 5], dtype='float32'))
Tensor(shape=[5], dtype=float32, place=Place(cpu), stop_gradient=True,
[-2., -1., 0., 1., 2.])
现在，我们可以将层作为组件合并到更复杂的模型中。
net = nn.Sequential()
net.add(nn.Dense(128), CenteredLayer())
net.initialize()
net = nn.Sequential(nn.Linear(8, 128), CenteredLayer())
net = tf.keras.Sequential([tf.keras.layers.Dense(128), CenteredLayer()])
net = nn.Sequential(nn.Linear(8, 128), CenteredLayer())
作为额外的健全性检查，我们可以在向该网络发送随机数据后，检查均值是否为0。 由于我们处理的是浮点数，因为存储精度的原因，我们仍然可能会看到一个非常小的非零数。
Y = net(np.random.uniform(size=(4, 8)))
Y.mean()
array(3.783498e-10)
Y = net(torch.rand(4, 8))
Y.mean()
tensor(-1.3970e-09, grad_fn=<MeanBackward0>)
Y = net(tf.random.uniform((4, 8)))
tf.reduce_mean(Y)
<tf.Tensor: shape=(), dtype=float32, numpy=2.561137e-09>
Y = net(paddle.rand([4, 8]))
Y.mean()
Tensor(shape=[1], dtype=float32, place=Place(cpu), stop_gradient=False,
[-0.00000000])
5.4.2. 带参数的层¶
以上我们知道了如何定义简单的层，下面我们继续定义具有参数的层， 这些参数可以通过训练进行调整。 我们可以使用内置函数来创建参数，这些函数提供一些基本的管理功能。 比如管理访问、初始化、共享、保存和加载模型参数。 这样做的好处之一是：我们不需要为每个自定义层编写自定义的序列化程序。
现在，让我们实现自定义版本的全连接层。
回想一下，该层需要两个参数，一个用于表示权重，另一个用于表示偏置项。
在此实现中，我们使用修正线性单元作为激活函数。
该层需要输入参数：in_units和units，分别表示输入数和输出数。
class MyDense(nn.Block):
def __init__(self, units, in_units, **kwargs):
super().__init__(**kwargs)
self.weight = self.params.get('weight', shape=(in_units, units))
self.bias = self.params.get('bias', shape=(units,))
def forward(self, x):
linear = np.dot(x, self.weight.data(ctx=x.ctx)) + self.bias.data(
ctx=x.ctx)
return npx.relu(linear)
接下来，我们实例化MyDense类并访问其模型参数。
dense = MyDense(units=3, in_units=5)
dense.params
mydense0_ (
Parameter mydense0_weight (shape=(5, 3), dtype=<class 'numpy.float32'>)
Parameter mydense0_bias (shape=(3,), dtype=<class 'numpy.float32'>)
)
class MyLinear(nn.Module):
def __init__(self, in_units, units):
super().__init__()
self.weight = nn.Parameter(torch.randn(in_units, units))
self.bias = nn.Parameter(torch.randn(units,))
def forward(self, X):
linear = torch.matmul(X, self.weight.data) + self.bias.data
return F.relu(linear)
接下来，我们实例化MyLinear类并访问其模型参数。
linear = MyLinear(5, 3)
linear.weight
Parameter containing:
tensor([[ 1.9094, -0.8244, -1.6846],
[ 0.6850, 0.8366, -1.3837],
[ 0.0289, 2.0976, 1.3855],
[-0.8574, -0.3557, -0.4109],
[ 2.2963, -1.3008, 1.2173]], requires_grad=True)
class MyDense(tf.keras.Model):
def __init__(self, units):
super().__init__()
self.units = units
def build(self, X_shape):
self.weight = self.add_weight(name='weight',
shape=[X_shape[-1], self.units],
initializer=tf.random_normal_initializer())
self.bias = self.add_weight(
name='bias', shape=[self.units],
initializer=tf.zeros_initializer())
def call(self, X):
linear = tf.matmul(X, self.weight) + self.bias
return tf.nn.relu(linear)
接下来，我们实例化MyDense类并访问其模型参数。
dense = MyDense(3)
dense(tf.random.uniform((2, 5)))
dense.get_weights()
[array([[-0.0620558 , -0.00174156, -0.01396979],
[ 0.09240353, -0.06282221, 0.07976198],
[-0.01926827, 0.02305873, -0.0326635 ],
[ 0.07772909, -0.07239415, -0.06653773],
[-0.01180842, -0.07552951, 0.07522093]], dtype=float32),
array([0., 0., 0.], dtype=float32)]
class MyLinear(nn.Layer):
def __init__(self, in_units, units):
super().__init__()
self.weight = paddle.create_parameter(shape=(in_units, units), dtype='float32')
self.bias = paddle.create_parameter(shape=(units,), dtype='float32')
def forward(self, X):
linear = paddle.matmul(X, self.weight) + self.bias
return F.relu(linear)
接下来，我们实例化MyLinear类并访问其模型参数。
linear = MyLinear(5, 3)
linear.weight
Parameter containing:
Tensor(shape=[5, 3], dtype=float32, place=Place(cpu), stop_gradient=False,
[[ 0.07968342, -0.18760359, -0.19434726],
[ 0.30317837, 0.80539447, 0.44053298],
[ 0.79712874, 0.19726187, 0.63960844],
[ 0.86305267, -0.34182781, 0.34887427],
[ 0.73524517, 0.16592330, -0.04958087]])
我们可以使用自定义层直接执行前向传播计算。
dense.initialize()
dense(np.random.uniform(size=(2, 5)))
array([[0. , 0.01633355, 0. ],
[0. , 0.01581812, 0. ]])
linear(torch.rand(2, 5))
tensor([[0.0984, 0.5687, 2.8316],
[2.2558, 0.0000, 1.8880]])
dense(tf.random.uniform((2, 5)))
<tf.Tensor: shape=(2, 3), dtype=float32, numpy=
array([[0. , 0. , 0.03520311],
[0.00862486, 0. , 0.0451693 ]], dtype=float32)>
linear(paddle.randn([2, 5]))
Tensor(shape=[2, 3], dtype=float32, place=Place(cpu), stop_gradient=False,
[[0.89794636, 0. , 0. ],
[1.52104723, 1.33450389, 0.26487458]])
我们还可以使用自定义层构建模型，就像使用内置的全连接层一样使用自定义层。
net = nn.Sequential()
net.add(MyDense(8, in_units=64),
MyDense(1, in_units=8))
net.initialize()
net(np.random.uniform(size=(2, 64)))
array([[0.06508517],
[0.0615553 ]])
net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))
net(torch.rand(2, 64))
tensor([[7.5465],
[4.6817]])
net = tf.keras.models.Sequential([MyDense(8), MyDense(1)])
net(tf.random.uniform((2, 64)))
<tf.Tensor: shape=(2, 1), dtype=float32, numpy=
array([[0.01407349],
[0.01214805]], dtype=float32)>
net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))
net(paddle.rand([2, 64]))
Tensor(shape=[2, 1], dtype=float32, place=Place(cpu), stop_gradient=False,
[[1.29990053],
[1.87737477]])
5.4.3. 小结¶
我们可以通过基本层类设计自定义层。这允许我们定义灵活的新层，其行为与深度学习框架中的任何现有层不同。
在自定义层定义完成后，我们就可以在任意环境和网络架构中调用该自定义层。
层可以有局部参数，这些参数可以通过内置函数创建。
5.4.4. 练习¶
设计一个接受输入并计算张量降维的层，它返回\(y_k = \sum_{i, j} W_{ijk} x_i x_j\)。
设计一个返回输入数据的傅立叶系数前半部分的层。