ホーム » Keras » TensorFlow 2.0 : ガイド : Keras :- Keras 概要

TensorFlow 2.0 : ガイド : Keras :- Keras 概要

TensorFlow 2.0 : ガイド : Keras :- Keras 概要 (翻訳/解説)

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

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

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

 

無料セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマにウェビナー (WEB セミナー) を定期的に開催しています。スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • Windows PC のブラウザからご参加が可能です。スマートデバイスもご利用可能です。

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com ; WebSite: https://www.classcat.com/
Facebook: https://www.facebook.com/ClassCatJP/

 

Keras :- Keras 概要

tf.keras をインポートする

tf.kerasKeras API 仕様 の TensorFlow 実装です。これはモデルを構築して訓練するための高位 API で、eager execution, tf.data パイプラインと Estimator のような TensorFlow-固有の機能のための first-class サポートを含みます。tf.keras は柔軟性やパフォーマンスを犠牲にすることなく TensorFlow を容易に利用できるようにします。

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

from __future__ import absolute_import, division, print_function, unicode_literals

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′ を渡してください (あるいは .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 モデルをどのように使用するかの完全な、短いサンプルは ここ で見つけられます。

Sequential モデルよりも進んだモデルの構築について学習するためには、 Guide to the Keras Functional – Guide to writing layers and models from scratch with subclassing を見てください。

 

層を configure する

利用可能な多くの tf.keras.layers があります。それらの殆どは幾つかの一般的なコンストラクタ引数を共有します :

  • activation: 層のための活性化関数を設定します。このパラメータは組み込み関数の名前か callable オブジェクトとして指定されます。デフォルトでは、activation は適用されません。
  • kernel_initializerbias_initializer: 層の重み (カーネルとバイアス) を作成する初期化スキームです。このパラメータは名前か callable オブジェクトです。これは “Glorot uniform” initializer がデフォルトです。
  • kernel_regularizebias_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 0x7fe74f13eac8>

 

訓練と評価

訓練のセットアップ

モデルが構築された後、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.01),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

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

  • optimizer: このオブジェクトは訓練手続きを指定します。tf.keras.optimizers.Adamtf.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 です。
  • 追加として、モデルが eager モードで訓練して評価されることを確かなものにするために、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 941us/sample - loss: 292.6379 - categorical_accuracy: 0.1150
Epoch 2/10
1000/1000 [==============================] - 0s 79us/sample - loss: 1195.7818 - categorical_accuracy: 0.0940
Epoch 3/10
1000/1000 [==============================] - 0s 79us/sample - loss: 2382.5031 - categorical_accuracy: 0.0850
Epoch 4/10
1000/1000 [==============================] - 0s 77us/sample - loss: 4133.6880 - categorical_accuracy: 0.0900
Epoch 5/10
1000/1000 [==============================] - 0s 78us/sample - loss: 6172.5911 - categorical_accuracy: 0.1010
Epoch 6/10
1000/1000 [==============================] - 0s 77us/sample - loss: 8432.6698 - categorical_accuracy: 0.1120
Epoch 7/10
1000/1000 [==============================] - 0s 79us/sample - loss: 11067.2603 - categorical_accuracy: 0.0920
Epoch 8/10
1000/1000 [==============================] - 0s 80us/sample - loss: 14060.8606 - categorical_accuracy: 0.0980
Epoch 9/10
1000/1000 [==============================] - 0s 76us/sample - loss: 17402.4838 - categorical_accuracy: 0.0930
Epoch 10/10
1000/1000 [==============================] - 0s 77us/sample - loss: 21134.0576 - categorical_accuracy: 0.0910

<tensorflow.python.keras.callbacks.History at 0x7fe74c0f1240>

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 178us/sample - loss: 24941.5426 - categorical_accuracy: 0.1110 - val_loss: 22170.3123 - val_categorical_accuracy: 0.0800
Epoch 2/10
1000/1000 [==============================] - 0s 95us/sample - loss: 27946.4825 - categorical_accuracy: 0.0990 - val_loss: 22531.8664 - val_categorical_accuracy: 0.1000
Epoch 3/10
1000/1000 [==============================] - 0s 95us/sample - loss: 33313.0864 - categorical_accuracy: 0.0960 - val_loss: 40268.1456 - val_categorical_accuracy: 0.1300
Epoch 4/10
1000/1000 [==============================] - 0s 93us/sample - loss: 39161.3360 - categorical_accuracy: 0.1050 - val_loss: 33861.4163 - val_categorical_accuracy: 0.1000
Epoch 5/10
1000/1000 [==============================] - 0s 100us/sample - loss: 44375.6921 - categorical_accuracy: 0.1040 - val_loss: 46568.1248 - val_categorical_accuracy: 0.0700
Epoch 6/10
1000/1000 [==============================] - 0s 95us/sample - loss: 48923.2586 - categorical_accuracy: 0.0970 - val_loss: 81242.8403 - val_categorical_accuracy: 0.0700
Epoch 7/10
1000/1000 [==============================] - 0s 94us/sample - loss: 58926.1624 - categorical_accuracy: 0.0910 - val_loss: 67530.7906 - val_categorical_accuracy: 0.0900
Epoch 8/10
1000/1000 [==============================] - 0s 92us/sample - loss: 61365.5712 - categorical_accuracy: 0.1020 - val_loss: 73100.3025 - val_categorical_accuracy: 0.1400
Epoch 9/10
1000/1000 [==============================] - 0s 94us/sample - loss: 71333.1506 - categorical_accuracy: 0.0980 - val_loss: 71719.7863 - val_categorical_accuracy: 0.1400
Epoch 10/10
1000/1000 [==============================] - 0s 94us/sample - loss: 74634.9986 - categorical_accuracy: 0.1100 - val_loss: 67717.8081 - val_categorical_accuracy: 0.1100

<tensorflow.python.keras.callbacks.History at 0x7fe74fad4ba8>

 

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)

model.fit(dataset, epochs=10)
Epoch 1/10
32/32 [==============================] - 0s 4ms/step - loss: 81467.1696 - categorical_accuracy: 0.1040
Epoch 2/10
32/32 [==============================] - 0s 3ms/step - loss: 95568.6485 - categorical_accuracy: 0.0970
Epoch 3/10
32/32 [==============================] - 0s 3ms/step - loss: 97389.2383 - categorical_accuracy: 0.1060
Epoch 4/10
32/32 [==============================] - 0s 3ms/step - loss: 104265.7252 - categorical_accuracy: 0.0950
Epoch 5/10
32/32 [==============================] - 0s 3ms/step - loss: 116323.9572 - categorical_accuracy: 0.1010
Epoch 6/10
32/32 [==============================] - 0s 3ms/step - loss: 124712.1657 - categorical_accuracy: 0.1090
Epoch 7/10
32/32 [==============================] - 0s 3ms/step - loss: 132602.0694 - categorical_accuracy: 0.0930
Epoch 8/10
32/32 [==============================] - 0s 3ms/step - loss: 144176.1806 - categorical_accuracy: 0.0930
Epoch 9/10
32/32 [==============================] - 0s 3ms/step - loss: 151150.5936 - categorical_accuracy: 0.1160
Epoch 10/10
32/32 [==============================] - 0s 3ms/step - loss: 163552.8846 - categorical_accuracy: 0.1040

