 TensorFlow.orgで表示 |
 Google Colabで実行 |
 GitHub でソースを表示{ |
 ノートブックをダウンロード/a0} |
セットアップ
import tensorflow as tf
from tensorflow import keras
Layer クラス：状態（重み）といくつかの計算の組み合わせ
Kerasの中心的な抽象概念の1つは、Layerクラスです。 レイヤーは、状態（レイヤーの「重み」）と入力から出力への変換（「呼び出し」、レイヤーのフォワードパス）をカプセル化します。
以下の密に接続されたレイヤーで、状態は変数wとbをもちます。
class Linear(keras.layers.Layer):
def __init__(self, units=32, input_dim=32):
super(Linear, self).__init__()
w_init = tf.random_normal_initializer()
self.w = tf.Variable(
initial_value=w_init(shape=(input_dim, units), dtype="float32"),
trainable=True,
)
b_init = tf.zeros_initializer()
self.b = tf.Variable(
initial_value=b_init(shape=(units,), dtype="float32"), trainable=True
)
def call(self, inputs):
return tf.matmul(inputs, self.w) + self.b
Python関数のように、レイヤーをテンソル入力で呼び出して使用します。
x = tf.ones((2, 2))
linear_layer = Linear(4, 2)
y = linear_layer(x)
print(y)
tf.Tensor( [[ 0.07282981 0.12652102 -0.07736319 -0.04927423] [ 0.07282981 0.12652102 -0.07736319 -0.04927423]], shape=(2, 4), dtype=float32)
重みwおよびbをレイヤー属性として設定すると、レイヤーによって自動的に追跡されるので注意してください。
assert linear_layer.weights == [linear_layer.w, linear_layer.b]
また、add_weight()を使用すると、レイヤーにより迅速に重みを追加することができます。
class Linear(keras.layers.Layer):
def __init__(self, units=32, input_dim=32):
super(Linear, self).__init__()
self.w = self.add_weight(
shape=(input_dim, units), initializer="random_normal", trainable=True
)
self.b = self.add_weight(shape=(units,), initializer="zeros", trainable=True)
def call(self, inputs):
return tf.matmul(inputs, self.w) + self.b
x = tf.ones((2, 2))
linear_layer = Linear(4, 2)
y = linear_layer(x)
print(y)
tf.Tensor( [[ 0.00278423 -0.05210945 -0.04448502 0.0174655 ] [ 0.00278423 -0.05210945 -0.04448502 0.0174655 ]], shape=(2, 4), dtype=float32)
トレーニングできない重みをレイヤーに追加
トレーニング可能な重みだけでなく、トレーニング不可能な重みもレイヤーに追加できます。このような重みは、レイヤーをトレーニングする際、バックプロパゲーションで考慮されません。
以下のようにトレーニング不可能な重みを追加して使用します。
class ComputeSum(keras.layers.Layer):
def __init__(self, input_dim):
super(ComputeSum, self).__init__()
self.total = tf.Variable(initial_value=tf.zeros((input_dim,)), trainable=False)
def call(self, inputs):
self.total.assign_add(tf.reduce_sum(inputs, axis=0))
return self.total
x = tf.ones((2, 2))
my_sum = ComputeSum(2)
y = my_sum(x)
print(y.numpy())
y = my_sum(x)
print(y.numpy())
[2. 2.] [4. 4.]
これはlayer.weightsの一部ですが、トレーニング不可能な重みとして分類されます。
print("weights:", len(my_sum.weights))
print("non-trainable weights:", len(my_sum.non_trainable_weights))
# It's not included in the trainable weights:
print("trainable_weights:", my_sum.trainable_weights)
weights: 1 non-trainable weights: 1 trainable_weights: []
ベストプラクティス：入力の形状がわかるまで重みづけを延期する
上記のLinear レイヤーは、input_dim引数を受け取り、この引数は__init__()の重みwおよびb の形状を計算するために使用されました。
class Linear(keras.layers.Layer):
def __init__(self, units=32, input_dim=32):
super(Linear, self).__init__()
self.w = self.add_weight(
shape=(input_dim, units), initializer="random_normal", trainable=True
)
self.b = self.add_weight(shape=(units,), initializer="zeros", trainable=True)
def call(self, inputs):
return tf.matmul(inputs, self.w) + self.b
多くの場合、入力値は事前に分からないので、その値が分かった時に後から（レイヤーをインスタンス化した後など）重みを定義したいと思うこともあるでしょう。
Keras APIでは、以下のようにレイヤーのbuild(self, inputs_shape)メソッドでレイヤーの重みを定義することをお勧めします。
class Linear(keras.layers.Layer):
def __init__(self, units=32):
super(Linear, self).__init__()
self.units = units
def build(self, input_shape):
self.w = self.add_weight(
shape=(input_shape[-1], self.units),
initializer="random_normal",
trainable=True,
)
self.b = self.add_weight(
shape=(self.units,), initializer="random_normal", trainable=True
)
def call(self, inputs):
return tf.matmul(inputs, self.w) + self.b
レイヤーの__call__()メソッドは、最初に呼び出されたときに自動的にビルドを実行します。後から重みを定義できる使いやすいレイヤーができました。
# At instantiation, we don't know on what inputs this is going to get called
linear_layer = Linear(32)
# The layer's weights are created dynamically the first time the layer is called
y = linear_layer(x)
レイヤーは再帰的に構成可能
レイヤーインスタンスを別のレイヤーの属性として割り当てると、外部レイヤーは内部レイヤーの重みを追跡し始めます。
そのようなサブレイヤーは、__init__()メソッドで作成することをお勧めします（通常、サブレイヤーにはビルドメソッドがあるため、外部レイヤーがビルドされるときにサブレイヤーがビルドされます）。
# Let's assume we are reusing the Linear class
# with a `build` method that we defined above.
class MLPBlock(keras.layers.Layer):
def __init__(self):
super(MLPBlock, self).__init__()
self.linear_1 = Linear(32)
self.linear_2 = Linear(32)
self.linear_3 = Linear(1)
def call(self, inputs):
x = self.linear_1(inputs)
x = tf.nn.relu(x)
x = self.linear_2(x)
x = tf.nn.relu(x)
return self.linear_3(x)
mlp = MLPBlock()
y = mlp(tf.ones(shape=(3, 64))) # The first call to the `mlp` will create the weights
print("weights:", len(mlp.weights))
print("trainable weights:", len(mlp.trainable_weights))
weights: 6 trainable weights: 6
add_loss()メソッド
レイヤーのcall()メソッドを記述する際、トレーニングループを作成するときに、後で使用する損失テンソルを作成できます。これは、self.add_loss(value)を呼び出すことで実行できます。
# A layer that creates an activity regularization loss
class ActivityRegularizationLayer(keras.layers.Layer):
def __init__(self, rate=1e-2):
super(ActivityRegularizationLayer, self).__init__()
self.rate = rate
def call(self, inputs):
self.add_loss(self.rate * tf.reduce_sum(inputs))
return inputs
これらの損失（内部レイヤーによって作成されたものを含む）は、 layer.lossesで取得できます。このプロパティは、すべての__call__()の開始時にトップレベルレイヤーにリセットされるので、 layer.losses には、最後のフォワードパス時に定義された損失値が常に含まれます。
class OuterLayer(keras.layers.Layer):
def __init__(self):
super(OuterLayer, self).__init__()
self.activity_reg = ActivityRegularizationLayer(1e-2)
def call(self, inputs):
return self.activity_reg(inputs)
layer = OuterLayer()
assert len(layer.losses) == 0 # No losses yet since the layer has never been called
_ = layer(tf.zeros(1, 1))
assert len(layer.losses) == 1 # We created one loss value
# `layer.losses` gets reset at the start of each __call__
_ = layer(tf.zeros(1, 1))
assert len(layer.losses) == 1 # This is the loss created during the call above
さらに、lossプロパティには、内部レイヤーの重みに対して定義された正則化損失も含まれます。
class OuterLayerWithKernelRegularizer(keras.layers.Layer):
def __init__(self):
super(OuterLayerWithKernelRegularizer, self).__init__()
self.dense = keras.layers.Dense(
32, kernel_regularizer=tf.keras.regularizers.l2(1e-3)
)
def call(self, inputs):
return self.dense(inputs)
layer = OuterLayerWithKernelRegularizer()
_ = layer(tf.zeros((1, 1)))
# This is `1e-3 * sum(layer.dense.kernel ** 2)`,
# created by the `kernel_regularizer` above.
print(layer.losses)
[<tf.Tensor: shape=(), dtype=float32, numpy=0.0014113332>]
これらの損失は、以下のようにトレーニングループを記述するときに考慮されることを意図しています。
# Instantiate an optimizer.
optimizer = tf.keras.optimizers.SGD(learning_rate=1e-3)
loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)
# Iterate over the batches of a dataset.
for x_batch_train, y_batch_train in train_dataset:
with tf.GradientTape() as tape:
logits = layer(x_batch_train) # Logits for this minibatch
# Loss value for this minibatch
loss_value = loss_fn(y_batch_train, logits)
# Add extra losses created during this forward pass:
loss_value += sum(model.losses)
grads = tape.gradient(loss_value, model.trainable_weights)
optimizer.apply_gradients(zip(grads, model.trainable_weights))
トレーニングループの記述に関する詳細は、「トレーニングループを新規作成するためのガイド」を参照してください。
これらの損失は、fit() とシームレスに連携します（自動的に集計され、メジャーな損失がある場合にはそれに追加されます）。
import numpy as np
inputs = keras.Input(shape=(3,))
outputs = ActivityRegularizationLayer()(inputs)
model = keras.Model(inputs, outputs)
# If there is a loss passed in `compile`, thee regularization
# losses get added to it
model.compile(optimizer="adam", loss="mse")
model.fit(np.random.random((2, 3)), np.random.random((2, 3)))
# It's also possible not to pass any loss in `compile`,
# since the model already has a loss to minimize, via the `add_loss`
# call during the forward pass!
model.compile(optimizer="adam")
model.fit(np.random.random((2, 3)), np.random.random((2, 3)))
1/1 [==============================] - 0s 113ms/step - loss: 0.1165 1/1 [==============================] - 0s 50ms/step - loss: 0.0290 <tensorflow.python.keras.callbacks.History at 0x7f71501d8198>
add_metric()メソッド
add_loss()と同様に、レイヤーではadd_metric()メソッドでトレーニング中の数量の移動平均を追跡できます。
「ロジスティックエンドポイント」レイヤーでは、入力として予測とターゲットを受け取り、 add_loss()を介して追跡する損失を計算し、add_metric()を介して追跡する精度スカラーを計算します。
class LogisticEndpoint(keras.layers.Layer):
def __init__(self, name=None):
super(LogisticEndpoint, self).__init__(name=name)
self.loss_fn = keras.losses.BinaryCrossentropy(from_logits=True)
self.accuracy_fn = keras.metrics.BinaryAccuracy()
def call(self, targets, logits, sample_weights=None):
# Compute the training-time loss value and add it
# to the layer using `self.add_loss()`.
loss = self.loss_fn(targets, logits, sample_weights)
self.add_loss(loss)
# Log accuracy as a metric and add it
# to the layer using `self.add_metric()`.
acc = self.accuracy_fn(targets, logits, sample_weights)
self.add_metric(acc, name="accuracy")
# Return the inference-time prediction tensor (for `.predict()`).
return tf.nn.softmax(logits)
この方法で追跡されるメトリクスは、layer.metricsで取得できます。
layer = LogisticEndpoint()
targets = tf.ones((2, 2))
logits = tf.ones((2, 2))
y = layer(targets, logits)
print("layer.metrics:", layer.metrics)
print("current accuracy value:", float(layer.metrics[0].result()))
layer.metrics: [<tensorflow.python.keras.metrics.BinaryAccuracy object at 0x7f720d2beeb8>] current accuracy value: 1.0
add_loss()の場合と同様に、これらのメトリックはfit()により追跡されます。
inputs = keras.Input(shape=(3,), name="inputs")
targets = keras.Input(shape=(10,), name="targets")
logits = keras.layers.Dense(10)(inputs)
predictions = LogisticEndpoint(name="predictions")(logits, targets)
model = keras.Model(inputs=[inputs, targets], outputs=predictions)
model.compile(optimizer="adam")
data = {
"inputs": np.random.random((3, 3)),
"targets": np.random.random((3, 10)),
}
model.fit(data)
1/1 [==============================] - 0s 258ms/step - loss: 0.8876 - binary_accuracy: 0.0000e+00 <tensorflow.python.keras.callbacks.History at 0x7f715014c0f0>
レイヤーのシリアル化をオプションで有効化
カスタムレイヤーをFunctionalモデルの一部としてシリアル化可能にする必要がある場合は、オプションでget_config() メソッドを実装できます。
class Linear(keras.layers.Layer):
def __init__(self, units=32):
super(Linear, self).__init__()
self.units = units
def build(self, input_shape):
self.w = self.add_weight(
shape=(input_shape[-1], self.units),
initializer="random_normal",
trainable=True,
)
self.b = self.add_weight(
shape=(self.units,), initializer="random_normal", trainable=True
)
def call(self, inputs):
return tf.matmul(inputs, self.w) + self.b
def get_config(self):
return {"units": self.units}
# Now you can recreate the layer from its config:
layer = Linear(64)
config = layer.get_config()
print(config)
new_layer = Linear.from_config(config)
{'units': 64}
基底 Layerクラスの__init__()メソッドでは、nameやdtypeなどのキーワード引数を使えます。これらの引数を __init__() で親クラスに渡し、レイヤーコンフィギュレーションに含めることをお勧めします。
class Linear(keras.layers.Layer):
def __init__(self, units=32, **kwargs):
super(Linear, 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(Linear, self).get_config()
config.update({"units": self.units})
return config
layer = Linear(64)
config = layer.get_config()
print(config)
new_layer = Linear.from_config(config)
{'name': 'linear_8', 'trainable': True, 'dtype': 'float32', 'units': 64}
構成からレイヤーを逆シリアル化するときに柔軟性が必要な場合は、 from_config() クラスメソッドをオーバーライドすることもできます。これは、from_config()の基本実装です。
def from_config(cls, config): return cls(**config)
シリアル化と保存の詳細については、「モデルの保存とシリアル化のガイド」を参照してください。
call() メソッドの特権付き トレーニング引数
一部のレイヤー、特にBatchNormalizationレイヤーとDropoutレイヤーでは、トレーニングと推論での動作が異なります。このようなレイヤーでは、call() メソッドでトレーニング引数（ブール値）を公開するのが標準的なメソッドです。
この引数を call()で公開することで、組み込みのトレーニングループと評価ループ（fit()など）を有効にして、トレーニングと推論でレイヤーを正しく使用できます。
class CustomDropout(keras.layers.Layer):
def __init__(self, rate, **kwargs):
super(CustomDropout, self).__init__(**kwargs)
self.rate = rate
def call(self, inputs, training=None):
if training:
return tf.nn.dropout(inputs, rate=self.rate)
return inputs
call() メソッドの特権付き マスク引数
call()がサポートするもう１つの特権引数は、マスク引数です。
これはすべてのKeras RNNレイヤーにあります。 マスクは、時系列データを処理するときに特定の入力タイムステップをスキップするために使用されるブールテンソルです。（入力するタイムステップごとに1つのブール値を返します）。
前のレイヤーによってマスクが生成されると、Kerasは、それをサポートするレイヤーの正しいマスク 引数を自動的に __call__()に渡します。 マスク生成レイヤーは、mask_zero=Trueで構成されたEmbeddingレイヤーと、Masking レイヤーです。
マスキングの詳細と、マスキングが有効なレイヤーの記述については、 「マスキングとパディングのガイド」を参照してください。
モデルクラス
一般的に、レイヤークラスを使用して内部計算ブロックを定義し、モデルクラスを使用して外部モデル（トレーニングするオブジェクト）を定義します。
たとえば、ResNet50モデルでは、レイヤーをサブクラス化する複数のResNetブロックと、ResNet50ネットワーク全体を包含する１つの モデルがあります。
モデルクラスはレイヤークラスと同じAPIをもちますが、以下の点で異なります。
- 組み込みのトレーニング、評価、予測ループを公開します(
model.fit()、model.evaluate()、model.predict())。 model.layersプロパティを介して、その内部レイヤーのリストを公開します。- 保存およびシリアル化APIを公開します(
save()、save_weights()...)
実質的にレイヤークラスは、文献で「レイヤー」（「畳み込みレイヤー」または「リカレントレイヤー」など）または「ブロック」（「ResNetブロック」または「Inceptionブロック」など）と呼ばれているものに対応します。
一方、モデルクラスは、文献で「モデル」（「ディープラーニングモデル」など）または「ネットワーク」（「ディープニューラルネットワーク」など）と呼ばれているものに対応します 。
レイヤークラスまたはモデルクラスのどちらを使用すべきか迷っている場合は、次の点を確認してください。 fit()やsave()を呼び出す必要がある場合は、モデルを使用してください。 その他の場合（クラスがより大きなシステムの単なるブロックである場合や自分でトレーニングを記述してコードを保存する場合）は、レイヤーを使用します。
たとえば、上のmini-resnetの例を使用してモデル を構築し、fit()でトレーニングし、save_weights()で保存できます。
class ResNet(tf.keras.Model):
def __init__(self):
super(ResNet, self).__init__()
self.block_1 = ResNetBlock()
self.block_2 = ResNetBlock()
self.global_pool = layers.GlobalAveragePooling2D()
self.classifier = Dense(num_classes)
def call(self, inputs):
x = self.block_1(inputs)
x = self.block_2(x)
x = self.global_pool(x)
return self.classifier(x)
resnet = ResNet()
dataset = ...
resnet.fit(dataset, epochs=10)
resnet.save(filepath)
まとめ：エンドツーエンドの例
今まで学んだことを復習しましょう。
レイヤーは、状態（__init__()またはbuild()で作成）といくつかの計算（call()で定義）をカプセル化します。- レイヤーを再帰的にネストし、新しい大きな計算ブロックを作成できます。
- レイヤーは、
add_loss()およびadd_metric()を介して、損失（通常は正則化損失）およびメトリックを作成および追跡できます。 - トレーニングの対象となる外部コンテナは、
モデルです。モデルはレイヤーに似ていますが、トレーニングとシリアル化ユーティリティが追加されます。
これらすべてをエンドツーエンドの例にまとめましょう。Variational AutoEncoder (VAE)を実装し、 MNISTディジットでトレーニングします。
VAEはモデルのサブクラスで、Layerをサブクラス化するLayerのネストされた構成として構築されます。 正則化損失（KLダイバージェンス）が特徴です。
from tensorflow.keras import layers
class Sampling(layers.Layer):
"""Uses (z_mean, z_log_var) to sample z, the vector encoding a digit."""
def call(self, inputs):
z_mean, z_log_var = inputs
batch = tf.shape(z_mean)[0]
dim = tf.shape(z_mean)[1]
epsilon = tf.keras.backend.random_normal(shape=(batch, dim))
return z_mean + tf.exp(0.5 * z_log_var) * epsilon
class Encoder(layers.Layer):
"""Maps MNIST digits to a triplet (z_mean, z_log_var, z)."""
def __init__(self, latent_dim=32, intermediate_dim=64, name="encoder", **kwargs):
super(Encoder, self).__init__(name=name, **kwargs)
self.dense_proj = layers.Dense(intermediate_dim, activation="relu")
self.dense_mean = layers.Dense(latent_dim)
self.dense_log_var = layers.Dense(latent_dim)
self.sampling = Sampling()
def call(self, inputs):
x = self.dense_proj(inputs)
z_mean = self.dense_mean(x)
z_log_var = self.dense_log_var(x)
z = self.sampling((z_mean, z_log_var))
return z_mean, z_log_var, z
class Decoder(layers.Layer):
"""Converts z, the encoded digit vector, back into a readable digit."""
def __init__(self, original_dim, intermediate_dim=64, name="decoder", **kwargs):
super(Decoder, self).__init__(name=name, **kwargs)
self.dense_proj = layers.Dense(intermediate_dim, activation="relu")
self.dense_output = layers.Dense(original_dim, activation="sigmoid")
def call(self, inputs):
x = self.dense_proj(inputs)
return self.dense_output(x)
class VariationalAutoEncoder(keras.Model):
"""Combines the encoder and decoder into an end-to-end model for training."""
def __init__(
self,
original_dim,
intermediate_dim=64,
latent_dim=32,
name="autoencoder",
**kwargs
):
super(VariationalAutoEncoder, self).__init__(name=name, **kwargs)
self.original_dim = original_dim
self.encoder = Encoder(latent_dim=latent_dim, intermediate_dim=intermediate_dim)
self.decoder = Decoder(original_dim, intermediate_dim=intermediate_dim)
def call(self, inputs):
z_mean, z_log_var, z = self.encoder(inputs)
reconstructed = self.decoder(z)
# Add KL divergence regularization loss.
kl_loss = -0.5 * tf.reduce_mean(
z_log_var - tf.square(z_mean) - tf.exp(z_log_var) + 1
)
self.add_loss(kl_loss)
return reconstructed
MNISTで簡単なトレーニングループを書いてみましょう。
original_dim = 784
vae = VariationalAutoEncoder(original_dim, 64, 32)
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
mse_loss_fn = tf.keras.losses.MeanSquaredError()
loss_metric = tf.keras.metrics.Mean()
(x_train, _), _ = tf.keras.datasets.mnist.load_data()
x_train = x_train.reshape(60000, 784).astype("float32") / 255
train_dataset = tf.data.Dataset.from_tensor_slices(x_train)
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)
epochs = 2
# Iterate over epochs.
for epoch in range(epochs):
print("Start of epoch %d" % (epoch,))
# Iterate over the batches of the dataset.
for step, x_batch_train in enumerate(train_dataset):
with tf.GradientTape() as tape:
reconstructed = vae(x_batch_train)
# Compute reconstruction loss
loss = mse_loss_fn(x_batch_train, reconstructed)
loss += sum(vae.losses) # Add KLD regularization loss
grads = tape.gradient(loss, vae.trainable_weights)
optimizer.apply_gradients(zip(grads, vae.trainable_weights))
loss_metric(loss)
if step % 100 == 0:
print("step %d: mean loss = %.4f" % (step, loss_metric.result()))
Start of epoch 0 step 0: mean loss = 0.3319 step 100: mean loss = 0.1247 step 200: mean loss = 0.0987 step 300: mean loss = 0.0888 step 400: mean loss = 0.0840 step 500: mean loss = 0.0807 step 600: mean loss = 0.0786 step 700: mean loss = 0.0770 step 800: mean loss = 0.0759 step 900: mean loss = 0.0749 Start of epoch 1 step 0: mean loss = 0.0746 step 100: mean loss = 0.0739 step 200: mean loss = 0.0734 step 300: mean loss = 0.0730 step 400: mean loss = 0.0726 step 500: mean loss = 0.0722 step 600: mean loss = 0.0719 step 700: mean loss = 0.0717 step 800: mean loss = 0.0714 step 900: mean loss = 0.0712
VAEはModelをサブクラス化しているため、組み込みのトレーニングループが備わっています。 そのため、次のようにトレーニングすることもできます。
vae = VariationalAutoEncoder(784, 64, 32)
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
vae.compile(optimizer, loss=tf.keras.losses.MeanSquaredError())
vae.fit(x_train, x_train, epochs=2, batch_size=64)
Epoch 1/2 938/938 [==============================] - 3s 2ms/step - loss: 0.0947 Epoch 2/2 938/938 [==============================] - 2s 3ms/step - loss: 0.0677 <tensorflow.python.keras.callbacks.History at 0x7f713c71e588>
オブジェクト指向開発を超えて：Functional API
ここでは、オブジェクト指向の開発の例を多く紹介しましたが、 Functional APIを使用してモデルを構築することもできます。重要なのは、いずれかのスタイルを選択しても、もう一方のスタイルで記述されたコンポーネントを組み合わせることができるということです。
たとえば、以下のFunctional APIの例では、上の例で定義した Sampling レイヤーを再利用しています。
original_dim = 784
intermediate_dim = 64
latent_dim = 32
# Define encoder model.
original_inputs = tf.keras.Input(shape=(original_dim,), name="encoder_input")
x = layers.Dense(intermediate_dim, activation="relu")(original_inputs)
z_mean = layers.Dense(latent_dim, name="z_mean")(x)
z_log_var = layers.Dense(latent_dim, name="z_log_var")(x)
z = Sampling()((z_mean, z_log_var))
encoder = tf.keras.Model(inputs=original_inputs, outputs=z, name="encoder")
# Define decoder model.
latent_inputs = tf.keras.Input(shape=(latent_dim,), name="z_sampling")
x = layers.Dense(intermediate_dim, activation="relu")(latent_inputs)
outputs = layers.Dense(original_dim, activation="sigmoid")(x)
decoder = tf.keras.Model(inputs=latent_inputs, outputs=outputs, name="decoder")
# Define VAE model.
outputs = decoder(z)
vae = tf.keras.Model(inputs=original_inputs, outputs=outputs, name="vae")
# Add KL divergence regularization loss.
kl_loss = -0.5 * tf.reduce_mean(z_log_var - tf.square(z_mean) - tf.exp(z_log_var) + 1)
vae.add_loss(kl_loss)
# Train.
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
vae.compile(optimizer, loss=tf.keras.losses.MeanSquaredError())
vae.fit(x_train, x_train, epochs=3, batch_size=64)
Epoch 1/3 938/938 [==============================] - 3s 3ms/step - loss: 0.0953 Epoch 2/3 938/938 [==============================] - 2s 2ms/step - loss: 0.0677 Epoch 3/3 938/938 [==============================] - 2s 2ms/step - loss: 0.0677 <tensorflow.python.keras.callbacks.History at 0x7f713c576358>
詳細につきましては、Functional API のガイドを参照してください。