Keras Core 0.1 : 開発者ガイド : サブクラス化で新しい層とモデルを作成する (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 07/16/2023 (0.1.0)

* 本ページは、Keras Core の以下のドキュメントを翻訳した上で適宜、補足説明したものです：

• Making new layers and models via subclassing
  (Author: fchollet ; Date created: 2019/03/11 ; Last modified: 2023/06/25)
  Description: Complete guide to writing Layer and Model objects from scratch.

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

 

Keras Core 0.1 : 開発者ガイド : サブクラス化で新しい層とモデルを作成する

セットアップ

import numpy as np
import keras_core as keras
from keras_core import ops
from keras_core import layers

Using TensorFlow backend

 

Layer クラス : 状態 (重み) と計算の組合せ

Keras の中心的な抽象化の一つは Layer クラスです。層は状態 (層の「重み」) と入力から出力への変換 (“call”、層の forward パス) をカプセル化しています。

ここに密結合の層があります。それは状態変数: 変数 w と b を持ちます。

class Linear(keras.layers.Layer):
    def __init__(self, units=32, input_dim=32):
        super().__init__()
        self.w = self.add_weight(
            shape=(input_dim, units),
            initializer="random_normal",
            trainable=True,
        )
        self.b = self.add_weight(shape=(units,), initializer="zeros", trainable=True)

    def call(self, inputs):
        return ops.matmul(inputs, self.w) + self.b

ちょうど Python 関数のように、それを幾つかのテンソル入力上で呼び出すことにより層を利用できます。

x = ops.ones((2, 2))
linear_layer = Linear(4, 2)
y = linear_layer(x)
print(y)

tf.Tensor(
[[-0.01436234 -0.04163354  0.05823036  0.01269709]
 [-0.01436234 -0.04163354  0.05823036  0.01269709]], shape=(2, 4), dtype=float32)

重み w と b は層の属性として設定されて層により自動的に追跡されることに注意してください :

assert linear_layer.weights == [linear_layer.w, linear_layer.b]

 

層は非訓練可能な重みを持つことができます

訓練可能な重みの他に、層に非訓練可能な重みを追加することもできます。そのような重みは、層を訓練しているとき、逆伝播の間は考慮されないことを意図しています。

ここに非訓練可能な重みを追加して使用する方法があります :

class ComputeSum(keras.layers.Layer):
    def __init__(self, input_dim):
        super().__init__()
        self.total = self.add_weight(
            initializer="zeros", shape=(input_dim,), trainable=False
        )

    def call(self, inputs):
        self.total.assign_add(ops.sum(inputs, axis=0))
        return self.total


x = ops.ones((2, 2))
my_sum = ComputeSum(2)
y = my_sum(x)
print(y.numpy())
y = my_sum(x)
print(y.numpy())

[2. 2.]
[4. 4.]

それは layer.weights の一部ですが、それは非訓練可能な重みとしてカテゴライズされます :

print("weights:", len(my_sum.weights))
print("non-trainable weights:", len(my_sum.non_trainable_weights))

# It's not included in the trainable weights:
print("trainable_weights:", my_sum.trainable_weights)

weights: 1
non-trainable weights: 1
trainable_weights: []

 

ベストプラクティス: 入力の shape が分かるまで重み作成を遅延する

上の Linear 層は __init__ で重み w と b の shape を計算するために使用される input_dim 引数を受け取りました :

class Linear(keras.layers.Layer):
    def __init__(self, units=32, input_dim=32):
        super().__init__()
        self.w = self.add_weight(
            shape=(input_dim, units),
            initializer="random_normal",
            trainable=True,
        )
        self.b = self.add_weight(shape=(units,), initializer="zeros", trainable=True)

    def call(self, inputs):
        return ops.matmul(inputs, self.w) + self.b

多くの場合、貴方は入力のサイズを前もって知らないかもしれません、そしてその値が分かるときに重みを遅れて作成したいでしょう、時に層をインスタンス化した後に。

Keras API では、層重みを層の build(self, inputs_shape) メソッドで作成することを推奨します。このようにです :

class Linear(keras.layers.Layer):
    def __init__(self, units=32):
        super().__init__()
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer="random_normal",
            trainable=True,
        )
        self.b = self.add_weight(
            shape=(self.units,), initializer="random_normal", trainable=True
        )

    def call(self, inputs):
        return ops.matmul(inputs, self.w) + self.b

