TensorFlow 2.4 : ガイド : Keras :- Keras モデルをセーブしてロードする (翻訳/解説)

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

* 本ページは、TensorFlow org サイトの Guide – Keras の以下のページを翻訳した上で
適宜、補足説明したものです：

• Save and load Keras models

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

 

 

ガイド : Keras :- Keras モデルをセーブしてロードする

イントロダクション

Keras モデルは複数のコンポーネントから成ります :

• アーキテクチャ、あるいは configuration、これはモデルがどの層を含むか、そしてそれらがどのように接続されるかを指定します。
• 重み値のセット (「モデルの状態」)。
• optimizer (モデルのコンパイルにより定義されます)。
• 損失とメトリクスのセット (モデルのコンパイルか add_loss() か add_metric() を呼び出すことで定義されます)。

Keras API はこれらのピースの総てをディスクに一度にセーブするか、それらの幾つかを選択的にセーブすることを可能にします :

• 総てを TensorFlow SavedModel 形式で (または古い Keras H5 形式で) 単一アーカイブにセーブします。これは標準的な実践です。
• アーキテクチャ / configuration だけをセーブします、典型的には JSON ファイルとして。
• 重み値だけをセーブします。これは一般にはモデルを訓練するときに使用されます。

これらのオプションの各々を見ましょう : 一つまたは他をいつ利用するのでしょう？それらはどのように動作するのでしょう？

 

セーブ & ロードへの短い回答

このガイドを読むために 10 秒だけを持つ場合、ここに貴方が知る必要があるものがあります。

 
Keras モデルをセーブする :

model = ...  # Get model (Sequential, Functional Model, or Model subclass)
model.save('path/to/location')

 
モデルをロードし戻す :

from tensorflow import keras
model = keras.models.load_model('path/to/location')

さて、詳細を見ましょう。

 

セットアップ

import numpy as np
import tensorflow as tf
from tensorflow import keras

 

モデル全体のセーブ & ロード

モデル全体を単一のアーティファクトにセーブできます。それは以下を含みます :

• モデルのアーキテクチャ/config
• モデルの重み値 (それは訓練の間に学習されました)
• モデルのコンパイル情報 (compile() が呼び出された場合)
• optimizer とその状態、もしあれば (これは貴方がやめたところで訓練を再開することを可能にします)

 
API

• model.save() or tf.keras.models.save_model()
• tf.keras.models.load_model()

モデル全体をディスクにセーブするために使用できる 2 つの形式があります : TensorFlow SavedModel 形式、そして より古い Keras H5 形式 です。推奨形式は SavedModel です。model.save() を使用するときそれはデフォルトです。

H5 形式に以下によりスイッチできます :

• save() に save_format=’h5′ を渡す。
• save() に .h5 or .keras で終わるファイル名を渡す。

 

SavedModel 形式

サンプル :

def get_model():
    # Create a simple model.
    inputs = keras.Input(shape=(32,))
    outputs = keras.layers.Dense(1)(inputs)
    model = keras.Model(inputs, outputs)
    model.compile(optimizer="adam", loss="mean_squared_error")
    return model


model = get_model()

# Train the model.
test_input = np.random.random((128, 32))
test_target = np.random.random((128, 1))
model.fit(test_input, test_target)

# Calling `save('my_model')` creates a SavedModel folder `my_model`.
model.save("my_model")

# It can be used to reconstruct the model identically.
reconstructed_model = keras.models.load_model("my_model")

# Let's check:
np.testing.assert_allclose(
    model.predict(test_input), reconstructed_model.predict(test_input)
)

# The reconstructed model is already compiled and has retained the optimizer
# state, so training can resume:
reconstructed_model.fit(test_input, test_target)

4/4 [==============================] - 1s 2ms/step - loss: 0.3164
INFO:tensorflow:Assets written to: my_model/assets
4/4 [==============================] - 0s 2ms/step - loss: 0.2706
<tensorflow.python.keras.callbacks.History at 0x7f4e56bc5978>

 
SavedModel が含むもの

model.save(‘my_model’) の呼び出しは my_model という名前のフォルダーを作成します、以下を含みます :

ls my_model

assets/  saved_model.pb  variables/

モデル・アーキテクチャ、そして訓練 configuration (optimizer、損失とメトリクスを含みます) が saved_model.pb にストアされます。
重みは variables/ ディレクトリにセーブされます。

SavedModel 形式の詳細情報については、SavedModel ガイド (ディスク上の SavedModel 形式) を見てください。

 
SavedModel がカスタムオブジェクトをどのように処理するか

モデルとその層をセーブするとき、SavedModel 形式はクラス名、call 関数、損失、そして重み (そして実装されていれば config) をストアします。

call 関数はモデル/層の計算グラフを定義します。

モデル/層 config がないときは、call 関数はオリジナル・モデルのように存在するモデルを作成するために使用されます、これは訓練、評価できて推論のために利用できます。

それにもかかわらず、カスタム・モデルや層クラスを書くとき get_config と from_config メソッドを定義することは常に良い実践です。これは必要な場合後で計算を容易に更新することを可能にします。より多くの情報については カスタム・オブジェクト についてのセクションを見てください。

下は、config メソッドを上書きすることなく SavedModel 形式からカスタム層をロードするとき何が起きるかのサンプルです。

class CustomModel(keras.Model):
    def __init__(self, hidden_units):
        super(CustomModel, self).__init__()
        self.dense_layers = [keras.layers.Dense(u) for u in hidden_units]

    def call(self, inputs):
        x = inputs
        for layer in self.dense_layers:
            x = layer(x)
        return x


model = CustomModel([16, 16, 10])
# Build the model by calling it
input_arr = tf.random.uniform((1, 5))
outputs = model(input_arr)
model.save("my_model")

# Delete the custom-defined model class to ensure that the loader does not have
# access to it.
del CustomModel

loaded = keras.models.load_model("my_model")
np.testing.assert_allclose(loaded(input_arr), outputs)

print("Original model:", model)
print("Loaded model:", loaded)

INFO:tensorflow:Assets written to: my_model/assets
WARNING:tensorflow:No training configuration found in save file, so the model was *not* compiled. Compile it manually.
Original model: <__main__.CustomModel object at 0x7f4e56bb36d8>
Loaded model: <tensorflow.python.keras.saving.saved_model.load.CustomModel object at 0x7f4e54b6d550>

上のサンプルで見られるように、ローダーはオリジナル・モデルのように動作する新しいモデルクラスを動的に作成します。

 

Keras H5 形式

Keras はまた単一の HDF5 ファイルをセーブすることもサポートします、これはモデルのアーキテクチャ、重み値、そして compile() 情報を含みます。

それは SavedModel への軽量な代替です。

 
サンプル :

model = get_model()

# Train the model.
test_input = np.random.random((128, 32))
test_target = np.random.random((128, 1))
model.fit(test_input, test_target)

# Calling `save('my_model.h5')` creates a h5 file `my_model.h5`.
model.save("my_h5_model.h5")

# It can be used to reconstruct the model identically.
reconstructed_model = keras.models.load_model("my_h5_model.h5")

# Let's check:
np.testing.assert_allclose(
    model.predict(test_input), reconstructed_model.predict(test_input)
)

# The reconstructed model is already compiled and has retained the optimizer
# state, so training can resume:
reconstructed_model.fit(test_input, test_target)

4/4 [==============================] - 0s 2ms/step - loss: 3.3511
4/4 [==============================] - 0s 2ms/step - loss: 3.2047
<tensorflow.python.keras.callbacks.History at 0x7f4e539fc470>

 
制限

SavedModel 形式と比較して、H5 ファイルには含まれない 2 つのものがあります :

• model.add_loss() & model.add_metric() を通して追加された 外部損失 & メトリクス は (SavedModel とは違い) セーブされません。貴方のモデル上でそのような損失 & メトリクスを持ちそして訓練を再開することを望む場合、モデルをロードした後これらの損失を追加し戻す必要があります。これは self.add_loss() & self.add_metric() を通して層の内部で作成された損失/メトリクスに適用されないことに注意してください。層がロードされる限り、これらの損失 & メトリクスは保持されます、何故ならばそれらは層の call メソッドの一部だからです。
• カスタム層のような カスタム・オブジェクトの計算グラフ はセーブされたファイルに含まれません。ロード時、Keras はモデルを再構築するためにこれらのオブジェクトの Python クラス/関数へのアクセスが必要です。カスタム・オブジェクト を見てください。

 

アーキテクチャをセーブする

モデルの configuration (or アーキテクチャ) はモデルが何の層を含むか、そしてこれらの層がどのように接続されるかを指定します (*)。モデルの configuration を持つ場合には、モデルは重みについて新たに初期化状態でそしてコンパイル情報なしに作成できます。

*これは (サブクラス化モデルではなく) functional or Sequential api を使用して定義されたモデルに適用されるだけであることに注意してください。

 

Sequential モデル or Functional API モデルの configuration

これらのタイプのモデルは層の明示的なグラフです : それらの configuration は構造化形式で常に利用可能です。

 
API

• get_config() と from_config()
• tf.keras.models.model_to_json() と tf.keras.models.model_from_json()

 
◆ get_config() と from_config()

config = model.get_config() の呼び出しはモデルの configuration を含む Python 辞書を返します。そして同じモデルが (Sequential モデルのために) Sequential.from_config(config) または (Functional API モデルのために) Model.from_config(config) を通して再構築できます。

同じワークフローが任意のシリアライズ可能な層のためにも動作します。

 
層サンプル :

layer = keras.layers.Dense(3, activation="relu")
layer_config = layer.get_config()
new_layer = keras.layers.Dense.from_config(layer_config)

 
Sequential モデル・サンプル :

model = keras.Sequential([keras.Input((32,)), keras.layers.Dense(1)])
config = model.get_config()
new_model = keras.Sequential.from_config(config)

 
Functional モデル・サンプル :

inputs = keras.Input((32,))
outputs = keras.layers.Dense(1)(inputs)
model = keras.Model(inputs, outputs)
config = model.get_config()
new_model = keras.Model.from_config(config)

 
◆ to_json() と tf.keras.models.model_from_json()

これは get_config / from_config に類似しています、それがモデルを JSON 文字列に変えることを除いて、これはそれから元のモデルクラスなしにロードできます。それはまたモデルに固有で、層のために意図されていません。

 
サンプル :

model = keras.Sequential([keras.Input((32,)), keras.layers.Dense(1)])
json_config = model.to_json()
new_model = keras.models.model_from_json(json_config)

 

カスタム・オブジェクト

モデルと層

サブクラス化モデルと層のアーキテクチャはメソッド __init__ と call で定義されます。それらは Python バイトコードとして考えられて、それらは JSON-互換 config にはシリアライズできません — バイトコードを (e.g. pickle を通して) シリアライズを試すことはできるでしょうけど、それは全く安全ではなく貴方のモデルは異なるシステム上でロードできないことを意味します。

カスタム定義層を持つモデル、あるいはサブクラス化モデルをセーブ/ロードためには、get_config とオプションで from_config メソッドを上書きするべきです。

更に、カスタム・オブジェクトを Keras がそれを知るように register を使用するべきです。

 
カスタム関数

カスタム定義関数 (e.g. 活性化損失や初期化) は get_config メソッドを必要としません。関数名がそれがカスタム・オブジェクトとして登録される限りはロードするために十分です。

 
TensorFlow グラフだけをロードする

Keras により生成された TensorFlow グラフをロードすることが可能です。それを行なう場合、どのような custom_objects も提供する必要がありません。それをこのように行なうことができます :

model.save("my_model")
tensorflow_graph = tf.saved_model.load("my_model")
x = np.random.uniform(size=(4, 32)).astype(np.float32)
predicted = tensorflow_graph(x).numpy()

INFO:tensorflow:Assets written to: my_model/assets

このメソッドは幾つかの欠点を持つことに注意してください :

• トレース可能性の理由のため、使用されたカスタム・オブジェクトへのアクセスを常に持つべきです。再作成できないモデルをプロダクションに配置することを望まないでしょう。
• tf.saved_model.load により返されるオブジェクトは Keras モデルではありません。そのため使いやすくはありません。例えば、.predict() や .fit() へのアクセスを持たないでしょう。

その使用は推奨されないとしても、貴方が困った状況にあれば、例えば、カスタム・オブジェクトのコードを失ったり、tf.keras.models.load_model() でモデルをロードする問題を持つ場合には、それは役立つ可能性があります。

tf.saved_model.load についてのページ でより多くを見つけることができます。

 
◆ config メソッドを定義する

仕様 :

• get_config は Keras アーキテクチャ- とモデルセーブ-API と互換であるために JSON-シリアライズ可能な辞書を返すべきです。
• from_config(config) (classmethod) は config から作成される新しい層やモデル・オブジェクトを返すべきです。デフォルト実装は cls(**config) を返します。

 
サンプル :

class CustomLayer(keras.layers.Layer):
    def __init__(self, a):
        self.var = tf.Variable(a, name="var_a")

    def call(self, inputs, training=False):
        if training:
            return inputs * self.var
        else:
            return inputs

    def get_config(self):
        return {"a": self.var.numpy()}

    # There's actually no need to define `from_config` here, since returning
    # `cls(**config)` is the default behavior.
    @classmethod
    def from_config(cls, config):
        return cls(**config)


layer = CustomLayer(5)
layer.var.assign(2)

serialized_layer = keras.layers.serialize(layer)
new_layer = keras.layers.deserialize(
    serialized_layer, custom_objects={"CustomLayer": CustomLayer}
)

 
カスタム・オブジェクトを登録する

Keras は config をどのクラスが生成したかを記録します。上のサンプルからは、tf.keras.layers.serialize がカスタム層のシリアライズされた形式を生成します :

{'class_name': 'CustomLayer', 'config': {'a': 2} }

Keras は総ての組込み層、モデル、optimizer、そしてメトリック・クラスのマスターリストを保持します、これは from_config を呼び出す正しいクラスを見つけるために使用されます。クラスが見つけられない場合、エラーが上げられます (Value Error: Unknown layer)。このリストにカスタムクラスを登録するためには 2,3 の方法があります :

1. loading 関数で custom_objects 引数を設定する (上のセクション “Defining the config methods” のサンプル参照)。
2. tf.keras.utils.custom_object_scope or tf.keras.utils.CustomObjectScope
3. tf.keras.utils.register_keras_serializable

 
カスタム層と関数サンプル

class CustomLayer(keras.layers.Layer):
    def __init__(self, units=32, **kwargs):
        super(CustomLayer, self).__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 tf.matmul(inputs, self.w) + self.b

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


def custom_activation(x):
    return tf.nn.tanh(x) ** 2


# Make a model with the CustomLayer and custom_activation
inputs = keras.Input((32,))
x = CustomLayer(32)(inputs)
outputs = keras.layers.Activation(custom_activation)(x)
model = keras.Model(inputs, outputs)

# Retrieve the config
config = model.get_config()

# At loading time, register the custom objects with a `custom_object_scope`:
custom_objects = {"CustomLayer": CustomLayer, "custom_activation": custom_activation}
with keras.utils.custom_object_scope(custom_objects):
    new_model = keras.Model.from_config(config)

 

In-メモリのモデル複製

tf.keras.models.clone_model() を通してモデルの in-メモリ複製も行なうことができます。これは config を得てその config からモデルを再作成することに等値です (従ってそれはコンパイル情報や層重み値を保全しません)。

 
サンプル :

with keras.utils.custom_object_scope(custom_objects):
    new_model = keras.models.clone_model(model)

 

モデルの重み値だけをセーブ & ロードする

モデルの重みだけをセーブ & ロードすることを選択できます。これは以下の場合に有用であり得ます :

• 推論のためだけにモデルを必要とする (場合) : この場合訓練を再開する必要はないので、コンパイル情報や optimizer 状態を必要としません。
• 貴方は転移学習を行なっている (場合) : この場合前のモデルの状態を再利用する新しいモデルを訓練していますので、前のモデルのコンパイル情報を必要としません。

 

in-メモリの重み転送 (= transfer) のための API

重みは get_weights と set_weights を使用して異なるオブジェクトの間でコピーできます :

• tf.keras.layers.Layer.get_weights() : numpy 配列のリストを返します。
• tf.keras.layers.Layer.set_weights() : weights 引数でモデル重みを値に設定します。

下のサンプル。

 
メモリ内で、重みを一つの層から他方へ転送する

def create_layer():
    layer = keras.layers.Dense(64, activation="relu", name="dense_2")
    layer.build((None, 784))
    return layer


layer_1 = create_layer()
layer_2 = create_layer()

# Copy weights from layer 2 to layer 1
layer_2.set_weights(layer_1.get_weights())

 
メモリで、一つのモデルから互換なアーキテクチャを持つ他のモデルへ重みを転送する

