自定义层

自定义层

深度学习成功背后的一个因素是神经网络的灵活性：
我们可以用创造性的方式组合不同的层，从而设计出适用于各种任务的架构。
例如，研究人员发明了专门用于处理图像、文本、序列数据和执行动态规划的层。
有时我们会遇到或要自己发明一个现在在深度学习框架中还不存在的层。
在这些情况下，必须构建自定义层。本节将展示如何构建自定义层。

不带参数的层

首先，我们(构造一个没有任何参数的自定义层)。
回忆一下在 :numref:sec_model_construction对块的介绍，
这应该看起来很眼熟。
下面的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()
​

#@tab pytorch
import torch
from torch import nn
import torch.nn.functional as F

class CenteredLayer(nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self, X):
        return X - X.mean()
​

#@tab tensorflow
import tensorflow as tf

class CenteredLayer(tf.keras.Model):
    def __init__(self):
        super().__init__()

    def call(self, inputs):
        return inputs - tf.reduce_mean(inputs)
​

#@tab paddle
import warnings
warnings.filterwarnings(action='ignore')
import paddle
from paddle import nn
import paddle.nn.functional as F

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]))
​

#@tab pytorch
layer = CenteredLayer()
layer(torch.FloatTensor([1, 2, 3, 4, 5]))
​

#@tab tensorflow
layer = CenteredLayer()
layer(tf.constant([1, 2, 3, 4, 5]))
​

#@tab paddle
layer = CenteredLayer()
layer(paddle.to_tensor([1, 2, 3, 4, 5], dtype='float32'))
​

现在，我们可以[将层作为组件合并到更复杂的模型中]。

net = nn.Sequential()
net.add(nn.Dense(128), CenteredLayer())
net.initialize()
​

#@tab pytorch, paddle
net = nn.Sequential(nn.Linear(8, 128), CenteredLayer())
​

#@tab tensorflow
net = tf.keras.Sequential([tf.keras.layers.Dense(128), CenteredLayer()])
​

作为额外的健全性检查，我们可以在向该网络发送随机数据后，检查均值是否为0。
由于我们处理的是浮点数，因为存储精度的原因，我们仍然可能会看到一个非常小的非零数。

Y = net(np.random.uniform(size=(4, 8)))
Y.mean()
​

#@tab pytorch
Y = net(torch.rand(4, 8))
Y.mean()
​

#@tab tensorflow
Y = net(tf.random.uniform((4, 8)))
tf.reduce_mean(Y)
​

#@tab paddle
Y = net(paddle.rand([4, 8]))
Y.mean()
​

[带参数的层]

以上我们知道了如何定义简单的层，下面我们继续定义具有参数的层，
这些参数可以通过训练进行调整。
我们可以使用内置函数来创建参数，这些函数提供一些基本的管理功能。
比如管理访问、初始化、共享、保存和加载模型参数。
这样做的好处之一是：我们不需要为每个自定义层编写自定义的序列化程序。

现在，让我们实现自定义版本的全连接层。
回想一下，该层需要两个参数，一个用于表示权重，另一个用于表示偏置项。
在此实现中，我们使用修正线性单元作为激活函数。
该层需要输入参数：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)
​

#@tab pytorch
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)
​

#@tab tensorflow
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)
​

#@tab paddle
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)
​

:begin_tab:mxnet, tensorflow
接下来，我们实例化MyDense类并访问其模型参数。
:end_tab:

:begin_tab:pytorch
接下来，我们实例化MyLinear类并访问其模型参数。
:end_tab:

:begin_tab:paddle
接下来，我们实例化MyLinear类并访问其模型参数。
:end_tab:

dense = MyDense(units=3, in_units=5)
dense.params
​

#@tab pytorch, paddle
linear = MyLinear(5, 3)
linear.weight
​

#@tab tensorflow
dense = MyDense(3)
dense(tf.random.uniform((2, 5)))
dense.get_weights()
​

我们可以[使用自定义层直接执行前向传播计算]。

dense.initialize()
dense(np.random.uniform(size=(2, 5)))
​

#@tab pytorch
linear(torch.rand(2, 5))
​

#@tab tensorflow
dense(tf.random.uniform((2, 5)))
​

#@tab paddle
linear(paddle.randn([2, 5]))
​

我们还可以(使用自定义层构建模型)，就像使用内置的全连接层一样使用自定义层。

net = nn.Sequential()
net.add(MyDense(8, in_units=64),
        MyDense(1, in_units=8))
net.initialize()
net(np.random.uniform(size=(2, 64)))
​

#@tab pytorch
net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))
net(torch.rand(2, 64))
​

#@tab tensorflow
net = tf.keras.models.Sequential([MyDense(8), MyDense(1)])
net(tf.random.uniform((2, 64)))
​

#@tab paddle
net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))
net(paddle.rand([2, 64]))
​

小结

• 我们可以通过基本层类设计自定义层。这允许我们定义灵活的新层，其行为与深度学习框架中的任何现有层不同。
• 在自定义层定义完成后，我们就可以在任意环境和网络架构中调用该自定义层。
• 层可以有局部参数，这些参数可以通过内置函数创建。

练习

1. 设计一个接受输入并计算张量降维的层，它返回y_k = \sum_{i, j} W_{ijk} x_i x_j。
2. 设计一个返回输入数据的傅立叶系数前半部分的层。

:begin_tab:mxnet
Discussions
:end_tab:

:begin_tab:pytorch
Discussions
:end_tab:

:begin_tab:tensorflow
Discussions
:end_tab:

:begin_tab:paddle
Discussions
:end_tab: