PyTorch教程6.5之自定义图层

2512958 2023-06-05 | pdf | 0.12 MB | 次下载 | 免费

资料介绍

深度学习成功背后的一个因素是广泛的层的可用性，这些层可以以创造性的方式组合以设计适合各种任务的架构。例如，研究人员发明了专门用于处理图像、文本、循环顺序数据和执行动态规划的层。迟早，您会遇到或发明深度学习框架中尚不存在的层。在这些情况下，您必须构建自定义层。在本节中，我们将向您展示如何操作。

						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()

							array(3.783498e-10)

						

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.
						