# Create a simple functional model
inputs = keras.Input(shape=(784,), name="digits")
x = keras.layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = keras.layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = keras.layers.Dense(10, name="predictions")(x)
functional_model = keras.Model(inputs=inputs, outputs=outputs, name="3_layer_mlp")

# Define a subclassed model with the same architecture
class SubclassedModel(keras.Model):
    def __init__(self, output_dim, name=None):
        super(SubclassedModel, self).__init__(name=name)
        self.output_dim = output_dim
        self.dense_1 = keras.layers.Dense(64, activation="relu", name="dense_1")
        self.dense_2 = keras.layers.Dense(64, activation="relu", name="dense_2")
        self.dense_3 = keras.layers.Dense(output_dim, name="predictions")

    def call(self, inputs):
        x = self.dense_1(inputs)
        x = self.dense_2(x)
        x = self.dense_3(x)
        return x

    def get_config(self):
        return {"output_dim": self.output_dim, "name": self.name}


subclassed_model = SubclassedModel(10)
# Call the subclassed model once to create the weights.
subclassed_model(tf.ones((1, 784)))

# Copy weights from functional_model to subclassed_model.
subclassed_model.set_weights(functional_model.get_weights())

assert len(functional_model.weights) == len(subclassed_model.weights)
for a, b in zip(functional_model.weights, subclassed_model.weights):
    np.testing.assert_allclose(a.numpy(), b.numpy())

 
ステートレス層のケース

ステートレス層は重みの順序や数を変更しないので、モデルは追加/欠落 (= extra/missing) のステートレス層がある場合でさえ互換なアーキテクチャを持つことができます。

inputs = keras.Input(shape=(784,), name="digits")
x = keras.layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = keras.layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = keras.layers.Dense(10, name="predictions")(x)
functional_model = keras.Model(inputs=inputs, outputs=outputs, name="3_layer_mlp")

inputs = keras.Input(shape=(784,), name="digits")
x = keras.layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = keras.layers.Dense(64, activation="relu", name="dense_2")(x)

# Add a dropout layer, which does not contain any weights.
x = keras.layers.Dropout(0.5)(x)
outputs = keras.layers.Dense(10, name="predictions")(x)
functional_model_with_dropout = keras.Model(
    inputs=inputs, outputs=outputs, name="3_layer_mlp"
)

functional_model_with_dropout.set_weights(functional_model.get_weights())

 

重みをディスクにセーブ & それらをロードし戻すための API

model.save_weights を呼び出すことにより重みは次の形式でディスクにセーブできます :

• TensorFlow チェックポイント
• HDF5

model.save_weights のためのデフォルト形式は TensorFlow チェックポイントです。セーブ形式を指定するには 2 つの方法があります :

1. save_format 引数 : 値を save_format=”tf” か save_format=”h5″ に設定する。
2. path 引数: path が .h5 か .hdf5 で終われば、HDF5 形式が使用されます。他のサフィックスは save_format が設定されない限りは TensorFlow チェックポイントという結果になります。

重みを in-メモリ numpy 配列として取得するオプションもあります。各 API は良い点と悪い点を持ち、これらは下で詳述されます。

 

TF チェックポイント形式

サンプル :

# Runnable example
sequential_model = keras.Sequential(
    [
        keras.Input(shape=(784,), name="digits"),
        keras.layers.Dense(64, activation="relu", name="dense_1"),
        keras.layers.Dense(64, activation="relu", name="dense_2"),
        keras.layers.Dense(10, name="predictions"),
    ]
)
sequential_model.save_weights("ckpt")
load_status = sequential_model.load_weights("ckpt")

# `assert_consumed` can be used as validation that all variable values have been
# restored from the checkpoint. See `tf.train.Checkpoint.restore` for other
# methods in the Status object.
load_status.assert_consumed()

<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f2945948cf8>

 
◆ 形式 (= format) 詳細

TensorFlow チェックポイント形式はオブジェクト属性名を使用して重みをセーブしてリストアします。例えば、tf.keras.layers.Dense 層を考えます。層は 2 つの重みを含みます : dense.kernel と dense.bias です。層が tf 形式にセーブされるとき、結果としてのチェックポイントはキー “kernel” と “bias” そしてそれに対応する重み値を含みます。より多くの情報については TF Checkpoint ガイドの “Loading mechanics” を見てください。

属性/グラフエッジは (変数の名前ではなく、) parent オブジェクトで使用された名前で命名されることに注意してください。下のサンプル CustomLayer を考えます。変数 CustomLayer.var はキーの一部として “var” でセーブされます、”var_a” ではありません。

class CustomLayer(keras.layers.Layer):
    def __init__(self, a):
        self.var = tf.Variable(a, name="var_a")


layer = CustomLayer(5)
layer_ckpt = tf.train.Checkpoint(layer=layer).save("custom_layer")

ckpt_reader = tf.train.load_checkpoint(layer_ckpt)

ckpt_reader.get_variable_to_dtype_map()

{'_CHECKPOINTABLE_OBJECT_GRAPH': tf.string,
 'layer/var/.ATTRIBUTES/VARIABLE_VALUE': tf.int32,
 'save_counter/.ATTRIBUTES/VARIABLE_VALUE': tf.int64}

 
◆ 転送学習サンプル

本質的には、2 つのモデルが同じアーキテクチャを持つ限りは、それらは同じチェックポイントを共有できます。

サンプル :

inputs = keras.Input(shape=(784,), name="digits")
x = keras.layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = keras.layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = keras.layers.Dense(10, name="predictions")(x)
functional_model = keras.Model(inputs=inputs, outputs=outputs, name="3_layer_mlp")

# Extract a portion of the functional model defined in the Setup section.
# The following lines produce a new model that excludes the final output
# layer of the functional model.
pretrained = keras.Model(
    functional_model.inputs, functional_model.layers[-1].input, name="pretrained_model"
)
# Randomly assign "trained" weights.
for w in pretrained.weights:
    w.assign(tf.random.normal(w.shape))
pretrained.save_weights("pretrained_ckpt")
pretrained.summary()

# Assume this is a separate program where only 'pretrained_ckpt' exists.
# Create a new functional model with a different output dimension.
inputs = keras.Input(shape=(784,), name="digits")
x = keras.layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = keras.layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = keras.layers.Dense(5, name="predictions")(x)
model = keras.Model(inputs=inputs, outputs=outputs, name="new_model")

# Load the weights from pretrained_ckpt into model.
model.load_weights("pretrained_ckpt")

# Check that all of the pretrained weights have been loaded.
for a, b in zip(pretrained.weights, model.weights):
    np.testing.assert_allclose(a.numpy(), b.numpy())

print("\n", "-" * 50)
model.summary()

# Example 2: Sequential model
# Recreate the pretrained model, and load the saved weights.
inputs = keras.Input(shape=(784,), name="digits")
x = keras.layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = keras.layers.Dense(64, activation="relu", name="dense_2")(x)
pretrained_model = keras.Model(inputs=inputs, outputs=x, name="pretrained")

# Sequential example:
model = keras.Sequential([pretrained_model, keras.layers.Dense(5, name="predictions")])
model.summary()

pretrained_model.load_weights("pretrained_ckpt")

# Warning! Calling `model.load_weights('pretrained_ckpt')` won't throw an error,
# but will *not* work as expected. If you inspect the weights, you'll see that
# none of the weights will have loaded. `pretrained_model.load_weights()` is the
# correct method to call.

Model: "pretrained_model"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
digits (InputLayer)          [(None, 784)]             0         
_________________________________________________________________
dense_1 (Dense)              (None, 64)                50240     
_________________________________________________________________
dense_2 (Dense)              (None, 64)                4160      
=================================================================
Total params: 54,400
Trainable params: 54,400
Non-trainable params: 0
_________________________________________________________________

 --------------------------------------------------
Model: "new_model"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
digits (InputLayer)          [(None, 784)]             0         
_________________________________________________________________
dense_1 (Dense)              (None, 64)                50240     
_________________________________________________________________
dense_2 (Dense)              (None, 64)                4160      
_________________________________________________________________
predictions (Dense)          (None, 5)                 325       
=================================================================
Total params: 54,725
Trainable params: 54,725
Non-trainable params: 0
_________________________________________________________________
Model: "sequential_3"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
pretrained (Functional)      (None, 64)                54400     
_________________________________________________________________
predictions (Dense)          (None, 5)                 325       
=================================================================
Total params: 54,725
Trainable params: 54,725
Non-trainable params: 0
_________________________________________________________________
<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f2945923be0>

モデルを構築するために同じ API に固執することを一般に推奨します。Sequential と Functional あるいは Functional とサブクラス化等の間で切り替える場合、常に事前訓練モデルを再構築してそのモデルに事前訓練重みをロードします。

次の質問は、モデル・アーキテクチャが非常に異なる場合重みはどのようにセーブされて異なるモデルにロードできるか？です。その解は正確な層/変数をセーブしてリストアするために tf.train.Checkpoint を使用することです。

 
サンプル :

# Create a subclassed model that essentially uses functional_model's first
# and last layers.
# First, save the weights of functional_model's first and last dense layers.
first_dense = functional_model.layers[1]
last_dense = functional_model.layers[-1]
ckpt_path = tf.train.Checkpoint(
    dense=first_dense, kernel=last_dense.kernel, bias=last_dense.bias
).save("ckpt")

# Define the subclassed model.
class ContrivedModel(keras.Model):
    def __init__(self):
        super(ContrivedModel, self).__init__()
        self.first_dense = keras.layers.Dense(64)
        self.kernel = self.add_variable("kernel", shape=(64, 10))
        self.bias = self.add_variable("bias", shape=(10,))

    def call(self, inputs):
        x = self.first_dense(inputs)
        return tf.matmul(x, self.kernel) + self.bias


model = ContrivedModel()
# Call model on inputs to create the variables of the dense layer.
_ = model(tf.ones((1, 784)))

# Create a Checkpoint with the same structure as before, and load the weights.
tf.train.Checkpoint(
    dense=model.first_dense, kernel=model.kernel, bias=model.bias
).restore(ckpt_path).assert_consumed()

<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7f29459231d0>

 

HDF5 format

HDF5 形式は層名によりグループ分けされる重みを含みます。訓練可能な重みのリストを非訓練可能な重みのリストに連結することにより順序付けられたリストです (layer.weights と同じです)。こうして、モデルはそれが同じ層と訓練可能な状態をチェックポイントでセーブされたものとして持てば hdf5 チェックポイントを利用できます。

 
サンプル :

# Runnable example
sequential_model = keras.Sequential(
    [
        keras.Input(shape=(784,), name="digits"),
        keras.layers.Dense(64, activation="relu", name="dense_1"),
        keras.layers.Dense(64, activation="relu", name="dense_2"),
        keras.layers.Dense(10, name="predictions"),
    ]
)
sequential_model.save_weights("weights.h5")
sequential_model.load_weights("weights.h5")

モデルがネストされた層を含むとき layer.trainable の変更は異なる layer.weights 順序という結果になるかもしれないことに注意してください。

class NestedDenseLayer(keras.layers.Layer):
    def __init__(self, units, name=None):
        super(NestedDenseLayer, self).__init__(name=name)
        self.dense_1 = keras.layers.Dense(units, name="dense_1")
        self.dense_2 = keras.layers.Dense(units, name="dense_2")

    def call(self, inputs):
        return self.dense_2(self.dense_1(inputs))


nested_model = keras.Sequential([keras.Input((784,)), NestedDenseLayer(10, "nested")])
variable_names = [v.name for v in nested_model.weights]
print("variables: {}".format(variable_names))

print("\nChanging trainable status of one of the nested layers...")
nested_model.get_layer("nested").dense_1.trainable = False

variable_names_2 = [v.name for v in nested_model.weights]
print("\nvariables: {}".format(variable_names_2))
print("variable ordering changed:", variable_names != variable_names_2)

variables: ['nested/dense_1/kernel:0', 'nested/dense_1/bias:0', 'nested/dense_2/kernel:0', 'nested/dense_2/bias:0']

Changing trainable status of one of the nested layers...

variables: ['nested/dense_2/kernel:0', 'nested/dense_2/bias:0', 'nested/dense_1/kernel:0', 'nested/dense_1/bias:0']
variable ordering changed: True

 
◆ 転移学習サンプル

HDF5 から事前訓練された重みをロードするとき、重みをオリジナルのチェックポイントされたモデルにロードしてから望まれる重み/層を新しいモデルに抽出することが推奨されます。

 
サンプル :

def create_functional_model():
    inputs = keras.Input(shape=(784,), name="digits")
    x = keras.layers.Dense(64, activation="relu", name="dense_1")(inputs)
    x = keras.layers.Dense(64, activation="relu", name="dense_2")(x)
    outputs = keras.layers.Dense(10, name="predictions")(x)
    return keras.Model(inputs=inputs, outputs=outputs, name="3_layer_mlp")


functional_model = create_functional_model()
functional_model.save_weights("pretrained_weights.h5")

# In a separate program:
pretrained_model = create_functional_model()
pretrained_model.load_weights("pretrained_weights.h5")

# Create a new model by extracting layers from the original model:
extracted_layers = pretrained_model.layers[:-1]
extracted_layers.append(keras.layers.Dense(5, name="dense_3"))
model = keras.Sequential(extracted_layers)
model.summary()

Model: "sequential_6"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_1 (Dense)              (None, 64)                50240     
_________________________________________________________________
dense_2 (Dense)              (None, 64)                4160      
_________________________________________________________________
dense_3 (Dense)              (None, 5)                 325       
=================================================================
Total params: 54,725
Trainable params: 54,725
Non-trainable params: 0
_________________________________________________________________

以上

TensorFlow 2.4 : ガイド : Keras :- 転移学習と再調整 (翻訳/解説)

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

* 本ページは、TensorFlow org サイトの Guide – Keras の以下のページを翻訳した上で
適宜、補足説明したものです：

• Transfer learning and fine-tuning

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

 

 

 

ガイド : Keras :- 転移学習と再調整

セットアップ

import numpy as np
import tensorflow as tf
from tensorflow import keras

 

イントロダクション

転移学習 は 1 つの問題上で学習された特徴を取り、そしてそれらを新しい、類似の問題上で活用することから成ります。例えば、アライグマ (= raccoon) を識別するために学習したモデルからの特徴はタヌキを識別することを意図したモデルを始動するために有用かもしれません。

転移学習はスクラッチから本格的な (= full-scale) モデルを訓練するには貴方のデータセットが少な過ぎるデータを持つようなタスクのために通常は行なわれます。

深層学習のコンテキストで転移学習の最も一般的な具現化は以下のワークフローです :

1. 前に訓練されたモデルから層を取ります。
2. 今後の訓練ラウンドの間にそれらが含む任意の情報を壊すことを避けるために、それらを凍結します。
3. 凍結された層の上に幾つかの新しい、訓練可能な層を追加します。それらは古い特徴を新しいデータセット上の予測に変えるために学習します。
4. 貴方のデータセット上で新しい層を訓練します。

最後の、オプションのステップは 再調整 で、これは上で得たモデル全体 (あるいはその一部) を解凍して、非常に低い学習率で新しいデータ上でそれを再訓練することから成ります。事前訓練された特徴を新しいデータに漸増的事前に適応させることによりこれは潜在的には意味のある改良を獲得できます。

最初に、Keras 訓練可能 API を詳細に調べます、これは殆どの転移学習 & 再調整ワークフソーの基礎となります。

そして、ImageNet データセット上で事前訓練されたモデルを取り、そしてそれを Kaggle “猫 vs 犬” 分類データセット上で再訓練することにより典型的なワークフローを実演します。

これは Deep Learning with Python と 2016 ブログ投稿 “building powerful image classification models using very little data” から採用されました。

 

層を凍結する : 訓練可能な属性を理解する

層 & モデルは 3 つの重み属性を持ちます :

• weights は層の総ての重み変数のリストです。
• trainable_weights は訓練の間に損失を最小化するために (勾配降下を通して) 更新されることを意図したそれらのリストです。
• non_trainable_weights は訓練されることを意図していないそれらのリストです。典型的にはそれらは forward パスの間にモデルにより更新されます。

サンプル: Dense 層は 2 つの訓練可能な重み (カーネル & バイアス) を持ちます。

layer = keras.layers.Dense(3)
layer.build((None, 4))  # Create the weights

print("weights:", len(layer.weights))
print("trainable_weights:", len(layer.trainable_weights))
print("non_trainable_weights:", len(layer.non_trainable_weights))

weights: 2
trainable_weights: 2
non_trainable_weights: 0