層の __call__ メソッドは最初にそれが呼び出されたときに build を自動的に実行します。今貴方は lazy であり従って容易に利用できる層を持ちます :

# At instantiation, we don't know on what inputs this is going to get called
linear_layer = Linear(32)

# The layer's weights are created dynamically the first time the layer is called
y = linear_layer(x)

上で示されたように build() の個別の実装は重みの一度だけの作成と、総ての呼び出しで重みを使用することを上手く分離します。

 

層は再帰的に構成可能です

Layer インスタンスを別の層の属性として割り当てる場合、外側の層は内側の層により作成された重みを追跡し始めます。

そのようなサブ層 (= sublayer) は __init__() メソッドで作成することを勧めます、そしてそれらの重みの build 開始は最初の __call__() に委ねます。

class MLPBlock(keras.layers.Layer):
    def __init__(self):
        super().__init__()
        self.linear_1 = Linear(32)
        self.linear_2 = Linear(32)
        self.linear_3 = Linear(1)

    def call(self, inputs):
        x = self.linear_1(inputs)
        x = keras.activations.relu(x)
        x = self.linear_2(x)
        x = keras.activations.relu(x)
        return self.linear_3(x)


mlp = MLPBlock()
y = mlp(ops.ones(shape=(3, 64)))  # The first call to the `mlp` will create the weights
print("weights:", len(mlp.weights))
print("trainable weights:", len(mlp.trainable_weights))

weights: 6
trainable weights: 6

 

バックエンド透過な層とバックエンド固有の層

層が keras.ops 名前空間 (あるいは keras.activations, keras.random, or keras.layers のような他の Keras 名前空間) の API だけを使用する限り、それは任意のバックエンド — TensorFlow, JAX, or PyTorch で使用可能です。

このガイドでここまでに貴方が見てきたすべての層はすべての Keras バックエンドで動作します。

keras.ops 名前空間は以下へのアクセスを提供します :

