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.
						