一般に、総ての重みは訓練可能な重みです。非訓練可能な重みを持つ唯一の組込み層は BatchNormalization 層 です。訓練の間 その入力の平均と分散を追跡するために非訓練可能な重みを利用します。貴方自身のカスタム層で非訓練可能な重みをどのように使用するかを学習するためには、writing new layers from scratch へのガイド を見てください。

 
サンプル: BatchNormalization 層は 2 つの訓練可能な重みと 2 つの非訓練可能な重みを持つ。

layer = keras.layers.BatchNormalization()
layer.build((None, 4))  # Create the weights

print("weights:", len(layer.weights))
print("trainable_weights:", len(layer.trainable_weights))
print("non_trainable_weights:", len(layer.non_trainable_weights))

weights: 4
trainable_weights: 2
non_trainable_weights: 2

層 & モデルはまたブーリアン属性 trainable も持ちます。その値は変更可能です。layer.trainable を False を設定すると総ての層の重みを訓練可能から非訓練可能に移します。これは層を「凍結する (= freezing)」と呼称されます : (fit() で訓練するとき、あるいは勾配更新を適用するために trainable_weights に依拠する任意のカスタムループで訓練するときのいずれかの) 訓練の間に凍結された層の状態は更新されません。

 
サンプル: trainable を False に設定します

layer = keras.layers.Dense(3)
layer.build((None, 4))  # Create the weights
layer.trainable = False  # Freeze the layer

print("weights:", len(layer.weights))
print("trainable_weights:", len(layer.trainable_weights))
print("non_trainable_weights:", len(layer.non_trainable_weights))

weights: 2
trainable_weights: 0
non_trainable_weights: 2

訓練可能な重みが非訓練可能になるとき、その値は訓練の間にもはや更新されません。

# Make a model with 2 layers
layer1 = keras.layers.Dense(3, activation="relu")
layer2 = keras.layers.Dense(3, activation="sigmoid")
model = keras.Sequential([keras.Input(shape=(3,)), layer1, layer2])

# Freeze the first layer
layer1.trainable = False

# Keep a copy of the weights of layer1 for later reference
initial_layer1_weights_values = layer1.get_weights()

# Train the model
model.compile(optimizer="adam", loss="mse")
model.fit(np.random.random((2, 3)), np.random.random((2, 3)))

# Check that the weights of layer1 have not changed during training
final_layer1_weights_values = layer1.get_weights()
np.testing.assert_allclose(
    initial_layer1_weights_values[0], final_layer1_weights_values[0]
)
np.testing.assert_allclose(
    initial_layer1_weights_values[1], final_layer1_weights_values[1]
)

1/1 [==============================] - 1s 565ms/step - loss: 0.1359

layer.trainable 属性を layer.__call__() の引数 training と混同しないでください (これは層がその forward パスを推論モードか訓練モードのいずれで実行するべきかを制御します)。より多くの情報については、Keras FAQ を見てください。

 

trainable 属性の再帰的な設定

モデルか副層 (= sublayer) を持つ任意の層上で trainable = False を設定する場合、総ての子層 (= children layers) もまた非訓練になります。

サンプル:

inner_model = keras.Sequential(
    [
        keras.Input(shape=(3,)),
        keras.layers.Dense(3, activation="relu"),
        keras.layers.Dense(3, activation="relu"),
    ]
)

model = keras.Sequential(
    [keras.Input(shape=(3,)), inner_model, keras.layers.Dense(3, activation="sigmoid"),]
)

model.trainable = False  # Freeze the outer model

assert inner_model.trainable == False  # All layers in `model` are now frozen
assert inner_model.layers[0].trainable == False  # `trainable` is propagated recursively

 

典型的な転移学習ワークフロー

これは典型的な転移学習ワークフローが Keras でどのように実装できるかに導いてくれます :

1. 基底モデルをインスタンス化して事前訓練された重みをその中にロードします。
2. trainable = False を設定して基底モデルの総ての層を凍結します。
3. 基底モデルからの一つ (or 幾つか) の層の出力の上に新しいモデルを作成します。
4. 貴方の新しいデータセット上で新しいモデルを訓練します。

代替の、より軽量なワークフローはまた次のようなものであり得ることに注意してください :

1. 基底モデルをインスタンス化して事前訓練された重みをその中にロードします。
2. それを通して新しいデータセットを実行してそして基底モデルからの一つ (or 幾つか) の層の出力を記録します。これは 特徴抽出 と呼ばれます。
3. その出力を新しい、より小さなモデルのための入力データとして利用します。

2 番目のワークフローの主要な優位点は基底モデルを (訓練のエポック毎に 1 度ではなく) 貴方のデータ上 1 度実行するだけであることです。従ってそれは遥かに高速で & 安価です。

けれども、その 2 番目のワークフローに伴う問題は、それは訓練の間に貴方の新しいモデルの入力データを動的に変更することを可能にしないことです、これは例えば、データ増強を行なうときに必要です。転移学習は典型的には貴方の新しいデータセットが完全な (= full-scale) モデルをスクラッチから訓練すためには非常に少ないデータを持つときタスクのために使用され、そしてそのようなシナリオではデータ増強は非常に重要です。そのため以下では、最初のワークフローにフォーカスします。

ここに最初のワークフローが Keras でどのようなものかがあります :

最初に、事前訓練された重みで基底モデルをインスタンス化します。

base_model = keras.applications.Xception(
    weights='imagenet',  # Load weights pre-trained on ImageNet.
    input_shape=(150, 150, 3),
    include_top=False)  # Do not include the ImageNet classifier at the top.

Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/xception/xception_weights_tf_dim_ordering_tf_kernels_notop.h5
83689472/83683744 [==============================] - 1s 0us/step

それから、基底モデルを凍結します。

base_model.trainable = False

上に新しいモデルを作成します。

inputs = keras.Input(shape=(150, 150, 3))
# We make sure that the base_model is running in inference mode here,
# by passing `training=False`. This is important for fine-tuning, as you will
# learn in a few paragraphs.
x = base_model(inputs, training=False)
# Convert features of shape `base_model.output_shape[1:]` to vectors
x = keras.layers.GlobalAveragePooling2D()(x)
# A Dense classifier with a single unit (binary classification)
outputs = keras.layers.Dense(1)(x)
model = keras.Model(inputs, outputs)

新しいデータでモデルを訓練します。

model.compile(optimizer=keras.optimizers.Adam(),
              loss=keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=[keras.metrics.BinaryAccuracy()])
model.fit(new_dataset, epochs=20, callbacks=..., validation_data=...)

 

再調整

貴方のモデルが新しいデータ上でひとたび収束したのであれば、基底モデルの総てまたは一部を解凍してそして非常に小さい学習率でモデル全体を end-to-end に再訓練することを試すができます。

これは増加的な (= incremental) 改良を潜在的に与えられるオプションの最後のステップです。それはまた潜在的に素早い overfitting に繋がる可能性があります — それに留意してください。

凍結された層を持つモデルが収束まで訓練された後だけにこのステップを行なうことが不可欠です。もしランダムに初期化された訓練可能な層を事前訓練された特徴を保持する訓練可能な層と混在させれば、ランダムに初期化された層は訓練の間に非常に大きな勾配更新を引き起こすでしょう、これは事前訓練された特徴を破壊します。

この段階で非常に低い学習率を利用することも重要です、何故ならば典型的には非常に小さいデータセット上で、訓練の最初のラウンドにおけるよりも遥かに大規模なモデルを訓練しているからです。その結果、大きな重み更新を適用する場合非常に迅速に overffitting する危険性があります。ここでは、漸増的な方法で事前訓練された重みを再適応させることを望むだけです。

これが基底モデル全体の再調整をどのように実装するかです :

# Unfreeze the base model
base_model.trainable = True

# It's important to recompile your model after you make any changes
# to the `trainable` attribute of any inner layer, so that your changes
# are take into account
model.compile(optimizer=keras.optimizers.Adam(1e-5),  # Very low learning rate
              loss=keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=[keras.metrics.BinaryAccuracy()])

# Train end-to-end. Be careful to stop before you overfit!
model.fit(new_dataset, epochs=10, callbacks=..., validation_data=...)

 
compile() と trainable についての重要なノート

モデル上での compile() の呼び出しはそのモデルの動作を「凍結する」ことを意図しています。これはモデルがコンパイルされた時の訓練可能な属性値は再度 compile が呼び出されるまでそのモデルのライフタイムを通して保存されるべきであることを含蓄します。こうして、任意の訓練可能な値を変更する場合、貴方の変更が考慮ためにモデル上で compile() を再度呼び出すことを確実にしてください。

 
BatchNormalization 層についての重要なノート

多くの画像モデルは BatchNormalization 層を含みます。その層は考えうる総てにおいて特別なケースです。ここに留意すべき幾つかのことがあります。

• BatchNormalization は訓練の間に更新されるべき 2 つの非訓練可能な重みを含みます。これらは入力の平均と分散を追跡する変数です。
• bn_layer.trainable = False を設定するとき、BatchNormalization 層は推論モードで実行され、そしてその平均 & 分散統計値を更新しません。これは一般には他の層には当てはまりません、というのは 重みの訓練可能性 & 推論/訓練モードは 2 つの直交する概念だからです。しかし 2 つは BatchNormalization 層の場合には結び付けられます。
• 再調整を行なうために BatchNormalization 層を含むモデルを解凍するとき、基底モデルを呼び出すとき training=False を渡して BatchNormalization 層を推論モードに保持するべきです。そうでないと非訓練可能な重みに適用される更新がモデルが学習したものを突然に破壊します。

このガイドの最後の end-to-end サンプルでこのパターンを実際に見ます。

 

カスタム訓練ループで転移学習 & 再調整

fit() の代わりに、貴方自身の低位訓練ループを使用している場合、ワークフローは本質的には同じままです。勾配更新を適用するときリスト model.trainable_weights を考慮することだけに注意すべきです :

# Create base model
base_model = keras.applications.Xception(
    weights='imagenet',
    input_shape=(150, 150, 3),
    include_top=False)
# Freeze base model
base_model.trainable = False

# Create new model on top.
inputs = keras.Input(shape=(150, 150, 3))
x = base_model(inputs, training=False)
x = keras.layers.GlobalAveragePooling2D()(x)
outputs = keras.layers.Dense(1)(x)
model = keras.Model(inputs, outputs)

loss_fn = keras.losses.BinaryCrossentropy(from_logits=True)
optimizer = keras.optimizers.Adam()

# Iterate over the batches of a dataset.
for inputs, targets in new_dataset:
    # Open a GradientTape.
    with tf.GradientTape() as tape:
        # Forward pass.
        predictions = model(inputs)
        # Compute the loss value for this batch.
        loss_value = loss_fn(targets, predictions)

    # Get gradients of loss wrt the *trainable* weights.
    gradients = tape.gradient(loss_value, model.trainable_weights)
    # Update the weights of the model.
    optimizer.apply_gradients(zip(gradients, model.trainable_weights))

Likewise for fine-tuning.

 

end-to-end サンプル:

猫 vs. 犬上で画像分類モデルを再調整します。

データセット

これらのコンセプトを固めるために、具体的な end-to-end 転移学習 & 再調整サンプルを通り抜けましょう。ImageNet 上で事前訓練された、Xception モデルをロードし、そしてそれを Kaggle “猫 vs. 犬” 分類データセット上で利用します。

 

データを得る

最初に、TFDS を使用して猫 vs. 犬データセットを取得しましょう。貴方自身のデータセットを持つ場合、クラス専用フォルダーにファイリングされた画像のセットから同様のラベル付けられたデータセット・オブジェクトを生成するために貴方は多分ユティリティ tf.keras.preprocessing.image_dataset_from_directory を使用することを望むでしょう。

転移学習は非常に小さいデータセットで作業するとき最も有用です。データセットを小さく保持するために、訓練のために元の訓練データ (25,000 画像) の 40%、検証のために 10%、そしてテストのために 10% を利用します。

import tensorflow_datasets as tfds

tfds.disable_progress_bar()

train_ds, validation_ds, test_ds = tfds.load(
    "cats_vs_dogs",
    # Reserve 10% for validation and 10% for test
    split=["train[:40%]", "train[40%:50%]", "train[50%:60%]"],
    as_supervised=True,  # Include labels
)

print("Number of training samples: %d" % tf.data.experimental.cardinality(train_ds))
print(
    "Number of validation samples: %d" % tf.data.experimental.cardinality(validation_ds)
)
print("Number of test samples: %d" % tf.data.experimental.cardinality(test_ds))

Number of training samples: 9305
Number of validation samples: 2326
Number of test samples: 2326

これらは訓練データセットの最初の 9 画像です — 見れるように、それらは総て異なるサイズです。

import matplotlib.pyplot as plt

plt.figure(figsize=(10, 10))
for i, (image, label) in enumerate(train_ds.take(9)):
    ax = plt.subplot(3, 3, i + 1)
    plt.imshow(image)
    plt.title(int(label))
    plt.axis("off")

ラベル 1 が「犬」でラベル 0 が「猫」であることも見れます。

 

データを標準化する

raw 画像は様々なサイズを持ちます。加えて、各ピクセルは 0 と 255 の間の 3 つの整数値 (RGB レベル値) から成ります。これはニューラルネットワークに供給するために素晴らしい適合ではありません。私達は 2 つのことを行なう必要があります :

• 固定画像サイズに標準化する。150×150 を選択します。
• ピクセル値を -1 と 1 の間に正規化する。モデル自身の一部として Normalization を使用してこれを行ないます。

一般に、既に前処理されたデータを取るモデルに対して、入力として raw データを取るモデルを開発することは良い実践です。その理由は、モデルが前処理されたデータを想定する場合、他で (web ブラウザ、モバイル app で) それを使用するためにモデルをエクスポートするたびに、正確に同じ前処理パイプラインを再実装する必要があるためです。それは非常に素早く非常に技巧的になります。そのためモデルに達する前に最小限の量の前処理を行なうべきです。

ここでは、データパイプラインで画像リサイズを行ない (何故ならば深層ニューラルネットワークはデータの連続的なバッチを処理するだけだからです)、そしてモデルの一部として入力値スケーリングを行ないます、それを作成するときに。

画像を 150×150 にリサイズしましょう :

size = (150, 150)

train_ds = train_ds.map(lambda x, y: (tf.image.resize(x, size), y))
validation_ds = validation_ds.map(lambda x, y: (tf.image.resize(x, size), y))
test_ds = test_ds.map(lambda x, y: (tf.image.resize(x, size), y))

更に、データをバッチ化してローディング・スピードを最適化するためにキャッシングと先取り (= prefetching) を利用しましょう。

batch_size = 32

train_ds = train_ds.cache().batch(batch_size).prefetch(buffer_size=10)
validation_ds = validation_ds.cache().batch(batch_size).prefetch(buffer_size=10)
test_ds = test_ds.cache().batch(batch_size).prefetch(buffer_size=10)

 

ランダムデータ増強を使用する

大規模な画像データセットを持たないとき、ランダムな水平反転や小さなランダム回転のような、サンプルの多様性を人工的に導入することは良い実践です。これは overfitting をスローダウンさせる一方で訓練データの様々な様相にモデルを晒す役に立ちます。

from tensorflow import keras
from tensorflow.keras import layers

data_augmentation = keras.Sequential(
    [
        layers.experimental.preprocessing.RandomFlip("horizontal"),
        layers.experimental.preprocessing.RandomRotation(0.1),
    ]
)

様々なランダム変換の後に最初のバッチの最初の画像がどのように見えるか可視化しましょう :

import numpy as np

for images, labels in train_ds.take(1):
    plt.figure(figsize=(10, 10))
    first_image = images[0]
    for i in range(9):
        ax = plt.subplot(3, 3, i + 1)
        augmented_image = data_augmentation(
            tf.expand_dims(first_image, 0), training=True
        )
        plt.imshow(augmented_image[0].numpy().astype("int32"))
        plt.title(int(labels[i]))
        plt.axis("off")

 

モデルを構築する

今は先に説明したブループリントに従ってモデルを構築しましょう。

以下に注意してください :

• (初期化時に [0, 255] 範囲内の) 入力値を [-1, 1] 範囲にスケールするために Normalization 層を追加します。
• 正則化のために、分類層の前に Dropout 層を追加します。
• 基底モデルを呼び出すときに、それが推論モードで動作するように training=False を渡すことを確実にします、その結果 batchnorm 統計値は再調整のために基底モデルを解凍した後でさえ更新されえません。

base_model = keras.applications.Xception(
    weights="imagenet",  # Load weights pre-trained on ImageNet.
    input_shape=(150, 150, 3),
    include_top=False,
)  # Do not include the ImageNet classifier at the top.

# Freeze the base_model
base_model.trainable = False

# Create new model on top
inputs = keras.Input(shape=(150, 150, 3))
x = data_augmentation(inputs)  # Apply random data augmentation

# Pre-trained Xception weights requires that input be normalized
# from (0, 255) to a range (-1., +1.), the normalization layer
# does the following, outputs = (inputs - mean) / sqrt(var)
norm_layer = keras.layers.experimental.preprocessing.Normalization()
mean = np.array([127.5] * 3)
var = mean ** 2
# Scale inputs to [-1, +1]
x = norm_layer(x)
norm_layer.set_weights([mean, var])

# The base model contains batchnorm layers. We want to keep them in inference mode
# when we unfreeze the base model for fine-tuning, so we make sure that the
# base_model is running in inference mode here.
x = base_model(x, training=False)
x = keras.layers.GlobalAveragePooling2D()(x)
x = keras.layers.Dropout(0.2)(x)  # Regularize with dropout
outputs = keras.layers.Dense(1)(x)
model = keras.Model(inputs, outputs)

model.summary()

Model: "model_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_12 (InputLayer)        [(None, 150, 150, 3)]     0         
_________________________________________________________________
sequential_6 (Sequential)    (None, 150, 150, 3)       0         
_________________________________________________________________
normalization (Normalization (None, 150, 150, 3)       7         
_________________________________________________________________
xception (Functional)        (None, 5, 5, 2048)        20861480  
_________________________________________________________________
global_average_pooling2d_2 ( (None, 2048)              0         
_________________________________________________________________
dropout (Dropout)            (None, 2048)              0         
_________________________________________________________________
dense_16 (Dense)             (None, 1)                 2049      
=================================================================
Total params: 20,863,536
Trainable params: 2,049
Non-trainable params: 20,861,487
_________________________________________________________________

 

トップ層を訓練する

model.compile(
    optimizer=keras.optimizers.Adam(),
    loss=keras.losses.BinaryCrossentropy(from_logits=True),
    metrics=[keras.metrics.BinaryAccuracy()],
)

epochs = 20
model.fit(train_ds, epochs=epochs, validation_data=validation_ds)

Epoch 1/20
291/291 [==============================] - 26s 80ms/step - loss: 0.0948 - binary_accuracy: 0.9621 - val_loss: 0.0689 - val_binary_accuracy: 0.9738
Epoch 2/20
291/291 [==============================] - 22s 77ms/step - loss: 0.0891 - binary_accuracy: 0.9634 - val_loss: 0.0700 - val_binary_accuracy: 0.9746
Epoch 3/20
291/291 [==============================] - 22s 77ms/step - loss: 0.0850 - binary_accuracy: 0.9659 - val_loss: 0.0684 - val_binary_accuracy: 0.9751
Epoch 4/20
291/291 [==============================] - 23s 77ms/step - loss: 0.0860 - binary_accuracy: 0.9675 - val_loss: 0.0701 - val_binary_accuracy: 0.9738
Epoch 5/20
291/291 [==============================] - 23s 78ms/step - loss: 0.0955 - binary_accuracy: 0.9628 - val_loss: 0.0809 - val_binary_accuracy: 0.9678
Epoch 6/20
291/291 [==============================] - 23s 78ms/step - loss: 0.0942 - binary_accuracy: 0.9616 - val_loss: 0.0711 - val_binary_accuracy: 0.9742
Epoch 7/20
291/291 [==============================] - 23s 78ms/step - loss: 0.0962 - binary_accuracy: 0.9616 - val_loss: 0.0738 - val_binary_accuracy: 0.9716
Epoch 8/20
291/291 [==============================] - 22s 77ms/step - loss: 0.0858 - binary_accuracy: 0.9654 - val_loss: 0.0707 - val_binary_accuracy: 0.9716
Epoch 9/20
291/291 [==============================] - 23s 78ms/step - loss: 0.0940 - binary_accuracy: 0.9613 - val_loss: 0.0730 - val_binary_accuracy: 0.9703
Epoch 10/20
291/291 [==============================] - 23s 78ms/step - loss: 0.0944 - binary_accuracy: 0.9616 - val_loss: 0.0814 - val_binary_accuracy: 0.9699
Epoch 11/20
291/291 [==============================] - 23s 78ms/step - loss: 0.0937 - binary_accuracy: 0.9617 - val_loss: 0.0730 - val_binary_accuracy: 0.9699
Epoch 12/20
291/291 [==============================] - 23s 77ms/step - loss: 0.0907 - binary_accuracy: 0.9646 - val_loss: 0.0774 - val_binary_accuracy: 0.9690
Epoch 13/20
291/291 [==============================] - 23s 78ms/step - loss: 0.0974 - binary_accuracy: 0.9604 - val_loss: 0.0713 - val_binary_accuracy: 0.9742
Epoch 14/20
291/291 [==============================] - 23s 78ms/step - loss: 0.0921 - binary_accuracy: 0.9616 - val_loss: 0.0723 - val_binary_accuracy: 0.9725
Epoch 15/20
291/291 [==============================] - 23s 77ms/step - loss: 0.0910 - binary_accuracy: 0.9625 - val_loss: 0.0723 - val_binary_accuracy: 0.9712
Epoch 16/20
291/291 [==============================] - 23s 78ms/step - loss: 0.0953 - binary_accuracy: 0.9631 - val_loss: 0.0745 - val_binary_accuracy: 0.9721
Epoch 17/20
291/291 [==============================] - 23s 78ms/step - loss: 0.0865 - binary_accuracy: 0.9656 - val_loss: 0.0731 - val_binary_accuracy: 0.9733
Epoch 18/20
291/291 [==============================] - 23s 77ms/step - loss: 0.0833 - binary_accuracy: 0.9662 - val_loss: 0.0748 - val_binary_accuracy: 0.9725
Epoch 19/20
291/291 [==============================] - 23s 78ms/step - loss: 0.0974 - binary_accuracy: 0.9589 - val_loss: 0.0761 - val_binary_accuracy: 0.9708
Epoch 20/20
291/291 [==============================] - 22s 77ms/step - loss: 0.0990 - binary_accuracy: 0.9613 - val_loss: 0.0904 - val_binary_accuracy: 0.9686
CPU times: user 2min 17s, sys: 17.9 s, total: 2min 34s
Wall time: 7min 34s

 

モデル全体の再調整のラウンドを行なう

最後に、基底モデルを解凍してそしてモデル全体を低い学習率で end-to-end に訓練しましょう。

重要なことは、基底モデルは訓練可能になりますが、それは依然として推論モードで動作していることです、何故ならばモデルを構築するときにそれを呼び出すとき training=False を渡したからです。これは、バッチ正規化層内部ではバッチ統計値を更新しないことを意味しています。それらが行なうのであれば、それらはそこまでにモデルにより学習された表現上で大暴れします (= wreck havoc)。

# Unfreeze the base_model. Note that it keeps running in inference mode
# since we passed `training=False` when calling it. This means that
# the batchnorm layers will not update their batch statistics.
# This prevents the batchnorm layers from undoing all the training
# we've done so far.
base_model.trainable = True
model.summary()

model.compile(
    optimizer=keras.optimizers.Adam(1e-5),  # Low learning rate
    loss=keras.losses.BinaryCrossentropy(from_logits=True),
    metrics=[keras.metrics.BinaryAccuracy()],
)

epochs = 10
model.fit(train_ds, epochs=epochs, validation_data=validation_ds)

Model: "model_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_7 (InputLayer)         [(None, 150, 150, 3)]     0         
_________________________________________________________________
sequential_3 (Sequential)    (None, 150, 150, 3)       0         
_________________________________________________________________
normalization (Normalization (None, 150, 150, 3)       7         
_________________________________________________________________
xception (Functional)        (None, 5, 5, 2048)        20861480  
_________________________________________________________________
global_average_pooling2d_1 ( (None, 2048)              0         
_________________________________________________________________
dropout (Dropout)            (None, 2048)              0         
_________________________________________________________________
dense_8 (Dense)              (None, 1)                 2049      
=================================================================
Total params: 20,863,536
Trainable params: 20,809,001
Non-trainable params: 54,535
_________________________________________________________________
Epoch 1/10
291/291 [==============================] - 89s 291ms/step - loss: 0.0808 - binary_accuracy: 0.9661 - val_loss: 0.0584 - val_binary_accuracy: 0.9772
Epoch 2/10
291/291 [==============================] - 86s 296ms/step - loss: 0.0623 - binary_accuracy: 0.9777 - val_loss: 0.0530 - val_binary_accuracy: 0.9781
Epoch 3/10
291/291 [==============================] - 87s 298ms/step - loss: 0.0485 - binary_accuracy: 0.9806 - val_loss: 0.0469 - val_binary_accuracy: 0.9794
Epoch 4/10
291/291 [==============================] - 89s 304ms/step - loss: 0.0337 - binary_accuracy: 0.9874 - val_loss: 0.0445 - val_binary_accuracy: 0.9789
Epoch 5/10
291/291 [==============================] - 88s 303ms/step - loss: 0.0269 - binary_accuracy: 0.9875 - val_loss: 0.0414 - val_binary_accuracy: 0.9837
Epoch 6/10
291/291 [==============================] - 88s 303ms/step - loss: 0.0264 - binary_accuracy: 0.9909 - val_loss: 0.0482 - val_binary_accuracy: 0.9819
Epoch 7/10
291/291 [==============================] - 87s 301ms/step - loss: 0.0239 - binary_accuracy: 0.9918 - val_loss: 0.0431 - val_binary_accuracy: 0.9824
Epoch 8/10
291/291 [==============================] - 87s 301ms/step - loss: 0.0176 - binary_accuracy: 0.9925 - val_loss: 0.0445 - val_binary_accuracy: 0.9837
Epoch 9/10
291/291 [==============================] - 87s 300ms/step - loss: 0.0163 - binary_accuracy: 0.9942 - val_loss: 0.0454 - val_binary_accuracy: 0.9828
Epoch 10/10
291/291 [==============================] - 87s 300ms/step - loss: 0.0110 - binary_accuracy: 0.9962 - val_loss: 0.0428 - val_binary_accuracy: 0.9832
<tensorflow.python.keras.callbacks.History at 0x7fda3008a278>

以上

TensorFlow 2.4 : ガイド : Keras :- 貴方自身のコールバックを書く (翻訳/解説)

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

* 本ページは、TensorFlow org サイトの Guide – Keras の以下のページを翻訳した上で
適宜、補足説明したものです：

• Writing your own callbacks

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

 

 

ガイド : Keras :- 貴方自身のコールバックを書く

イントロダクション

コールバックは 訓練、評価や推論の間の Keras モデルの動作をカスタマイズするためのパワフルなツールです。サンプルは訓練進捗と結果が TensorBoard でエクスポートされて可視化できる tf.keras.callbacks.TensorBoard や、訓練の間にモデルを定期的にセーブする tf.keras.callbacks.ModelCheckpoint を含みます。

このガイドでは、Keras コールバックが何か、それは何ができるか、そして貴方自身のものをどのように構築できるかを学習します。貴方を始めさせるために単純なコールバック・アプリケーションの幾つかのデモを提供します。

 

セットアップ

import tensorflow as tf
from tensorflow import keras

 

Keras コールバック概要

総てのコールバックは keras.callbacks.Callback クラスをサブクラス化して、そして訓練、テストと予測の様々なステージで呼び出されるメソッドのセットを override します。コールバックは訓練の間のモデルの内部状態と統計上のビューを得るために有用です。

コールバックのリストを (キーワード引数 callbacks として) 以下のモデル・メソッドに渡すことができます :

• keras.Model.fit()
• keras.Model.evaluate()
• keras.Model.predict()

 

コールバック・メソッドの概要

グローバル・メソッド

on_(train|test|predict)_begin(self, logs=None)

fit/evaluate/predict の最初に呼び出されます。

on_(train|test|predict)_end(self, logs=None)

fit/evaluate/predict の最後に呼び出されます。

 

訓練/テスト/予測のためのバッチレベル・メソッド

on_(train|test|predict)_batch_begin(self, batch, logs=None)

訓練/テスト/予測の間のバッチを処理するすぐ前に呼び出されます。

on_(train|test|predict)_batch_end(self, batch, logs=None)

バッチを訓練/テスト/予測する最後に呼び出されます。このメソッド内では、logs はメトリクス結果を含む辞書です。

 

エポックレベル・メソッド (訓練 only)

on_epoch_begin(self, epoch, logs=None)

訓練の間にエポックの最初に呼び出されます。

on_epoch_end(self, epoch, logs=None)

訓練の間にエポックの最後に呼び出されます。

 

基本的なサンプル

具体的なサンプルを見ましょう。始めるために、tensorflow をインポートして単純な Sequential Keras モデルを定義しましょう :

# Define the Keras model to add callbacks to
def get_model():
    model = keras.Sequential()
    model.add(keras.layers.Dense(1, input_dim=784))
    model.compile(
        optimizer=keras.optimizers.RMSprop(learning_rate=0.1),
        loss="mean_squared_error",
        metrics=["mean_absolute_error"],
    )
    return model

それから訓練とテストのために Keras datasets API から MNIST データをロードします :

# Load example MNIST data and pre-process it
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train = x_train.reshape(-1, 784).astype("float32") / 255.0
x_test = x_test.reshape(-1, 784).astype("float32") / 255.0

# Limit the data to 1000 samples
x_train = x_train[:1000]
y_train = y_train[:1000]
x_test = x_test[:1000]
y_test = y_test[:1000]

今は、以下をログ出力する単純なカスタム・コールバックを定義します :

• fit/evaluate/predict の最初と最後
• 各エポックの最初 & 最後
• 各訓練バッチの最初 & 最後
• 各評価 (テスト) バッチの最初 & 最後
• 各推論 (予測) バッチの最初 & 最後

class CustomCallback(keras.callbacks.Callback):
    def on_train_begin(self, logs=None):
        keys = list(logs.keys())
        print("Starting training; got log keys: {}".format(keys))

    def on_train_end(self, logs=None):
        keys = list(logs.keys())
        print("Stop training; got log keys: {}".format(keys))

    def on_epoch_begin(self, epoch, logs=None):
        keys = list(logs.keys())
        print("Start epoch {} of training; got log keys: {}".format(epoch, keys))

    def on_epoch_end(self, epoch, logs=None):
        keys = list(logs.keys())
        print("End epoch {} of training; got log keys: {}".format(epoch, keys))

    def on_test_begin(self, logs=None):
        keys = list(logs.keys())
        print("Start testing; got log keys: {}".format(keys))

    def on_test_end(self, logs=None):
        keys = list(logs.keys())
        print("Stop testing; got log keys: {}".format(keys))

    def on_predict_begin(self, logs=None):
        keys = list(logs.keys())
        print("Start predicting; got log keys: {}".format(keys))

    def on_predict_end(self, logs=None):
        keys = list(logs.keys())
        print("Stop predicting; got log keys: {}".format(keys))

    def on_train_batch_begin(self, batch, logs=None):
        keys = list(logs.keys())
        print("...Training: start of batch {}; got log keys: {}".format(batch, keys))

    def on_train_batch_end(self, batch, logs=None):
        keys = list(logs.keys())
        print("...Training: end of batch {}; got log keys: {}".format(batch, keys))

    def on_test_batch_begin(self, batch, logs=None):
        keys = list(logs.keys())
        print("...Evaluating: start of batch {}; got log keys: {}".format(batch, keys))

    def on_test_batch_end(self, batch, logs=None):
        keys = list(logs.keys())
        print("...Evaluating: end of batch {}; got log keys: {}".format(batch, keys))

    def on_predict_batch_begin(self, batch, logs=None):
        keys = list(logs.keys())
        print("...Predicting: start of batch {}; got log keys: {}".format(batch, keys))

    def on_predict_batch_end(self, batch, logs=None):
        keys = list(logs.keys())
        print("...Predicting: end of batch {}; got log keys: {}".format(batch, keys))

Let’s try it out:

model = get_model()
model.fit(
    x_train,
    y_train,
    batch_size=128,
    epochs=1,
    verbose=0,
    validation_split=0.5,
    callbacks=[CustomCallback()],
)

res = model.evaluate(
    x_test, y_test, batch_size=128, verbose=0, callbacks=[CustomCallback()]
)

res = model.predict(x_test, batch_size=128, callbacks=[CustomCallback()])

Starting training; got log keys: []
Start epoch 0 of training; got log keys: []
...Training: start of batch 0; got log keys: []
...Training: end of batch 0; got log keys: ['loss', 'mean_absolute_error']
...Training: start of batch 1; got log keys: []
...Training: end of batch 1; got log keys: ['loss', 'mean_absolute_error']
...Training: start of batch 2; got log keys: []
...Training: end of batch 2; got log keys: ['loss', 'mean_absolute_error']
...Training: start of batch 3; got log keys: []
...Training: end of batch 3; got log keys: ['loss', 'mean_absolute_error']
Start testing; got log keys: []
...Evaluating: start of batch 0; got log keys: []
...Evaluating: end of batch 0; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 1; got log keys: []
...Evaluating: end of batch 1; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 2; got log keys: []
...Evaluating: end of batch 2; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 3; got log keys: []
...Evaluating: end of batch 3; got log keys: ['loss', 'mean_absolute_error']
Stop testing; got log keys: ['loss', 'mean_absolute_error']
End epoch 0 of training; got log keys: ['loss', 'mean_absolute_error', 'val_loss', 'val_mean_absolute_error']
Stop training; got log keys: ['loss', 'mean_absolute_error', 'val_loss', 'val_mean_absolute_error']
Start testing; got log keys: []
...Evaluating: start of batch 0; got log keys: []
...Evaluating: end of batch 0; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 1; got log keys: []
...Evaluating: end of batch 1; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 2; got log keys: []
...Evaluating: end of batch 2; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 3; got log keys: []
...Evaluating: end of batch 3; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 4; got log keys: []
...Evaluating: end of batch 4; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 5; got log keys: []
...Evaluating: end of batch 5; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 6; got log keys: []
...Evaluating: end of batch 6; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 7; got log keys: []
...Evaluating: end of batch 7; got log keys: ['loss', 'mean_absolute_error']
Stop testing; got log keys: ['loss', 'mean_absolute_error']
Start predicting; got log keys: []
...Predicting: start of batch 0; got log keys: []
...Predicting: end of batch 0; got log keys: ['outputs']
...Predicting: start of batch 1; got log keys: []
...Predicting: end of batch 1; got log keys: ['outputs']
...Predicting: start of batch 2; got log keys: []
...Predicting: end of batch 2; got log keys: ['outputs']
...Predicting: start of batch 3; got log keys: []
...Predicting: end of batch 3; got log keys: ['outputs']
...Predicting: start of batch 4; got log keys: []
...Predicting: end of batch 4; got log keys: ['outputs']
...Predicting: start of batch 5; got log keys: []
...Predicting: end of batch 5; got log keys: ['outputs']
...Predicting: start of batch 6; got log keys: []
...Predicting: end of batch 6; got log keys: ['outputs']
...Predicting: start of batch 7; got log keys: []
...Predicting: end of batch 7; got log keys: ['outputs']
Stop predicting; got log keys: []

 

logs 辞書の使用方法

logs 辞書はバッチかエポックの最後の損失値と総てのメトリックを含みます。サンプルは損失と平均絶対誤差 (MAE) を含みます。

class LossAndErrorPrintingCallback(keras.callbacks.Callback):
    def on_train_batch_end(self, batch, logs=None):
        print("For batch {}, loss is {:7.2f}.".format(batch, logs["loss"]))

    def on_test_batch_end(self, batch, logs=None):
        print("For batch {}, loss is {:7.2f}.".format(batch, logs["loss"]))

    def on_epoch_end(self, epoch, logs=None):
        print(
            "The average loss for epoch {} is {:7.2f} "
            "and mean absolute error is {:7.2f}.".format(
                epoch, logs["loss"], logs["mean_absolute_error"]
            )
        )


model = get_model()
model.fit(
    x_train,
    y_train,
    batch_size=128,
    epochs=2,
    verbose=0,
    callbacks=[LossAndErrorPrintingCallback()],
)

res = model.evaluate(
    x_test,
    y_test,
    batch_size=128,
    verbose=0,
    callbacks=[LossAndErrorPrintingCallback()],
)

For batch 0, loss is   28.35.
For batch 1, loss is  495.31.
For batch 2, loss is  338.58.
For batch 3, loss is  256.09.
For batch 4, loss is  206.61.
For batch 5, loss is  173.36.
For batch 6, loss is  149.41.
For batch 7, loss is  134.53.
The average loss for epoch 0 is  134.53 and mean absolute error is    6.17.
For batch 0, loss is    5.50.
For batch 1, loss is    5.29.
For batch 2, loss is    5.42.
For batch 3, loss is    5.37.
For batch 4, loss is    5.01.
For batch 5, loss is    4.77.
For batch 6, loss is    4.67.
For batch 7, loss is    4.74.
The average loss for epoch 1 is    4.74 and mean absolute error is    1.78.
For batch 0, loss is    5.57.
For batch 1, loss is    5.10.
For batch 2, loss is    5.00.
For batch 3, loss is    4.99.
For batch 4, loss is    5.14.
For batch 5, loss is    5.18.
For batch 6, loss is    5.13.
For batch 7, loss is    5.07.

 

self.model の使用方法

これらのメソッドの一つが呼び出されるとき、ログ情報を受け取ることに加えて、コールバックは訓練/評価/推論の現在のラウンドに関連するモデルへのアクセスを持ちます : self.model です。

コールバック内で self.model で行なうことができることの幾つかがあります :

• 訓練を直ちに中断するために self.model.stop_training = True を設定します。
• self.model.optimizer.learning_rate のような、(self.model.optimizer として利用可能な) optimizer のハイパーパラメータを変化させます。
• 定期的な間隔でモデルをセーブします。
• 訓練の間の正当性チェックとして使用するため、各エポックの最後で幾つかのテストサンプル上 model.predict() の出力を記録します。
• 時間につれてモデルが何を学習しているか監視するため、各エポックの最後に中間特徴の可視化を抽出します。
• 等々。

これを 2, 3 のサンプルで実際に見ましょう。

 

Keras コールバック・アプリケーションのサンプル

最小損失における Early Stopping

最初の例はコールバックの作成を示します、これは損失の最小に達したとき属性 self.model.stop_training (boolean) を設定することにより訓練を停止します。オプションで、ローカル最小に達した後で停止する前に幾つのエポックを待つべきかを指定するための引数 patience を貴方は提供できます。

tf.keras.callbacks.EarlyStopping はより完全で一般的な実装を提供します。

import numpy as np


class EarlyStoppingAtMinLoss(keras.callbacks.Callback):
    """Stop training when the loss is at its min, i.e. the loss stops decreasing.

  Arguments:
      patience: Number of epochs to wait after min has been hit. After this
      number of no improvement, training stops.
  """

    def __init__(self, patience=0):
        super(EarlyStoppingAtMinLoss, self).__init__()
        self.patience = patience
        # best_weights to store the weights at which the minimum loss occurs.
        self.best_weights = None

    def on_train_begin(self, logs=None):
        # The number of epoch it has waited when loss is no longer minimum.
        self.wait = 0
        # The epoch the training stops at.
        self.stopped_epoch = 0
        # Initialize the best as infinity.
        self.best = np.Inf

    def on_epoch_end(self, epoch, logs=None):
        current = logs.get("loss")
        if np.less(current, self.best):
            self.best = current
            self.wait = 0
            # Record the best weights if current results is better (less).
            self.best_weights = self.model.get_weights()
        else:
            self.wait += 1
            if self.wait >= self.patience:
                self.stopped_epoch = epoch
                self.model.stop_training = True
                print("Restoring model weights from the end of the best epoch.")
                self.model.set_weights(self.best_weights)

    def on_train_end(self, logs=None):
        if self.stopped_epoch > 0:
            print("Epoch %05d: early stopping" % (self.stopped_epoch + 1))


model = get_model()
model.fit(
    x_train,
    y_train,
    batch_size=64,
    steps_per_epoch=5,
    epochs=30,
    verbose=0,
    callbacks=[LossAndErrorPrintingCallback(), EarlyStoppingAtMinLoss()],
)

For batch 0, loss is   31.46.
For batch 1, loss is  431.85.
For batch 2, loss is  299.28.
For batch 3, loss is  227.94.
For batch 4, loss is  184.11.
The average loss for epoch 0 is  184.11 and mean absolute error is    8.47.
For batch 0, loss is    7.22.
For batch 1, loss is    6.92.
For batch 2, loss is    6.74.
For batch 3, loss is    6.27.
For batch 4, loss is    6.40.
The average loss for epoch 1 is    6.40 and mean absolute error is    2.04.
For batch 0, loss is    5.56.
For batch 1, loss is    6.04.
For batch 2, loss is    5.59.
For batch 3, loss is    5.10.
For batch 4, loss is    4.92.
The average loss for epoch 2 is    4.92 and mean absolute error is    1.79.
For batch 0, loss is    5.98.
For batch 1, loss is    4.58.
For batch 2, loss is    6.00.
For batch 3, loss is    8.78.
For batch 4, loss is   13.73.
The average loss for epoch 3 is   13.73 and mean absolute error is    2.96.
Restoring model weights from the end of the best epoch.
Epoch 00004: early stopping
<tensorflow.python.keras.callbacks.History at 0x7f77f173fe48>

 

学習率スケジューリング

この例では、カスタム・コールバックが訓練の過程において optimizer の学習率を動的に変更するためにどのように使用できるかを示しています。

より一般的な実装については callbacks.LearningRateScheduler を見てください。

class CustomLearningRateScheduler(keras.callbacks.Callback):
    """Learning rate scheduler which sets the learning rate according to schedule.

  Arguments:
      schedule: a function that takes an epoch index
          (integer, indexed from 0) and current learning rate
          as inputs and returns a new learning rate as output (float).
  """

    def __init__(self, schedule):
        super(CustomLearningRateScheduler, self).__init__()
        self.schedule = schedule

    def on_epoch_begin(self, epoch, logs=None):
        if not hasattr(self.model.optimizer, "lr"):
            raise ValueError('Optimizer must have a "lr" attribute.')
        # Get the current learning rate from model's optimizer.
        lr = float(tf.keras.backend.get_value(self.model.optimizer.learning_rate))
        # Call schedule function to get the scheduled learning rate.
        scheduled_lr = self.schedule(epoch, lr)
        # Set the value back to the optimizer before this epoch starts
        tf.keras.backend.set_value(self.model.optimizer.lr, scheduled_lr)
        print("\nEpoch %05d: Learning rate is %6.4f." % (epoch, scheduled_lr))


LR_SCHEDULE = [
    # (epoch to start, learning rate) tuples
    (3, 0.05),
    (6, 0.01),
    (9, 0.005),
    (12, 0.001),
]


def lr_schedule(epoch, lr):
    """Helper function to retrieve the scheduled learning rate based on epoch."""
    if epoch < LR_SCHEDULE[0][0] or epoch > LR_SCHEDULE[-1][0]:
        return lr
    for i in range(len(LR_SCHEDULE)):
        if epoch == LR_SCHEDULE[i][0]:
            return LR_SCHEDULE[i][1]
    return lr


model = get_model()
model.fit(
    x_train,
    y_train,
    batch_size=64,
    steps_per_epoch=5,
    epochs=15,
    verbose=0,
    callbacks=[
        LossAndErrorPrintingCallback(),
        CustomLearningRateScheduler(lr_schedule),
    ],
)

Epoch 00000: Learning rate is 0.1000.
For batch 0, loss is   32.28.
For batch 1, loss is  477.32.
For batch 2, loss is  327.87.
For batch 3, loss is  248.14.
For batch 4, loss is  199.64.
The average loss for epoch 0 is  199.64 and mean absolute error is    8.51.

Epoch 00001: Learning rate is 0.1000.
For batch 0, loss is    7.94.
For batch 1, loss is    6.56.
For batch 2, loss is    6.11.
For batch 3, loss is    5.98.
For batch 4, loss is    5.82.
The average loss for epoch 1 is    5.82 and mean absolute error is    1.97.

Epoch 00002: Learning rate is 0.1000.
For batch 0, loss is    5.04.
For batch 1, loss is    4.87.
For batch 2, loss is    5.04.
For batch 3, loss is    4.71.
For batch 4, loss is    4.68.
The average loss for epoch 2 is    4.68 and mean absolute error is    1.76.

Epoch 00003: Learning rate is 0.0500.
For batch 0, loss is    5.27.
For batch 1, loss is    4.22.
For batch 2, loss is    4.10.
For batch 3, loss is    4.00.
For batch 4, loss is    3.93.
The average loss for epoch 3 is    3.93 and mean absolute error is    1.59.

Epoch 00004: Learning rate is 0.0500.
For batch 0, loss is    3.29.
For batch 1, loss is    3.94.
For batch 2, loss is    3.96.
For batch 3, loss is    4.24.
For batch 4, loss is    4.32.
The average loss for epoch 4 is    4.32 and mean absolute error is    1.63.

Epoch 00005: Learning rate is 0.0500.
For batch 0, loss is    4.12.
For batch 1, loss is    4.32.
For batch 2, loss is    4.80.
For batch 3, loss is    5.20.
For batch 4, loss is    5.33.
The average loss for epoch 5 is    5.33 and mean absolute error is    1.84.

Epoch 00006: Learning rate is 0.0100.
For batch 0, loss is    5.05.
For batch 1, loss is    4.55.
For batch 2, loss is    3.81.
For batch 3, loss is    3.58.
For batch 4, loss is    3.53.
The average loss for epoch 6 is    3.53 and mean absolute error is    1.47.

Epoch 00007: Learning rate is 0.0100.
For batch 0, loss is    3.30.
For batch 1, loss is    4.03.
For batch 2, loss is    3.57.
For batch 3, loss is    3.48.
For batch 4, loss is    3.39.
The average loss for epoch 7 is    3.39 and mean absolute error is    1.45.

Epoch 00008: Learning rate is 0.0100.
For batch 0, loss is    2.76.
For batch 1, loss is    3.08.
For batch 2, loss is    2.95.
For batch 3, loss is    3.00.
For batch 4, loss is    3.16.
The average loss for epoch 8 is    3.16 and mean absolute error is    1.39.

Epoch 00009: Learning rate is 0.0050.
For batch 0, loss is    3.62.
For batch 1, loss is    4.01.
For batch 2, loss is    4.27.
For batch 3, loss is    3.95.
For batch 4, loss is    3.71.
The average loss for epoch 9 is    3.71 and mean absolute error is    1.48.

Epoch 00010: Learning rate is 0.0050.
For batch 0, loss is    3.41.
For batch 1, loss is    2.97.
For batch 2, loss is    2.78.
For batch 3, loss is    2.98.
For batch 4, loss is    3.01.
The average loss for epoch 10 is    3.01 and mean absolute error is    1.34.

Epoch 00011: Learning rate is 0.0050.
For batch 0, loss is    3.48.
For batch 1, loss is    3.39.
For batch 2, loss is    3.24.
For batch 3, loss is    3.20.
For batch 4, loss is    3.43.
The average loss for epoch 11 is    3.43 and mean absolute error is    1.44.

Epoch 00012: Learning rate is 0.0010.
For batch 0, loss is    3.49.
For batch 1, loss is    3.63.
For batch 2, loss is    3.23.
For batch 3, loss is    3.22.
For batch 4, loss is    3.19.
The average loss for epoch 12 is    3.19 and mean absolute error is    1.37.

Epoch 00013: Learning rate is 0.0010.
For batch 0, loss is    2.18.
For batch 1, loss is    2.91.
For batch 2, loss is    2.87.
For batch 3, loss is    3.00.
For batch 4, loss is    3.16.
The average loss for epoch 13 is    3.16 and mean absolute error is    1.34.

Epoch 00014: Learning rate is 0.0010.
For batch 0, loss is    2.55.
For batch 1, loss is    3.37.
For batch 2, loss is    3.27.
For batch 3, loss is    3.41.
For batch 4, loss is    3.29.
The average loss for epoch 14 is    3.29 and mean absolute error is    1.39.
<tensorflow.python.keras.callbacks.History at 0x7f77f1683b38>

 

組込み Keras コールバック

API doc を読むことにより既存の Keras コールバックを確実に調べてください。アプリケーションは CSV へのロギング、モデルのセーブ、TensorBoard 内の可視化、そしてそれ以上を含みます！

以上

TensorFlow 2.4 : ガイド : Keras :- Keras でマスキングとパディング (翻訳/解説)

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

* 本ページは、TensorFlow org サイトの Guide – Keras の以下のページを翻訳した上で
適宜、補足説明したものです：

• Masking and padding with Keras

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

 

 

ガイド : Keras :- Keras でマスキングとパディング

セットアップ

import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

 

イントロダクション

マスキング はシークエンス処理層に入力のある時間ステップは欠損していて、そのためにデータを処理するときにスキップされるべきであることを伝える方法です。

パディング はマスキングの特殊な形式で、そこではマスクされるステップはシークエンスの最初か最後です。パディングはシークエンスデータを連続するバッチにエンコードするための必要性に由来します : バッチの総てのシークエンスを与えられた標準的な長さにするためには、幾つかのシークエンスをパッドしたり切り詰める (= truncate) 必要あります。

Let’s take a close look.

 

シークエンス・データをパディング

シークエンス・データを処理するとき、個々のサンプルが異なる長さを持つことは非常に一般的です。次のサンプルを考えます (単語としてトークン化されたテキスト) :

[
  ["Hello", "world", "!"],
  ["How", "are", "you", "doing", "today"],
  ["The", "weather", "will", "be", "nice", "tomorrow"],
]

語彙検索の後、データは整数としてベクトル化されるかもしれません、例えば :

[
  [83, 91, 1, 645, 1253, 927],
  [73, 8, 3215, 55, 927],
  [71, 1331, 4231]
]

データはネストされたリストで、そこでは個々のサンプルはそれぞれ長さ 3, 5 と 6 を持ちます。深層学習モデルのための入力データは (この場合 e.g. (batch_size, 6, vocab_size) の shape の) 単一の tensorでなければならないので、最長の項目よりも短いサンプルはあるプレースホルダー値でパディングされる必要があります (代替的に、短いサンプルをパッドする前に長いサンプルを切る詰めるかもしれません)。

Keras は共通の長さに Python リストを切り詰めてパッドするユティリティ関数を提供します : tf.keras.preprocessing.sequence.pad_sequences です。

raw_inputs = [
    [711, 632, 71],
    [73, 8, 3215, 55, 927],
    [83, 91, 1, 645, 1253, 927],
]

# By default, this will pad using 0s; it is configurable via the
# "value" parameter.
# Note that you could "pre" padding (at the beginning) or
# "post" padding (at the end).
# We recommend using "post" padding when working with RNN layers
# (in order to be able to use the
# CuDNN implementation of the layers).
padded_inputs = tf.keras.preprocessing.sequence.pad_sequences(
    raw_inputs, padding="post"
)
print(padded_inputs)

[[ 711  632   71    0    0    0]
 [  73    8 3215   55  927    0]
 [  83   91    1  645 1253  927]]

 

マスキング

総てのサンプルが一様な (= uniform) 長さを持つ今、モデルはデータのある部分は実際にはパディングで無視されるべきであることを知らされなければなりません。そのメカニズムが マスキング です。

Keras モデルで入力マスクを導入するには 3 つの方法があります :

• keras.layers.Masking 層を追加する。
• keras.layers.Embedding 層を mask_zero=True で configure する。
• mask 引数を手動で渡します、この引数をサポートする層を呼び出すとき (e.g. RNN 層)。

 

マスク生成層 : Embedding と Masking

内部的には、これらの層はマスク tensor (shape (batch, sequence_length) の 2D tensor) を作成し、そしてそれを Masking か Embedding 層により返される tensor 出力に装着します。

embedding = layers.Embedding(input_dim=5000, output_dim=16, mask_zero=True)
masked_output = embedding(padded_inputs)

print(masked_output._keras_mask)

masking_layer = layers.Masking()
# Simulate the embedding lookup by expanding the 2D input to 3D,
# with embedding dimension of 10.
unmasked_embedding = tf.cast(
    tf.tile(tf.expand_dims(padded_inputs, axis=-1), [1, 1, 10]), tf.float32
)

masked_embedding = masking_layer(unmasked_embedding)
print(masked_embedding._keras_mask)

tf.Tensor(
[[ True  True  True False False False]
 [ True  True  True  True  True False]
 [ True  True  True  True  True  True]], shape=(3, 6), dtype=bool)
tf.Tensor(
[[ True  True  True False False False]
 [ True  True  True  True  True False]
 [ True  True  True  True  True  True]], shape=(3, 6), dtype=bool)

プリントされた結果から見れるように、マスクは shape (batch_size, sequence_length) を持つ 2D ブーリアン tensor で、そこでは各個々の False エントリは対応する時間ステップは処理の間無視されるべきであることを示します。

 

Functional API と Sequential API のマスク伝播

Functional API か Sequential API を使用するとき、Embedding か Masking 層により生成されたマスクはそれらを使用できる任意の層 (例えば、RNN 層) に対してネットワークを通して伝播されます。Keras は入力に対応するマスクを自動的に取得してそれをどのように使用するかを知る任意の層に渡します。

例えば、次の Sequential モデルでは、LSTM 層は自動的にマスクを受け取ります、それはそれがパッドされた値を無視することを意味します :

model = keras.Sequential(
    [layers.Embedding(input_dim=5000, output_dim=16, mask_zero=True), layers.LSTM(32),]
)

これはまた次の Functional API モデルにも当てはまります :

inputs = keras.Input(shape=(None,), dtype="int32")
x = layers.Embedding(input_dim=5000, output_dim=16, mask_zero=True)(inputs)
outputs = layers.LSTM(32)(x)

model = keras.Model(inputs, outputs)

 

マスク tensor を直接的に層に渡す

(LSTM 層のような) マスクを処理できる層は __call__ メソッドで mask 引数を持ちます。

一方で、マスクを生成する層 (e.g. Embedding) は呼び出せる compute_mask(input, previous_mask) メソッドを公開します。

こうして、マスク生成層の compute_mask() メソッドの出力をマスク消費層の __call__ メソッドに渡すことができます、このようにです :

class MyLayer(layers.Layer):
    def __init__(self, **kwargs):
        super(MyLayer, self).__init__(**kwargs)
        self.embedding = layers.Embedding(input_dim=5000, output_dim=16, mask_zero=True)
        self.lstm = layers.LSTM(32)

    def call(self, inputs):
        x = self.embedding(inputs)
        # Note that you could also prepare a `mask` tensor manually.
        # It only needs to be a boolean tensor
        # with the right shape, i.e. (batch_size, timesteps).
        mask = self.embedding.compute_mask(inputs)
        output = self.lstm(x, mask=mask)  # The layer will ignore the masked values
        return output


layer = MyLayer()
x = np.random.random((32, 10)) * 100
x = x.astype("int32")
layer(x)

<tf.Tensor: shape=(32, 32), dtype=float32, numpy=
array([[ 5.17572416e-03, -2.62944121e-03, -1.35105345e-02, ...,
        -4.60889516e-03,  5.47572691e-03,  4.72571421e-03],
       [ 1.64351589e-03, -4.22070269e-03, -5.25859464e-03, ...,
         2.60032900e-03,  1.49587099e-03, -4.24058782e-03],
       [-4.32722829e-03,  1.06376233e-02,  1.42529635e-02, ...,
         2.60018371e-03,  7.20684696e-03,  1.94990877e-02],
       ...,
       [ 4.70825378e-03, -1.18944524e-02, -1.36345504e-02, ...,
        -1.12335877e-02,  3.96840260e-05, -3.31538590e-03],
       [-1.87381962e-03,  4.51480271e-03, -1.13129790e-03, ...,
         4.01536841e-03,  1.47789170e-03,  7.81966280e-03],
       [-6.34184107e-03, -1.26939616e-03,  2.88227363e-03, ...,
        -4.33679670e-03, -6.08236482e-03, -4.22849880e-05]], dtype=float32)>

 

貴方のカスタム層でマスキングをサポートする

時に貴方は (Embedding のような) マスクを生成する層や、現在のマスクを変更する必要がある層を書く必要があるかもしれません。

例えば、時間次元上で連結する Concatenate 層のような、入力とは異なる時間次元を持つ tensor を生成する任意の層は現在のマスクを変更する必要があります、その結果下流の層はマスクされた時間ステップを正しく考慮に入れることができます。

これを行なうために、貴方の層は layer.compute_mask() メソッドを実装するべきです、これは入力と現在のマスクが与えられたとき新しいマスクを生成します。

ここに現在のマスクを変更する必要がある TemporalSplit 層のサンプルがあります。

class TemporalSplit(keras.layers.Layer):
    """Split the input tensor into 2 tensors along the time dimension."""

    def call(self, inputs):
        # Expect the input to be 3D and mask to be 2D, split the input tensor into 2
        # subtensors along the time axis (axis 1).
        return tf.split(inputs, 2, axis=1)

    def compute_mask(self, inputs, mask=None):
        # Also split the mask into 2 if it presents.
        if mask is None:
            return None
        return tf.split(mask, 2, axis=1)


first_half, second_half = TemporalSplit()(masked_embedding)
print(first_half._keras_mask)
print(second_half._keras_mask)

tf.Tensor(
[[ True  True  True]
 [ True  True  True]
 [ True  True  True]], shape=(3, 3), dtype=bool)
tf.Tensor(
[[False False False]
 [ True  True False]
 [ True  True  True]], shape=(3, 3), dtype=bool)

ここに入力値からマスクを生成できる CustomEmbedding 層のもう一つのサンプルがあります :

class CustomEmbedding(keras.layers.Layer):
    def __init__(self, input_dim, output_dim, mask_zero=False, **kwargs):
        super(CustomEmbedding, self).__init__(**kwargs)
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.mask_zero = mask_zero

    def build(self, input_shape):
        self.embeddings = self.add_weight(
            shape=(self.input_dim, self.output_dim),
            initializer="random_normal",
            dtype="float32",
        )

    def call(self, inputs):
        return tf.nn.embedding_lookup(self.embeddings, inputs)

    def compute_mask(self, inputs, mask=None):
        if not self.mask_zero:
            return None
        return tf.not_equal(inputs, 0)


layer = CustomEmbedding(10, 32, mask_zero=True)
x = np.random.random((3, 10)) * 9
x = x.astype("int32")

y = layer(x)
mask = layer.compute_mask(x)

print(mask)

tf.Tensor(
[[ True  True  True  True  True  True  True False  True  True]
 [ True  True False  True  True  True  True  True False  True]
 [False  True False  True False  True  True  True  True  True]], shape=(3, 10), dtype=bool)

 

互換な層上でマスク伝播にオプトインする

殆どの層は時間次元を変更しませんので、現在のマスクを変更する必要はありません。けれども、それらは依然として現在のマスクを、変更されないまま、次の層に 伝播 できることを望むかもしれません。これはオプトイン (= opt-in) 動作です。デフォルトでは、カスタム層は現在のマスクを壊します (何故ならばフレームワークはマスクの伝播が行なうに安全であるか識別する方法を持たないからです)。

時間次元を変更しないカスタム層を持つ場合、そしてそれに現在の入力マスクを伝播できることを望む場合、層コンストラクタで self.supports_masking = True を設定するべきです。この場合、compute_mask() のデフォルト動作は単に現在のマスクを通過することです。

ここにマスク伝播のためにホワイトリストに登録された層のサンプルがあります :

class MyActivation(keras.layers.Layer):
    def __init__(self, **kwargs):
        super(MyActivation, self).__init__(**kwargs)
        # Signal that the layer is safe for mask propagation
        self.supports_masking = True

    def call(self, inputs):
        return tf.nn.relu(inputs)

今では (Embedding のような) マスク生成層と (LSTM のような) マスク消費層を媒介するこのカスタム層を使用できて、そしてそれは一緒にマスクを渡します、その結果それはマスク消費層に到達します。

inputs = keras.Input(shape=(None,), dtype="int32")
x = layers.Embedding(input_dim=5000, output_dim=16, mask_zero=True)(inputs)
x = MyActivation()(x)  # Will pass the mask along
print("Mask found:", x._keras_mask)
outputs = layers.LSTM(32)(x)  # Will receive the mask

model = keras.Model(inputs, outputs)

Mask found: KerasTensor(type_spec=TensorSpec(shape=(None, None), dtype=tf.bool, name=None), name='Placeholder_1:0')

 

マスク情報を必要とする層を書く

いくつかの層はマスク消費者です : それらは call で mask 引数を受け取りそしてそれを特定の時間ステップをスキップするかどうかを決定するために使用します。

そのような層を書くために、単純に call シグネチャで mask=None 引数を追加できます。入力に関連するマスクはそれが利用可能なときにいつでも層に渡されます。

下の単純なサンプルがここにあります : 層は入力シークエンスの時間次元に渡り softmax を計算する一方で、マスクされた時間ステップは破棄します。

class TemporalSoftmax(keras.layers.Layer):
    def call(self, inputs, mask=None):
        broadcast_float_mask = tf.expand_dims(tf.cast(mask, "float32"), -1)
        inputs_exp = tf.exp(inputs) * broadcast_float_mask
        inputs_sum = tf.reduce_sum(inputs * broadcast_float_mask, axis=1, keepdims=True)
        return inputs_exp / inputs_sum


inputs = keras.Input(shape=(None,), dtype="int32")
x = layers.Embedding(input_dim=10, output_dim=32, mask_zero=True)(inputs)
x = layers.Dense(1)(x)
outputs = TemporalSoftmax()(x)

model = keras.Model(inputs, outputs)
y = model(np.random.randint(0, 10, size=(32, 100)), np.random.random((32, 100, 1)))

 

要点

それが Keras でマスキングについて知る必要があることの総てです。まとめると :

• 「マスキング」は層がシークエンス入力である時間ステップをいつスキップ/無視するかをどのように知ることができるかです。
• 幾つかの層はマスク生成者 (-generator) です : Embedding は (mask_zero=True の場合) 入力値からマスクを生成できて、Masking 層もそれができます。
• 幾つかの層はマスク消費者 (-consumer) です : それらは __call__ メソッドで mask 引数を公開します。これは RNN 層が当てはまります。
• Functional API と Sequential API では、マスク情報は自動的に伝播されます。
• スタンドアロンな方法で層を使用するとき、層に mask 引数を手動で渡すことができます。
• 現在のマスクを変更する層を容易に書くことができます、それは新しいマスクを生成するか、入力に関連するマスクを消費します。

以上

TensorFlow 2.0 : ガイド : Keras :- 訓練ループをスクラッチから書く (翻訳/解説)

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

* 本ページは、TensorFlow org サイトの Guide – Keras の以下のページを翻訳した上で
適宜、補足説明したものです：

• Writing a training loop from scratch

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

 

 

ガイド : Keras :- 訓練ループをスクラッチから書く

セットアップ

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np

 

イントロダクション

Keras はデフォルトの訓練と評価ループ、fit() と evaluate() を提供します、それらの使用方法はガイド 組込みメソッドで訓練と評価 でカバーされます。

(例えば、fit() を使用して GAN を訓練するために) fit() の便利さを依然として活用しながら貴方のモデルの学習アルゴリズムをカスタマイズすることを望む場合、Model クラスをサブクラス化して貴方自身の train_step() メソッドを実装できます、これは fit() の間に繰り返し呼び出されます。これはガイド Model.fit で起きることをカスタマイズする でカバーされます。

今は、訓練 & 評価に渡り非常に低位な制御を望む場合、貴方自身の訓練 & 評価ループをスクラッチから書くべきです。このガイドはこれについてです。

 

GradientTape を使用する : 最初の end-to-end サンプル

GradientTape スコープ内でのモデルの呼び出しは損失値に関する層の訓練可能な重みの勾配を取得することを可能にします。optimizer インスタンスを使用して、これらの変数 (これらは model.trainable_weights を使用して取得できます) を更新するためにこれらの勾配を使用できます。

単純な MNIST モデルを考えましょう :

inputs = keras.Input(shape=(784,), name="digits")
x1 = layers.Dense(64, activation="relu")(inputs)
x2 = layers.Dense(64, activation="relu")(x1)
outputs = layers.Dense(10, name="predictions")(x2)
model = keras.Model(inputs=inputs, outputs=outputs)

カスタム訓練ループでミニバッチ勾配を使用してそれを訓練しましょう。

最初に、optimizer、損失関数、そしてデータセットを必要とします :

# Instantiate an optimizer.
optimizer = keras.optimizers.SGD(learning_rate=1e-3)
# Instantiate a loss function.
loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)

# Prepare the training dataset.
batch_size = 64
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = np.reshape(x_train, (-1, 784))
x_test = np.reshape(x_test, (-1, 784))

# Reserve 10,000 samples for validation.
x_val = x_train[-10000:]
y_val = y_train[-10000:]
x_train = x_train[:-10000]
y_train = y_train[:-10000]

# Prepare the training dataset.
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(batch_size)

# Prepare the validation dataset.
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(batch_size)

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step

ここに私達の訓練ループがあります :

• エポックに渡り反復する for ループを開始します。
• 各エポックについて、データセットに渡り、バッチで反復する for ループを開始します。
• 各バッチについて、GradientTape() スコープを開始します。
• このスコープ内で、model (forward パス) を呼び出して損失を計算します。
• スコープの外で、損失に関するモデルの重みの勾配を取得します。
• 最後に、勾配に基づいてモデルの重みを更新するために optimizer を使用します。

epochs = 2
for epoch in range(epochs):
    print("\nStart of epoch %d" % (epoch,))

    # Iterate over the batches of the dataset.
    for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):

        # Open a GradientTape to record the operations run
        # during the forward pass, which enables auto-differentiation.
        with tf.GradientTape() as tape:

            # Run the forward pass of the layer.
            # The operations that the layer applies
            # to its inputs are going to be recorded
            # on the GradientTape.
            logits = model(x_batch_train, training=True)  # Logits for this minibatch

            # Compute the loss value for this minibatch.
            loss_value = loss_fn(y_batch_train, logits)

        # Use the gradient tape to automatically retrieve
        # the gradients of the trainable variables with respect to the loss.
        grads = tape.gradient(loss_value, model.trainable_weights)

        # Run one step of gradient descent by updating
        # the value of the variables to minimize the loss.
        optimizer.apply_gradients(zip(grads, model.trainable_weights))

        # Log every 200 batches.
        if step % 200 == 0:
            print(
                "Training loss (for one batch) at step %d: %.4f"
                % (step, float(loss_value))
            )
            print("Seen so far: %s samples" % ((step + 1) * 64))

Start of epoch 0
Training loss (for one batch) at step 0: 96.9620
Seen so far: 64 samples
Training loss (for one batch) at step 200: 1.8153
Seen so far: 12864 samples
Training loss (for one batch) at step 400: 1.1619
Seen so far: 25664 samples
Training loss (for one batch) at step 600: 1.1577
Seen so far: 38464 samples

Start of epoch 1
Training loss (for one batch) at step 0: 0.8497
Seen so far: 64 samples
Training loss (for one batch) at step 200: 0.6811
Seen so far: 12864 samples
Training loss (for one batch) at step 400: 1.0251
Seen so far: 25664 samples
Training loss (for one batch) at step 600: 0.6824
Seen so far: 38464 samples

 

メトリクスの低位処理

この基本的なループにメトリクス監視を追加しましょう。

スクラッチから書かれたそのような訓練ループで組込みメトリクス (or 貴方が書いたカスタムメトリクス) を容易に再利用できます。ここにフローがあります :

• ループの開始でメトリックをインスタンス化します。
• 各バッチ後に metric.update_state() を呼び出します。
• メトリックの現在の値を表示する必要があるとき metric.result() を呼び出します。
• メトリックの状態をクリアする必要があるとき (典型的にはエポックの最後) metric.reset_states() を呼び出します。

各エポックの最後に検証データ上 SparseCategoricalAccuracy を計算するためにこの知識を利用しましょう :

# Get model
inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = layers.Dense(10, name="predictions")(x)
model = keras.Model(inputs=inputs, outputs=outputs)

# Instantiate an optimizer to train the model.
optimizer = keras.optimizers.SGD(learning_rate=1e-3)
# Instantiate a loss function.
loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)

# Prepare the metrics.
train_acc_metric = keras.metrics.SparseCategoricalAccuracy()
val_acc_metric = keras.metrics.SparseCategoricalAccuracy()

ここに私達の訓練 & 評価ループがあります :

import time

epochs = 2
for epoch in range(epochs):
    print("\nStart of epoch %d" % (epoch,))
    start_time = time.time()

    # Iterate over the batches of the dataset.
    for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):
        with tf.GradientTape() as tape:
            logits = model(x_batch_train, training=True)
            loss_value = loss_fn(y_batch_train, logits)
        grads = tape.gradient(loss_value, model.trainable_weights)
        optimizer.apply_gradients(zip(grads, model.trainable_weights))

        # Update training metric.
        train_acc_metric.update_state(y_batch_train, logits)

        # Log every 200 batches.
        if step % 200 == 0:
            print(
                "Training loss (for one batch) at step %d: %.4f"
                % (step, float(loss_value))
            )
            print("Seen so far: %d samples" % ((step + 1) * 64))

    # Display metrics at the end of each epoch.
    train_acc = train_acc_metric.result()
    print("Training acc over epoch: %.4f" % (float(train_acc),))

    # Reset training metrics at the end of each epoch
    train_acc_metric.reset_states()

    # Run a validation loop at the end of each epoch.
    for x_batch_val, y_batch_val in val_dataset:
        val_logits = model(x_batch_val, training=False)
        # Update val metrics
        val_acc_metric.update_state(y_batch_val, val_logits)
    val_acc = val_acc_metric.result()
    val_acc_metric.reset_states()
    print("Validation acc: %.4f" % (float(val_acc),))
    print("Time taken: %.2fs" % (time.time() - start_time))

