TensorFlow : Guide : 高位 API : Keras (tf.keras) (翻訳/解説)

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

* TensorFlow 1.9.0 で tf.keras のドキュメントが追加されましたので翻訳しておきます。
* 本ページは、TensorFlow 本家サイトの Guide – High Level APIs – Keras を翻訳した上で適宜、補足説明したものです：

• https://www.tensorflow.org/guide/keras

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

 

 

Keras は深層学習モデルを構築してビルドするための高位 API です。それは、次の 3 つの主要な優位点を持ち高速なプロトタイピング、先進的な研究、そしてプロダクションのために使用されます。

• ユーザ・フレンドリー
  Keras は一般的なユースケースのために最適化された単純で、首尾一貫したインターフェイスを持ちます。それはユーザ・エラーのために明瞭でアクション可能なフィードバックを提供します。

• モジュール式で組み立て可能
  Keras モデルは構成可能なビルディングブロックを一緒に接続することにより作成され、殆ど制限はありません。

• 簡単に拡張
  研究のための新しいアイデアを表わすためにカスタム・ビルディングブロックを書いてください。新しい層、損失関数を作成し、最先端技術のモデルを開発してください。

 

tf.keras をインポートする

tf.keras は Keras API 仕様 の TensorFlow 実装です。これはモデルを構築して訓練するための高位 API で、eager execution, tf.data pipelines, そして Estimators のような、TensorFlow-特有の機能のためのファーストクラス・サポートを含みます。tf.keras は柔軟性とパフォーマンスを犠牲にすることなく TensorFlow をより簡単に使用可能にします。

始めるためには、貴方の TensorFlow プログラムのセットアップの一部として tf.keras をインポートします :

import tensorflow as tf
from tensorflow import keras

tf.keras は任意の Keras 互換コードを実行できますが、以下に留意してください :

• 最新の TensorFlow リリースの tf.keras バージョンは PyPI からの最新の keras バージョンと同じではないかもしれません。tf.keras.version (訳注: 7/13 現在リンク切れ) を確認してください。
• モデルの重みをセーブするとき、tf.keras はチェックポイント・フォーマットをデフォルトにしています。HDF5 を使用するためには save_format=’h5′ を渡してください。

 

単純なモデルを構築する

Sequential モデル

Keras では、モデルを構築するために層を組み立てます。モデルは (通常は) 層のグラフです。モデルの最も一般的なタイプは層のスタック : tf.keras.Sequential です。

単純な、完全結合ネットワーク(i.e. 多層パーセプトロン) を構築するためには :

model = keras.Sequential()
# Adds a densely-connected layer with 64 units to the model:
model.add(keras.layers.Dense(64, activation='relu'))
# Add another:
model.add(keras.layers.Dense(64, activation='relu'))
# Add a softmax layer with 10 output units:
model.add(keras.layers.Dense(10, activation='softmax'))

 

層を設定する

幾つかの一般的なコンストラクタ・パラメータを持つ、利用可能な tf.keras.layers は多くあります :

• activation: 層のための活性化関数を設定します。このパラメータは組み込み関数の名前か呼び出し可能なオブジェクトとして指定されます。デフォルトでは、活性は適用されません。
• kernel_initializer と bias_initializer: 層の重み (カーネルとバイアス) を作成する初期化スキームです。このパラメータは名前か呼び出し可能なオブジェクトです。これは “Glorot uniform” initializer をデフォルトとします。
• kernel_regularizer と bias_regularizer: L1 または L2 正則化のような、層の重み (カーネルとバイアス) に適用する正則化スキームです。デフォルトでは、正則化は適用されません。

次は tf.keras.layers.Dense 層をコンストラクタ引数を使用してインスタンス化します :

# Create a sigmoid layer:
layers.Dense(64, activation='sigmoid')
# Or:
layers.Dense(64, activation=tf.sigmoid)

# A linear layer with L1 regularization of factor 0.01 applied to the kernel matrix:
layers.Dense(64, kernel_regularizer=keras.regularizers.l1(0.01))
# A linear layer with L2 regularization of factor 0.01 applied to the bias vector:
layers.Dense(64, bias_regularizer=keras.regularizers.l2(0.01))