<tensorflow.python.keras.callbacks.History at 0x7fe72c563940>

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)
Epoch 1/10
32/32 [==============================] - 0s 4ms/step - loss: 174823.2109 - categorical_accuracy: 0.1040 - val_loss: 0.0000e+00 - val_categorical_accuracy: 0.0000e+00
Epoch 2/10
32/32 [==============================] - 0s 3ms/step - loss: 182694.2235 - categorical_accuracy: 0.0920 - val_loss: 207405.1328 - val_categorical_accuracy: 0.1000
Epoch 3/10
32/32 [==============================] - 0s 3ms/step - loss: 198014.8274 - categorical_accuracy: 0.0910 - val_loss: 254707.6133 - val_categorical_accuracy: 0.0900
Epoch 4/10
32/32 [==============================] - 0s 3ms/step - loss: 210588.8274 - categorical_accuracy: 0.1020 - val_loss: 169632.5312 - val_categorical_accuracy: 0.1300
Epoch 5/10
32/32 [==============================] - 0s 3ms/step - loss: 219237.8966 - categorical_accuracy: 0.1020 - val_loss: 213207.9141 - val_categorical_accuracy: 0.1300
Epoch 6/10
32/32 [==============================] - 0s 3ms/step - loss: 234645.3691 - categorical_accuracy: 0.1040 - val_loss: 273672.8672 - val_categorical_accuracy: 0.0900
Epoch 7/10
32/32 [==============================] - 0s 3ms/step - loss: 246899.7756 - categorical_accuracy: 0.1050 - val_loss: 215929.5312 - val_categorical_accuracy: 0.1000
Epoch 8/10
32/32 [==============================] - 0s 3ms/step - loss: 257410.2769 - categorical_accuracy: 0.1090 - val_loss: 303968.7422 - val_categorical_accuracy: 0.1300
Epoch 9/10
32/32 [==============================] - 0s 3ms/step - loss: 273098.0448 - categorical_accuracy: 0.0910 - val_loss: 279622.2812 - val_categorical_accuracy: 0.0900
Epoch 10/10
32/32 [==============================] - 0s 3ms/step - loss: 291685.4157 - categorical_accuracy: 0.0890 - val_loss: 277359.3203 - val_categorical_accuracy: 0.1000

<tensorflow.python.keras.callbacks.History at 0x7fe72c27f0f0>

 

評価と予測

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

提供されたデータのために推論モードの損失とメトリクスをどのように評価するがここにあります :

# With Numpy arrays
data = np.random.random((1000, 32))
labels = np.random.random((1000, 10))

model.evaluate(data, labels, batch_size=32)

# With a Dataset
dataset = tf.data.Dataset.from_tensor_slices((data, labels))
dataset = dataset.batch(32)

model.evaluate(dataset)
1000/1 [========= ... =========] - 0s 53us/sample - loss: 249148.8575 - categorical_accuracy: 0.0960
32/32 [==============================] - 0s 2ms/step - loss: 262983.5693 - categorical_accuracy: 0.0960

[262983.5693359375, 0.096]

そして提供されたデータのために推論で最後の層の出力をどのように予測するかがここにあります、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 によるモデル構築はこのように動作します :

  1. 層インスタンスは callable で tensor を返します。
  2. 入力 tensor と出力 tensor は tf.keras.Model インスタンスを定義するために使用されます。
  3. このモデルは丁度 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 472us/sample - loss: 14.3942 - accuracy: 0.0980
Epoch 2/5
1000/1000 [==============================] - 0s 83us/sample - loss: 29.4704 - accuracy: 0.1010
Epoch 3/5
1000/1000 [==============================] - 0s 80us/sample - loss: 54.4626 - accuracy: 0.1120
Epoch 4/5
1000/1000 [==============================] - 0s 78us/sample - loss: 87.0312 - accuracy: 0.1020
Epoch 5/5
1000/1000 [==============================] - 0s 80us/sample - loss: 125.3873 - accuracy: 0.1160

<tensorflow.python.keras.callbacks.History at 0x7fe72c01f128>

 

Model サブクラス化

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

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

Note: 貴方のモデルが常に命令的に実行されることが必要な場合には、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 [==============================] - 1s 572us/sample - loss: 11.4854 - accuracy: 0.0910
Epoch 2/5
1000/1000 [==============================] - 0s 78us/sample - loss: 11.4548 - accuracy: 0.0910
Epoch 3/5
1000/1000 [==============================] - 0s 83us/sample - loss: 11.4474 - accuracy: 0.1060
Epoch 4/5
1000/1000 [==============================] - 0s 81us/sample - loss: 11.4434 - accuracy: 0.1070
Epoch 5/5
1000/1000 [==============================] - 0s 80us/sample - loss: 11.4400 - accuracy: 0.1070

<tensorflow.python.keras.callbacks.History at 0x7fe6d05a1d30>

 

カスタム層

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

  • __init__: オプションでこの層により使用される部分層 (= sublayers) を定義します。
  • 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 289us/sample - loss: 11.4484 - accuracy: 0.1000