Start of epoch 0
Training loss (for one batch) at step 0: 112.9925
Seen so far: 64 samples
Training loss (for one batch) at step 200: 1.3940
Seen so far: 12864 samples
Training loss (for one batch) at step 400: 1.2486
Seen so far: 25664 samples
Training loss (for one batch) at step 600: 1.9907
Seen so far: 38464 samples
Training acc over epoch: 0.6960
Validation acc: 0.7993
Time taken: 5.56s

Start of epoch 1
Training loss (for one batch) at step 0: 0.5860
Seen so far: 64 samples
Training loss (for one batch) at step 200: 0.9344
Seen so far: 12864 samples
Training loss (for one batch) at step 400: 0.5471
Seen so far: 25664 samples
Training loss (for one batch) at step 600: 0.6339
Seen so far: 38464 samples
Training acc over epoch: 0.8266
Validation acc: 0.8626
Time taken: 5.49s

 

貴方の訓練ステップを tf.function でスピードアップする

TensorFlow 2.0 のデフォルトのランタイムは eager 実行 です。そのようなものとして、上の訓練ループは eagerly に実行されます。

これはデバッグのためには素晴らしいですが、グラフコンパイルは明らかなパフォーマンス優位を持ちます。貴方の計算を静的グラフとして記述することはフレームワークがグローバルなパフォーマンス最適化を適用することを有効にします。これはフレームワークが (次に何が来るかの知識なしに) 1 つの演算を他の 1 つの後に貪欲に実行するように制約されているときには不可能です。