# A linear layer with a kernel initialized to a random orthogonal matrix:
layers.Dense(64, kernel_initializer='orthogonal')
# A linear layer with a bias vector initialized to 2.0s:
layers.Dense(64, bias_initializer=keras.initializers.constant(2.0))

 

訓練と評価

訓練のセットアップ

モデルがコンストラクトされた後、その学習プロセスを compile メソッドを呼び出すことにより設定します :

model.compile(optimizer=tf.train.AdamOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

tf.keras.Model.compile は 3 つの重要な引数を取ります :

• optimizer: このオブジェクトは訓練手続きを指定します。AdamOptimizer, RMSPropOptimizer, または GradientDescentOptimizer のような、tf.train モジュールからの optimizer インスタンスをそれに渡します。
• loss: 最適化の間に最小化する関数です。一般的な選択はmean square error (mse), categorical_crossentropy, そして binary_crossentropy を含みます。損失関数は名前か tf.keras.losses からの呼び出し可能なオブジェクトを渡すことで指定されます。
• metrics: 訓練を監視するために使用されます。これらは文字列名か tf.keras.metrics モジュールからの呼び出し可能 (オブジェクト) です。

以下は訓練のためにモデルを設定する 2, 3 のサンプルを示します :

# Configure a model for mean-squared error regression.
model.compile(optimizer=tf.train.AdamOptimizer(0.01),
              loss='mse',       # mean squared error
              metrics=['mae'])  # mean absolute error

# Configure a model for categorical classification.
model.compile(optimizer=tf.train.RMSPropOptimizer(0.01),
              loss=keras.losses.categorical_crossentropy,
              metrics=[keras.metrics.categorical_accuracy])

 

NumPy データの入力

小さいデータセットに対しては、モデルを訓練して評価するためにインメモリ NumPy 配列を使用します。モデルは fit メソッドを使用して訓練データに “fit” します :

import numpy as np

data = np.random.random((1000, 32))
labels = np.random.random((1000, 10))

model.fit(data, labels, epochs=10, batch_size=32)

tf.keras.Model.fit は 3 つの重要な引数を取ります :

• epochs: 訓練はエポックに構造化されます。1 つのエポックは入力データ全体に渡る 1 回の反復です (これはより小さいバッチ内で遂行されます)。
• batch_size: NumPy データが渡されたとき、モデルはデータをより小さいバッチにスライスして (薄切りにして) 訓練の間これらのバッチに渡り反復します。この整数は各バッチのサイズを指定します。サンプル総数がバッチサイズで割り切れない場合は最後のバッチはより小さいかもしれないことに留意してください。
• validation_data: モデルをプロトタイピングするとき、何某かの検証データ上でそのパフォーマンスを容易に監視することを望みます。この引数 — 入力とラベルのタプル — を渡すと、各エポックの最後に、モデルが渡されたデータに対して推論モードで損失とメトリクスを示すことを可能にします。

ここに validation_data を使用するサンプルがあります :

import numpy as np

data = np.random.random((1000, 32))
labels = np.random.random((1000, 10))

val_data = np.random.random((100, 32))
val_labels = np.random.random((100, 10))

model.fit(data, labels, epochs=10, batch_size=32,
          validation_data=(val_data, val_labels))

 

tf.data データセットの入力

巨大なデータセットやマルチデバイス訓練にスケールするためには Datasets API を使用します。tf.data.Dataset インスタンスを fit メソッドに渡します :

# Instantiates a toy dataset instance:
dataset = tf.data.Dataset.from_tensor_slices((data, labels))
dataset = dataset.batch(32)
dataset = dataset.repeat()

# Don't forget to specify `steps_per_epoch` when calling `fit` on a dataset.
model.fit(dataset, epochs=10, steps_per_epoch=30)

ここで、fit メソッドは steps_per_epoch 引数を使用します — これはモデルが次のエポックに移る前に実行する訓練ステップ数です。Dataset がデータのバッチを yield するので、このスニペットは batch_size を必要としません。

Datasets はまた検証のためにも使用できます :

dataset = tf.data.Dataset.from_tensor_slices((data, labels))
dataset = dataset.batch(32).repeat()

val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels))
val_dataset = val_dataset.batch(32).repeat()

model.fit(dataset, epochs=10, steps_per_epoch=30,
          validation_data=val_dataset,
          validation_steps=3)

 

評価と予測

tf.keras.Model.evaluate と tf.keras.Model.predict メソッドは NumPy データと tf.data.Dataset を使用できます。

提供されるデータのために推論モード損失とメトリクスを評価するには :

model.evaluate(x, y, batch_size=32)

model.evaluate(dataset, steps=30)

そして提供されるデータのために最後の層の出力を推論で予測するためには、NumPy 配列として :

model.predict(x, batch_size=32)

model.predict(dataset, steps=30)

 

上級モデルを構築する

Functional API

tf.keras.Sequential は層の単純なスタックで、任意のモデルを表わすことはできません。次のような複雑なモデル・トポロジーを構築するためには Keras functional API を使用します :

• マルチ入力モデル、
• マルチ出力モデル、
• 共有層を持つモデル (同じ層が何回か呼ばれます)、
• 非シーケンシャル・データフローを持つモデル (e.g. 残差接続)。

functional API によるモデル構築はこのように作業します :

1. 層インスタンスは呼び出し可能で tensor を返します。
2. 入力 tensor と出力 tensor は tf.keras.Model インスタンスを定義するために使用されます。
3. このモデルは丁度 Sequential モデルのように訓練されます。

次のサンプルは単純な、完全結合ネットワークを構築するために functional API を使用します :

inputs = keras.Input(shape=(32,))  # Returns a placeholder tensor

# A layer instance is callable on a tensor, and returns a tensor.
x = keras.layers.Dense(64, activation='relu')(inputs)
x = keras.layers.Dense(64, activation='relu')(x)
predictions = keras.layers.Dense(10, activation='softmax')(x)

# Instantiate the model given inputs and outputs.
model = keras.Model(inputs=inputs, outputs=predictions)

# The compile step specifies the training configuration.
model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Trains for 5 epochs
model.fit(data, labels, batch_size=32, epochs=5)

 

Model サブクラス化

tf.keras.Model をサブクラス化して貴方自身の forward パスを定義して完全にカスタマイズ可能なモデルを構築します。__init__ メソッドで層を作成してそれらをクラス・インスタンスの属性として設定します。call メソッドで forward パスを定義します。

Model サブクラ化は eager execution が有効なときに特に有用です、何故ならば forward パスが命令的に書けるからです。

Key Point: ジョブのために適切な API を使用してください。model サブクラス化が柔軟性を提供する一方で、それは大きな複雑さとユーザエラーのより多くの機会という代償を伴います。可能であれば、functional API を選択してください。

次のサンプルはカスタム forward パスを使用してサブクラス化した tf.keras.Model を示します :

class MyModel(keras.Model):

  def __init__(self, num_classes=10):
    super(MyModel, self).__init__(name='my_model')
    self.num_classes = num_classes
    # Define your layers here.
    self.dense_1 = keras.layers.Dense(32, activation='relu')
    self.dense_2 = keras.layers.Dense(num_classes, activation='sigmoid')

  def call(self, inputs):
    # Define your forward pass here,
    # using layers you previously defined (in `__init__`).
    x = self.dense_1(inputs)
    return self.dense_2(x)

  def compute_output_shape(self, input_shape):
    # You need to override this function if you want to use the subclassed model
    # as part of a functional-style model.
    # Otherwise, this method is optional.
    shape = tf.TensorShape(input_shape).as_list()
    shape[-1] = self.num_classes
    return tf.TensorShape(shape)


# Instantiates the subclassed model.
model = MyModel(num_classes=10)

# The compile step specifies the training configuration.
model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Trains for 5 epochs.
model.fit(data, labels, batch_size=32, epochs=5)

 

カスタム層

tf.keras.layers.Layer のサブクラス化と次のメソッドの実装でカスタム層を作成します :

• build: 層の重みを作成します。add_weight メソッドで重みを追加します。
• call: forward パスを定義します。
• compute_output_shape: 入力 shape が与えられたとき層の出力 shape をどのように計算するかを指定します。
• オプションで、get_config メソッドと from_config クラスメソッドを実装することにより層はシリアライズできます。

