TensorFlow 2.0 Beta : ガイド : Keras :- 簡単な概要 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/10/2019
* 本ページは、TensorFlow の本家サイトの TF 2.0 Beta の以下のページを翻訳した上で適宜、補足説明したものです：
* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。
ガイド : Keras :- 簡単な概要
tf.keras をインポートする
tf.keras は Keras API 仕様 の TensorFlow 実装です。これはモデルを構築して訓練するための高位 API で、eager execution, tf.data パイプラインと Estimator のような TensorFlow-特有の機能のための first-class サポートを含みます。tf.keras は柔軟性やパフォーマンスを犠牲にすることなく TensorFlow を容易に利用できるようにします。
始めるには、貴方の TensorFlow プログラム・セットアップの一部として tf.keras をインポートします :
!pip install -q pyyaml # pyyaml is optional
from __future__ import absolute_import, division, print_function, unicode_literals !pip install -q tensorflow-gpu==2.0.0-beta0 import tensorflow as tf from tensorflow import keras
tf.keras は任意の Keras 互換コードを実行できますが、以下に留意してください :
- 最新の TensorFlow リリースの tf.keras バージョンは PyPI からの最新の keras バージョンと同じではないかもしれません。tf.keras.__version__ を確認してください。
- モデルの重みをセーブするとき、tf.keras はチェックポイント形式をデフォルトにしています。HDF5 を使用するためには save_format=’h5′ を渡してください。
単純なモデルを構築する
Sequential モデル
Keras では、モデルを構築するために層を集めます。モデルは (通常は) 層のグラフです。モデルの最も一般的なタイプは層のスタック : tf.keras.Sequential モデルです。
単純な、完全結合ネットワーク (i.e. 多層パーセプトロン) を構築するには :
from tensorflow.keras import layers model = tf.keras.Sequential() # Adds a densely-connected layer with 64 units to the model: model.add(layers.Dense(64, activation='relu')) # Add another: model.add(layers.Dense(64, activation='relu')) # Add a softmax layer with 10 output units: model.add(layers.Dense(10, activation='softmax'))
Sequential モデルをどのように使用するかの完全な、短いサンプルは ここ で見つけられます。
Guide to the Keras Functional – Guide to writing layers and models from scratch with subclassing を見てください。
層を configure する
幾つかの一般的なコンストラクタ・パラメータとともに利用可能な多くの tf.keras.layers があります。
- activation: 層のための活性化関数を設定します。このパラメータは組み込み関数の名前か callable オブジェクトとして指定されます。デフォルトでは、activation は適用されません。
- kernel_initializer と bias_initializer: 層の重み (カーネルとバイアス) を作成する初期化スキームです。このパラメータは名前か callable オブジェクトです。これは “Glorot uniform” initializer がデフォルトです。
- kernel_regularize と bias_regularizer: L1 や L2 正則化のような、層の重み (カーネルとバイアス) に適用される正則化スキームです。デフォルトでは、正則化は適用されません。
以下はコンストラクタ引数を使用して tf.keras.layers.Dense 層をインスタンス化します :
# Create a sigmoid layer: layers.Dense(64, activation='sigmoid') # Or: layers.Dense(64, activation=tf.keras.activations.sigmoid) # A linear layer with L1 regularization of factor 0.01 applied to the kernel matrix: layers.Dense(64, kernel_regularizer=tf.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=tf.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=tf.keras.initializers.Constant(2.0))
<tensorflow.python.keras.layers.core.Dense at 0x7fba63a4a4a8>
訓練と評価
訓練のセットアップ
モデルが構築された後、compile メソッドを呼び出してその学習プロセスを configure します :
model = tf.keras.Sequential([
# Adds a densely-connected layer with 64 units to the model:
layers.Dense(64, activation='relu', input_shape=(32,)),
# Add another:
layers.Dense(64, activation='relu'),
# Add a softmax layer with 10 output units:
layers.Dense(10, activation='softmax')])
model.compile(optimizer=tf.keras.optimizers.Adam(0.001),
loss='categorical_crossentropy',
metrics=['accuracy'])
tf.keras.Model.compile は 3 つの重要な引数を取ります :
- optimizer: このオブジェクトは訓練手続きを指定します。tf.keras.optimizers.Adam や tf.keras.optimizers.SGD のような、tf.keras.optimizers モジュールからの optimizer インスタンスをそれに渡します。単にデフォルト・パラメータを使用することを望む場合には、’adam’ や ‘sgd’ のような、文字列を通して optimizer を指定することも可能です。
- loss: 最適化の間に最小化するための関数です。一般的な選択は mean square error (mse), categorical_crossentropy そして binary_crossentropy を含みます。損失関数は名前か tf.keras.losses モジュールからの callable オブジェクトを渡すことにより指定されます。
- metrics: 訓練を監視するために使用されます。これらは文字列名か tf.keras.metrics モジュールからの callable です。
- 追加として、モデルが eagaly に訓練して評価されることを確かなものにするために、compile へのパラメータとして run_eagerly=True を確実に渡すことができます。
次は訓練のためにモデルを configure する幾つかの例を示します :
# Configure a model for mean-squared error regression.
model.compile(optimizer=tf.keras.optimizers.Adam(0.01),
loss='mse', # mean squared error
metrics=['mae']) # mean absolute error
# Configure a model for categorical classification.
model.compile(optimizer=tf.keras.optimizers.RMSprop(0.01),
loss=tf.keras.losses.CategoricalCrossentropy(),
metrics=[tf.keras.metrics.CategoricalAccuracy()])
NumPy データから訓練する
小さいデータセットについては、モデルを訓練して評価するために in-memory 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)
Train on 1000 samples Epoch 1/10 1000/1000 [==============================] - 1s 573us/sample - loss: 11.5185 - categorical_accuracy: 0.0920 Epoch 2/10 1000/1000 [==============================] - 0s 89us/sample - loss: 11.4708 - categorical_accuracy: 0.1110 Epoch 3/10 1000/1000 [==============================] - 0s 84us/sample - loss: 11.4722 - categorical_accuracy: 0.1090 Epoch 4/10 1000/1000 [==============================] - 0s 85us/sample - loss: 11.4707 - categorical_accuracy: 0.0990 Epoch 5/10 1000/1000 [==============================] - 0s 87us/sample - loss: 11.4699 - categorical_accuracy: 0.1170 Epoch 6/10 1000/1000 [==============================] - 0s 77us/sample - loss: 11.4652 - categorical_accuracy: 0.1130 Epoch 7/10 1000/1000 [==============================] - 0s 84us/sample - loss: 11.4659 - categorical_accuracy: 0.1160 Epoch 8/10 1000/1000 [==============================] - 0s 84us/sample - loss: 11.4599 - categorical_accuracy: 0.1100 Epoch 9/10 1000/1000 [==============================] - 0s 84us/sample - loss: 11.4550 - categorical_accuracy: 0.1250 Epoch 10/10 1000/1000 [==============================] - 0s 85us/sample - loss: 11.4543 - categorical_accuracy: 0.1240 <tensorflow.python.keras.callbacks.History at 0x7fba603cd5f8>
tf.keras.Model.fit は 3 つの重要な引数を取ります :
- epochs: 訓練はエポックに構造化されます。エポックは入力データ全体に渡る一つの iteration です (これはより小さなバッチで成されます)。
- batch_size: NumPy データが渡されたとき、モデルはデータをより小さいバッチにスライスして訓練の間これらのバッチに渡り iterate します。この整数は各バッチのサイズを指定します。サンプル総数がバッチサイズで割り切れない場合は最後のバッチはより小さいかもしれないことに留意してください。
- 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))
Train on 1000 samples, validate on 100 samples Epoch 1/10 1000/1000 [==============================] - 0s 183us/sample - loss: 11.6683 - categorical_accuracy: 0.1030 - val_loss: 11.6501 - val_categorical_accuracy: 0.0900 Epoch 2/10 1000/1000 [==============================] - 0s 181us/sample - loss: 11.6628 - categorical_accuracy: 0.1070 - val_loss: 11.6470 - val_categorical_accuracy: 0.0800 Epoch 3/10 1000/1000 [==============================] - 0s 91us/sample - loss: 11.6612 - categorical_accuracy: 0.1140 - val_loss: 11.6525 - val_categorical_accuracy: 0.0600 Epoch 4/10 1000/1000 [==============================] - 0s 84us/sample - loss: 11.6591 - categorical_accuracy: 0.1160 - val_loss: 11.6753 - val_categorical_accuracy: 0.0900 Epoch 5/10 1000/1000 [==============================] - 0s 85us/sample - loss: 11.6573 - categorical_accuracy: 0.1250 - val_loss: 11.6517 - val_categorical_accuracy: 0.0700 Epoch 6/10 1000/1000 [==============================] - 0s 89us/sample - loss: 11.6545 - categorical_accuracy: 0.1000 - val_loss: 11.6656 - val_categorical_accuracy: 0.1100 Epoch 7/10 1000/1000 [==============================] - 0s 92us/sample - loss: 11.6509 - categorical_accuracy: 0.1510 - val_loss: 11.6775 - val_categorical_accuracy: 0.0700 Epoch 8/10 1000/1000 [==============================] - 0s 95us/sample - loss: 11.6452 - categorical_accuracy: 0.1350 - val_loss: 11.6693 - val_categorical_accuracy: 0.0800 Epoch 9/10 1000/1000 [==============================] - 0s 95us/sample - loss: 11.6426 - categorical_accuracy: 0.1430 - val_loss: 11.6636 - val_categorical_accuracy: 0.0900 Epoch 10/10 1000/1000 [==============================] - 0s 93us/sample - loss: 11.6357 - categorical_accuracy: 0.1490 - val_loss: 11.7268 - val_categorical_accuracy: 0.1300 <tensorflow.python.keras.callbacks.History at 0x7fba500b7668>
tf.data datasets から訓練する
巨大なデータセットやマルチデバイス訓練にスケールするには Datasets API を使用します。tf.data.Dataset インスタンスを fit メソッドに渡します :
# Instantiates a toy dataset instance: dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) # Don't forget to specify `steps_per_epoch` when calling `fit` on a dataset. model.fit(dataset, epochs=10, steps_per_epoch=30)
W0608 04:30:06.144505 140440776103680 training_utils.py:1436] Expected a shuffled dataset but input dataset `x` is not shuffled. Please invoke `shuffle()` on input dataset. Epoch 1/10 30/30 [==============================] - 0s 6ms/step - loss: 11.6491 - categorical_accuracy: 0.1552 Epoch 2/10 2/30 [=>............................] - ETA: 1s - loss: 11.2221 - categorical_accuracy: 0.1250 W0608 04:30:06.415772 140440776103680 training_generator.py:235] Your dataset ran out of data; interrupting training. Make sure that your dataset can generate at least `steps_per_epoch * epochs` batches (in this case, 300 batches). You may need to use the repeat() function when building your dataset. <tensorflow.python.keras.callbacks.History at 0x7fba500b7748>
ここで、fit メソッドは steps_per_epoch 引数を使用します — これはモデルが次のエポックに移行する前に実行する訓練ステップの数です。Dataset はデータのバッチを yield するので、このスニペットは batch_size を必要としません。
Datasets はまた検証のためにも使用できます :
dataset = tf.data.Dataset.from_tensor_slices((data, labels))
dataset = dataset.batch(32)
val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels))
val_dataset = val_dataset.batch(32)
model.fit(dataset, epochs=10,
validation_data=val_dataset)
W0307 18:13:21.444809 139743906965248 training_utils.py:1353] Expected a shuffled dataset but input dataset `x` is not shuffled. Please invoke `shuffle()` on input dataset. Epoch 1/10 32/32 [==============================] - 0s 4ms/step - loss: 63254.3520 - categorical_accuracy: 0.1070 - val_loss: 72984.6680 - val_categorical_accuracy: 0.0900 Epoch 2/10 32/32 [==============================] - 0s 4ms/step - loss: 67955.6909 - categorical_accuracy: 0.0980 - val_loss: 62399.8779 - val_categorical_accuracy: 0.1700 Epoch 3/10 32/32 [==============================] - 0s 4ms/step - loss: 70544.7288 - categorical_accuracy: 0.0840 - val_loss: 93031.5527 - val_categorical_accuracy: 0.1000 Epoch 4/10 32/32 [==============================] - 0s 4ms/step - loss: 77979.4031 - categorical_accuracy: 0.0970 - val_loss: 74229.4023 - val_categorical_accuracy: 0.1100 Epoch 5/10 32/32 [==============================] - 0s 4ms/step - loss: 83574.9339 - categorical_accuracy: 0.1260 - val_loss: 78287.6426 - val_categorical_accuracy: 0.0900 Epoch 6/10 32/32 [==============================] - 0s 4ms/step - loss: 90891.1725 - categorical_accuracy: 0.1060 - val_loss: 94735.4883 - val_categorical_accuracy: 0.1700 Epoch 7/10 32/32 [==============================] - 0s 4ms/step - loss: 94002.2560 - categorical_accuracy: 0.1060 - val_loss: 100048.7207 - val_categorical_accuracy: 0.1000 Epoch 8/10 32/32 [==============================] - 0s 4ms/step - loss: 101943.8282 - categorical_accuracy: 0.1090 - val_loss: 108326.5488 - val_categorical_accuracy: 0.0800 Epoch 9/10 32/32 [==============================] - 0s 4ms/step - loss: 111068.3402 - categorical_accuracy: 0.1160 - val_loss: 145687.4141 - val_categorical_accuracy: 0.1700 Epoch 10/10 32/32 [==============================] - 0s 4ms/step - loss: 119871.4167 - categorical_accuracy: 0.0950 - val_loss: 143137.7383 - val_categorical_accuracy: 0.1000 <tensorflow.python.keras.callbacks.History at 0x7f182817c358>
評価と予測
tf.keras.Model.evaluate と tf.keras.Model.predict メソッドは NumPy データと tf.data.Dataset を使用できます。
提供されたデータのために推論モードの損失とメトリクスを評価するには :
data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.evaluate(data, labels, batch_size=32) model.evaluate(dataset, steps=30)
1000/1000 [==============================] - 0s 70us/sample - loss: 11.5954 - categorical_accuracy: 0.0850 30/30 [==============================] - 0s 2ms/step - loss: 11.6008 - categorical_accuracy: 0.1698 [11.600848929087322, 0.16979167]
そして提供されたデータのために推論で最後の層の出力を予測します、NumPy 配列として :
result = model.predict(data, batch_size=32) print(result.shape)
(1000, 10)
カスタム訓練ループをスクラッチからどのように書くかを含めて、訓練と評価の完全なガイドについては、訓練 & 評価へのガイド を見てください。
上級モデルを構築する
Functional API
tf.keras.Sequential モデルは層の単純なスタックで任意のモデルを表わすことはできません。次のような複雑なモデル・トポロジーを構築するには Keras functional API を使用します :
- マルチ入力モデル、
- マルチ出力モデル、
- 共有層を持つモデル (同じ層が幾度も呼び出されます)、
- 非-sequential データフローを持つモデル (e.g. 残差コネクション)。
funcitonal API によるモデル構築は次のように動作します :
- 層インスタンスは callable で tensor を返します。
- 入力 tensor と出力 tensor は tf.keras.Model インスタンスを定義するために使用されます。
- このモデルは丁度 Sequential モデルのように訓練されます。
次のサンプルは単純な、完全結合ネットワークを構築するために functional API を使用します :
inputs = tf.keras.Input(shape=(32,)) # Returns an input placeholder # A layer instance is callable on a tensor, and returns a tensor. x = layers.Dense(64, activation='relu')(inputs) x = layers.Dense(64, activation='relu')(x) predictions = layers.Dense(10, activation='softmax')(x)
与えられた入力と出力でモデルをインスタンス化します。
model = tf.keras.Model(inputs=inputs, outputs=predictions)
# The compile step specifies the training configuration.
model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001),
loss='categorical_crossentropy',
metrics=['accuracy'])
# Trains for 5 epochs
model.fit(data, labels, batch_size=32, epochs=5)
Train on 1000 samples Epoch 1/5 1000/1000 [==============================] - 0s 245us/sample - loss: 11.5521 - accuracy: 0.1080 Epoch 2/5 1000/1000 [==============================] - 0s 85us/sample - loss: 11.5213 - accuracy: 0.1210 Epoch 3/5 1000/1000 [==============================] - 0s 85us/sample - loss: 11.5114 - accuracy: 0.1040 Epoch 4/5 1000/1000 [==============================] - 0s 78us/sample - loss: 11.5055 - accuracy: 0.1220 Epoch 5/5 1000/1000 [==============================] - 0s 81us/sample - loss: 11.4977 - accuracy: 0.1240 <tensorflow.python.keras.callbacks.History at 0x7fba14257fd0>
Model サブクラス化
tf.keras.Model のサブクラス化と貴方自身の forward パスを定義することにより完全にカスタマイズ可能なモデルを構築します。__init__ メソッドで層を作成してそれらをクラスインスタンスの属性として設定します。call メソッドで forward パスを定義します。
Model サブクラス化は eager execution が有効なときに特に有用です、何故ならば forward パスが命令的に書けるからです。
Note: forward パスが常に命令的に実行されることを確実にするためには、super コンストラクタを呼び出すときに dynamic=True を設定しなければなりません。
Key Point: ジョブのために正しい API を使用してください。モデルのサブクラス化は柔軟性を提供する一方で、それはより大きな複雑性とユーザエラーのより多くの機会というのコストがかかります。可能であれば、functional API を選択してください。
次のサンプルは、命令的に実行されなくても良いカスタム forward パスを使用するサブクラス化された tf.keras.Model を示します :
class MyModel(tf.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 = layers.Dense(32, activation='relu')
self.dense_2 = 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)
新しいモデル・クラスをインスタンス化します :
model = MyModel(num_classes=10)
# The compile step specifies the training configuration.
model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001),
loss='categorical_crossentropy',
metrics=['accuracy'])
# Trains for 5 epochs.
model.fit(data, labels, batch_size=32, epochs=5)
Train on 1000 samples Epoch 1/5 1000/1000 [==============================] - 0s 191us/sample - loss: 11.5330 - accuracy: 0.0810 Epoch 2/5 1000/1000 [==============================] - 0s 73us/sample - loss: 11.5169 - accuracy: 0.1100 Epoch 3/5 1000/1000 [==============================] - 0s 75us/sample - loss: 11.5133 - accuracy: 0.1080 Epoch 4/5 1000/1000 [==============================] - 0s 72us/sample - loss: 11.5107 - accuracy: 0.1160 Epoch 5/5 1000/1000 [==============================] - 0s 78us/sample - loss: 11.5087 - accuracy: 0.1120 <tensorflow.python.keras.callbacks.History at 0x7fba6ae20f60>
カスタム層
tf.keras.layers.Layer をサブクラス化して次のメソッドを実装することでカスタム層を作成します :
- __init__: オプションでこの層により使用されるサブ層を定義します。
- build: 層の重みを作成します。add_weight メソッドで重みを追加します。
- call: forward パスを定義します。
- オプションで、get_config メソッドと from_config クラス・メソッドを実装することにより層をシリアライズ化できます。
kernel 行列による入力の matmul を実装するカスタム層のサンプルがここにあります :
class MyLayer(layers.Layer):
def __init__(self, output_dim, **kwargs):
self.output_dim = output_dim
super(MyLayer, self).__init__(**kwargs)
def build(self, input_shape):
# Create a trainable weight variable for this layer.
self.kernel = self.add_weight(name='kernel',
shape=(input_shape[1], self.output_dim),
initializer='uniform',
trainable=True)
def call(self, inputs):
return tf.matmul(inputs, self.kernel)
def get_config(self):
base_config = super(MyLayer, self).get_config()
base_config['output_dim'] = self.output_dim
return base_config
@classmethod
def from_config(cls, config):
return cls(**config)
貴方のカスタム層を使用してモデルを作成します :
model = tf.keras.Sequential([
MyLayer(10),
layers.Activation('softmax')])
# The compile step specifies the training configuration
model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001),
loss='categorical_crossentropy',
metrics=['accuracy'])
# Trains for 5 epochs.
model.fit(data, labels, batch_size=32, epochs=5)
Train on 1000 samples Epoch 1/5 1000/1000 [==============================] - 0s 143us/sample - loss: 11.5147 - accuracy: 0.0890 Epoch 2/5 1000/1000 [==============================] - 0s 61us/sample - loss: 11.5111 - accuracy: 0.1110 Epoch 3/5 1000/1000 [==============================] - 0s 59us/sample - loss: 11.5084 - accuracy: 0.1030 Epoch 4/5 1000/1000 [==============================] - 0s 62us/sample - loss: 11.5068 - accuracy: 0.1160 Epoch 5/5 1000/1000 [==============================] - 0s 61us/sample - loss: 11.5048 - accuracy: 0.1130 <tensorflow.python.keras.callbacks.History at 0x7fb9fc2f8518>
Guide to writing layers and models from scratch でサブクラス化による新しい層とモデルのスクラッチからの作成について更に学習してください。
コールバック
コールバックは訓練の間にその挙動をカスタマイズして拡張するためにモデルに渡されるオブジェクトです。貴方自身のカスタム・コールバックを書いたり、以下を含む組み込み 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
tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'),
# Write TensorBoard logs to `./logs` directory
tf.keras.callbacks.TensorBoard(log_dir='./logs')
]
model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks,
validation_data=(val_data, val_labels))s))
Train on 1000 samples, validate on 100 samples Epoch 1/5 1000/1000 [==============================] - 0s 147us/sample - loss: 11.5031 - accuracy: 0.1180 - val_loss: 11.6469 - val_accuracy: 0.1200 Epoch 2/5 1000/1000 [==============================] - 0s 72us/sample - loss: 11.5022 - accuracy: 0.1230 - val_loss: 11.6491 - val_accuracy: 0.0600 Epoch 3/5 1000/1000 [==============================] - 0s 70us/sample - loss: 11.5009 - accuracy: 0.1200 - val_loss: 11.6551 - val_accuracy: 0.0900 <tensorflow.python.keras.callbacks.History at 0x7fb9f45bc438>
セーブとリストア
Weights only
tf.keras.Model.save_weights を使用してモデルの重みをセーブしてロードします :
model = tf.keras.Sequential([
layers.Dense(64, activation='relu', input_shape=(32,)),
layers.Dense(10, activation='softmax')])
model.compile(optimizer=tf.keras.optimizers.Adam(0.001),
loss='categorical_crossentropy',
metrics=['accuracy'])
# Save weights to a TensorFlow Checkpoint file
model.save_weights('./weights/my_model')
# Restore the model's state,
# this requires a model with the same architecture.
model.load_weights('./weights/my_model')
<tensorflow.python.training.tracking.util.CheckpointLoadStatus at 0x7fb9fc10b9b0>
デフォルトでは、これはモデルの重みを TensorFlow チェックポイント ファイル形式でセーブします。重みはまた Keras HDF5 形式でもセーブできます (Keras の multi-backend 実装のためのデフォルト) :
# 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() json_string
'{"keras_version": "2.2.4-tf", "class_name": "Sequential", "config": {"name": "sequential_3", "layers": [{"class_name": "Dense", "config": {"activation": "relu", "use_bias": true, "units": 64, "kernel_regularizer": null, "trainable": true, "batch_input_shape": [null, 32], "name": "dense_17", "bias_regularizer": null, "bias_initializer": {"class_name": "Zeros", "config": {}}, "dtype": "float32", "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_constraint": null, "kernel_constraint": null, "activity_regularizer": null}}, {"class_name": "Dense", "config": {"activation": "softmax", "use_bias": true, "name": "dense_18", "kernel_regularizer": null, "trainable": true, "bias_regularizer": null, "bias_initializer": {"class_name": "Zeros", "config": {}}, "dtype": "float32", "units": 10, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_constraint": null, "kernel_constraint": null, "activity_regularizer": null}}]}, "backend": "tensorflow"}'
import json import pprint pprint.pprint(json.loads(json_string))
{'backend': 'tensorflow',
'class_name': 'Sequential',
'config': {'layers': [{'class_name': 'Dense',
'config': {'activation': 'relu',
'activity_regularizer': None,
'batch_input_shape': [None, 32],
'bias_constraint': None,
'bias_initializer': {'class_name': 'Zeros',
'config': {}},
'bias_regularizer': None,
'dtype': 'float32',
'kernel_constraint': None,
'kernel_initializer': {'class_name': 'GlorotUniform',
'config': {'seed': None}},
'kernel_regularizer': None,
'name': 'dense_17',
'trainable': True,
'units': 64,
'use_bias': True}},
{'class_name': 'Dense',
'config': {'activation': 'softmax',
'activity_regularizer': None,
'bias_constraint': None,
'bias_initializer': {'class_name': 'Zeros',
'config': {}},
'bias_regularizer': None,
'dtype': 'float32',
'kernel_constraint': None,
'kernel_initializer': {'class_name': 'GlorotUniform',
'config': {'seed': None}},
'kernel_regularizer': None,
'name': 'dense_18',
'trainable': True,
'units': 10,
'use_bias': True}}],
'name': 'sequential_3'},
'keras_version': '2.2.4-tf'}
JSON から (新たに初期化された) モデルを再作成します :
fresh_model = tf.keras.models.model_from_json(json_string)
モデルの YAML 形式へのシリアライズは TensorFlow をインポートする前に pyyaml をインストールする必要があります :
yaml_string = model.to_yaml() print(yaml_string)
backend: tensorflow
class_name: Sequential
config:
layers:
- class_name: Dense
config:
activation: relu
activity_regularizer: null
batch_input_shape: !!python/tuple [null, 32]
bias_constraint: null
bias_initializer:
class_name: Zeros
config: {}
bias_regularizer: null
dtype: float32
kernel_constraint: null
kernel_initializer:
class_name: GlorotUniform
config: {seed: null}
kernel_regularizer: null
name: dense_17
trainable: true
units: 64
use_bias: true
- class_name: Dense
config:
activation: softmax
activity_regularizer: null
bias_constraint: null
bias_initializer:
class_name: Zeros
config: {}
bias_regularizer: null
dtype: float32
kernel_constraint: null
kernel_initializer:
class_name: GlorotUniform
config: {seed: null}
kernel_regularizer: null
name: dense_18
trainable: true
units: 10
use_bias: true
name: sequential_3
keras_version: 2.2.4-tf
YAML からモデルを再作成します :
fresh_model = tf.keras.models.model_from_yaml(yaml_string)
Caution: サブクラス化されたモデルはシリアライズ可能ではありません、何故ならばそれらのアーキテクチャは call メソッドの本体で Python コードで定義されているからです。
モデル全体
モデル全体は重み値、モデルの configuration そして optimizer の configuration さえも含むファイルにセーブできます。これはモデルをチェックポイントして後で元のコードにアクセスすることなく — 正確に同じ状態から — 訓練を再開することを可能にします。
# Create a simple model
model = tf.keras.Sequential([
layers.Dense(10, activation='softmax', input_shape=(32,)),
layers.Dense(10, activation='softmax')
])
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(data, labels, 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 = tf.keras.models.load_model('my_model.h5')
Train on 1000 samples Epoch 1/5 1000/1000 [==============================] - 0s 195us/sample - loss: 11.5139 - accuracy: 0.0980 Epoch 2/5 1000/1000 [==============================] - 0s 77us/sample - loss: 11.5105 - accuracy: 0.1000 Epoch 3/5 1000/1000 [==============================] - 0s 76us/sample - loss: 11.5097 - accuracy: 0.1070 Epoch 4/5 1000/1000 [==============================] - 0s 78us/sample - loss: 11.5092 - accuracy: 0.0990 Epoch 5/5 1000/1000 [==============================] - 0s 77us/sample - loss: 11.5088 - accuracy: 0.0950
Keras モデルのためのセーブとシリアライゼーションについて save and serialize models へのガイドで更に学習してください。
Eager execution
Eager execution は演算を直ちに評価する命令型プログラミング環境です。これは Keras に必要ではありませんが、tf.keras によりサポートされます、そして貴方のプログラムを調べてデバッグするために有用です。
総ての tf.keras モデル構築 API は eager execution と互換です。そして Sequential と functional API が使用できる一方で、eager execution は特にモデルのサブクラス化とカスタム層の構築に役立ちます — API は貴方に forward パスをコードとして書くことを要求します (既存の層を集めてモデルを作成する API の代わりに)。
カスタム訓練ループと tf.GradientTape を伴う Keras モデルを使用するサンプルについては eager execution ガイド を見てください。貴方はまた ここ で完全な、短いサンプルを見つけられます。
分散
マルチ GPU
tf.keras モデルは tf.distribute.Strategy を使用してマルチ GPU 上で実行できます。この API は既存のコードに殆ど変更なしでマルチ GPU 上の分散訓練を提供します。
現在は、tf.distribute.MirroredStrategy が唯一のサポートされる分散ストラテジーです。MirroredStrategy は単一マシン上で all-reduce を使用して同期訓練を伴う in-graph レプリケーションを行ないます。distribute.Strategys を使用するには、Strategy の .scope() で optimizer インスタンス化とモデル構築とコンパイルをネストして、それからモデルを訓練します。
次のサンプルは単一マシン上のマルチ GPU に渡り tf.keras.Model を分散します。
最初に、分散ストラテジー・スコープの内側でモデルを定義します :
strategy = tf.distribute.MirroredStrategy() with strategy.scope(): model = tf.keras.Sequential() model.add(layers.Dense(16, activation='relu', input_shape=(10,))) model.add(layers.Dense(1, activation='sigmoid')) optimizer = tf.keras.optimizers.SGD(0.2) model.compile(loss='binary_crossentropy', optimizer=optimizer) model.summary()
Model: "sequential_5" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= dense_21 (Dense) (None, 16) 176 _________________________________________________________________ dense_22 (Dense) (None, 1) 17 ================================================================= Total params: 193 Trainable params: 193 Non-trainable params: 0 _________________________________________________________________
次に、通常のようにモデルを訓練します :
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.shuffle(buffer_size=1024).batch(32) model.fit(dataset, epochs=1)
Train on 32 steps 32/32 [==============================] - 1s 21ms/step - loss: 0.7022 <tensorflow.python.keras.callbacks.History at 0x7fb9dc581cf8>
より多くの情報については、full guide on Distributed Training in TensorFlow を見てください。
以上