入力として tensor を取る任意の関数を静的グラフにコンパイルできます。その上に @tf.function デコレータを単に追加します、このようにです :

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        logits = model(x, training=True)
        loss_value = loss_fn(y, logits)
    grads = tape.gradient(loss_value, model.trainable_weights)
    optimizer.apply_gradients(zip(grads, model.trainable_weights))
    train_acc_metric.update_state(y, logits)
    return loss_value

評価ステップでも同じことを行ないましょう :

@tf.function
def test_step(x, y):
    val_logits = model(x, training=False)
    val_acc_metric.update_state(y, val_logits)

今は、訓練ループをこのコンパイルされた訓練ステップで再実行しましょう :

import time

epochs = 2
for epoch in range(epochs):
    print("\nStart of epoch %d" % (epoch,))
    start_time = time.time()

    # Iterate over the batches of the dataset.
    for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):
        loss_value = train_step(x_batch_train, y_batch_train)

        # Log every 200 batches.
        if step % 200 == 0:
            print(
                "Training loss (for one batch) at step %d: %.4f"
                % (step, float(loss_value))
            )
            print("Seen so far: %d samples" % ((step + 1) * 64))

    # Display metrics at the end of each epoch.
    train_acc = train_acc_metric.result()
    print("Training acc over epoch: %.4f" % (float(train_acc),))

    # Reset training metrics at the end of each epoch
    train_acc_metric.reset_states()

    # Run a validation loop at the end of each epoch.
    for x_batch_val, y_batch_val in val_dataset:
        test_step(x_batch_val, y_batch_val)

    val_acc = val_acc_metric.result()
    val_acc_metric.reset_states()
    print("Validation acc: %.4f" % (float(val_acc),))
    print("Time taken: %.2fs" % (time.time() - start_time))

