深度学习成功背后的一个因素是广泛的层的可用性，这些层可以以创造性的方式组合以设计适合各种任务的架构。例如，研究人员发明了专门用于处理图像、文本、循环顺序数据和执行动态规划的层。迟早，您会遇到或发明深度学习框架中尚不存在的层。在这些情况下，您必须构建自定义层。在本节中，我们将向您展示如何操作。
import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l
from mxnet import np, npx
from mxnet.gluon import nn
from d2l import mxnet as d2l
npx.set_np()
import jax
from flax import linen as nn
from jax import numpy as jnp
from d2l import jax as d2l
No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)
import tensorflow as tf
from d2l import tensorflow as d2l
6.5.1. 没有参数的图层
首先，我们构建一个自定义层，它自己没有任何参数。如果您还记得我们在第 6.1 节中对模块的介绍，这应该看起来很熟悉。以下 CenteredLayer类只是从其输入中减去平均值。要构建它，我们只需要继承基础层类并实现前向传播功能。
class CenteredLayer(nn.Module):
def __init__(self):
super().__init__()
def forward(self, X):
return X - X.mean()
class CenteredLayer(nn.Block):
def __init__(self, **kwargs):
super().__init__(**kwargs)
def forward(self, X):
return X - X.mean()
class CenteredLayer(nn.Module):
def __call__(self, X):
return X - X.mean()
class CenteredLayer(tf.keras.Model):
def __init__(self):
super().__init__()
def call(self, X):
return X - tf.reduce_mean(X)
让我们通过提供一些数据来验证我们的层是否按预期工作。
layer = CenteredLayer()
layer(torch.tensor([1.0, 2, 3, 4, 5]))
tensor([-2., -1., 0., 1., 2.])
layer = CenteredLayer()
layer(np.array([1.0, 2, 3, 4, 5]))
array([-2., -1., 0., 1., 2.])
layer = CenteredLayer()
layer(jnp.array([1.0, 2, 3, 4, 5]))
Array([-2., -1., 0., 1., 2.], dtype=float32)
layer = CenteredLayer()
layer(tf.constant([1.0, 2, 3, 4, 5]))
<tf.Tensor: shape=(5,), dtype=float32, numpy=array([-2., -1., 0., 1., 2.], dtype=float32)>
我们现在可以将我们的层合并为构建更复杂模型的组件。
net = nn.Sequential(nn.LazyLinear(128), CenteredLayer())
net = nn.Sequential()
net.add(nn.Dense(128), CenteredLayer())
net.initialize()
net = nn.Sequential([nn.Dense(128), CenteredLayer()])
net = tf.keras.Sequential([tf.keras.layers.Dense(128), CenteredLayer()])
作为额外的健全性检查，我们可以通过网络发送随机数据并检查均值实际上是否为 0。因为我们处理的是浮点数，由于量化，我们可能仍然会看到非常小的非零数。
Y = net(torch.rand(4, 8))
Y.mean()
tensor(0., grad_fn=<MeanBackward0>)
Y = net(np.random.rand(4, 8))
Y.mean()
Here we utilize the init_with_output method which returns both the output of the network as well as the parameters. In this case we only focus on the output.
Y, _ = net.init_with_output(d2l.get_key(), jax.random.uniform(d2l.get_key(),
(4, 8)))
Y.mean()
Array(5.5879354e-09, dtype=float32)
Y = net(tf.random.uniform((4, 8)))
tf.reduce_mean(Y)
<tf.Tensor: shape=(), dtype=float32, numpy=1.8626451e-09>
6.5.2. 带参数的图层
现在我们知道如何定义简单的层，让我们继续定义具有可通过训练调整的参数的层。我们可以使用内置函数来创建参数，这些参数提供了一些基本的内务处理功能。特别是，它们管理访问、初始化、共享、保存和加载模型参数。这样，除了其他好处之外，我们将不需要为每个自定义层编写自定义序列化例程。
现在让我们实现我们自己的全连接层版本。回想一下，该层需要两个参数，一个代表权重，另一个代表偏差。在此实现中，我们将 ReLU 激活作为默认值进行烘焙。该层需要两个输入参数： in_units和units，分别表示输入和输出的数量。
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.2894e+00, 6.5869e-01, -1.3933e+00],
[ 7.2590e-01, 7.1593e-01, 1.8115e-03],
[-1.5900e+00, 4.1654e-01, -1.3358e+00],
[ 2.2732e-02, -2.1329e+00, 1.8811e+00],
[-1.0993e+00, 2.9763e-01, -1.4413e+00]], requires_grad=True)
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.