Epoch 2/5
1000/1000 [==============================] - 0s 62us/sample - loss: 11.4486 - accuracy: 0.1030
Epoch 3/5
1000/1000 [==============================] - 0s 65us/sample - loss: 11.4487 - accuracy: 0.1010
Epoch 4/5
1000/1000 [==============================] - 0s 64us/sample - loss: 11.4484 - accuracy: 0.1030
Epoch 5/5
1000/1000 [==============================] - 0s 64us/sample - loss: 11.4483 - accuracy: 0.1000

<tensorflow.python.keras.callbacks.History at 0x7fe6c0714160>

Guide to writing layers and models from scratch でサブクラス化による新しい層とモデルのスクラッチからの作成について更に学習してください。

 

コールバック

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

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))
Train on 1000 samples, validate on 100 samples
Epoch 1/5
1000/1000 [==============================] - 0s 157us/sample - loss: 11.4479 - accuracy: 0.1000 - val_loss: 11.7400 - val_accuracy: 0.1400
Epoch 2/5
1000/1000 [==============================] - 0s 82us/sample - loss: 11.4479 - accuracy: 0.1010 - val_loss: 11.7400 - val_accuracy: 0.1400
Epoch 3/5
1000/1000 [==============================] - 0s 79us/sample - loss: 11.4478 - accuracy: 0.1040 - val_loss: 11.7404 - val_accuracy: 0.1400
Epoch 4/5
1000/1000 [==============================] - 0s 80us/sample - loss: 11.4478 - accuracy: 0.1030 - val_loss: 11.7407 - val_accuracy: 0.1400

<tensorflow.python.keras.callbacks.History at 0x7fe6c02d5240>

 

セーブとリストア

単に重み値をセーブする

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 0x7fe76d32d128>

デフォルトでは、これはモデルの重みを 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 をセーブする

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

# Serialize a model to JSON format
json_string = model.to_json()
json_string
'{"class_name": "Sequential", "config": {"name": "sequential_3", "layers": [{"class_name": "Dense", "config": {"name": "dense_17", "trainable": true, "batch_input_shape": [null, 32], "dtype": "float32", "units": 64, "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, {"class_name": "Dense", "config": {"name": "dense_18", "trainable": true, "dtype": "float32", "units": 10, "activation": "softmax", "use_bias": true, "kernel_initializer": {"class_name": "GlorotUniform", "config": {"seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}]}, "keras_version": "2.2.4-tf", "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 404us/sample - loss: 11.4749 - accuracy: 0.1130
Epoch 2/5
1000/1000 [==============================] - 0s 73us/sample - loss: 11.4722 - accuracy: 0.1040
Epoch 3/5
1000/1000 [==============================] - 0s 75us/sample - loss: 11.4959 - accuracy: 0.1060
Epoch 4/5
1000/1000 [==============================] - 0s 73us/sample - loss: 11.5455 - accuracy: 0.0990
Epoch 5/5
1000/1000 [==============================] - 0s 74us/sample - loss: 11.5848 - accuracy: 0.0970

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 を見てください。

 

以上



AI導入支援 #2 ウェビナー

スモールスタートを可能としたAI導入支援   Vol.2
[無料 WEB セミナー] [詳細]
「画像認識 AI PoC スターターパック」の紹介
既に AI 技術を実ビジネスで活用し、成果を上げている日本企業も多く存在しており、競争優位なビジネスを展開しております。
しかしながら AI を導入したくとも PoC (概念実証) だけでも高額な費用がかかり取組めていない企業も少なくないようです。A I導入時には欠かせない PoC を手軽にしかも短期間で認知度を確認可能とするサービの紹介と共に、AI 技術の特性と具体的な導入プロセスに加え運用時のポイントについても解説いたします。
日時:2021年10月13日(水)
会場:WEBセミナー
共催:クラスキャット、日本FLOW(株)
後援:働き方改革推進コンソーシアム
参加費: 無料 (事前登録制)
人工知能開発支援
◆ クラスキャットは 人工知能研究開発支援 サービスを提供しています :
  • テクニカルコンサルティングサービス
  • 実証実験 (プロトタイプ構築)
  • アプリケーションへの実装
  • 人工知能研修サービス
◆ お問合せ先 ◆
(株)クラスキャット
セールス・インフォメーション
E-Mail:sales-info@classcat.com