Start of epoch 0
Training loss (for one batch) at step 0: 0.8467
Seen so far: 64 samples
Training loss (for one batch) at step 200: 0.4002
Seen so far: 12864 samples
Training loss (for one batch) at step 400: 0.7801
Seen so far: 25664 samples
Training loss (for one batch) at step 600: 0.3799
Seen so far: 38464 samples
Training acc over epoch: 0.8683
Validation acc: 0.8857
Time taken: 1.38s

Start of epoch 1
Training loss (for one batch) at step 0: 0.7573
Seen so far: 64 samples
Training loss (for one batch) at step 200: 0.3093
Seen so far: 12864 samples
Training loss (for one batch) at step 400: 0.3223
Seen so far: 25664 samples
Training loss (for one batch) at step 600: 0.7105
Seen so far: 38464 samples
Training acc over epoch: 0.8869
Validation acc: 0.8948
Time taken: 1.03s

Much faster, isn’t it?

 

モデルにより追跡される損失の低位処理

層 & モデルは self.add_loss(value) を呼び出す層により forward パスの間に作成された任意の損失を再帰的に追跡します。スカラー損失値の結果としてのリストは forward パスの最後にプロパティ model.losses を通して利用可能です。

これらの損失成分を使用することを望む場合、訓練ステップ内でそれらを合計してそれらを主要損失に追加するべきです。

この層を考えます、これは activity 正則化損失を作成します :

class ActivityRegularizationLayer(layers.Layer):
    def call(self, inputs):
        self.add_loss(1e-2 * tf.reduce_sum(inputs))
        return inputs

それを使用する実際に単純なモデルを構築しましょう :

inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu")(inputs)
# Insert activity regularization as a layer
x = ActivityRegularizationLayer()(x)
x = layers.Dense(64, activation="relu")(x)
outputs = layers.Dense(10, name="predictions")(x)

model = keras.Model(inputs=inputs, outputs=outputs)

ここに今は訓練ステップがどのように見えるべきかがあります :

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        logits = model(x, training=True)
        loss_value = loss_fn(y, logits)
        # Add any extra losses created during the forward pass.
        loss_value += sum(model.losses)
    grads = tape.gradient(loss_value, model.trainable_weights)
    optimizer.apply_gradients(zip(grads, model.trainable_weights))
    train_acc_metric.update_state(y, logits)
    return loss_value

 

要約

今では組込み訓練ループを使用することと貴方自身のものをスクラッチから書くことについて知るべき (存在する) 総てのことを貴方は知っています。

結論として、ここに単純な end-to-end サンプルがあります、これはこのガイドで学習した総てを一緒に結び付けています : MNIST 数字上で訓練された DCGAN です。

 

End-to-end サンプル : スクラッチからの GAN 訓練ループ

貴方は敵対的生成ネットワーク (GAN, Generative Adversarial Networks) に馴染みがあるかもしれません。GAN は画像の訓練データセットの潜在的分布を学習することにより (画像の「潜在的空間 (= latent space)」)、殆どリアルに見える新しい画像を生成できます。

GAN は 2 つのパートから成ります : “generator” モデル、これは潜在的空間のポイントを画像空間のポイントにマップし、そして “discrimintor” モデル、分類器は (訓練データセットからの) リアル画像と (generator ネットワークの出力) フェイク画像の間の違いを識別できます。

GAN 訓練はこのようなものです :

1) discriminator を訓練する。- 潜在的空間のランダムポイントのバッチをサンプリングします。- ポイントを “generator” モデルを通してフェイク画像に変えます。- リアル画像のバッチを得てそれらを生成された画像と結合します。- 生成された (画像) vs. リアル画像を分類するために “discriminator” モデルを訓練します。

2) generator を訓練する。- 潜在的空間のランダムポイントをサンプリングします。- ポイントを “generator” ネットワークを通してフェイク画像に変えます。- リアル画像のバッチを得てそれらを生成された画像と結合します。- discriminator を「騙して (= fool)」そしてフェイク画像をリアルとして分類するように “generator” モデルを訓練します。

GAN がどのように動作するかの遥かに詳細な概要については、Deep Learning with Python を見てください。

この訓練ループを実装しましょう。最初に、フェイク vs リアル数字を分類することを意図した discriminator を作成します :

discriminator = keras.Sequential(
    [
        keras.Input(shape=(28, 28, 1)),
        layers.Conv2D(64, (3, 3), strides=(2, 2), padding="same"),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(128, (3, 3), strides=(2, 2), padding="same"),
        layers.LeakyReLU(alpha=0.2),
        layers.GlobalMaxPooling2D(),
        layers.Dense(1),
    ],
    name="discriminator",
)
discriminator.summary()

Model: "discriminator"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 14, 14, 64)        640       
_________________________________________________________________
leaky_re_lu (LeakyReLU)      (None, 14, 14, 64)        0         
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 7, 7, 128)         73856     
_________________________________________________________________
leaky_re_lu_1 (LeakyReLU)    (None, 7, 7, 128)         0         
_________________________________________________________________
global_max_pooling2d (Global (None, 128)               0         
_________________________________________________________________
dense_4 (Dense)              (None, 1)                 129       
=================================================================
Total params: 74,625
Trainable params: 74,625
Non-trainable params: 0
_________________________________________________________________

そして generator ネットワークを生成しましょう、それは潜在ベクトルを (MNIST 数字を表す) shape (28, 28, 1) の出力に変えます :

latent_dim = 128

generator = keras.Sequential(
    [
        keras.Input(shape=(latent_dim,)),
        # We want to generate 128 coefficients to reshape into a 7x7x128 map
        layers.Dense(7 * 7 * 128),
        layers.LeakyReLU(alpha=0.2),
        layers.Reshape((7, 7, 128)),
        layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding="same"),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding="same"),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(1, (7, 7), padding="same", activation="sigmoid"),
    ],
    name="generator",
)

ここにキービット (= key bit) があります : 訓練ループです。見れるようにそれは非常に簡単です。訓練ステップ関数は 17 行だけを取ります。

# Instantiate one optimizer for the discriminator and another for the generator.
d_optimizer = keras.optimizers.Adam(learning_rate=0.0003)
g_optimizer = keras.optimizers.Adam(learning_rate=0.0004)

# Instantiate a loss function.
loss_fn = keras.losses.BinaryCrossentropy(from_logits=True)


@tf.function
def train_step(real_images):
    # Sample random points in the latent space
    random_latent_vectors = tf.random.normal(shape=(batch_size, latent_dim))
    # Decode them to fake images
    generated_images = generator(random_latent_vectors)
    # Combine them with real images
    combined_images = tf.concat([generated_images, real_images], axis=0)

    # Assemble labels discriminating real from fake images
    labels = tf.concat(
        [tf.ones((batch_size, 1)), tf.zeros((real_images.shape[0], 1))], axis=0
    )
    # Add random noise to the labels - important trick!
    labels += 0.05 * tf.random.uniform(labels.shape)

    # Train the discriminator
    with tf.GradientTape() as tape:
        predictions = discriminator(combined_images)
        d_loss = loss_fn(labels, predictions)
    grads = tape.gradient(d_loss, discriminator.trainable_weights)
    d_optimizer.apply_gradients(zip(grads, discriminator.trainable_weights))

    # Sample random points in the latent space
    random_latent_vectors = tf.random.normal(shape=(batch_size, latent_dim))
    # Assemble labels that say "all real images"
    misleading_labels = tf.zeros((batch_size, 1))

    # Train the generator (note that we should *not* update the weights
    # of the discriminator)!
    with tf.GradientTape() as tape:
        predictions = discriminator(generator(random_latent_vectors))
        g_loss = loss_fn(misleading_labels, predictions)
    grads = tape.gradient(g_loss, generator.trainable_weights)
    g_optimizer.apply_gradients(zip(grads, generator.trainable_weights))
    return d_loss, g_loss, generated_images

画像のバッチ上で train_step を繰り返し呼び出すことにより、私達の GAN を訓練しましょう。discriminator と generator は convnet (畳込みネットワーク) ですので、このコードを GPU 上で実行することを望むはずです。

import os

# Prepare the dataset. We use both the training & test MNIST digits.
batch_size = 64
(x_train, _), (x_test, _) = keras.datasets.mnist.load_data()
all_digits = np.concatenate([x_train, x_test])
all_digits = all_digits.astype("float32") / 255.0
all_digits = np.reshape(all_digits, (-1, 28, 28, 1))
dataset = tf.data.Dataset.from_tensor_slices(all_digits)
dataset = dataset.shuffle(buffer_size=1024).batch(batch_size)

epochs = 1  # In practice you need at least 20 epochs to generate nice digits.
save_dir = "./"

for epoch in range(epochs):
    print("\nStart epoch", epoch)

    for step, real_images in enumerate(dataset):
        # Train the discriminator & generator on one batch of real images.
        d_loss, g_loss, generated_images = train_step(real_images)

        # Logging.
        if step % 200 == 0:
            # Print metrics
            print("discriminator loss at step %d: %.2f" % (step, d_loss))
            print("adversarial loss at step %d: %.2f" % (step, g_loss))

            # Save one generated image
            img = tf.keras.preprocessing.image.array_to_img(
                generated_images[0] * 255.0, scale=False
            )
            img.save(os.path.join(save_dir, "generated_img" + str(step) + ".png"))

        # To limit execution time we stop after 10 steps.
        # Remove the lines below to actually train the model!
        if step > 10:
            break