入力のカーネル行列による matmul を実装するカスタム層のサンプルがここにあります :

class MyLayer(keras.layers.Layer):

  def __init__(self, output_dim, **kwargs):
    self.output_dim = output_dim
    super(MyLayer, self).__init__(**kwargs)

  def build(self, input_shape):
    shape = tf.TensorShape((input_shape[1], self.output_dim))
    # Create a trainable weight variable for this layer.
    self.kernel = self.add_weight(name='kernel',
                                  shape=shape,
                                  initializer='uniform',
                                  trainable=True)
    # Be sure to call this at the end
    super(MyLayer, self).build(input_shape)

  def call(self, inputs):
    return tf.matmul(inputs, self.kernel)

  def compute_output_shape(self, input_shape):
    shape = tf.TensorShape(input_shape).as_list()
    shape[-1] = self.output_dim
    return tf.TensorShape(shape)

  def get_config(self):
    base_config = super(MyLayer, self).get_config()
    base_config['output_dim'] = self.output_dim

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


# Create a model using the custom layer
model = keras.Sequential([MyLayer(10),
                          keras.layers.Activation('softmax')])

# The compile step specifies the training configuration
model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Trains for 5 epochs.
model.fit(data, targets, batch_size=32, epochs=5)

 

Callbacks

callback は訓練の間の (モデルの) 挙動をカスタマイズして拡張するためにモデルに渡されるオブジェクトです。貴方自身のカスタム callback を書く、あるいは以下を含む組み込み tf.keras.callbacks を使用することができます :

• tf.keras.callbacks.ModelCheckpoint: モデルのチェックポイントを通常の間隔でセーブします。
• tf.keras.callbacks.LearningRateScheduler: 動的に学習率を変更します。
• tf.keras.callbacks.EarlyStopping: 検証パフォーマンスが改善しなくなったとき訓練を中止します。
• tf.keras.callbacks.TensorBoard: TensorBoard を使用してモデルの挙動を監視します。

tf.keras.callbacks.Callback を使用するためには、モデルの fit メソッドにそれを渡します :

callbacks = [
  # Interrupt training if `val_loss` stops improving for over 2 epochs
  keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'),
  # Write TensorBoard logs to `./logs` directory
  keras.callbacks.TensorBoard(log_dir='./logs')
]
model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks,
          validation_data=(val_data, val_targets))

 

セーブとリストア

Weights (重み) only

tf.keras.Model.save_weights を使用してモデルの重みをセーブしてロードします :

# Save weights to a TensorFlow Checkpoint file
model.save_weights('./my_model')

# Restore the model's state,
# this requires a model with the same architecture.
model.load_weights('my_model')

デフォルトでは、これはモデルの重みを TensorFlow チェックポイント・ファイルフォーマットでセーブします。重みはまた Keras HDF5 フォーマットでもセーブできます (Keras のマルチ・バックエンド実装のためのデフォルトです) :

# Save weights to a HDF5 file
model.save_weights('my_model.h5', save_format='h5')

# Restore the model's state
model.load_weights('my_model.h5')

 

Configuration only

モデルの configuration をセーブできます — これはモデル・アーキテクチャを重みなしでシリアライズします。セーブされた configuration は (元のモデルを定義するコードなしでさえも) 同じモデルを再作成して初期化することができます。Keras は JSON と YAML シリアライゼーション・フォーマットをサポートします :

# Serialize a model to JSON format
json_string = model.to_json()

# Recreate the model (freshly initialized)
fresh_model = keras.models.from_json(json_string)

# Serializes a model to YAML format
yaml_string = model.to_yaml()

# Recreate the model
fresh_model = keras.models.from_yaml(yaml_string)

Caution: サブクラス化されたモデルはシリアライズ可能ではありません、何故ならばそれらのアーキテクチャは call メソッドの本体内で Python コードで定義されるからです。

 

モデル全体

モデル全体は、重み値、モデルの configuration、そして optimizer の configuration さえも含むファイルにセーブできます。これはモデルをチェックポイントして後で— 正確に同じ状態から — 元のコードへのアクセスなしに訓練を再開することを可能にします。