• NumPy API, e.g. ops.matmul, ops.sum, ops.reshape, ops.stack, 等。
• ops.softmax, ops.conv,ops.binary_crossentropy,ops.relu`, 等のようなニューラルネットワーク固有の API。

貴方の層で (tf.nn 関数のような) バックエンド-native API を使用することもできますが、これを行なう場合、その層は特定のバックエンドでだけ利用可能となります。例えば、jax.numpy を使用して次の JAX-固有な層を書くことができるでしょう :

import jax

class Linear(keras.layers.Layer):
    ...

    def call(self, inputs):
        return jax.numpy.matmul(inputs, self.w) + self.b

This would be the equivalent TensorFlow-specific layer:

import tensorflow as tf

class Linear(keras.layers.Layer):
    ...

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

And this would be the equivalent PyTorch-specific layer:

import torch

class Linear(keras.layers.Layer):
    ...

    def call(self, inputs):
        return torch.matmul(inputs, self.w) + self.b

バックエンド間の互換性は非常に有用な特性ですので、Keras API だけを利用して層を常にバックエンド透過にしようとすることを強く勧めます。

 

add_loss() メソッド

層の call メソッドを書くとき、訓練ループを書くときに、後で使用することを望む損失テンソルを作成できます。これは self.add_loss(value) を呼び出すことで行なうことができます :

# A layer that creates an activity regularization loss
class ActivityRegularizationLayer(keras.layers.Layer):
    def __init__(self, rate=1e-2):
        super().__init__()
        self.rate = rate

    def call(self, inputs):
        self.add_loss(self.rate * ops.mean(inputs))
        return inputs

(任意の内側の層で作成されたものを含む) これらの損失は layer.losses を通して取得できます。このプロパティは top-level 層への総ての __call__ の開始でリセットされますので、layer.losses は最後の forward パスの間に作成された損失値を常に含みます。

class OuterLayer(keras.layers.Layer):
    def __init__(self):
        super().__init__()
        self.activity_reg = ActivityRegularizationLayer(1e-2)

    def call(self, inputs):
        return self.activity_reg(inputs)


layer = OuterLayer()
assert len(layer.losses) == 0  # No losses yet since the layer has never been called

_ = layer(ops.zeros((1, 1)))
assert len(layer.losses) == 1  # We created one loss value

# `layer.losses` gets reset at the start of each __call__
_ = layer(ops.zeros((1, 1)))
assert len(layer.losses) == 1  # This is the loss created during the call above

加えて、loss プロパティはまた任意の内側の層の重みのために作成された正則化損失を含みます :

class OuterLayerWithKernelRegularizer(keras.layers.Layer):
    def __init__(self):
        super().__init__()
        self.dense = keras.layers.Dense(
            32, kernel_regularizer=keras.regularizers.l2(1e-3)
        )

    def call(self, inputs):
        return self.dense(inputs)


layer = OuterLayerWithKernelRegularizer()
_ = layer(ops.zeros((1, 1)))

# This is `1e-3 * sum(layer.dense.kernel ** 2)`,
# created by the `kernel_regularizer` above.
print(layer.losses)

[<tf.Tensor: shape=(), dtype=float32, numpy=0.001990685>]

これらの損失はカスタム訓練ループを書くときに考慮されることを意図しています。

これらの損失はまた fit() でシームレスに動作します (もしあれば、それらは自動的に合計されて main 損失に追加されます) :

inputs = keras.Input(shape=(3,))
outputs = ActivityRegularizationLayer()(inputs)
model = keras.Model(inputs, outputs)

# If there is a loss passed in `compile`, the regularization
# losses get added to it
model.compile(optimizer="adam", loss="mse")
model.fit(np.random.random((2, 3)), np.random.random((2, 3)))

# It's also possible not to pass any loss in `compile`,
# since the model already has a loss to minimize, via the `add_loss`
# call during the forward pass!
model.compile(optimizer="adam")
model.fit(np.random.random((2, 3)), np.random.random((2, 3)))

 1/1 ━━━━━━━━━━━━━━━━━━━━  0s 118ms/step - loss: 0.1854
 1/1 ━━━━━━━━━━━━━━━━━━━━  0s 18ms/step - loss: 0.0981

/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/keras_core/src/backend/tensorflow/trainer.py:67: UserWarning: The model does not have any trainable weights.
  warnings.warn("The model does not have any trainable weights.")

<keras_core.src.callbacks.history.History at 0x28a4262f0>

 

オプションで層上でシリアライゼーションを有効にできます

貴方のカスタム層が 関数型モデル の一部としてシリアライズ可能であることが必要ならば、オプションで get_config メソッドを実装できます :

class Linear(keras.layers.Layer):
    def __init__(self, units=32):
        super().__init__()
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer="random_normal",
            trainable=True,
        )
        self.b = self.add_weight(
            shape=(self.units,), initializer="random_normal", trainable=True
        )

    def call(self, inputs):
        return ops.matmul(inputs, self.w) + self.b

    def get_config(self):
        return {"units": self.units}


# Now you can recreate the layer from its config:
layer = Linear(64)
config = layer.get_config()
print(config)
new_layer = Linear.from_config(config)

{'units': 64}

基底 Layer クラスの __init__ メソッドは幾つかのキーワード引数、特に nameと dtype を受け取ることに注意してください。これらの引数を __init__ で親クラスに渡してそれらを層 config に含めることは良い実践です :

class Linear(keras.layers.Layer):
    def __init__(self, units=32, **kwargs):
        super().__init__(**kwargs)
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer="random_normal",
            trainable=True,
        )
        self.b = self.add_weight(
            shape=(self.units,), initializer="random_normal", trainable=True
        )

    def call(self, inputs):
        return ops.matmul(inputs, self.w) + self.b

    def get_config(self):
        config = super().get_config()
        config.update({"units": self.units})
        return config


layer = Linear(64)
config = layer.get_config()
print(config)
new_layer = Linear.from_config(config)

{'name': 'linear_7', 'trainable': True, 'dtype': 'float32', 'units': 64}

層をその config からデシリアライズするときにより柔軟性を必要とする場合には、from_config クラス・メソッドをオーバーライドすることもできます。これは from_config の基底実装です :

def from_config(cls, config):
    return cls(**config)

シリアライゼーションとセービングについて更に学習するためには、完全な Saving and Serializing Models へのガイド を見てください。

 

call メソッドの特権的な training 引数

幾つかの層、特に BatchNormalization 層と Dropout 層は訓練と推論の間で異なる動作を持ちます。そのような層のために、call メソッドで training (ブーリアン) 引数を公開することは標準的な実践です。

call でこの引数を公開することで、組込み訓練と評価ループ (e.g. fit) に訓練と推論で層を正しく使用することを可能にします。

class CustomDropout(keras.layers.Layer):
    def __init__(self, rate, **kwargs):
        super().__init__(**kwargs)
        self.rate = rate

    def call(self, inputs, training=None):
        if training:
            return keras.random.dropout(inputs, rate=self.rate)
        return inputs

 

call() メソッドの特権的な mask 引数

call() によりサポートされる別の特権的な引数は mask 引数です。

総ての Keras RNN 層でそれを見つけるでしょう。mask は時系列データを処理するとき特定の入力時間ステップをスキップするために使用されるブーリアン・テンソル (入力の時間ステップ毎に 1 つのブーリアン値) です。

Keras は mask が前の層により生成されるとき、それをサポートする層のために正しい mask 引数を __call__() に自動的に渡します。mask-生成層は mask_zero=True で configure された Embedding 層、そして Masking 層です。

 

Model クラス

一般に、内側の計算ブロックを定義するために Layer クラスを使用し、そして外側のモデル — 貴方が訓練するオブジェクト — を定義するために Model クラスを使用します。

例えば、ResNet 50 モデルでは、Layer をサブクラス化した幾つかの ResNet ブロックと、ResNet50 ネットワーク全体を取り囲む単一のモデルを持つでしょう。

Model クラスは Layer と同じ API を持ちますが、以下の違いがあります :

• それは組み込み訓練、評価と予測ループを公開しています (model.fit(), model.evaluate(), model.predict())。
• それはその内側の層のリストを model.layers プロパティを通して公開します。
• それはセービングとシリアライゼーション API を公開します (save(), save_weights()…)

事実上、Layer クラス は文献で (「畳込み層」や「リカレント層」の) 「層 (= layer)」や (「ResNet ブロック」や「Inception ブロック」の) 「ブロック」として言及するものに対応しています。

その一方で、Model クラス は文献で (「深層学習モデル」の)「モデル」や (「深層ニューラルネットワーク」の)「ネットワーク」として言及されるものに対応しています。

そこでもし貴方が疑問に思うのであれば、「私は Layer クラスか Model クラスのいずれを使用するべきか？」と自問してください : その上で fit() を呼び出す必要がありますか？ その上で save() を呼び出す必要がありますか？もしそうであれば、Model で進めてください。そうでないなら (貴方のクラスがより大きなシステム内の単なるブロックであるか貴方自身で訓練 & セービングコードを書いているのであれば)、Layer を使用してください。

例えば、上の mini-resnet サンプルを取り、それを fit() で訓練可能で save_weights でセーブできるような Model を構築するために使用できるでしょう :

class ResNet(keras.Model):

    def __init__(self, num_classes=1000):
        super().__init__()
        self.block_1 = ResNetBlock()
        self.block_2 = ResNetBlock()
        self.global_pool = layers.GlobalAveragePooling2D()
        self.classifier = Dense(num_classes)

    def call(self, inputs):
        x = self.block_1(inputs)
        x = self.block_2(x)
        x = self.global_pool(x)
        return self.classifier(x)


resnet = ResNet()
dataset = ...
resnet.fit(dataset, epochs=10)
resnet.save(filepath.keras)

 

総てを一つにまとめる : end-to-end サンプル

ここに貴方がここまでに学習したものがあります :

• 層は (__init__ か build で作成された) 状態と (call 内で定義された) 計算をカプセル化します。
• 層は新しい、より大きな計算ブロックを作成するために再帰的にネストできます。
• 層は Keras API だけを使用する限りバックエンド透過です。(jax.numpy, torch.nn や tf.nn のような) バックエンド-native API を使用できますが、層はその特定のバックエンドでのみ利用可能になります。
• 層は add_loss() を通して、損失 (通常は正則化損失) を作成して追跡できます。
• 外側のコンテナ、貴方が訓練したいものはモデルです。モデルはちょうど層のようなものですが、追加の訓練とシリアライゼーション・ユティリティを持ちます。

これら総てのものを end-to-end サンプルにまとめましょう : バックエンド透過な流儀で変分オートエンコーダ (VAE) を実装していきます — その結果、それは TensorFlow, JAX と PyTorch で同じように動作します。それを MNIST 数字の上で訓練します。

私達の VAE は Model のサブクラスで、 Layer をサブクラス化した層のネストされた構成として構築されます。それは正則化損失 (KL ダイバージェンス) をフィーチャーします。

class Sampling(layers.Layer):
    """Uses (z_mean, z_log_var) to sample z, the vector encoding a digit."""

    def call(self, inputs):
        z_mean, z_log_var = inputs
        batch = ops.shape(z_mean)[0]
        dim = ops.shape(z_mean)[1]
        epsilon = keras.random.normal(shape=(batch, dim))
        return z_mean + ops.exp(0.5 * z_log_var) * epsilon


class Encoder(layers.Layer):
    """Maps MNIST digits to a triplet (z_mean, z_log_var, z)."""

    def __init__(self, latent_dim=32, intermediate_dim=64, name="encoder", **kwargs):
        super().__init__(name=name, **kwargs)
        self.dense_proj = layers.Dense(intermediate_dim, activation="relu")
        self.dense_mean = layers.Dense(latent_dim)
        self.dense_log_var = layers.Dense(latent_dim)
        self.sampling = Sampling()

    def call(self, inputs):
        x = self.dense_proj(inputs)
        z_mean = self.dense_mean(x)
        z_log_var = self.dense_log_var(x)
        z = self.sampling((z_mean, z_log_var))
        return z_mean, z_log_var, z


class Decoder(layers.Layer):
    """Converts z, the encoded digit vector, back into a readable digit."""

    def __init__(self, original_dim, intermediate_dim=64, name="decoder", **kwargs):
        super().__init__(name=name, **kwargs)
        self.dense_proj = layers.Dense(intermediate_dim, activation="relu")
        self.dense_output = layers.Dense(original_dim, activation="sigmoid")

    def call(self, inputs):
        x = self.dense_proj(inputs)
        return self.dense_output(x)


class VariationalAutoEncoder(keras.Model):
    """Combines the encoder and decoder into an end-to-end model for training."""

    def __init__(
        self,
        original_dim,
        intermediate_dim=64,
        latent_dim=32,
        name="autoencoder",
        **kwargs
    ):
        super().__init__(name=name, **kwargs)
        self.original_dim = original_dim
        self.encoder = Encoder(latent_dim=latent_dim, intermediate_dim=intermediate_dim)
        self.decoder = Decoder(original_dim, intermediate_dim=intermediate_dim)

    def call(self, inputs):
        z_mean, z_log_var, z = self.encoder(inputs)
        reconstructed = self.decoder(z)
        # Add KL divergence regularization loss.
        kl_loss = -0.5 * ops.mean(
            z_log_var - ops.square(z_mean) - ops.exp(z_log_var) + 1
        )
        self.add_loss(kl_loss)
        return reconstructed

fit() API を使用してそれを MNIST 上で訓練しましょう :

(x_train, _), _ = keras.datasets.mnist.load_data()
x_train = x_train.reshape(60000, 784).astype("float32") / 255

original_dim = 784
vae = VariationalAutoEncoder(784, 64, 32)

optimizer = keras.optimizers.Adam(learning_rate=1e-3)
vae.compile(optimizer, loss=keras.losses.MeanSquaredError())

vae.fit(x_train, x_train, epochs=2, batch_size=64)

Epoch 1/2
 938/938 ━━━━━━━━━━━━━━━━━━━━  2s 1ms/step - loss: 0.0922
Epoch 2/2
 938/938 ━━━━━━━━━━━━━━━━━━━━  1s 1ms/step - loss: 0.0676

<keras_core.src.callbacks.history.History at 0x28a4dfa90>

以上