Start epoch 0
discriminator loss at step 0: 0.70
adversarial loss at step 0: 0.68

That’s it! Colab GPU 上で単なる ~30s の訓練後に見栄えの良いフェイク MNIST 数字を得るでしょう。

以上

TensorFlow 2.0 : ガイド : Keras :- Model.fit で起きることをカスタマイズする (翻訳/解説)

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

* 本ページは、TensorFlow org サイトの Guide – Keras の以下のページを翻訳した上で
適宜、補足説明したものです：

• Customize what happens in Model.fit

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

 

 

ガイド : Keras :- Model.fit で起きることをカスタマイズする

イントロダクション

教師あり学習を行なっているとき、fit() を使用できて総てがスムースに動作します。

貴方自身の訓練ループをスクラッチから書く必要があるとき、GradientTape を利用して総ての小さな詳細を制御できます。

しかしカスタム訓練アルゴリズムを必要としながら、コールバック、組込みの分散サポート、あるはステップ融合 (= fusing) のような fit() の便利な特徴から依然として恩恵を受けることを望む場合にはどうでしょう？

Keras の中心的な原理は 複雑さの進歩的な (= progressive) 公開 です。貴方は低位ワークフローに漸進的に進むことができるはずです。高位機能が貴方のユースケースに正確には適合しない場合、崖から落ちるべきではありません。高位の同等の便利さを維持しながら詳細に渡る制御を得ることができるはずです。

fit() が行なうことをカスタマイズする必要があるとき、Model クラスの訓練ステップ関数を override する べきです。これはデータの総てのバッチのために fit() により呼び出される関数です。それから通常のように fit() を呼び出すことができます — そしてそれは貴方自身の学習アルゴリズムを実行しているでしょう。

このパターンはモデルを Functional API で構築することを妨げないことに注意してください。貴方がシーケンシャル・モデル、Functional API モデル、あるいはサブクラス化モデルを構築していようが、これを行なうことができます。

それがどのように動作するか見ましょう。

 

セットアップ

TensorFlow 2.2 かそれ以後を必要とします。

import tensorflow as tf
from tensorflow import keras

 

最初の単純なサンプル

単純なサンプルから始めましょう :

• keras.Model をサブクラス化する新しいクラスを作成します。
• メソッド train_step(self, data) を単に override します。
• (損失を含む) メトリック名をそれらの現在の値にマップする辞書を返します。

入力引数 data は訓練データとして fit に渡されるものです :

• fit(x, y, …) を呼び出すことにより、Numpy 配列を渡す場合には、データはタプル (x, y) です。
• fit(dataset, …) を呼び出すことにより、tf.data.Dataset を渡す場合には、データは各バッチでデータセットにより yield されるものになります。

train_step メソッドの本体で、既に馴染みがあるものに類似した通常の訓練更新を実装します。重要なことは、self.compiled_loss を通して損失を計算する ことです、これは compile() に渡された損失関数をラップします。

同様に、compile() に渡されたメトリクスの状態を更新するために self.compiled_metrics.update_state(y, y_pred) を呼び出し、そしてそれらの現在の値を取得するために最後に self.metrics からの結果を問い合わせます。

class CustomModel(keras.Model):
    def train_step(self, data):
        # Unpack the data. Its structure depends on your model and
        # on what you pass to `fit()`.
        x, y = data

        with tf.GradientTape() as tape:
            y_pred = self(x, training=True)  # Forward pass
            # Compute the loss value
            # (the loss function is configured in `compile()`)
            loss = self.compiled_loss(y, y_pred, regularization_losses=self.losses)

        # Compute gradients
        trainable_vars = self.trainable_variables
        gradients = tape.gradient(loss, trainable_vars)
        # Update weights
        self.optimizer.apply_gradients(zip(gradients, trainable_vars))
        # Update metrics (includes the metric that tracks the loss)
        self.compiled_metrics.update_state(y, y_pred)
        # Return a dict mapping metric names to current value
        return {m.name: m.result() for m in self.metrics}

Let’s try this out:

import numpy as np

# Construct and compile an instance of CustomModel
inputs = keras.Input(shape=(32,))
outputs = keras.layers.Dense(1)(inputs)
model = CustomModel(inputs, outputs)
model.compile(optimizer="adam", loss="mse", metrics=["mae"])

# Just use `fit` as usual
x = np.random.random((1000, 32))
y = np.random.random((1000, 1))
model.fit(x, y, epochs=3)

Epoch 1/3
32/32 [==============================] - 1s 1ms/step - loss: 0.4041 - mae: 0.5120
Epoch 2/3
32/32 [==============================] - 0s 958us/step - loss: 0.2610 - mae: 0.4111
Epoch 3/3
32/32 [==============================] - 0s 914us/step - loss: 0.2933 - mae: 0.4311
<tensorflow.python.keras.callbacks.History at 0x7f1e109407b8>

 

低位に進む

自然に、compile() で損失関数を渡すことを単にスキップし、そして代わりに train_step で手動で総てを行なうことができるでしょう。メトリクスのためのようにです。

ここに低位サンプルがあります、それは optimizer を configure するために compile() を使用するだけです :

• 損失と MAE スコアを追跡するために Metric インスタンスを作成することから始めます。
• (update_state() を呼び出して) これらのメトリクスの状態を更新するカスタム train_step() を実装してから、進捗バーにより表示されて任意のコールバックに渡される (result() を通して) 現在の平均値を返すようにそれらに問い合わせます。
• 各エポック間でメトリクス上 reset_states() を呼び出す必要があることに注意してください！そうでなければ result() は訓練の開始からの平均を返すでしょう、その一方で通常はエポック毎平均で作業します。ありがたいことに、フレームワークはそれを私達のために行なうことができます : モデルの metrics プロパティでリセットすることを望む任意のメトリックを単にリストします。モデルは、各 fit() エポックの最初か evaluate() への呼び出しの最初にここでリストされた任意のオブジェクト上で reset_states を呼び出します。

loss_tracker = keras.metrics.Mean(name="loss")
mae_metric = keras.metrics.MeanAbsoluteError(name="mae")


class CustomModel(keras.Model):
    def train_step(self, data):
        x, y = data

        with tf.GradientTape() as tape:
            y_pred = self(x, training=True)  # Forward pass
            # Compute our own loss
            loss = keras.losses.mean_squared_error(y, y_pred)

        # Compute gradients
        trainable_vars = self.trainable_variables
        gradients = tape.gradient(loss, trainable_vars)

        # Update weights
        self.optimizer.apply_gradients(zip(gradients, trainable_vars))

        # Compute our own metrics
        loss_tracker.update_state(loss)
        mae_metric.update_state(y, y_pred)
        return {"loss": loss_tracker.result(), "mae": mae_metric.result()}

    @property
    def metrics(self):
        # We list our `Metric` objects here so that `reset_states()` can be
        # called automatically at the start of each epoch
        # or at the start of `evaluate()`.
        # If you don't implement this property, you have to call
        # `reset_states()` yourself at the time of your choosing.
        return [loss_tracker, mae_metric]


# Construct an instance of CustomModel
inputs = keras.Input(shape=(32,))
outputs = keras.layers.Dense(1)(inputs)
model = CustomModel(inputs, outputs)

# We don't passs a loss or metrics here.
model.compile(optimizer="adam")

# Just use `fit` as usual -- you can use callbacks, etc.
x = np.random.random((1000, 32))
y = np.random.random((1000, 1))
model.fit(x, y, epochs=5)

Epoch 1/5
32/32 [==============================] - 0s 992us/step - loss: 0.3279 - mae: 0.4593
Epoch 2/5
32/32 [==============================] - 0s 876us/step - loss: 0.2278 - mae: 0.3866
Epoch 3/5
32/32 [==============================] - 0s 899us/step - loss: 0.2207 - mae: 0.3808
Epoch 4/5
32/32 [==============================] - 0s 969us/step - loss: 0.2131 - mae: 0.3746
Epoch 5/5
32/32 [==============================] - 0s 978us/step - loss: 0.2058 - mae: 0.3681

 

sample_weight & class_weight をサポートする

最初の基本的なサンプルはサンプル重み付けにどのような言及もしていないことに気付いたかもしれません。fit() 引数 sample_weight と class_weight をサポートすることを望む場合、単純に以下を行なうでしょう :

• data 引数から sample_weight をアンパックする
• それを compiled_loss & compiled_metrics に渡す (もちろん、損失 & メトリクスのために compile() に依拠しない場合、単にそれを手動で適用することもできるでしょう)
• That’s it. That’s the list.

class CustomModel(keras.Model):
    def train_step(self, data):
        # Unpack the data. Its structure depends on your model and
        # on what you pass to `fit()`.
        if len(data) == 3:
            x, y, sample_weight = data
        else:
            x, y = data

        with tf.GradientTape() as tape:
            y_pred = self(x, training=True)  # Forward pass
            # Compute the loss value.
            # The loss function is configured in `compile()`.
            loss = self.compiled_loss(
                y,
                y_pred,
                sample_weight=sample_weight,
                regularization_losses=self.losses,
            )

        # Compute gradients
        trainable_vars = self.trainable_variables
        gradients = tape.gradient(loss, trainable_vars)

        # Update weights
        self.optimizer.apply_gradients(zip(gradients, trainable_vars))

        # Update the metrics.
        # Metrics are configured in `compile()`.
        self.compiled_metrics.update_state(y, y_pred, sample_weight=sample_weight)

        # Return a dict mapping metric names to current value.
        # Note that it will include the loss (tracked in self.metrics).
        return {m.name: m.result() for m in self.metrics}


# Construct and compile an instance of CustomModel
inputs = keras.Input(shape=(32,))
outputs = keras.layers.Dense(1)(inputs)
model = CustomModel(inputs, outputs)
model.compile(optimizer="adam", loss="mse", metrics=["mae"])

# You can now use sample_weight argument
x = np.random.random((1000, 32))
y = np.random.random((1000, 1))
sw = np.random.random((1000, 1))
model.fit(x, y, sample_weight=sw, epochs=3)

Epoch 1/3
32/32 [==============================] - 0s 1ms/step - loss: 1.1263 - mae: 1.3582
Epoch 2/3
32/32 [==============================] - 0s 973us/step - loss: 0.5116 - mae: 0.8744
Epoch 3/3
32/32 [==============================] - 0s 902us/step - loss: 0.2700 - mae: 0.5867
<tensorflow.python.keras.callbacks.History at 0x7f1e0c8ce3c8>

 

貴方自身の評価ステップを提供する

model.evaluate() への呼び出しのために同じことを行なうことを望むとすればどうでしょう？それならば正確に同じ方法で test_step を override するでしょう。ここにそれがどのように見えるかがあります :

class CustomModel(keras.Model):
    def test_step(self, data):
        # Unpack the data
        x, y = data
        # Compute predictions
        y_pred = self(x, training=False)
        # Updates the metrics tracking the loss
        self.compiled_loss(y, y_pred, regularization_losses=self.losses)
        # Update the metrics.
        self.compiled_metrics.update_state(y, y_pred)
        # Return a dict mapping metric names to current value.
        # Note that it will include the loss (tracked in self.metrics).
        return {m.name: m.result() for m in self.metrics}


# Construct an instance of CustomModel
inputs = keras.Input(shape=(32,))
outputs = keras.layers.Dense(1)(inputs)
model = CustomModel(inputs, outputs)
model.compile(loss="mse", metrics=["mae"])

# Evaluate with our custom test_step
x = np.random.random((1000, 32))
y = np.random.random((1000, 1))
model.evaluate(x, y)

32/32 [==============================] - 0s 857us/step - loss: 0.4283 - mae: 0.5305
[0.41645824909210205, 0.5266892313957214]

 

仕上げる : end-to-end GAN サンプル

貴方が丁度学習した総てを活用する end-to-end サンプルをウォークスルーしましょう。

以下を考えましょう :

• 28x28x1 画像を生成することを意図した generator ネットワーク。
• 28x28x1 画像を 2 つのクラス (“fake” と “real”) に分類することを意図した discriminator ネットワーク。
• 各々に 1 つの optimizer。
• discriminator を訓練するための損失関数。

from tensorflow.keras import layers

# Create the discriminator
discriminator = keras.Sequential(
    [
        keras.Input(shape=(28, 28, 1)),
        layers.Conv2D(64, (3, 3), strides=(2, 2), padding="same"),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(128, (3, 3), strides=(2, 2), padding="same"),
        layers.LeakyReLU(alpha=0.2),
        layers.GlobalMaxPooling2D(),
        layers.Dense(1),
    ],
    name="discriminator",
)

# Create the generator
latent_dim = 128
generator = keras.Sequential(
    [
        keras.Input(shape=(latent_dim,)),
        # We want to generate 128 coefficients to reshape into a 7x7x128 map
        layers.Dense(7 * 7 * 128),
        layers.LeakyReLU(alpha=0.2),
        layers.Reshape((7, 7, 128)),
        layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding="same"),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding="same"),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(1, (7, 7), padding="same", activation="sigmoid"),
    ],
    name="generator",
)

ここに機能完全な GAN クラスがあります、それ自身のシグネチャを使用するために compile() を override し、そして train_step の 17 行で GAN アルゴリズム全体を実装しています :

class GAN(keras.Model):
    def __init__(self, discriminator, generator, latent_dim):
        super(GAN, self).__init__()
        self.discriminator = discriminator
        self.generator = generator
        self.latent_dim = latent_dim

    def compile(self, d_optimizer, g_optimizer, loss_fn):
        super(GAN, self).compile()
        self.d_optimizer = d_optimizer
        self.g_optimizer = g_optimizer
        self.loss_fn = loss_fn

    def train_step(self, real_images):
        if isinstance(real_images, tuple):
            real_images = real_images[0]
        # Sample random points in the latent space
        batch_size = tf.shape(real_images)[0]
        random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim))

        # Decode them to fake images
        generated_images = self.generator(random_latent_vectors)

        # Combine them with real images
        combined_images = tf.concat([generated_images, real_images], axis=0)

        # Assemble labels discriminating real from fake images
        labels = tf.concat(
            [tf.ones((batch_size, 1)), tf.zeros((batch_size, 1))], axis=0
        )
        # Add random noise to the labels - important trick!
        labels += 0.05 * tf.random.uniform(tf.shape(labels))

        # Train the discriminator
        with tf.GradientTape() as tape:
            predictions = self.discriminator(combined_images)
            d_loss = self.loss_fn(labels, predictions)
        grads = tape.gradient(d_loss, self.discriminator.trainable_weights)
        self.d_optimizer.apply_gradients(
            zip(grads, self.discriminator.trainable_weights)
        )

        # Sample random points in the latent space
        random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim))

        # Assemble labels that say "all real images"
        misleading_labels = tf.zeros((batch_size, 1))

        # Train the generator (note that we should *not* update the weights
        # of the discriminator)!
        with tf.GradientTape() as tape:
            predictions = self.discriminator(self.generator(random_latent_vectors))
            g_loss = self.loss_fn(misleading_labels, predictions)
        grads = tape.gradient(g_loss, self.generator.trainable_weights)
        self.g_optimizer.apply_gradients(zip(grads, self.generator.trainable_weights))
        return {"d_loss": d_loss, "g_loss": g_loss}

それを試運転しましょう :

# Prepare the dataset. We use both the training & test MNIST digits.
batch_size = 64
(x_train, _), (x_test, _) = keras.datasets.mnist.load_data()
all_digits = np.concatenate([x_train, x_test])
all_digits = all_digits.astype("float32") / 255.0
all_digits = np.reshape(all_digits, (-1, 28, 28, 1))
dataset = tf.data.Dataset.from_tensor_slices(all_digits)
dataset = dataset.shuffle(buffer_size=1024).batch(batch_size)

gan = GAN(discriminator=discriminator, generator=generator, latent_dim=latent_dim)
gan.compile(
    d_optimizer=keras.optimizers.Adam(learning_rate=0.0003),
    g_optimizer=keras.optimizers.Adam(learning_rate=0.0003),
    loss_fn=keras.losses.BinaryCrossentropy(from_logits=True),
)

# To limit the execution time, we only train on 100 batches. You can train on
# the entire dataset. You will need about 20 epochs to get nice results.
gan.fit(dataset.take(100), epochs=1)

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
100/100 [==============================] - 9s 24ms/step - d_loss: 0.4919 - g_loss: 0.8347
<tensorflow.python.keras.callbacks.History at 0x7f8b38026780>

The ideas behind deep learning are simple, so why should their implementation be painful?

以上