×

PyTorch教程6.5之自定义图层

消耗积分:0 | 格式:pdf | 大小:0.12 MB | 2023-06-05

张英

分享资料个

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

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_unitsunits,分别表示输入和输出的数量。

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.

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉

评论(0)
发评论

下载排行榜

全部0条评论

快来发表一下你的评论吧 !