# Create a trivial model
model = keras.Sequential([
  keras.layers.Dense(10, activation='softmax', input_shape=(32,)),
  keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit(data, targets, batch_size=32, epochs=5)


# Save entire model to a HDF5 file
model.save('my_model.h5')

# Recreate the exact same model, including weights and optimizer.
model = keras.models.load_model('my_model.h5')

 

Eager execution

Eager execution は演算を直ちに評価する命令的なプログラミング環境です。これは Keras のために必要ではありませんが、tf.keras によりサポートされて貴方のプログラムを調査してデバッグするために有用です。

総ての tf.keras モデル構築 API は eager execution と互換です。そして Sequential and functional API が使用できる一方で、eager execution は特にモデル・サブクラス化とカスタム層の構築に利益を与えます forward パスをコードとして書くことを要求する API です (既存の層を組み立てることによりモデルを作成する API の代わりに)。

カスタム訓練ループと tf.GradientTape で Keras モデルを使用するサンプルのための eager execution ガイド を見てください。

 

分散

Estimators

Estimators API は分散環境のためのモデルを訓練するために使用されます。これは巨大なデータセット上での分散訓練のような、プロダクションのためのモデルをエクスポートできる industry ユースケースを対象としています。

tf.keras.Model は tf.keras.estimator.model_to_estimator で tf.estimator.Estimator オブジェクトにモデルを変換することにより tf.estimator API で訓練できます。Keras モデルから Estimator を作成する を見てください。

model = keras.Sequential([layers.Dense(10,activation='softmax'),
                          layers.Dense(10,activation='softmax')])

model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

estimator = keras.estimator.model_to_estimator(model)

Note: Estimator 入力関数 をデバッグしてデータを調査するためには eager execution を有効にしてください。

 

マルチ GPU

tf.keras モデルは tf.contrib.distribute.DistributionStrategy を使用して
マルチ GPU 上で実行できます。この API はマルチ GPU 上の分散訓練を既存のコードへの殆ど変更なしに提供します。

現在、tf.contrib.distribute.MirroredStrategy が唯一サポートされる分散ストラテジーです。MirroredStrategy はシングル・マシン上で all-reduce を使用して同期訓練で in-graph レプリケーションを行ないます。Keras で DistributionStrategy を使用するためには、tf.keras.Model を tf.keras.estimator.model_to_estimator で tf.estimator.Estimator に変換し、それから estimator を訓練します。

次のサンプルはシングルマシン上のマルチ GPU に渡り tf.keras.Model を分散します。

最初に、単純なモデルを定義します :

model = keras.Sequential()
model.add(keras.layers.Dense(16, activation='relu', input_shape=(10,)))
model.add(keras.layers.Dense(1, activation='sigmoid'))

optimizer = tf.train.GradientDescentOptimizer(0.2)

model.compile(loss='binary_crossentropy', optimizer=optimizer)
model.summary()

入力パイプラインを定義します。input_fn はマルチデバイスに渡りデータを分散するために使用される tf.data.Dataset オブジェクトを返します — 各デバイスは入力バッチのスライスを処理します。

def input_fn():
  x = np.random.random((1024, 10))
  y = np.random.randint(2, size=(1024, 1))
  x = tf.cast(x, tf.float32)
  dataset = tf.data.Dataset.from_tensor_slices((x, y))
  dataset = dataset.repeat(10)
  dataset = dataset.batch(32)
  return dataset

次に、tf.estimator.RunConfig を作成して tf.contrib.distribute.MirroredStrategy インスタンスに train_distribute 引数を設定します。MirroredStrategy を作成するとき、デバイスのリストを指定するか num_gpus 引数を設定することができます。デフォルトでは総ての利用可能な GPU を使用します、次のようにです :

strategy = tf.contrib.distribute.MirroredStrategy()
config = tf.estimator.RunConfig(train_distribute=strategy)

Keras モデルを tf.estimator.Estimator インスタンスに変換します :

keras_estimator = keras.estimator.model_to_estimator(
  keras_model=model,
  config=config,
  model_dir='/tmp/model_dir')

最後に、input_fn と steps 引数を提供することにより Estimator インスタンスを訓練します :

keras_estimator.train(input_fn=input_fn, steps=10)

 
以上