Skip to content

TensorFlow チートシート

Google によるエンドツーエンドのオープンソース機械学習プラットフォーム。

01

はじめに

インストールと基本

TensorFlow 2.x は、デフォルトでイーガーに実行します(演算が通常の Python のように即座に実行されます)。CUDA GPU が可視か検証するには、tf.config.list_physical_devices('GPU') を使いましょう。GPU 対応のためには、Linux/Windows では [and-cuda] のエクストラを、Apple Silicon では tensorflow-metal をインストールします。TF 2.x は、Keras を tf.keras としてマージしました — ほとんどのワークフローで使われる高レベル API です。

tensorflow
# install TensorFlow (CPU)
pip install tensorflow

# with GPU support on Linux/Windows (CUDA-enabled)
pip install tensorflow[and-cuda]

import tensorflow as tf

# check version and devices
print(tf.__version__)
print("GPU:", tf.config.list_physical_devices('GPU'))

# eager execution is on by default in TF2
print(tf.executing_eagerly())   # True

最初のテンソル

tf.constant は不変のテンソルを作り、tf.zeros / tf.ones / tf.random.* はよくあるパターンを作ります。すべてのテンソルには、shape、dtype、rank があります。.numpy() は NumPy へ戻す橋渡しです — GPU 上では、同期コピーが引き起こされ得ます。パフォーマンスを壊すサイレントなアップキャストを避けるため、明示的な dtype(ML では float32 がデフォルト)を優先しましょう。

tensorflow
import tensorflow as tf

# constants are immutable
x = tf.constant([[1, 2], [3, 4]])
y = tf.zeros((3, 3))
z = tf.random.normal((2, 3), mean=0.0, stddev=1.0)

print(x.shape, x.dtype)   # (2, 2) int32
print(tf.reduce_sum(x))   # tf.Tensor(10, shape=(), dtype=int32)

# numpy interop is zero-copy when possible
print(x.numpy())          # array([[1, 2], [3, 4]])

イーガー実行と勾配

イーガー実行により、TF が通常の Python のようにデバッグ可能になります — print、pdb、トレースバックがすべて機能します。GradientTape は、監視されたテンソル上の順伝播の演算を記録するため(tf.Variable は自動的に監視されます)、tape.gradient が微分を計算できます。カスタムの訓練ループの基礎がこれです。テープはデフォルトで単回利用です。複数回 gradient を呼ぶには、persistent=True を使いましょう。

tensorflow
import tensorflow as tf

a = tf.constant(3.0)
b = tf.constant(4.0)
print(a * b + 1)   # tf.Tensor(13.0, ...)

# GradientTape records ops for automatic differentiation
with tf.GradientTape() as tape:
    tape.watch(a)
    y = a ** 2 + b    # y = a^2 + b, dy/da = 2a
grad = tape.gradient(y, a)
print(grad)   # tf.Tensor(6.0, ...)  (= 2*3)

tf.function とグラフ

@tf.function は、Python の関数をポータブルで最適化可能な TensorFlow グラフに変換します — GPU 上でずっと速く、分散に必要です。関数は入力シグネチャごとに 1 回トレースされるため、内側で Python の副作用やデータ依存の Python 制御フローを避けましょう(tf.cond / tf.while_loop を使わないと、再トレースされます)。変数は関数の外で一度だけ作るか、同じ名前の tf.Variable を再利用しましょう。

tensorflow
import tensorflow as tf

@tf.function  # traces a graph; runs in graph mode after first call
def train_step(x, y):
    with tf.GradientTape() as tape:
        preds = x * w + b
        loss = tf.reduce_mean((preds - y) ** 2)
    grads = tape.gradient(loss, [w, b])
    optimizer.apply_gradients(zip(grads, [w, b]))
    return loss

w = tf.Variable(0.1)
b = tf.Variable(0.0)
optimizer = tf.keras.optimizers.SGD(0.01)

# first call builds the graph (slower); subsequent calls are fast
loss = train_step(tf.constant([1., 2.]), tf.constant([2., 4.]))

混合精度

混合精度は float16 で計算しますが、float32 のマスター コピーを保つため、Tensor Core GPU(Volta+)で 2〜3 倍のスループットと半分のメモリが得られます。「mixed_float16」のポリシーは、アンダーフローを防ぐためロススケーリングを自動的に扱います。数値安定性のために、出力層を float32 に強制しましょう。計算能力 >= 7.0 が必要です。古い GPU では遅くなり得ます。

tensorflow
import tensorflow as tf

# enable mixed precision: compute in float16, store in float32
tf.keras.mixed_precision.set_global_policy('mixed_float16')

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', dtype='float32'),
    tf.keras.layers.Dense(10, activation='softmax', dtype='float32')
])

# loss scaling is automatic with mixed_float16 policy
print(tf.keras.mixed_precision.global_policy())
02

テンソル

tf.constant

tf.constant は不変のテンソルを作ります — 要素への代入はできません。訓練可能なテンソルには tf.Variable を使いましょう。tf.random.normal/uniform は、再現性のために seed 引数を受け付け、tf.random.set_seed(42) はプログラム全体を再現可能にします。驚きを避けるため、多次元の作成には(int でなく)shape のタプルを使いましょう。

tensorflow
import tensorflow as tf

a = tf.constant([1, 2, 3])
b = tf.constant([[1.0, 2.0], [3.0, 4.0]], dtype=tf.float32)

zeros = tf.zeros((2, 3))
ones = tf.ones((3, 3))
eye = tf.eye(3)
full = tf.fill((2, 3), 7.0)

arange = tf.range(0, 10, 2)       # [0, 2, 4, 6, 8]
linspace = tf.linspace(0.0, 1.0, 5)

rand = tf.random.uniform((2, 3))
randn = tf.random.normal((2, 3))

# constants are immutable: a[0] = 5  -> TypeError

tf.Variable

tf.Variable は、モデルのパラメータとオプティマイザの状態に使われる可変のテンソルラッパーです。assign / assign_add / assign_sub がその場で更新し — 通常の Python の代入(w = w + 1)は新しいテンソルを作り、ミューテートしません。変数は GradientTape により自動的に監視されますが、tf.constant は tape.watch() を明示的にしなければなりません。変数は、それを使う演算と同じデバイスに保ちましょう。

tensorflow
import tensorflow as tf

w = tf.Variable(0.1, dtype=tf.float32)
W = tf.Variable(tf.random.normal((3, 4)))
b = tf.Variable(tf.zeros((4,)))

# read value
print(w.numpy())        # 0.1

# update value
w.assign(0.5)
w.assign_add(0.1)       # w += 0.1
w.assign_sub(0.05)

# assign in place on a slice
W[0, 0].assign(99.0)

# watched by GradientTape automatically
with tf.GradientTape() as tape:
    y = w ** 2
grad = tape.gradient(y, w)   # 2w

テンソルの演算

ほとんどの数学は NumPy を映し返します:tf.reduce_sum / reduce_mean / reduce_max は、np.sum/mean/max に相当します。特定の次元を還元するには axis= を、ブロードキャストのために rank を保つには keepdims=True を使いましょう。tf.matmul と @ 演算子は行列乗算を行います(入力が 3D+ のときバッチ化されます)。reshape は可能なときビューを返し、TF で transpose は常にコピーを返します。

tensorflow
import tensorflow as tf

a = tf.constant([[1.0, 2.0], [3.0, 4.0]])
b = tf.constant([[5.0, 6.0], [7.0, 8.0]])

a + b; a - b; a * b; a / b      # element-wise
c = tf.matmul(a, b)              # matrix multiply
c = a @ b                        # equivalent

tf.reduce_sum(a)                 # sum of all
tf.reduce_sum(a, axis=0)         # sum along axis 0
tf.reduce_mean(a, axis=1)        # mean along axis 1
tf.reduce_max(a, axis=1)
tf.reduce_sum(a, axis=1, keepdims=True)

x = tf.range(12)
y = tf.reshape(x, (3, 4))
t = tf.transpose(y)              # shape (4, 3)

インデックスとスライス

TF は、イーガーモードと tf.function の内側で、NumPy 風のスライスをサポートします。マスクが True の要素を抽出するのが、tf.boolean_mask(フラット化されます)です。デフォルトで軸 0 に沿って選択するのが、tf.gather です(ファンシーインデックスのようです)。ベクトル化された三項演算であるのが、tf.where(cond, x, y) で — cond が True のとき x から、さもなければ y から選びます。代入には、tf.tensor_scatter_nd_update か tf.Variable を使いましょう。

tensorflow
import tensorflow as tf

x = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

x[0]              # first row
x[1, 2]           # element (1,2) -> 6
x[:, 1]           # second column
x[0:2]            # first two rows
x[:, ::2]         # every other column

# boolean mask
mask = x > 4
sel = tf.boolean_mask(x, mask)   # tensor([5, 6, 7, 8, 9])

# gather by indices
idx = tf.constant([0, 2])
rows = tf.gather(x, idx)         # rows 0 and 2

# where: select from two tensors
tf.where(x > 4, x, tf.zeros_like(x))

Ragged と Sparse のテンソル

Ragged テンソルは、パディングなしで可変長のシーケンスを保存します — 異なる長さの NLP のバッチに最適です。Sparse テンソルは、非ゼロのインデックスと値だけを保存するため、高度にスパースなデータ(推薦、グラフ)でメモリを節約します。ほとんどの演算にはスパース対応のバリアントがあり、演算が必要なときだけ dense へ変換しましょう。埋め込みの参照のために矩形へパディングするのが、tf.RaggedTensor.to_tensor() です。

tensorflow
import tensorflow as tf

# ragged: variable-length sequences
ragged = tf.ragged.constant([[1, 2, 3], [4], [5, 6]])
print(ragged.shape)           # (3, None)
ragged.to_tensor()            # pad to (3, 3)

# sparse: mostly-zero tensors
indices = [[0, 0], [1, 2], [2, 1]]
values = [1.0, 2.0, 3.0]
sparse = tf.sparse.SparseTensor(
    indices=indices, values=values, dense_shape=[3, 3])
dense = tf.sparse.to_dense(sparse)

sp_sum = tf.sparse.reduce_sum(sparse)
sp_matmul = tf.sparse.sparse_dense_matmul(sparse, tf.eye(3))

ブロードキャストと数学

ブロードキャストは、小さい次元のテンソルを大きいものに合わせ伸ばし、要素ごとに作用します。TF のクランプであるのが、clip_by_value です。要素ごとのものが、tf.maximum/minimum で(次元を還元する tf.reduce_max/min とは異なります)。軸に沿った累積の和/積を作るのが、cumsum/cumprod で — カスタム層での累積メトリックとプレフィックス和のアルゴリズムに有用です。

tensorflow
import tensorflow as tf

# broadcasting follows NumPy rules
a = tf.constant([[1.0, 2.0, 3.0]])    # shape (1, 3)
b = tf.constant([[10.0], [20.0]])      # shape (2, 1)
c = a + b                              # shape (2, 3)

tf.abs(x); tf.sqrt(x); tf.exp(x); tf.log(x)
tf.square(x); tf.pow(x, 3)
tf.maximum(a, b); tf.minimum(a, b)
tf.clip_by_value(x, 0.0, 1.0)

tf.norm(x)                  # L2 norm
tf.norm(x, ord=1)           # L1 norm

tf.cumsum(tf.range(5))      # [0, 1, 3, 6, 10]
tf.cumprod(tf.range(1, 5))  # [1, 2, 6, 24]
03

Keras モデル

Sequential API

Sequential は、最も簡単な Keras のモデルです — 各層の出力が次を養う、線形のパイプラインです。input_shape はバッチ次元を含みません(可変バッチには None を使います)。layer の shape とパラメータ数を表示するのが、model.summary() です。input_shape を渡さないと、モデルは最初の fit/フォワードの呼び出しで遅延構築されます — より早く検査するには、build() を明示的に呼びましょう。

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax'),
])

model.summary()

# build later with input_shape (or first call)
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dense(10))
model.build((None, 784))   # None = variable batch

Functional API

Functional API は、層が分岐、マージ、スキップできるようにします — 非線形なもの(ResNet、マルチ入力/出力、シアメスネット)には必須です。Input のテンソルを定義し、層を呼び出すことで連鎖させ、inputs/outputs を Model へ渡しましょう。結果のモデルは、fit/predict において Sequential と同一に振る舞います。きれいな保存とサービングのシグネチャのために、inputs/outputs に名前を付けましょう。

tensorflow
import tensorflow as tf

inputs = tf.keras.Input(shape=(784,), name='img')
x = tf.keras.layers.Dense(128, activation='relu')(inputs)
x = tf.keras.layers.Dropout(0.5)(x)
x = tf.keras.layers.Dense(64, activation='relu')(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)

model = tf.keras.Model(inputs=inputs, outputs=outputs, name='mlp')

# multi-input / multi-output
img_in = tf.keras.Input(shape=(224, 224, 3))
meta_in = tf.keras.Input(shape=(10,))
x = tf.keras.layers.Conv2D(32, 3, activation='relu')(img_in)
x = tf.keras.layers.GlobalAveragePooling2D()(x)
x = tf.keras.layers.concatenate([x, meta_in])
out = tf.keras.layers.Dense(1, activation='sigmoid')(x)
model = tf.keras.Model([img_in, meta_in], out)

モデルのサブクラス化

tf.keras.Model のサブクラス化は、(PyTorch のような)フォワードの完全な制御を与えます。__init__ で層を定義し、call(inputs, training=) を実装します。training フラグが、dropout と BatchNorm の挙動を切り替えます。サブクラス化はより柔軟ですが、Functional API の一部の利点を失います:検査/プロットが難しく、入力 shape の推論が自動でなく、直列化も厄介です。ほとんどのアーキテクチャには Functional を優先し、研究のモデルにはサブクラス化を。

tensorflow
import tensorflow as tf

class MLP(tf.keras.Model):
    def __init__(self, hidden=128, num_classes=10):
        super().__init__()
        self.dense1 = tf.keras.layers.Dense(hidden, activation='relu')
        self.drop = tf.keras.layers.Dropout(0.5)
        self.dense2 = tf.keras.layers.Dense(hidden, activation='relu')
        self.out = tf.keras.layers.Dense(num_classes, activation='softmax')

    def call(self, inputs, training=False):
        x = self.dense1(inputs)
        x = self.drop(x, training=training)
        x = self.dense2(x)
        return self.out(x)

model = MLP(hidden=64)
model.build((None, 784))
model.summary()

モデルのコンパイル

compile は、fit の前にオプティマイザ、損失、メトリックを結線します。文字列(「adam」、「mse」)は対応するクラスへのショートカットです。カスタムのハイパーパラメータのためには、オブジェクトを渡しましょう。マルチ出力のモデルのためには、出力名を損失へマッピングする辞書を渡します。tf.function のトレースを無効化するのが、run_eagerly=True で、pdb と print が使えます — デバッグに極めて有用ですが、遅いです。

tensorflow
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy'],
    loss_weights={'cls': 1.0, 'box': 0.5},
)

# explicit objects (more control)
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(),
    metrics=[tf.keras.metrics.SparseCategoricalAccuracy(name='acc')],
    run_eagerly=False,   # debug mode: run without graph
)

モデルのサマリーとプロット

summary() は、出力 shape とパラメータ数付きの層ごとのテーブルを表示します — shape のバグを見つける最速の方法です。視覚的なグラフを保存するのが、plot_model です(pydot と Graphviz が必要です)。serializable な dict を返すのが、get_config で、アーキテクチャが重みなしで再構築できます — model.to_json() と Keras の保存形式が使うものです。Functional のモデルでは、config がアーキテクチャを完全に捉えます。サブクラス化されたモデルでは、get_config を自分で実装しなければなりません。

tensorflow
model.summary()
print(model.layers)
print(model.inputs, model.outputs)

# plot architecture (needs pydot + graphviz)
tf.keras.utils.plot_model(
    model, to_file='model.png', show_shapes=True,
    show_layer_names=True, rankdir='TB',
)

print(f"{model.count_params():,} params")

config = model.get_config()
new_model = tf.keras.Model.from_config(config)

モデル内の前処理

前処理をモデルの内側に置くと(Rescaling、拡張の Keras 層)、配備可能になります:同じ SavedModel が、推論で生の画像を受け付け、別の前処理のステップが不要です。Keras の前処理の層は、GPU 上と tf.function の内側で走るため速いです。訓練専用の拡張のためには、fit で training=True を設定しましょう。そうすれば、推論で層は非アクティブです。Rescaling(1./255) は、uint8 [0,255] の画像を float [0,1] へ変換します。

tensorflow
import tensorflow as tf

# preprocessing as part of the model (deployable)
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(224, 224, 3)),
    tf.keras.layers.Rescaling(1./255),
    tf.keras.layers.RandomFlip('horizontal'),
    tf.keras.layers.RandomRotation(0.1),
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    # ...
])
# the model now includes preprocessing, so inference needs raw images
04

層

Dense 層

Dense は全結合層です:y = activation(xW + b) です。重みの shape は (in_features, out_features) で — PyTorch の転置です。kernel_initializer のデフォルトは Glorot/Xavier の一様で、tanh/sigmoid に良く、ReLU 系には「he_normal」を使いましょう。kernel_regularizer 経由で L2 の正則化を加えます。transformers でのデフォルトの活性化が、GELU です。

tensorflow
import tensorflow as tf

dense = tf.keras.layers.Dense(
    units=64, activation='relu', use_bias=True,
    kernel_initializer='glorot_uniform',
    bias_initializer='zeros',
    kernel_regularizer=tf.keras.regularizers.l2(1e-4),
)

x = tf.random.normal((4, 128))
y = dense(x)                     # shape (4, 64)

print(dense.kernel.shape)        # (128, 64)
print(dense.bias.shape)          # (64,)

dense = tf.keras.layers.Dense(64, activation=tf.nn.gelu)

Conv2D 層

TF/Keras は、デフォルトで NHWC(channels-last)を使います — PyTorch の NCHW と逆です。padding='same' は、出力の空間サイズ = 入力サイズ / ストライドになるようパディングし、「valid」はパディングなしを意味します。入力チャネルごとに 1 つのフィルタを適用するのが、DepthwiseConv2D です(MobileNet で使われます)。アップサンプルするのが、Conv2DTranspose です(セグメンテーションのデコーダで使われます)。カーネルの shape は、(kH, kW, in_channels, filters) です。

tensorflow
import tensorflow as tf

conv = tf.keras.layers.Conv2D(
    filters=32, kernel_size=3, strides=(1, 1),
    padding='same', activation='relu', use_bias=True,
)

x = tf.random.normal((4, 28, 28, 3))   # NHWC
out = conv(x)
print(out.shape)                        # (4, 28, 28, 32) with padding='same'

dw = tf.keras.layers.DepthwiseConv2D(3, padding='same', activation='relu')
up = tf.keras.layers.Conv2DTranspose(32, 3, strides=2, padding='same')

再帰層(LSTM/GRU)

RNN の入力 shape は、(batch, timesteps, features) です。RNN を積むときや seq2seq のモデルには、return_sequences=True が必要で、sequence-to-vector には False です。順方向と逆方向の出力を連結し、出力サイズを倍にするのが、Bidirectional です。recurrent_dropout は便利ですが遅いです(cuDNN の加速がありません)— 代わりに、入力への素の dropout を優先しましょう。

tensorflow
import tensorflow as tf

lstm = tf.keras.layers.LSTM(units=128, return_sequences=False)
x = tf.random.normal((4, 10, 64))   # (batch, time, features)
out = lstm(x)                       # (4, 128)

# stacked LSTM needs return_sequences=True
model = tf.keras.Sequential([
    tf.keras.layers.LSTM(128, return_sequences=True, input_shape=(10, 64)),
    tf.keras.layers.LSTM(64),
    tf.keras.layers.Dense(10),
])

gru = tf.keras.layers.GRU(128)
bi = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64))
out = bi(x)   # shape (4, 128) — 64 * 2

Dropout と正則化

Dropout は、共適応を防ぐため訓練中にユニットをランダムにゼロにします — 推論では自動的に無効です(training=False です)。特徴マップ全体を落とすのが、SpatialDropout2D で、conv ネットにはより良いです。最もよくある正則化が、L2(重み減衰)です。特徴軸上(サンプルごと)で正規化するのが、LayerNormalization で、バッチ軸上で正規化する BatchNorm と異なります — transformers と RNN に好まれます。

tensorflow
import tensorflow as tf

drop = tf.keras.layers.Dropout(0.5)
x = tf.random.normal((4, 10))
y = drop(x, training=True)   # training=True activates dropout

tf.keras.layers.SpatialDropout2D(0.5)   # drop entire feature maps
tf.keras.layers.GaussianDropout(0.5)
tf.keras.layers.AlphaDropout(0.5)

# weight regularization
tf.keras.layers.Dense(64,
    kernel_regularizer=tf.keras.regularizers.l2(1e-4),
    activity_regularizer=tf.keras.regularizers.l1(1e-5))

norm = tf.keras.layers.LayerNormalization()

Batch Normalization

BatchNormalization は、チャネルごとに活性化を正規化し、推論のための EMA の実行統計を保ちます。NHWC のために最後の(チャネル)軸を正規化するのが、axis=-1 です。BN を conv の後、活性化の前に置き、BN の beta がシフトを扱うため、conv のバイアスを無効化しましょう(use_bias=False)。実行統計がデータを追う速さを制御するのが、momentum で — 高い値(0.99)がより安定です。BN は、(training フラグにより)訓練と推論で異なって振る舞います。

tensorflow
import tensorflow as tf

bn = tf.keras.layers.BatchNormalization(
    axis=-1, momentum=0.99, epsilon=1e-3,
)

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, padding='same', use_bias=False),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.ReLU(),
])

print(len(bn.weights))         # 4
print(len(bn.trainable_weights))    # 2

カスタム層

カスタムの演算を構築するには、Layer をサブクラス化しましょう。__init__ でなく build()(入力 shape と共に一度呼ばれます)で重みを定義すれば、層が入力サイズに適応します。層が直列化されリロードできるよう、get_config() を実装しましょう。add_weight は、テンソルを Keras のトラッキングに登録します(weights に現れ、保存され、デバイスへ動かされます)。ステートレスな変換のためには、build() を省き、call() をオーバーライドするだけでも構いません。

tensorflow
import tensorflow as tf

class Linear(tf.keras.layers.Layer):
    def __init__(self, units=32, **kwargs):
        super().__init__(**kwargs)
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer='glorot_uniform', trainable=True, name='w')
        self.b = self.add_weight(
            shape=(self.units,), initializer='zeros', trainable=True, name='b')

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

    def get_config(self):
        config = super().get_config()
        config.update({'units': self.units})
        return config

layer = Linear(64)
out = layer(tf.random.normal((4, 10)))
05

損失

BinaryCrossentropy

BinaryCrossentropy は、二値のタスクかマルチラベル(各クラスが独立)のためのものです。モデルが生のロジットを出力するなら、from_logits=True を渡しましょう — sigmoid + BCE を別々に適用するより数値的に安全です。不均衡を扱うため、正の例を重くするのが、pos_weight です。C クラスのマルチラベルの問題のためには、ターゲットの shape が 0/1 の (N, C) で、予測は (N, C) の確率かロジットです。

tensorflow
import tensorflow as tf

bce = tf.keras.losses.BinaryCrossentropy(from_logits=False)
y_true = tf.constant([[1.0], [0.0], [1.0], [0.0]])
y_pred = tf.constant([[0.9], [0.1], [0.8], [0.2]])
loss = bce(y_true, y_pred)

# from_logits=True is more numerically stable
bce_logits = tf.keras.losses.BinaryCrossentropy(from_logits=True)
logits = tf.constant([[2.0], [-2.0], [1.5], [-1.5]])
loss = bce_logits(y_true, logits)

bce = tf.keras.losses.BinaryCrossentropy(
    from_logits=True, pos_weight=tf.constant([5.0]))

CategoricalCrossentropy

CategoricalCrossentropy は one-hot のターゲットを期待し、SparseCategoricalCrossentropy は整数のクラスインデックスを期待します(多くのクラスでよりメモリ効率が良いです)。モデルが softmax で終わらないときは、必ず from_logits=True を渡しましょう — 数値安定性のために log-sum-exp のトリックを使います。ラベルスムージングには、CategoricalCrossentropy(label_smoothing=0.1) を使いましょう — 分類と NLP の強い正則化です。

tensorflow
import tensorflow as tf

# one-hot labels
cce = tf.keras.losses.CategoricalCrossentropy(from_logits=False)
y_true = tf.constant([[0, 1, 0], [1, 0, 0]], dtype=tf.float32)
y_pred = tf.constant([[0.1, 0.8, 0.1], [0.7, 0.2, 0.1]])
loss = cce(y_true, y_pred)

# integer labels -> use sparse version
scce = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
y_true_int = tf.constant([1, 0])
logits = tf.constant([[1.0, 3.0, 0.5], [2.5, 0.2, 0.1]])
loss = scce(y_true_int, logits)

MSE と回帰の損失

MSE は大きな誤差を二次的に罰します(外れ値に敏感で)、MAE は線形です。ゼロ近くでは MSE のように、遠くでは MAE のように振る舞うのが、Huber で — 物体検出の回帰のデフォルトです。似ていますがどこでも 2 回微分可能なのが、LogCosh で、二階の勾配が必要なときに有用です。すべてデフォルトでバッチ上の平均へ還元されます。サンプルごとの損失のためには、reduction=tf.keras.losses.Reduction.NONE で上書きしましょう。

tensorflow
import tensorflow as tf

mse = tf.keras.losses.MeanSquaredError()
y_true = tf.constant([3.0, -0.5, 2.0, 7.0])
y_pred = tf.constant([2.5, 0.0, 2.0, 8.0])
loss = mse(y_true, y_pred)

mae = tf.keras.losses.MeanAbsoluteError()
loss = mae(y_true, y_pred)

huber = tf.keras.losses.Huber(delta=1.0)
loss = huber(y_true, y_pred)

logcosh = tf.keras.losses.LogCosh()
loss = logcosh(y_true, y_pred)

カスタム損失

カスタムの損失とは、(y_true, y_pred) を取り、スカラーのテンソルを返す任意の callable です。直列化やハイパーパラメータのためには、tf.keras.losses.Loss をサブクラス化し、call() + get_config() を実装しましょう。すべての演算を微分可能に保ちましょう。簡単な例を重み減衰し難しい例に集中させるのが、FocalLoss で — 物体検出で人気です。マスキングが機能してほしいなら、call() で Reduction.NONE を使い、最後に Keras に還元させましょう。

tensorflow
import tensorflow as tf

def weighted_mse(y_true, y_pred):
    weights = tf.cast(y_true != 0, tf.float32)
    return tf.reduce_sum(weights * tf.square(y_true - y_pred)) / tf.reduce_sum(weights)

class FocalLoss(tf.keras.losses.Loss):
    def __init__(self, alpha=0.25, gamma=2.0, **kwargs):
        super().__init__(**kwargs)
        self.alpha = alpha
        self.gamma = gamma

    def call(self, y_true, y_pred):
        bce = tf.keras.losses.binary_crossentropy(y_true, y_pred)
        p = y_pred
        pt = p * y_true + (1 - p) * (1 - y_true)
        return self.alpha * tf.pow(1 - pt, self.gamma) * bce

    def get_config(self):
        config = super().get_config()
        config.update({'alpha': self.alpha, 'gamma': self.gamma})
        return config

loss = FocalLoss(alpha=0.25, gamma=2.0)

Logits からの損失

softmax とクロスエントロピーを別々に計算すると、大きなロジット(e^100)でオーバーフローし得ます。from_logits=True を渡せば、TF が数値的に安定な log-sum-exp のトリックでそれらを融合します。同じことをするのが、tf.nn.*_cross_entropy_with_logits の関数型 API です。from_logits=True を使うときは、モデルが softmax/sigmoid で終わらないことを確保しましょう。さもなければ、活性化を二重に適用します。

tensorflow
import tensorflow as tf

# why logits? numerical stability
logits = tf.constant([[100.0, 0.0, 0.0]])

# BAD: softmax first then CCE (can overflow)
probs = tf.nn.softmax(logits)
loss_bad = tf.keras.losses.CategoricalCrossentropy()(
    tf.constant([[1.0, 0.0, 0.0]]), probs)

# GOOD: from_logits=True uses log-sum-exp internally
loss_good = tf.keras.losses.CategoricalCrossentropy(from_logits=True)(
    tf.constant([[1.0, 0.0, 0.0]]), logits)

loss = tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=z)
loss = tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=z)

マルチ出力の損失

マルチ出力のモデルのためには、出力名を損失関数へマッピングする dict と、バランスを取る loss_weights の dict を渡しましょう。総損失は重み付きの和です。マルチタスク学習の標準のパターンがこれです — 各ヘッドが自身の損失とメトリックを得ます。fit のとき、同じキーを持つ dict として訓練ターゲットを渡しましょう。どのタスクも勾配を支配しないよう、loss_weights を調整しましょう。

tensorflow
import tensorflow as tf

model.compile(
    optimizer='adam',
    loss={
        'priority': tf.keras.losses.BinaryCrossentropy(from_logits=True),
        'department': tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    },
    loss_weights={'priority': 1.0, 'department': 0.5},
    metrics={'priority': ['accuracy'], 'department': ['accuracy']},
)

inputs = tf.keras.Input(shape=(64,))
x = tf.keras.layers.Dense(64, activation='relu')(inputs)
out_a = tf.keras.layers.Dense(1, name='priority')(x)
out_b = tf.keras.layers.Dense(10, name='department')(x)
model = tf.keras.Model(inputs, [out_a, out_b])

model.fit(x_train, {'priority': y_pri, 'department': y_dep}, epochs=5)
06

オプティマイザ

Adam

ほとんどのタスクでのデフォルトのオプティマイザであるのが、Adam です — パラメータごとの適応的な学習率を持ち、ハイパーパラメータの選択に頑健です。1 次と 2 次のモーメントの EMA 減衰を制御するのが、beta_1/beta_2 です。訓練をかけ LR を減衰させるには、float の代わりに LearningRateSchedule のオブジェクトを渡しましょう。結合ノルムが閾値を超えると全勾配を再スケールするのが、global_clipnorm で — RNN と transformers に重要です。

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.Adam(learning_rate=1e-3)

opt = tf.keras.optimizers.Adam(
    learning_rate=1e-3, beta_1=0.9, beta_2=0.999,
    epsilon=1e-7, amsgrad=False,
)

# schedule as learning_rate
lr_schedule = tf.keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=1e-3, decay_steps=10000)
opt = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

# gradient clipping
opt = tf.keras.optimizers.Adam(learning_rate=1e-3, global_clipnorm=1.0)

SGD

大バッチの CNN 訓練では、SGD + momentum がしばしば Adam より良く汎化しますが、より多くの LR 調整を代償とします。標準が、momentum=0.9 で、Nesterov が小さな追加の利点を与えます。分離された L2 正則化を加えるのが、weight_decay です(Keras 3)— 古いバージョンでは、代わりに層上の kernel_regularizer を使います。SGD が箱から出して即座に Adam に対抗するには、ウォームアップと LR スケジューリングが必要です。

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.SGD(learning_rate=0.01)
opt = tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)
opt = tf.keras.optimizers.SGD(
    learning_rate=0.01, momentum=0.9, nesterov=True)

# with weight decay (Keras 2.13+ / 3.x)
opt = tf.keras.optimizers.SGD(
    learning_rate=0.01, momentum=0.9, weight_decay=1e-4)

# clip gradients by value
opt = tf.keras.optimizers.SGD(
    learning_rate=0.01, momentum=0.9, clipvalue=0.5)

AdamW と他のオプティマイザ

重み減衰を勾配の更新から分離するのが、AdamW で、スケールで重要になります(transformers、大きい CNN)。RNN のクラシックなオプティマイザが、RMSprop です。パラメータごとに適応するが早く停滞し得るのが、Adagrad で — スパースな特徴には構いません。スパースな特徴を持つ大規模なオンライン学習のために設計されたのが、FTRL です(クリックスルー予測)。新しいプロジェクトでは、AdamW から始めましょう。

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.AdamW(
    learning_rate=3e-4, weight_decay=0.01,
    beta_1=0.9, beta_2=0.999)

opt = tf.keras.optimizers.RMSprop(learning_rate=1e-3, rho=0.9)
opt = tf.keras.optimizers.Adagrad(learning_rate=1e-2)
opt = tf.keras.optimizers.Adadelta(learning_rate=1.0)
opt = tf.keras.optimizers.Nadam(learning_rate=1e-3)
opt = tf.keras.optimizers.Ftrl(learning_rate=0.1)

勾配の適用

カスタムの訓練ループでは、GradientTape で勾配を計算し、その後、opt.apply_gradients(zip(grads, vars)) を呼びます。カスタムの訓練ループの構成要素がこれです(カスタム訓練ループのセクションを参照)。結合 L2 ノルムが閾値の下に留まるよう勾配を再スケールするのが、clip_by_global_norm です。None の勾配は、変数が損失に影響しなかったことを意味します — 未使用のパラメータでよくあり、ログを取る価値があります。

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.Adam(1e-3)
vars = [w, b]

with tf.GradientTape() as tape:
    preds = model(x)
    loss = loss_fn(y, preds)
grads = tape.gradient(loss, vars)

grads, _ = tf.clip_by_global_norm(grads, 1.0)
opt.apply_gradients(zip(grads, vars))

for v, g in zip(vars, grads):
    print(v.name, g is not None, g.numpy().norm() if g is not None else None)

学習率スケジュール

LearningRateSchedule のオブジェクトは、オプティマイザのステップカウンタの関数として LR を計算します。alpha*initial_lr へ滑らかにアニールするのが、CosineDecay で — 強いデフォルトです。SGDR 風のウォームリスタートを実装するのが、CosineDecayRestarts です。オプティマイザの構築時に、learning_rate としてスケジュールを渡しましょう。Keras が各ステップで自動的に呼びます。ウォームアップのためには、カスタムのスケジュールで包むか、tensorflow/addons の WarmUp コールバックを使いましょう。

tensorflow
import tensorflow as tf

sched = tf.keras.optimizers.schedules.PiecewiseConstantDecay(
    boundaries=[500, 1500], values=[1e-3, 1e-4, 1e-5])

sched = tf.keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate=1e-3, decay_steps=1000, decay_rate=0.96,
    staircase=True)

sched = tf.keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=1e-3, decay_steps=10000, alpha=0.0)

opt = tf.keras.optimizers.Adam(learning_rate=sched)
print(opt.learning_rate(opt.iterations))

勾配のクリッピングと EMA

(すべての勾配を一緒に再スケールする)global_clipnorm が最もよくある選択で、transformers が使うものです。各要素をハードクランプするのが、clipvalue です。カスタムのクリッピングのためには、tape.gradient と apply_gradients の間で勾配を修正しましょう。重みの指数移動平均(EMA)は、推論で小さな精度の向上をしばしば与えます — 各ステップの後で適用し、評価に平均化された重みを使いましょう。TF Addons には、MovingAverage のオプティマイザラッパーがあります。

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.Adam(1e-3, global_clipnorm=1.0)
opt = tf.keras.optimizers.Adam(1e-3, clipvalue=0.5)
opt = tf.keras.optimizers.Adam(1e-3, clipnorm=1.0)

# manual clipping (more control)
grads = tape.gradient(loss, vars)
grads = [tf.clip_by_norm(g, 1.0) if g is not None else g for g in grads]
grads, _ = tf.clip_by_global_norm(grads, 1.0)
opt.apply_gradients(zip(grads, vars))

# exponential moving average of weights (improves generalization)
ema = tf.train.ExponentialMovingAverage(decay=0.999)
07

訓練

compile と fit

fit は高レベルの訓練 API です:バッチ化、シャッフル、検証、コールバック、進捗を扱います。validation_data=(x, y) か validation_split=0.2(訓練から外れます)のどちらかを渡しましょう。1 エポックごとに 1 行表示するのが、verbose=2 で(ログに良く)、進捗バーを表示するのが 1 です。返される history オブジェクトが、エポックごとの損失とメトリックを保存します — 過学習を見つけるためにプロットしましょう。

tensorflow
import tensorflow as tf

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy'],
)

history = model.fit(
    x_train, y_train, batch_size=32, epochs=10,
    validation_data=(x_val, y_val),
    validation_split=0.2, shuffle=True, verbose=2,
)

print(history.history['loss'])

検証とメトリック

メトリックは、バッチをまたいで蓄積し、エポック終了時に最終値を計算するステートフルなオブジェクトです — 損失と違い、訓練に影響しません。文字列(「accuracy」)かカスタムメトリックのための Metric オブジェクトを渡しましょう。tf.keras.metrics.Metric をサブクラス化し、update_state/result/reset_state を実装します。各エポックの開始時に呼ばれるのが、reset_state です(TF 2.11+ で reset_states から改名されました)。

tensorflow
model.compile(
    optimizer='adam', loss='sparse_categorical_crossentropy',
    metrics=[
        'accuracy',
        tf.keras.metrics.SparseTopKCategoricalAccuracy(k=5, name='top5_acc'),
        tf.keras.metrics.Precision(name='precision'),
        tf.keras.metrics.Recall(name='recall'),
    ],
)

class F1Score(tf.keras.metrics.Metric):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.precision = tf.keras.metrics.Precision()
        self.recall = tf.keras.metrics.Recall()
    def update_state(self, y_true, y_pred, sample_weight=None):
        self.precision.update_state(y_true, y_pred, sample_weight)
        self.recall.update_state(y_true, y_pred, sample_weight)
    def result(self):
        p, r = self.precision.result(), self.recall.result()
        return 2 * p * r / (p + r + 1e-8)
    def reset_state(self):
        self.precision.reset_state(); self.recall.reset_state()

エポック、バッチサイズ、ステップ

tf.data.Dataset を使うときは、batch_size を渡してはいけません — データセットは既にバッチ化されています。データセットが無限に繰り返すとき、1 エポックを構成するバッチ数を fit に伝えるのが、steps_per_epoch です。検証で同じことをするのが、validation_steps です。チェックポイントから訓練を再開するには、initial_epoch を使いましょう — fit は最初の N エポックをスキップしますが、オプティマイザの状態(LR スケジュール、momentum)は正しく続きます。

tensorflow
model.fit(x_train, y_train, batch_size=32, epochs=10)

# with tf.data.Dataset
model.fit(train_dataset, epochs=10, validation_data=val_dataset)

# Dataset of unknown size: use steps_per_epoch
model.fit(
    train_dataset, epochs=10, steps_per_epoch=500,
    validation_data=val_dataset, validation_steps=50,
)

# initial epoch (resume training)
model.fit(train_dataset, initial_epoch=5, epochs=10)

クラスとサンプルの重み

不均衡に対抗するため各クラスの損失をスケールするのが、class_weight で — 余分な計算なしのオーバーサンプリングに相当します。例ごとの制御を与えるのが、sample_weight で、難しい例のマイニングやパディング位置のマスキングに有用です。tf.data.Dataset を使うときは、データセットが (x, y, w) を出すよう、3 番目のタプル要素として sample_weight を含めましょう。バランスの取れた重みを自動的に計算するのが、sklearn.utils.class_weight です。

tensorflow
class_weight = {0: 1.0, 1: 5.0, 2: 1.0}   # class 1 is rare
model.fit(x_train, y_train, class_weight=class_weight, epochs=10)

sample_weight = np.where(y_train == 1, 5.0, 1.0)
model.fit(x_train, y_train, sample_weight=sample_weight, epochs=10)

# with Dataset: yield (x, y, sample_weight) tuples
ds = tf.data.Dataset.from_tensor_slices((x, y, w))
model.fit(ds, epochs=10)

from sklearn.utils import class_weight
cw = class_weight.compute_class_weight('balanced', classes=np.unique(y), y=y)
class_weight = dict(enumerate(cw))

Predict と Evaluate

全入力の予測の NumPy 配列を返すのが、predict です — メモリを制御するには batch_size を使いましょう。compile からの損失と任意のメトリックを返すのが、evaluate です。非常に大きい入力のためには、predict_on_batch でバッチを手動で反復しましょう。モデルを直接呼ぶ(model(x))と、テンソルが返り training= が尊重されますが、predict は常に推論モードで走り NumPy を返します。テスト時の拡張には、model(x, training=True) を使いましょう。

tensorflow
preds = model.predict(x_test, batch_size=64)
print(preds.shape)   # (N, num_classes)

pred = model.predict(x_test[:1])

loss, acc = model.evaluate(x_test, y_test, batch_size=64, verbose=2)
test_loss, test_acc, test_prec = model.evaluate(test_dataset)

for batch in test_dataset:
    preds = model.predict_on_batch(batch[0])

preds = model(x_test, training=True)   # callable form, test-time aug

train_step のオーバーライド

train_step をオーバーライドすると、fit のエポックループ、コールバック、分散を保ったまま、各 fit のバッチで起きることをカスタマイズできます。高レベルの fit と完全にカスタムなループの間の橋渡しであり — GAN、対照学習、任意の非標準の目的に最適です。compile() からの損失/メトリックがまだ機能するよう、self.compiled_loss と self.compiled_metrics を使いましょう。同じ方法で検証の挙動をオーバーライドするのが、test_step です。

tensorflow
import tensorflow as tf

class CustomModel(tf.keras.Model):
    def train_step(self, data):
        x, y = data
        with tf.GradientTape() as tape:
            y_pred = self(x, training=True)
            loss = self.compiled_loss(y, y_pred, regularization_losses=self.losses)
        grads = tape.gradient(loss, self.trainable_variables)
        self.optimizer.apply_gradients(zip(grads, self.trainable_variables))
        self.compiled_metrics.update_state(y, y_pred)
        return {m.name: m.result() for m in self.metrics}

    def test_step(self, data):
        x, y = data
        y_pred = self(x, training=False)
        self.compiled_loss(y, y_pred)
        self.compiled_metrics.update_state(y, y_pred)
        return {m.name: m.result() for m in self.metrics}

model = CustomModel(inputs, outputs)
model.compile(optimizer='adam', loss='...', metrics=['accuracy'])
model.fit(dataset, epochs=10)
08

コールバック

EarlyStopping

監視されるメトリックが改善を止めると訓練を止めるのが、EarlyStopping で、時間を節約し過学習を防ぎます。停止の前に N エポックの改善なしを待つのが、patience=N です。終了時に最良のエポックへロールバックするのが、restore_best_weights=True で — なければ、(より悪いかもしれない)最終の重みを保ちます。損失には mode='min'、精度には「max」です。寛大な最大エポックを設定し、コールバックに決めさせましょう。

tensorflow
import tensorflow as tf

early = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', min_delta=0.001, patience=5,
    mode='auto', restore_best_weights=True, verbose=1,
)

model.fit(train_ds, validation_data=val_ds, epochs=100, callbacks=[early])

ModelCheckpoint

訓練中にモデルを保存するのが、ModelCheckpoint で、クラッシュから回復したり最良のエポックを選べます。最良のチェックポイントだけを保つのが、save_best_only=True で(monitor メトリックにより)— monitor を val メトリックに設定しましょう。より小さくアーキテクチャ非依存であるのが、save_weights_only=True ですが、リロードにはモデルのクラスが必要です。ファイル名にエポック番号を埋め込むのが、{epoch:02d} のような形式のプレースホルダーです。デフォルトが save_freq='epoch' で、整数 N は N バッチごとに保存します。

tensorflow
import tensorflow as tf

ckpt = tf.keras.callbacks.ModelCheckpoint(
    filepath='checkpoints/epoch-{epoch:02d}-val-{val_loss:.3f}.keras',
    monitor='val_loss', save_best_only=True, save_weights_only=False,
    mode='min', save_freq='epoch', verbose=1,
)

ckpt = tf.keras.callbacks.ModelCheckpoint(
    'weights.{epoch:02d}.h5', save_weights_only=True, save_freq='epoch',
)

model.fit(train_ds, validation_data=val_ds, epochs=50, callbacks=[ckpt])

ReduceLROnPlateau

監視されるメトリックが停滞すると LR を落とすのが、ReduceLROnPlateau で — 正しいスケジュールが事前にわからないときに有用です。乗数が、factor(0.5 = 半分)で、待つエポック数が、patience、下限が、min_lr です。新しい LR が落ち着くよう、還元の直後に監視を一時停止するのが、cooldown です。EarlyStopping と組み合わせましょう:まず LR を減らし、その後、さらなる改善がなければ止めます。各還元を表示するのが、verbose=1 です。

tensorflow
import tensorflow as tf

reduce = tf.keras.callbacks.ReduceLROnPlateau(
    monitor='val_loss', factor=0.5, patience=3, min_lr=1e-7,
    mode='min', min_delta=1e-4, cooldown=0, verbose=1,
)

model.fit(train_ds, validation_data=val_ds, epochs=100, callbacks=[reduce])

TensorBoard コールバック

TensorBoard コールバックは、訓練のメトリック、重みのヒストグラム、モデルのグラフ、プロファイリングのデータをログのディレクトリへストリームします。エポックごとに重みの分布をログするのが、histogram_freq=1 で — スペースを節約するには 0 にしましょう。バッチ 2 で TF Profiler を実行し、パフォーマンスのボトルネック(入力パイプライン、演算のレイテンシ)を特定するのが、profile_batch=2 です。チャートを見るには、log_dir を指して TensorBoard を起動しましょう。実行を比較するため、実験ごとに別々のサブディレクトリを使いましょう。

tensorflow
import tensorflow as tf

tb = tf.keras.callbacks.TensorBoard(
    log_dir='./logs/fit', histogram_freq=1, write_graph=True,
    write_images=False, update_freq='epoch',
    profile_batch=2, embeddings_freq=0,
)

model.fit(train_ds, validation_data=val_ds, epochs=10, callbacks=[tb])
# launch: tensorboard --logdir=./logs

LearningRateScheduler

(epoch, lr) の関数を取り、各エポックの開始時に新しい LR を適用するのが、LearningRateScheduler です — 単純ですが、エポックごとのみです。ステップごとのスケジュールには、(オプティマイザのセクションを参照)オプティマイザへ渡される LearningRateSchedule のオブジェクトを優先しましょう — 毎バッチ呼ばれ、tf.function の内側で機能します。大まかなスケジュールには、Callback の形式で十分です。ウォームアップ + 減衰のためには、スケジュールオブジェクトのほうがきれいです。

tensorflow
import tensorflow as tf

def schedule(epoch, lr):
    if epoch < 10:
        return lr
    return lr * tf.math.exp(-0.1).numpy()

scheduler = tf.keras.callbacks.LearningRateScheduler(schedule, verbose=1)

class StepScheduler(tf.keras.callbacks.Callback):
    def on_train_batch_begin(self, batch, logs=None):
        step = self.model.optimizer.iterations.numpy()
        new_lr = 1e-3 * (0.5 ** (step // 1000))
        self.model.optimizer.learning_rate.assign(new_lr)

scheduler = tf.keras.callbacks.LearningRateScheduler(
    lambda epoch: 1e-3 * 0.9 ** epoch)

カスタムコールバック

コールバックは、訓練のライフサイクルにフックします:on_epoch_begin/end、on_train_batch_begin/end、on_test_*、on_predict_* です。self.model 経由でモデルへ、self.model.optimizer 経由でオプティマイザへアクセスしましょう。現在のメトリックの dict が、logs です。カスタムコールバックは、ログ、LR の操作、早期終了(self.model.stop_training = True)、外部システムとの同期(W&B、MLflow)に最適です。安価に保ちましょう — 毎バッチ走るのです。

tensorflow
import tensorflow as tf

class DebugCallback(tf.keras.callbacks.Callback):
    def on_epoch_end(self, epoch, logs=None):
        lr = self.model.optimizer.learning_rate
        if hasattr(lr, 'numpy'):
            lr = lr.numpy()
        print(f"Epoch {epoch}: lr={lr}, logs={logs}")

    def on_train_batch_end(self, batch, logs=None):
        if batch % 100 == 0:
            print(f"  batch {batch}: loss={logs.get('loss'):.4f}")

    def on_train_end(self, logs=None):
        print("Training finished!")

model.fit(train_ds, epochs=5, callbacks=[DebugCallback()])
09

tf.data パイプライン

tf.data.Dataset

TF のストリーミングデータ API であるのが、tf.data.Dataset です — ディスク/CPU から GPU へデータを効率的にパイプラインします。軸 0 に沿ってテンソルを zip するのが、from_tensor_slices です。標準のチェーンが、shuffle -> batch -> prefetch です:シャッフルがランダム化し、バッチがグループ化し、prefetch が現在の訓練と次のバッチの準備を重ね合わせます。TF に prefetch バッファサイズを自動選択させるのが、AUTOTUNE です。

tensorflow
import tensorflow as tf

ds = tf.data.Dataset.from_tensor_slices((x_train, y_train))

def gen():
    for i in range(len(x_train)):
        yield x_train[i], y_train[i]
ds = tf.data.Dataset.from_generator(gen, output_signature=(
    tf.TensorSpec(shape=(28, 28), dtype=tf.float32),
    tf.TensorSpec(shape=(), dtype=tf.int32),
))

ds = ds.shuffle(10000).batch(32).prefetch(tf.data.AUTOTUNE)

for x, y in ds:
    print(x.shape, y.shape)
    break

Map、Filter、Cache

各要素へ関数を適用するのが、map です — 拡張、正規化、トークン化です。CPU コアをまたいで並列化するのが、num_parallel_calls=AUTOTUNE です。メモリ(かファイル)にデータセットを保存するのが、cache() で、後続のエポックがソースをスキップします — 小〜中規模のデータで巨大な高速化ですが、ランダムな演算の前に cache しましょう。さもなければ、毎エポック同じ拡張を繰り返します。標準の順序が、cache -> map(augment) -> shuffle -> batch -> prefetch です。

tensorflow
import tensorflow as tf

def augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_brightness(image, 0.2)
    return image, label

ds = tf.data.Dataset.from_tensor_slices((images, labels))
ds = ds.map(augment, num_parallel_calls=tf.data.AUTOTUNE)
ds = ds.map(lambda x, y: (tf.cast(x, tf.float32) / 255.0, y))
ds = ds.filter(lambda x, y: y < 10)

ds = ds.cache()                    # in memory
ds = ds.cache('/tmp/data.cache')   # to file

ds = ds.cache().shuffle(1000).batch(32).prefetch(tf.data.AUTOTUNE)

Batch、Shuffle、Repeat

shuffle はサイズ N のバッファを使います:バッファを満たし、1 つサンプルし、再び満たします — そのため、データセットサイズ以上のバッファが本物のランダム順を与えます。毎エポック再シャッフルされるのが、shuffle -> repeat -> batch です。steps_per_epoch での訓練のためには、repeat() を使ってデータセットが決して尽きないようにしましょう。最後の短いバッチを落とすのが、drop_remainder=True で — BatchNorm と固定 shape のモデルに重要です。同じ seed で reshuffle_each_iteration=True のときのみ、シードが反復をまたいでシャッフルを再現可能にします。

tensorflow
import tensorflow as tf

ds = tf.data.Dataset.from_tensor_slices((x, y))
ds = ds.batch(32, drop_remainder=False)
ds = ds.shuffle(buffer_size=10000, seed=42, reshuffle_each_iteration=True)
ds = ds.repeat()         # infinite
ds = ds.repeat(5)        # 5 epochs

# recommended order: shuffle -> repeat -> batch
ds = ds.shuffle(10000).repeat().batch(32)

Prefetch とパフォーマンス

単独で最大の勝利であるのが、prefetch(AUTOTUNE) です — GPU がバッチ N で訓練する間、CPU がバッチ N+1 を準備でき、どちらも待ちません。map 上の num_parallel_calls=AUTOTUNE が、CPU バウンドの前処理を並列化します。最適なパイプラインの順序は:source -> cache -> shuffle -> map(augment) -> batch -> prefetch です。tf.data.experimental.AUTOTUNE(tf.data.AUTOTUNE と同じ)を使い、TF にバッファサイズを調整させましょう。最適化の前に必ずプロファイルしましょう — ボトルネックはしばしば別のところにあります。

tensorflow
import tensorflow as tf

ds = ds.prefetch(tf.data.AUTOTUNE)
ds = ds.map(parse_fn, num_parallel_calls=tf.data.AUTOTUNE)

# full recommended pipeline
ds = (tf.data.Dataset.from_tensor_slices((x, y))
      .cache()
      .shuffle(10000)
      .map(augment, num_parallel_calls=tf.data.AUTOTUNE)
      .batch(32)
      .prefetch(tf.data.AUTOTUNE))

ファイルの読み取り

テキストファイルから行をストリームするのが、TextLineDataset です(ログ、CSV の行)。自動の列の型推論で CSV をパースするのが、make_csv_dataset です。PyTorch の ImageFolder に相当する Keras のものが、image_dataset_from_directory で — サブディレクトリ名からラベルを推論し、(image_batch, label_batch) を返します。画像のロードをより制御するには、map 関数の内側で tf.io.read_file + tf.io.decode_image を使いましょう。fit へ渡す前に、必ずデータセットをバッチ化しましょう。

tensorflow
import tensorflow as tf

ds = tf.data.TextLineDataset(['file1.txt', 'file2.txt'])

ds = tf.data.experimental.make_csv_dataset(
    'data.csv', batch_size=32, label_name='label',
    num_epochs=1, shuffle_buffer_size=1000,
)

ds = tf.keras.utils.image_dataset_from_directory(
    'data/train', image_size=(224, 224), batch_size=32,
    shuffle=True, seed=42, validation_split=0.2, subset='training',
)

TFRecord

TF のバイナリレコード形式であるのが、TFRecord です — ディスクから大きなデータセットを養う最速の方法です。各レコードは、(特徴の dict である)serial 化された tf.train.Example です。読み取りは逐次 I/O であり、(GCS/S3 の)クラウドストレージでのランダム読み取りよりずっと速いです。画像のためには、生のバイトを保存し、map() でデコードしましょう。より小さいファイルのためには、compression='GZIP' 付きの tf.data.TFRecordDataset を使いましょう。(.tfrecord-0000N-of-0000M の複数ファイルである)シャーディングが、並列読み取りを可能にします。

tensorflow
import tensorflow as tf

def serialize(x, y):
    feature = {
        'x': tf.train.Feature(float_list=tf.train.FloatList(value=x.flatten())),
        'y': tf.train.Feature(int64_list=tf.train.Int64List(value=[y])),
    }
    return tf.train.Example(features=tf.train.Features(feature=feature)).SerializeToString()

with tf.io.TFRecordWriter('data.tfrecord') as w:
    for x, y in dataset:
        w.write(serialize(x, y))

def parse(serialized):
    feature = {'x': tf.io.FixedLenFeature([784], tf.float32),
               'y': tf.io.FixedLenFeature([], tf.int64)}
    parsed = tf.io.parse_single_example(serialized, feature)
    return parsed['x'], parsed['y']

ds = tf.data.TFRecordDataset('data.tfrecord').map(parse).batch(32)
10

保存とロード

SavedModel 形式

本番グレードの形式であるのが、SavedModel です:アーキテクチャ、重み、トレースされたグラフを束ねるため、元の Python のコードなしで、TF Serving、TFLite、TF.js、C++ でロードできます。Python へリロードするのが、tf.keras.models.load_model です。サービングのシグネチャを明示的に定義するのが、input_signature の渡しで — TF Serving には必須です。単一のファイルでなくディレクトリであるのが、SavedModel です。

tensorflow
import tensorflow as tf

model.save('saved_model')   # SavedModel directory
loaded = tf.keras.models.load_model('saved_model')
loaded.evaluate(x_test, y_test)

# export for serving (explicit signature)
@tf.function(input_signature=[tf.TensorSpec([None, 784], tf.float32)])
def serve(x):
    return {'outputs': model(x)}

tf.saved_model.save(model, 'serving_model', signatures=serve)

Keras 形式(.keras)

.keras 形式(Keras 3 のデフォルト)は、アーキテクチャの config、重み、オプティマイザの状態を含む単一の zip ファイルです — 共有とバージョン管理が容易です。レガシーの HDF5 形式であるのが、.h5 で、今もサポートされますが、新しいプロジェクトには推奨されません。配備(TFLite、TF Serving)には、(ディレクトリである)SavedModel が必要です。カスタム層のためには、.keras が config を保存するため、層を再構築できます — get_config() が正しいことを確保しましょう。

tensorflow
import tensorflow as tf

model.save('model.keras')   # Keras 3 default
loaded = tf.keras.models.load_model('model.keras')

# legacy HDF5 format
model.save('model.h5')
loaded = tf.keras.models.load_model('model.h5')

# .keras  — Keras 3 default, supports custom layers via config
# .h5     — legacy, weights + architecture but limited custom layer support
# SavedModel — directory, best for deployment/serving

重みのみの保存とロード

パラメータのテンソルだけを保存するのが、save_weights で — フルモデルよりずっと小さく、アーキテクチャから切り離されます。ロードの前に、同じ構造でモデルを再構築しなければなりません。一致する層だけをロードするのが、skip_mismatch=True で(Keras 3)、転移学習に有用です。チェックポイント形式(「ckpt」の接頭辞)は、checkpoint/weights-of-ckpt-1.index のファイルを作ります — fit のコールバックが内部で使う TF のネイティブのチェックポイント形式です。

tensorflow
import tensorflow as tf

model.save_weights('weights.keras')

model = build_model()   # must match the saved architecture
model.load_weights('weights.keras')

model.save_weights('weights.h5')
model.load_weights('weights.h5')

# load weights from one model into another (partial)
model.load_weights('weights.keras', skip_mismatch=True, by_name=True)

model.save_weights('ckpt')
model.load_weights('ckpt')

Checkpoint Manager

カスタムの訓練ループでの保存を完全に制御させてくれるのが、Checkpoint + CheckpointManager です — 最後の N チェックポイントを保ち、最新を自動的に復元し、ステップによりバージョン管理します。復元されなかったスロット(例:新しい変数のためのオプティマイザの momentum)についての警告を黙らせるのが、expect_partial() です。チェックポイントは、クラス定義でなくオブジェクトのグラフを保存します — 復元にはまだモデルのコードが必要です。古いチェックポイントを自動削除するのが、CheckpointManager.max_to_keep=3 です。

tensorflow
import tensorflow as tf

ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer, step=optimizer.iterations)
manager = tf.train.CheckpointManager(
    ckpt, directory='./ckpts', max_to_keep=3,
    checkpoint_name='step-{step}',
)

manager.save()
ckpt.restore(manager.latest_checkpoint).expect_partial()

# in a custom loop: save every N steps
if step % 1000 == 0:
    manager.save()

カスタムオブジェクトでのロード

カスタムの層、損失、メトリックを使うモデルをロードするとき、Keras はそれらをどう再構築するか知る必要があります。名前をクラス/関数へマッピングする custom_objects の dict を渡しましょう。よりきれいなコードのためには、クラスを @register_keras_serializable で装飾しましょう。そうすれば、グローバルに登録され、custom_objects が不要になります。オブジェクトが正確に再構築できるよう、get_config がすべてのコンストラクタの引数を返すことを確保しましょう — Keras は内部で from_config(config) を呼びます。

tensorflow
import tensorflow as tf

class MyLayer(tf.keras.layers.Layer):
    ...

custom_objects = {'MyLayer': MyLayer, 'focal_loss': FocalLoss}

loaded = tf.keras.models.load_model(
    'model.keras', custom_objects=custom_objects,
)

# or register globally
@tf.keras.utils.register_keras_serializable(package='my_pkg')
class MyLayer(tf.keras.layers.Layer):
    ...

サービングのためのエクスポート

TF Serving は、(モデルのホットスワップができるよう)バージョン付きのディレクトリ(serving/1/、serving/2/)を期待します。クライアントが使う入力/出力のテンソル名と shape を定義するのが、サービングのシグネチャです。これを自動的に包むのが、model.export()(Keras 3)です。カスタムの前処理のためには、モデルを tf.Module で包み、生の入力(例:uint8 の画像)を含み最終出力を返す input_signature 付きの __call__ を定義しましょう。クライアントがアドレスできるよう、テンソルに名前を付けましょう。

tensorflow
import tensorflow as tf

# Keras 3 export API (recommended)
model.export('serving/1')

class ServingModule(tf.Module):
    def __init__(self, model):
        self.model = model
    @tf.function(input_signature=[tf.TensorSpec([None, 784], tf.float32, name='inputs')])
    def __call__(self, x):
        return {'outputs': self.model(x)}

module = ServingModule(model)
tf.saved_model.save(module, 'serving/1',
                    signatures={'serving_default': module.__call__})

loaded = tf.saved_model.load('serving/1')
print(list(loaded.signatures.keys()))   # ['serving_default']
11

CNN

Conv2D と Pooling

Keras の標準の CNN ブロック:Conv2D -> BatchNormalization -> ReLU -> MaxPooling です。ストライド 1 のため空間サイズを保つのが、padding='same' です。空間次元をベクトルへ潰すのが、GlobalAveragePooling2D で — Flatten + Dense よりパラメータ効率が良く、過学習しにくいです。Keras はデフォルトで NHWC(channels-last)を使うため、Input の shape は、バッチ次元なしの (H, W, C) です。学習可能なダウンサンプリングのために、ストライド付き conv がプーリングを置き換えられます。

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.MaxPooling2D(),                # 28 -> 14
    tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.MaxPooling2D(),                # 14 -> 7
    tf.keras.layers.Conv2D(128, 3, padding='same', activation='relu'),
    tf.keras.layers.GlobalAveragePooling2D(),      # (7,7,128) -> (128,)
    tf.keras.layers.Dense(10, activation='softmax'),
])
model.summary()

CNN の構築

各ステージでフィルタを倍にし(32 -> 64 -> 128)、MaxPooling で空間サイズを半分にする、VGG スタイルの CNN です。1 つより豊富な特徴を抽出するのが、ステージごとの 2 つの conv です(VGG ブロック)。モデルの内側の Rescaling により配備可能になり — 生の uint8 の画像がそのまま入ります。ヘッドを正則化するのが、GlobalAveragePooling + Dropout です。ラベルが整数のクラスインデックスであるため、sparse_categorical_crossentropy でコンパイルしましょう。

tensorflow
import tensorflow as tf

inputs = tf.keras.Input(shape=(32, 32, 3))
x = tf.keras.layers.Rescaling(1./255)(inputs)

for filters in [32, 64, 128]:
    x = tf.keras.layers.Conv2D(filters, 3, padding='same', activation='relu')(x)
    x = tf.keras.layers.BatchNormalization()(x)
    x = tf.keras.layers.Conv2D(filters, 3, padding='same', activation='relu')(x)
    x = tf.keras.layers.MaxPooling2D()(x)
    x = tf.keras.layers.Dropout(0.25)(x)

x = tf.keras.layers.GlobalAveragePooling2D()(x)
x = tf.keras.layers.Dense(256, activation='relu')(x)
x = tf.keras.layers.Dropout(0.5)(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

特徴マップと可視化

各層が何を学ぶか検査するには、同じ入力だが複数の出力(conv 層の活性化)を持つ Model を作りましょう。早い層がエッジ/色を検出し、深い層がテクスチャ/パーツを検出します。デバッグに極めて有用です — 死んだ特徴マップ(すべてゼロ)は、壊れた ReLU か学習率の問題を示します。Grad-CAM(クラスの活性化マップ)のためには、tf-keras-vis を使うか、どの領域が予測を駆動したか見るため、勾配重み付きのクラス活性化を実装しましょう。

tensorflow
import tensorflow as tf
import matplotlib.pyplot as plt

feature_model = tf.keras.Model(
    inputs=model.inputs,
    outputs=[layer.output for layer in model.layers if 'conv2d' in layer.name],
)

img = x_test[0:1]
features = feature_model.predict(img)
print([f.shape for f in features])

fig, axes = plt.subplots(4, 8, figsize=(12, 6))
for i, ax in enumerate(axes.flat):
    if i < features[0].shape[-1]:
        ax.imshow(features[0][0, :, :, i], cmap='viridis')
    ax.axis('off')

事前訓練済みの CNN バックボーン

ImageNet の重み付きで、ResNet、EfficientNet、MobileNet、ViT などを公開するのが、keras.applications です。1000 クラスのヘッドを落とし、自分のものを付けられるのが、include_top=False です。バックボーンが訓練された正確な正規化を適用するのが、preprocess_input で — 配備のためには、モデルの内側で呼びましょう。バックボーンを凍結し(trainable=False)、呼び出しで training=False を設定しましょう。そうすれば、BatchNorm が推論の統計を使います — 小さいデータセットでの転移学習に重要です。

tensorflow
import tensorflow as tf

backbone = tf.keras.applications.ResNet50(
    include_top=False, weights='imagenet',
    input_shape=(224, 224, 3), pooling='avg',
)
backbone.trainable = False

inputs = tf.keras.Input(shape=(224, 224, 3))
x = tf.keras.applications.resnet50.preprocess_input(inputs)
x = backbone(x, training=False)
x = tf.keras.layers.Dense(256, activation='relu')(x)
x = tf.keras.layers.Dropout(0.5)(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

残差接続

ブロックの出力に入力を加えるのが、残差(スキップ)接続で、勾配が直接早い層へ流れられます — 非常に深いネットワーク(ResNet)の訓練を可能にするのがこれです。ショートカットは、出力のチャネルと空間サイズに一致しなければなりません。異なるとき調整するのが、ストライド付きの 1x1 conv です。2 つのパスをマージするのが、Add() です。スキップ接続のある任意のアーキテクチャには、(Sequential でなく)functional API を使いましょう。多くのそのようなブロックを積むのが、ResNet-50 です。

tensorflow
import tensorflow as tf

def residual_block(x, filters, stride=1):
    shortcut = x
    x = tf.keras.layers.Conv2D(filters, 3, strides=stride, padding='same', use_bias=False)(x)
    x = tf.keras.layers.BatchNormalization()(x)
    x = tf.keras.layers.ReLU()(x)
    x = tf.keras.layers.Conv2D(filters, 3, padding='same', use_bias=False)(x)
    x = tf.keras.layers.BatchNormalization()(x)
    if stride != 1 or shortcut.shape[-1] != filters:
        shortcut = tf.keras.layers.Conv2D(filters, 1, strides=stride, use_bias=False)(shortcut)
        shortcut = tf.keras.layers.BatchNormalization()(shortcut)
    x = tf.keras.layers.Add()([x, shortcut])
    return tf.keras.layers.ReLU()(x)

inputs = tf.keras.Input(shape=(32, 32, 3))
x = residual_block(inputs, 64)
x = residual_block(x, 128, stride=2)
model = tf.keras.Model(inputs, x)

検出ヘッド

検出のヘッドは、アンカーごとかピクセルごとのボックスとクラスの確率を予測します。マルチ出力のモデルを容易にするのが、functional API です:名前付きテンソルの dict を返しましょう。本物のプロジェクトのためには、TensorFlow Object Detection API か KerasCV(検出、セグメンテーション)を使いましょう — アンカーのマッチング、NMS、評価を扱います。ゼロから完全な検出器を書くのは高度な練習です:ボックスのエンコード、IoU 損失、focal 損失を注意深く扱いましょう。

tensorflow
import tensorflow as tf

# YOLO-style detection head: conv to (grid * grid * (5 + num_classes))
def detection_head(x, num_classes, num_anchors=3):
    out = tf.keras.layers.Conv2D(
        num_anchors * (5 + num_classes), 1, activation='linear')(x)
    return out

# anchor-free alternative: predict (cx, cy, w, h, obj, class_logits)
def center_net_head(features, num_classes):
    cls = tf.keras.layers.Conv2D(num_classes, 1, activation='sigmoid', name='cls')(features)
    wh = tf.keras.layers.Conv2D(2, 1, name='wh')(features)
    offset = tf.keras.layers.Conv2D(2, 1, name='offset')(features)
    return {'cls': cls, 'wh': wh, 'offset': offset}
12

RNN と LSTM

LSTM と GRU の層

LSTM/GRU の入力 shape は、(batch, timesteps, features) です。最後の出力を返すのが(分類のため)、return_sequences=False で、完全なシーケンスを返すのが(積み重ねか seq2seq のため)、True です。順方向と逆方向の出力を連結し、特徴サイズを倍にするのが、Bidirectional です。バッチをまたいで隠れ状態を運ぶのが、stateful=True で — 非常に長いシーケンスをチャンクに分けたときに有用ですが、固定の batch_size とエポック間の手動の状態リセットが必要です。

tensorflow
import tensorflow as tf

lstm = tf.keras.layers.LSTM(128, return_sequences=False)
x = tf.random.normal((4, 10, 64))
out = lstm(x)                       # (4, 128)

gru = tf.keras.layers.GRU(128)
out = gru(x)                        # (4, 128)

lstm = tf.keras.layers.LSTM(128, return_sequences=True)
out = lstm(x)                       # (4, 10, 128)

bi = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64))
out = bi(x)                         # (4, 128) — 64*2

lstm = tf.keras.layers.LSTM(64, stateful=True)

積み重ねた RNN

最後の LSTM/GRU 以外のすべてに return_sequences=True を設定することで RNN を積みましょう。Embedding 層の mask_zero=True は、RNN が尊重するマスクを生成します — パディングされた位置をスキップするため、隠れ状態に影響せず可変長のシーケンスをバッチ化できます。RNN 層の間の dropout が正則化し、RNN の内側の recurrent_dropout は遅いです(cuDNN なし)— 入力の dropout を優先しましょう。テキスト分類では、この biLSTM が強いベースラインです。

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(10000, 128, input_length=100, mask_zero=True),
    tf.keras.layers.LSTM(128, return_sequences=True),
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.LSTM(64),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax'),
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

RNN によるテキスト分類

標準のテキスト分類器:Embedding -> biLSTM -> biLSTM -> Dense -> sigmoid です。重要なのが、mask_zero=True です — なければ、LSTM がパディングのトークンを処理し、隠れ状態が偏ります。シーケンスを両方向に読むことで表現力を倍にするのが、Bidirectional です。二値分類には、sigmoid + binary_crossentropy を使いましょう。長いシーケンス(500 トークン以上)では、transformers が LSTM を上回りますが、より多くのデータと計算が必要です。

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(200,)),
    tf.keras.layers.Embedding(10000, 128, mask_zero=True),
    tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64, return_sequences=True)),
    tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(1, activation='sigmoid'),
])

model.compile(optimizer=tf.keras.optimizers.Adam(1e-3),
              loss='binary_crossentropy', metrics=['accuracy'])
model.fit(train_ds, validation_data=val_ds, epochs=5)

エンコーダ-デコーダの Seq2Seq

seq2seq(翻訳、要約)のためのエンコーダ-デコーダの LSTM です。エンコーダの最終の隠れ状態がデコーダを初期化し、デコーダがトークンごとにターゲットのシーケンスを生成します。teacher forcing で訓練しましょう:シフトされたターゲットのシーケンスをデコーダの入力として養います。推論のためには、各予測トークンを次の入力として養う、別のループを書きましょう。Attention(Bahdanau/Luong)は、seq2seq を劇的に改善し、transformers の概念的な祖先です。

tensorflow
import tensorflow as tf

encoder_input = tf.keras.Input(shape=(None,), name='enc_in')
enc_emb = tf.keras.layers.Embedding(vocab_src, 128)(encoder_input)
encoder = tf.keras.layers.LSTM(256, return_state=True)
enc_out, state_h, state_c = encoder(enc_emb)

decoder_input = tf.keras.Input(shape=(None,), name='dec_in')
dec_emb = tf.keras.layers.Embedding(vocab_tgt, 128)(decoder_input)
decoder_lstm = tf.keras.layers.LSTM(256, return_sequences=True, return_state=True)
dec_out, _, _ = decoder_lstm(dec_emb, initial_state=[state_h, state_c])
decoder_dense = tf.keras.layers.Dense(vocab_tgt, activation='softmax')
outputs = decoder_dense(dec_out)

model = tf.keras.Model([encoder_input, decoder_input], outputs)
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

時系列予測

時系列のためには、窓付きの (input, target) のペアを構築しましょう:各窓の最後の値がターゲットで、残りが入力です。重なり合う窓を作るのが、window(shift=1) で、同じサイズに保つのが、drop_remainder です。時間的パターンを学ぶのが、LSTM で、次の値を予測するのが、最後の Dense(1) です。マルチステップの予測のためには、地平線のベクトルを予測するか、seq2seq のアーキテクチャを使いましょう。訓練の統計だけを使い、必ず系列を標準化しましょう。

tensorflow
import tensorflow as tf

def make_dataset(series, window=20, batch=32):
    ds = tf.data.Dataset.from_tensor_slices(series)
    ds = ds.window(window + 1, shift=1, drop_remainder=True)
    ds = ds.flat_map(lambda w: w.batch(window + 1))
    ds = ds.map(lambda w: (w[:-1][..., tf.newaxis], w[-1:]))
    return ds.shuffle(1000).batch(batch).prefetch(tf.data.AUTOTUNE)

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(20, 1)),
    tf.keras.layers.LSTM(32, return_sequences=False),
    tf.keras.layers.Dense(1),
])
model.compile(optimizer='adam', loss='mse')
model.fit(make_dataset(train_series), epochs=10)

Attention 機構

単一の固定ベクトルに頼るのでなく、関連するエンコーダの状態にデコーダが集中させてくれるのが、Attention です — 長いシーケンスへの大きな改善です。2 つのクラシックなバリアントが、Bahdanau(加法的)と Luong(乗法的)です。すぐ使える層として、tf.keras.layers.AdditiveAttention と Attention を Keras が提供します。transformers への概念的な橋渡しが、Attention です:マルチヘッドの自己注意は、同じシーケンスに適用された attention に過ぎません。

tensorflow
import tensorflow as tf

class BahdanauAttention(tf.keras.layers.Layer):
    def __init__(self, units):
        super().__init__()
        self.W1 = tf.keras.layers.Dense(units)
        self.W2 = tf.keras.layers.Dense(units)
        self.V = tf.keras.layers.Dense(1)
    def call(self, query, values):
        q = tf.expand_dims(query, 1)
        scores = self.V(tf.nn.tanh(self.W1(values) + self.W2(q)))
        attn = tf.nn.softmax(scores, axis=1)
        context = tf.reduce_sum(attn * values, axis=1)
        return context, attn

attn = tf.keras.layers.AdditiveAttention()
context = attn([query, value])
13

Transformer

MultiHeadAttention

transformer のコアの層であるのが、MultiHeadAttention です — q/k/v を複数のヘッドへ射影し、並列に attends し、再結合します。自己注意のためには、query、key、value に同じテンソルを渡しましょう。causal マスク(下三角)がデコーディングのため、padding マスク(True = 無視)があり得るのが、attention_mask です。可視化のための注意の行列を返すのが、return_attention_scores=True です。ブロックが積み重ねられるよう、出力の次元が入力の次元に等しくなります。

tensorflow
import tensorflow as tf

mha = tf.keras.layers.MultiHeadAttention(
    num_heads=8, key_dim=64, dropout=0.1, use_bias=True)

x = tf.random.normal((4, 10, 512))
out, attn_weights = mha(query=x, value=x, key=x,
                        return_attention_scores=True)
print(out.shape)          # (4, 10, 512)
print(attn_weights.shape) # (4, 8, 10, 10)

# causal mask (decoder self-attention)
mask = tf.linalg.band_part(tf.ones((10, 10)), -1, 0)
out = mha(query=x, value=x, key=x, attention_mask=mask)

# key padding mask (ignore pad positions)
padding = tf.cast(tokens == 0, tf.bool)[:, tf.newaxis, tf.newaxis, :]
out = mha(query=x, value=x, key=x, attention_mask=padding)

Transformer のエンコーダブロック

transformer のエンコーダブロックは:マルチヘッドの自己注意 + add & norm + フィードフォワード(MLP)+ add & norm です。ゼロからの訓練には、Pre-LN(サブレイヤーの前の norm)がより安定で、post-LN にはウォームアップが必要です。GELU 付きの 2 層の MLP である FFN が、「ff」の隠れユニットへ拡大し、「dim」へ戻ります。完全なエンコーダのために、これらを N 個積みましょう。小さい分散でのゼロ除算を避けるのが、LayerNorm の epsilon=1e-6 です。

tensorflow
import tensorflow as tf

class TransformerBlock(tf.keras.layers.Layer):
    def __init__(self, dim=512, heads=8, ff=2048, dropout=0.1, **kwargs):
        super().__init__(**kwargs)
        self.att = tf.keras.layers.MultiHeadAttention(num_heads=heads, key_dim=dim // heads)
        self.ffn = tf.keras.Sequential([
            tf.keras.layers.Dense(ff, activation='gelu'),
            tf.keras.layers.Dense(dim),
        ])
        self.norm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.norm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.drop1 = tf.keras.layers.Dropout(dropout)
        self.drop2 = tf.keras.layers.Dropout(dropout)

    def call(self, x, training=False, mask=None):
        attn = self.att(x, x, x, attention_mask=mask)
        x = self.norm1(x + self.drop1(attn, training=training))
        ffn = self.ffn(x)
        return self.norm2(x + self.drop2(ffn, training=training))

位置エンコーディング

transformers は置換不変です — トークンの順序を知るために位置情報が必要です。位置と次元に基づく固定パターンを加えるのが、サイン波のエンコーディングで、訓練で見たより長いシーケンスへ汎化します。埋め込みの出力へ位置エンコーディングを加えましょう。あるいは、学習された位置の埋め込み(位置でインデックスされる Embedding 層)か、相対位置のエンコーディング(T5 のようなモダンな transformers で使われます)を使いましょう。画像(ViT)のためには、パッチごとに学習可能な位置の埋め込みを加えましょう。

tensorflow
import tensorflow as tf
import numpy as np

class PositionalEncoding(tf.keras.layers.Layer):
    def __init__(self, max_len=5000, dim=512, **kwargs):
        super().__init__(**kwargs)
        pos = np.arange(max_len)[:, np.newaxis]
        i = np.arange(dim)[np.newaxis, :]
        angle = pos / np.power(10000, (2 * (i // 2)) / np.float32(dim))
        angle[:, 0::2] = np.sin(angle[:, 0::2])
        angle[:, 1::2] = np.cos(angle[:, 1::2])
        self.pos = tf.constant(angle[np.newaxis, ...], dtype=tf.float32)

    def call(self, x):
        return x + self.pos[:, :tf.shape(x)[1], :]

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(10000, 512),
    PositionalEncoding(max_len=200, dim=512),
    tf.keras.layers.Dropout(0.1),
])

テキスト分類の Transformer

ゼロからの transformer のテキスト分類器:embedding + 位置エンコーディング + N 個のエンコーダブロック + global average pool + Dense のヘッドです。シーケンス次元を潰すのが、GlobalAveragePooling1D です(学習可能な集約のためには、CLS トークンを使いましょう)。MultiHeadAttention が尊重するマスクを伝播させるのが、mask_zero=True で — 必要なら、手動で通しましょう。本物の NLP のためには、HuggingFace から事前訓練済みの transformer(BERT、T5)を使いましょう — ゼロからの訓練には巨大なデータが必要です。

tensorflow
import tensorflow as tf

class TransformerEncoder(tf.keras.layers.Layer):
    def __init__(self, dim, heads, ff, num_layers, dropout=0.1, **kwargs):
        super().__init__(**kwargs)
        self.blocks = [TransformerBlock(dim, heads, ff, dropout)
                       for _ in range(num_layers)]
    def call(self, x, training=False, mask=None):
        for block in self.blocks:
            x = block(x, training=training, mask=mask)
        return x

inputs = tf.keras.Input(shape=(200,))
x = tf.keras.layers.Embedding(10000, 128, mask_zero=True)(inputs)
x = PositionalEncoding(200, 128)(x)
x = TransformerEncoder(128, 4, 512, 4)(x)
x = tf.keras.layers.GlobalAveragePooling1D()(x)
x = tf.keras.layers.Dropout(0.3)(x)
outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x)
model = tf.keras.Model(inputs, outputs)

Vision Transformer(ViT)

Vision Transformer は、ストライド付きの Conv2d(kernel=stride=patch_size)で画像をパッチ化し、パッチをトークンとして扱い、CLS トークンを前に置き、位置の埋め込みを加え、transformer のエンコーダブロックを走らせます。分類のための全体的な画像の表現であるのが、CLS トークンの最終の隠れ状態です。本物の利用のためには、keras.applications か HuggingFace から事前訓練済みの ViT をロードしましょう — よく機能するには、ImageNet-21k の事前訓練が必要です。ViT-Base のデフォルトが、パッチサイズ 16 と dim 768 です。

tensorflow
import tensorflow as tf

class ViTPatchEmbed(tf.keras.layers.Layer):
    def __init__(self, patch_size=16, dim=768, **kwargs):
        super().__init__(**kwargs)
        self.proj = tf.keras.layers.Conv2D(dim, patch_size, strides=patch_size)
    def call(self, x):
        x = self.proj(x)
        shape = tf.shape(x)
        x = tf.reshape(x, [shape[0], -1, x.shape[-1]])
        return x

inputs = tf.keras.Input(shape=(224, 224, 3))
x = ViTPatchEmbed(16, 768)(inputs)
x = x + tf.Variable(tf.random.normal((1, 196, 768)))
cls = tf.Variable(tf.random.normal((1, 1, 768)))
x = tf.keras.layers.Concatenate(axis=1)([cls, x])
for _ in range(6):
    x = TransformerBlock(768, 12, 3072, 0.1)(x)
x = tf.keras.layers.Lambda(lambda t: t[:, 0])(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

Transformer のデコーダ

デコーダブロックには、3 つのサブレイヤーがあります:masked 自己注意(位置 t が未来を見られない causal マスク)、cross-attention(decoder からの query、encoder 出力からの key/value)、そして FFN です。各サブレイヤーには、残差 + LayerNorm があります。デコーダにソースのシーケンスを「振り返らせる」のが、cross-attention です。decoder-only のモデル(GPT)のためには、cross-attention のサブレイヤーを落としましょう。完全なデコーダのために、N ブロック積みましょう。推論には、予測トークンを養い戻す自己回帰のループが必要です。

tensorflow
import tensorflow as tf

class DecoderBlock(tf.keras.layers.Layer):
    def __init__(self, dim, heads, ff, dropout=0.1, **kwargs):
        super().__init__(**kwargs)
        self.self_att = tf.keras.layers.MultiHeadAttention(heads, dim // heads)
        self.cross_att = tf.keras.layers.MultiHeadAttention(heads, dim // heads)
        self.ffn = tf.keras.Sequential([
            tf.keras.layers.Dense(ff, activation='gelu'),
            tf.keras.layers.Dense(dim),
        ])
        self.norm1 = self.norm2 = self.norm3 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.drop = tf.keras.layers.Dropout(dropout)

    def call(self, x, enc_out, training=False, causal_mask=None, padding_mask=None):
        attn = self.self_att(x, x, x, attention_mask=causal_mask)
        x = self.norm1(x + self.drop(attn, training=training))
        cross = self.cross_att(query=x, value=enc_out, key=enc_out, attention_mask=padding_mask)
        x = self.norm2(x + self.drop(cross, training=training))
        x = self.norm3(x + self.drop(self.ffn(x), training=training))
        return x
14

TensorBoard

セットアップとコールバック

fit の間、メトリック、グラフ、プロファイリングのデータを log_dir へストリームするのが、TensorBoard コールバックです。エポックごとに重みの分布をログするのが、histogram_freq=1 で — スペースを節約するには 0 にしましょう。そのバッチで TF Profiler を実行し、ボトルネック(入力パイプライン、演算のレイテンシ、メモリ)を特定するのが、profile_batch=2 です。TensorBoard がそれらを重ね合わせるよう、実験ごとに別々のサブディレクトリ(logs/exp1、logs/exp2)を使いましょう — ハイパーパラメータのスイープに最適です。起動は、`tensorboard --logdir=logs` です。

tensorflow
import tensorflow as tf

tb = tf.keras.callbacks.TensorBoard(
    log_dir='logs/experiment_1', histogram_freq=1,
    write_graph=True, profile_batch=2,
)

model.fit(train_ds, validation_data=val_ds, epochs=10, callbacks=[tb])

# launch tensorboard
# tensorboard --logdir=logs

import datetime
log_dir = 'logs/fit/' + datetime.datetime.now().strftime('%Y%m%d-%H%M%S')

カスタムスカラー(Summary Writer)

カスタムの訓練ループでカスタムスカラーをログする低レベルのハンドルを与えてくれるのが、tf.summary.create_file_writer です。書くには、writer.as_default() と tf.summary.scalar(name, value, step=step) を使いましょう。ステップは整数でなければなりません(通常はオプティマイザの反復カウンタです)。イベントがディスクに届くよう、定期的にフラッシュしましょう。TensorBoard の UI でチャートを整理するには、名前空間(train/loss、val/loss)を使いましょう。LR、勾配のノルム、気になる任意のカスタムメトリックをログしましょう。

tensorflow
import tensorflow as tf

writer = tf.summary.create_file_writer('logs/custom')

with writer.as_default():
    tf.summary.scalar('train/loss', loss, step=step)
    tf.summary.scalar('train/lr', lr, step=step)
    tf.summary.scalar('val/accuracy', acc, step=step)
    tf.summary.text('config', 'lr=1e-3, batch=32', step=0)
    writer.flush()

# in a custom training loop
for step, (x, y) in enumerate(train_ds):
    # ... train step ...
    if step % 100 == 0:
        with writer.as_default():
            tf.summary.scalar('loss', loss, step=step)

画像とヒストグラム

視覚的な QA のために画像をログするのが、tf.summary.image です — max_outputs までの B 付きの shape (B, H, W, C) を渡しましょう。時間をかけた重みと勾配の分布を示すのが、ヒストグラムで、突然のスパイクは不安定性を示唆します。スカラーのメトリックだけでなく、質的な進捗を見るため、エポックごとにいくつかの検証のサンプルをログしましょう。音声モデルには音声が有用です。すべてのサマリーは、TensorBoard で x 軸になる step 引数を取ります。N ステップごとにサンプリングし、ログを安価に保ちましょう。

tensorflow
import tensorflow as tf

writer = tf.summary.create_file_writer('logs/viz')

with writer.as_default():
    tf.summary.image('sample', img[None, ...], step=step)
    tf.summary.image('batch', images[:8], step=step, max_outputs=8)
    for var in model.trainable_variables:
        tf.summary.histogram('weights/' + var.name, var, step=step)
    tf.summary.audio('waveform', audio[None, ...], sample_rate=16000, step=step)
    writer.flush()

ハイパーパラメータの調整

TensorBoard でハイパーパラメータのスイープを整理するのが、HParams プラグインです — テーブルビューにより、実行をフィルタし最良の config を見つけられます。範囲/離散値付きの HParam オブジェクトを定義し、hp.hparams_config で config を一度ログし、その後、各実行で hp.hparams(hparams) と最終のメトリックをログしましょう。真剣なスイープには、KerasTuner(RandomSearch、Hyperband、BayesianOptimization)を使いましょう — 検索を自動化し TensorBoard と統合します。

tensorflow
import tensorflow as tf
# from tensorboard.plugins.hparams import api as hp
# (run: pip install tensorboard-plugin-hparams)

HP_LR = hp.HParam('lr', hp.RealInterval(1e-4, 1e-2))
HP_DROPOUT = hp.HParam('dropout', hp.Discrete([0.1, 0.3, 0.5]))
METRIC_ACC = 'accuracy'

with tf.summary.create_file_writer('logs/hparam_tuning').as_default():
    hp.hparams_config(hparams=[HP_LR, HP_DROPOUT], metrics=[hp.Metric(METRIC_ACC)])

for lr in [1e-3, 5e-3]:
    for dropout in [0.1, 0.3]:
        hparams = {HP_LR: lr, HP_DROPOUT: dropout}
        run_name = f"lr-{lr}-drop-{dropout}"
        with tf.summary.create_file_writer('logs/hparam_tuning/' + run_name).as_default():
            hp.hparams(hparams)
            acc = train(hparams)
            tf.summary.scalar(METRIC_ACC, acc, step=1)

パフォーマンスのプロファイリング

どこに時間が費やされているか示すのが、TF Profiler です:演算ごと、デバイスごと、入力パイプラインです。バッチ 10〜20 をプロファイルするのが、profile_batch='10,20' です(ウォームアップが終わるよう最初のいくつかをスキップします)。実行可能な推奨を与えるのが、Overview ページです(例:「入力パイプラインがボトルネックです」)。ピークメモリとどのテンソルが支配的か示すのが、Memory Viewer です。深掘りのための Chrome 風のタイムラインが、Trace Viewer です。常にターゲットのハードウェアでプロファイルしましょう — CPU 対 GPU のボトルネックは異なります。

tensorflow
import tensorflow as tf

# profile via callback
tb = tf.keras.callbacks.TensorBoard(
    log_dir='logs/profile', profile_batch='10,20',
)

# or use the Profiler API directly
tf.profiler.experimental.start('logs/profile')
# ... run a few batches ...
tf.profiler.experimental.stop()

# in TensorBoard, open the Profile tab to see:
# - op-level time breakdown
# - input pipeline analysis (tf.data bottleneck)
# - memory viewer
# - overview page with recommendations
15

GPU / TPU 訓練

GPU の検出とメモリ

デフォルトで TF は、起動時にすべての GPU メモリを grabbing し、他のプロセスをブロックします。必要なものだけを割り当てるのが、set_memory_growth(True) で — GPU を共有するのに不可欠です。メモリを制限するか、1 つの GPU を複数の論理デバイスに分割するのが、set_logical_device_configuration です(1 つの GPU でマルチ GPU のコードをテストするのに有用)。演算を特定のデバイスに置くのが、tf.device('/GPU:1') です。CPU の演算は、「/CPU:0」で走ります。一致しないデバイスの配置は、パフォーマンスを損なう暗黙のコピーを引き起こします。

tensorflow
import tensorflow as tf

gpus = tf.config.list_physical_devices('GPU')
print('GPUs:', gpus)

# set memory growth (don't grab all GPU memory at start)
for gpu in gpus:
    tf.config.experimental.set_memory_growth(gpu, True)

# or limit GPU memory explicitly
tf.config.set_logical_device_configuration(
    gpus[0],
    [tf.config.LogicalDeviceConfiguration(memory_limit=4096)],
)

with tf.device('/GPU:1'):
    x = tf.random.normal((1000, 1000))
    y = tf.matmul(x, x)

分散ストラテジー

デバイスのトポロジーを抽象化するのが、分散ストラテジーです。シングルマシンのマルチ GPU のためのものが、MirroredStrategy です(変数を GPU をまたいでミラーし、勾配を all-reduce します)— 最も簡単なマルチ GPU のパスです。複数のマシンへ拡張するのが、MultiWorkerMirroredStrategy です。Google の TPU(Colab/Cloud)で走るのが、TPUStrategy です。変数が正しくミラーされるよう、常に strategy.scope() の内側でモデルを作りましょう。同じ fit/predict のコードが、ストラテジーをまたいで機能します。

tensorflow
import tensorflow as tf

strategy = tf.distribute.OneDeviceStrategy(device='/gpu:0')
strategy = tf.distribute.MirroredStrategy()
print('num replicas:', strategy.num_replicas_in_sync)

# TPU
resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
tf.config.experimental_connect_to_cluster(resolver)
tf.tpu.experimental.initialize_tpu_system(resolver)
strategy = tf.distribute.TPUStrategy(resolver)

with strategy.scope():
    model = build_model()
    model.compile(optimizer='adam', loss='...', metrics=['accuracy'])

model.fit(train_ds, epochs=10)

マルチ GPU 訓練

各 GPU 上にモデルの変数をミラーし、各バッチをレプリカに分割するのが、MirroredStrategy です — 実効的なバッチサイズが、global_batch です(例:64 per GPU * 4 GPUs = 256)。グローバルバッチをデータセットへ渡しましょう。TF がシャードを自動的に分配します。内部で勾配の all-reduce を扱うのが、fit() です。カスタムの訓練ループのためには、strategy.experimental_distribute_dataset と strategy.run(train_step) を使いましょう。

tensorflow
import tensorflow as tf

strategy = tf.distribute.MirroredStrategy()
print(f'using {strategy.num_replicas_in_sync} GPUs')

global_batch = 64 * strategy.num_replicas_in_sync
train_ds = make_dataset().batch(global_batch)

with strategy.scope():
    model = build_model()
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

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

TPU 訓練(Colab)

TPU は、Google Colab(ランタイムのタイプを変更 -> TPU)と Google Cloud で利用可能です。TPU システムを一度初期化し、その後、strategy.scope() でモデルの作成を包みましょう。大きなバッチサイズ(1024+)と固定の shape で最も速いのが、TPU です — バッチ化では drop_remainder=True を使いましょう。TPU はローカルのファイルを直接読めません。メモリへデータをロードするか、tf.data 経由で GCS からストリームしましょう。混合精度(bfloat16)は、TPU 上で大きな高速化を与え、ロススケーリングを必要としません。

tensorflow
import tensorflow as tf

try:
    resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
    tf.config.experimental_connect_to_cluster(resolver)
    tf.tpu.experimental.initialize_tpu_system(resolver)
    strategy = tf.distribute.TPUStrategy(resolver)
    print('TPUs:', strategy.num_replicas_in_sync)
except ValueError:
    print('No TPU found')
    strategy = tf.distribute.get_strategy()

with strategy.scope():
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
        tf.keras.layers.Dense(10, activation='softmax'),
    ])
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

model.fit(x_train, y_train, batch_size=1024, epochs=5)

混合精度

混合精度は float16 で計算しますが、float32 のマスター コピーを保つため、Tensor Core GPU(Volta+)で 2〜3 倍のスループットと半分のメモリを与えます。ロススケーリングが必要なのが、「mixed_float16」です(Keras が LossScaleOptimizer 経由で自動的に扱います)。float32 と同じ範囲を持つためスケーリングが不要なのが、「mixed_bfloat16」ですが、Ampere+ の GPU と TPU のみがサポートします。数値安定性のために(softmax/ロジット)、最終層を float32 に強制しましょう。最も簡単な単独のパフォーマンスの勝利が、混合精度です。

tensorflow
import tensorflow as tf

tf.keras.mixed_precision.set_global_policy('mixed_float16')
# or bfloat16 on Ampere+ / TPU (no loss scaling needed)
tf.keras.mixed_precision.set_global_policy('mixed_bfloat16')

model = tf.keras.Sequential([
    tf.keras.layers.Dense(512, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(10, dtype='float32'),
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
print(model.layers[0].dtype_policy)   # <Policy "mixed_float16">
16

データ拡張

Keras の前処理の層

Keras の前処理の層(RandomFlip、RandomRotation など)は、GPU 上と tf.function の内側で走ります — PIL/numpy の拡張よりずっと速いです。モデルの内側に置くと、推論で自動的に無効になります(training=False です)。あるいは、より多くの制御のために、tf.data の map で適用しましょう。これらの層はステートレスで JIT コンパイルされるため、推論を遅くしません。ステートフルな前処理(例:フィットされたスケーラー)には、Adapt API を使いましょう。

tensorflow
import tensorflow as tf

augment = tf.keras.Sequential([
    tf.keras.layers.RandomFlip('horizontal'),
    tf.keras.layers.RandomRotation(0.1),
    tf.keras.layers.RandomZoom(0.1),
    tf.keras.layers.RandomContrast(0.2),
    tf.keras.layers.RandomTranslation(0.1, 0.1),
])

# put augmentation INSIDE the model (training-only, inactive at inference)
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(224, 224, 3)),
    tf.keras.layers.Rescaling(1./255),
    augment,
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
])

# or apply via dataset.map
ds = ds.map(lambda x, y: (augment(x, training=True), y))

ImageDataGenerator(レガシー)

レガシーの拡張 API であるのが、ImageDataGenerator です — 機能しますが CPU で走り、Keras の前処理の層より遅いです。ディレクトリ反復の便利さかレガシーのコードが必要なときだけ使いましょう。新しいプロジェクトには、keras.utils.image_dataset_from_directory + Keras の前処理の層(RandomFlip など)を優先しましょう — GPU 加速され、tf.data と統合します。サブディレクトリ名からクラスラベルを推論するのが、flow_from_directory です(ImageFolder のように)。

tensorflow
from tensorflow.keras.preprocessing.image import ImageDataGenerator

train_datagen = ImageDataGenerator(
    rescale=1./255, rotation_range=20,
    width_shift_range=0.2, height_shift_range=0.2,
    shear_range=0.2, zoom_range=0.2,
    horizontal_flip=True, fill_mode='nearest',
    validation_split=0.2,
)

train_gen = train_datagen.flow_from_directory(
    'data/train', target_size=(224, 224), batch_size=32,
    class_mode='binary', subset='training',
)

model.fit(train_gen, epochs=10)

画像拡張の演算

カスタムの拡張のためのきめ細かい制御を与えるのが、tf.image.* の演算です。幾何なしで色を変えるのが、random_brightness/contrast/saturation/hue です。正則化を改善する高度な拡張であるのが、Cutout と Mixup で、tf.image の演算 + tf.tensor_scatter_nd_update で実装します。CPU ワーカーで走り GPU を決してブロックしないよう、num_parallel_calls=AUTOTUNE 付きの tf.data の map で拡張を適用しましょう。色のジッターの後、必ず有効なピクセル範囲へクリップバックしましょう。

tensorflow
import tensorflow as tf

def augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_brightness(image, max_delta=0.2)
    image = tf.image.random_contrast(image, lower=0.8, upper=1.2)
    image = tf.image.random_saturation(image, lower=0.8, upper=1.2)
    image = tf.image.random_hue(image, max_delta=0.1)
    image = tf.clip_by_value(image, 0.0, 1.0)
    return image, label

ds = ds.map(augment, num_parallel_calls=tf.data.AUTOTUNE)

Mixup と CutMix

2 つの画像とそのラベルを線形にブレンドし、クラス間の仮想例を作るのが、Mixup で — 過学習を減らし、較正を改善する強い正則化です。ある画像から矩形のパッチを別の画像に貼るのが、CutMix で、Mixup より局所構造をよく保ちます。どちらも、損失がソフト(混合)ラベルを受け付ける必要があります — sparse でなく、categorical_crossentropy を使いましょう。バッチ化の後、バッチごとに適用しましょう。最良の結果のためには、標準の幾何の拡張と組み合わせましょう。

tensorflow
import tensorflow as tf

def mixup(images, labels, alpha=0.2):
    lam = tf.random.beta([], alpha, alpha)
    batch_size = tf.shape(images)[0]
    idx = tf.random.shuffle(tf.range(batch_size))
    mixed_images = lam * images + (1 - lam) * tf.gather(images, idx)
    mixed_labels = lam * labels + (1 - lam) * tf.gather(labels, idx)
    return mixed_images, mixed_labels

ds = ds.batch(32).map(mixup, num_parallel_calls=tf.data.AUTOTUNE)

テキストと表形式の拡張

テキストのためには、単語レベルの簡単な拡張(同義語の交換、ランダムな削除/スワップ)が安価で効果的です。真剣な NLP には、逆翻訳や EDA/AugBERT のようなモデルを使いましょう。表形式のデータのためには、行をブレンドするのが mixup で、数値特徴上のガウスノイズが正則化します。拡張は訓練データのみに適用し、決して検証/テストには適用しないように。拡張をラベル保持(か mixup のようなラベル混合)に保ちましょう — ラベルの破壊は、助けるより傷つけます。

tensorflow
import tensorflow as tf
import random

def text_augment(text):
    words = text.split()
    if random.random() < 0.2:
        words = [w for w in words if random.random() > 0.2]
    if len(words) > 1 and random.random() < 0.2:
        i, j = random.sample(range(len(words)), 2)
        words[i], words[j] = words[j], words[i]
    return ' '.join(words)

def tabular_mixup(x, y, alpha=0.2):
    lam = tf.random.beta([], alpha, alpha)
    idx = tf.random.shuffle(tf.range(tf.shape(x)[0]))
    return lam * x + (1 - lam) * tf.gather(x, idx), lam * y + (1 - lam) * tf.gather(y, idx)

def add_noise(x, std=0.01):
    return x + tf.random.normal(tf.shape(x), stddev=std)
17

転移学習

事前訓練済みのモデル

ImageNet の重み付きで、ResNet、EfficientNet、MobileNet、ViT などを公開するのが、keras.applications です。1000 クラスのヘッドを落とし、自分のものを付けられるのが、include_top=False です。バックボーンが期待する正確な正規化を適用するのが、preprocess_input で — 配備のためには、モデルの内側で呼びましょう。バックボーンを凍結し(trainable=False)、base(x, training=False) を呼びましょう。そうすれば、BatchNorm が推論の統計を使います — さもなければ、BN の統計がノイズだらけになる小さいデータセットには重要です。

tensorflow
import tensorflow as tf

base = tf.keras.applications.ResNet50(
    include_top=False, weights='imagenet',
    input_shape=(224, 224, 3), pooling='avg',
)
base.trainable = False

inputs = tf.keras.Input(shape=(224, 224, 3))
x = tf.keras.applications.resnet50.preprocess_input(inputs)
x = base(x, training=False)
x = tf.keras.layers.Dense(256, activation='relu')(x)
x = tf.keras.layers.Dropout(0.5)(x)
outputs = tf.keras.layers.Dense(num_classes, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

特徴抽出

バックボーン全体を凍結し、新しいヘッドだけを訓練するのが、特徴抽出で — 最速の転移学習のベースラインです。バックボーンが固定であるため、特徴を一度前計算し(base.predict(train_ds))、その上で小さな分類器を訓練でき、巨大な計算を節約します。BatchNorm が実行統計を使うよう、バックボーンを呼ぶとき training=False を設定しましょう — さもなければ、小さいバッチがそれらを壊します。ファインチューニングが過学習する、(数百の画像の)小さいデータセットに適しています。

tensorflow
import tensorflow as tf

base = tf.keras.applications.MobileNetV2(
    include_top=False, weights='imagenet', pooling='avg')
base.trainable = False

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(224, 224, 3)),
    tf.keras.applications.mobilenet_v2.preprocess_input,
    base,
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.Dense(num_classes, activation='softmax'),
])

model.compile(optimizer=tf.keras.optimizers.Adam(1e-3),
              loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(train_ds, validation_data=val_ds, epochs=5)

ファインチューニング

バックボーンの一部の層を凍結解除し、小さい LR で訓練するのが、ファインチューニングで、事前訓練の特徴がタスクに適応します。必ず最初に(ヘッドのみの)特徴抽出を数エポック行い、その後、凍結解除しましょう — さもなければ、ランダムなヘッドの大きな勾配が事前訓練の特徴を破壊します。ずっと小さい LR を使いましょう(ヘッドの 1e-3 対 1e-5)。上から下へ凍結解除しましょう(後の層がよりタスク特化で、早い層が汎用です)。実行統計を保存するため、BatchNorm の層は凍結されたまま保ちましょう。

tensorflow
import tensorflow as tf

base = tf.keras.applications.ResNet50(include_top=False, weights='imagenet', pooling='avg')
base.trainable = True

# freeze everything except the last few blocks
for layer in base.layers[:-20]:
    layer.trainable = False

model.compile(
    optimizer=tf.keras.optimizers.Adam(1e-5),   # 10x smaller than head
    loss='sparse_categorical_crossentropy', metrics=['accuracy'],
)
model.fit(train_ds, validation_data=val_ds, epochs=5)

凍結と凍結解除

凍結するのが、layer.trainable=False の設定です。trainable を変えた後、オプティマイザが新しい trainable のセットを拾うよう、必ずモデルを再コンパイルしなければなりません。ファインチューニング中、BatchNorm の層は凍結されたまま保ちましょう — その実行統計は貴重で、小さいファインチューニングのバッチがそれらを壊します。何が更新されるか確認するには、trainable_weights 対 weights を検査しましょう。偶発的にすべてを凍結/凍結解除しないよう、訓練可能なパラメータ数をログしましょう(よくあるサイレントなバグです)。

tensorflow
import tensorflow as tf

base = tf.keras.applications.EfficientNetB0(
    include_top=False, weights='imagenet', pooling='avg')

base.trainable = False
for layer in base.layers:
    layer.trainable = 'block7' in layer.name

# freeze BatchNorm specifically (recommended during fine-tuning)
for layer in base.layers:
    if isinstance(layer, tf.keras.layers.BatchNormalization):
        layer.trainable = False

n_train = sum(tf.keras.backend.count_params(w) for w in model.trainable_weights)
n_total = sum(tf.keras.backend.count_params(w) for w in model.weights)
print(f"trainable: {n_train:,} / {n_total:,}")

マルチタスクの転移

関連するタスクをまたいでバックボーンを共有するのが、マルチタスク学習で、表現を正則化し計算を節約します。共有された特徴からの小さいブランチであるのが、各ヘッドです。タスクの勾配をバランスさせるため、compile で出力ごとの損失と loss_weights を渡しましょう(どのタスクも支配しないよう重みを調整します)。fit のとき、出力名に一致する dict としてターゲットを渡しましょう。多くのデータを持つ 1 つのタスクと少ししかない別のタスクがあるとき、マルチタスクの転移が強力です — 共有バックボーンが両方に利益を与えます。

tensorflow
import tensorflow as tf

base = tf.keras.applications.ResNet50(include_top=False, weights='imagenet')
base.trainable = False

inputs = tf.keras.Input(shape=(224, 224, 3))
x = tf.keras.applications.resnet50.preprocess_input(inputs)
features = base(x, training=False)
features = tf.keras.layers.GlobalAveragePooling2D()(features)

cls_out = tf.keras.layers.Dense(num_classes, activation='softmax', name='cls')(features)
box_out = tf.keras.layers.Dense(4, name='box')(features)
attr_out = tf.keras.layers.Dense(num_attr, activation='sigmoid', name='attr')(features)

model = tf.keras.Model(inputs, [cls_out, box_out, attr_out])
model.compile(
    optimizer='adam',
    loss={'cls': 'sparse_categorical_crossentropy', 'box': 'mse',
          'attr': 'binary_crossentropy'},
    loss_weights={'cls': 1.0, 'box': 5.0, 'attr': 0.5},
)
18

モデルの配備

TFLite Converter

モバイル、組み込み、エッジデバイスのための flatbuffer 形式へ TF のモデルを変換するのが、TFLite です。訓練後の量子化を自動的に適用するのが、Optimize.DEFAULT で、完全な int8 の量子化には、活性化の範囲を較正する代表的なデータセットが必要で、Edge TPU / マイクロコントローラで走るモデルを生成します。GPU の互換性を保つのが、float16 で、int8 が精度を損なうならより安全です。コンバータはモデルから入力 shape を推論します。動的な shape のためには、concrete 関数で固定しましょう。

tensorflow
import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

# with quantization (8-bit, ~4x smaller, faster on CPU)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
# float16 quantization (GPU-friendly, 2x smaller)
converter.target_spec.supported_types = [tf.float16]
# full integer quantization (needs representative dataset)
converter.representative_dataset = rep_data
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
tflite_quant = converter.convert()

TFLite Interpreter

CPU、GPU、Edge TPU、マイクロコントローラで .tflite のモデルを走らせるのが、TFLite Interpreter です。固定の入力 shape に基づきメモリを準備するのが、allocate_tensors で、動的な shape のためのリサイズが、resize_tensor_input です。推論のループが、set_tensor / invoke / get_tensor です。バッチ化された推論のためには、モデルが固定のバッチサイズで変換されなければならないか、resize_tensor_input を使いましょう。Python、C++、Java、Swift、JavaScript のバインディングがあるのが、TFLite です — 同じ .tflite ファイルがどこでも走ります。

tensorflow
import tensorflow as tf
import numpy as np

interpreter = tf.lite.Interpreter(model_path='model.tflite')
interpreter.allocate_tensors()

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
print(input_details)
# [{'name': 'input', 'shape': (1, 224, 224, 3), 'dtype': tf.float32, ...}]

input_data = np.expand_dims(img, axis=0).astype(np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
output = interpreter.get_tensor(output_details[0]['index'])
print(output.shape, output.argmax())

TF Serving

バージョン管理、バッチ化、GPU 対応付きの gRPC/REST API の背後で SavedModel をホストするのが、TF Serving です。モデルのホットスワップを可能にするのが、serving/1/、serving/2/ のディレクトリ構造です。最も簡単なローカルの配備が Docker イメージで、本番には Vertex AI、SageMaker、KServe を使いましょう。GPU 利用率を最大化するため、リクエストを自動的にバッチ化するのが、TF Serving です。REST API は、入力に {instances: [...]} を使い、{predictions: [...]} を返します。名前付きの入力/出力には、signature_name パラメータを使いましょう。

tensorflow
# save model in SavedModel format with versioning
# model.export('serving/1')  # Keras 3
tf.saved_model.save(model, 'serving/1')

# run TF Serving via Docker
# docker run -p 8501:8501 --name tfserving \
#   -v $(pwd)/serving:/models/my_model \
#   -e MODEL_NAME=my_model \
#   tensorflow/serving

# query via REST
import json, requests
data = json.dumps({'instances': x_test[:3].tolist()})
resp = requests.post(
    'http://localhost:8501/v1/models/my_model:predict',
    data=data, headers={'content-type': 'application/json'})
print(resp.json()['predictions'])

量子化対応訓練

訓練中に偽の量子化の演算を挿入するのが、Quantization-Aware Training(QAT)で、モデルが int8 の推論で見る丸めノイズに適応するため、訓練後の量子化で失われた精度のほとんどを通常回復します。訓練されたモデルを包むのが、tfmot(tensorflow-model-optimization)で、数エポックのファインチューニングの後、TFLite へ変換しましょう。int8 の訓練後の量子化が精度を閾値以下に落とすとき(例:EfficientNet、物体検出器)、QAT が不可欠です。結果の TFLite モデルは、Edge TPU で走ります。

tensorflow
import tensorflow as tf
# (requires: pip install tensorflow-model-optimization)
import tensorflow_model_optimization as tfmot

model = tf.keras.applications.MobileNetV2(weights='imagenet')
annot_model = tfmot.quantization.keras.quantize_model(model)
annot_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
annot_model.fit(train_ds, epochs=3)

converter = tf.lite.TFLiteConverter.from_keras_model(annot_model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_qat = converter.convert()

TF.js とエッジの配備

ブラウザか Node.js でモデルを走らせるのが、TF.js です。SavedModel/.keras/.h5 を、model.json + バイナリの重みのディレクトリへ変換するのが、コンバータです。Keras API(fit、predict、その場での訓練さえ)をサポートするのが、Layers models で、より互換性があるが柔軟性が低いのが、graph models です。ブラウザの推論は WebGL/WASM を使います。Node.js は CUDA を使えます。クライアントサイド ML に優れているのが、TF.js です(サーバーの往復なし、プライバシー、オフライン)。モバイルには、TFLite を優先しましょう(より小さく速く、ハードウェアの加速があります)。

tensorflow
# convert to TF.js format
# pip install tensorflowjs
# tensorflowjs_converter --input_format=keras model.keras tfjs_model/

# in JavaScript:
# import * as tf from '@tensorflow/tfjs';
# const model = await tf.loadLayersModel('tfjs_model/model.json');
# const out = model.predict(tf.tensor4d(img, [1, 224, 224, 3]));

# OR convert SavedModel -> TF.js
# tensorflowjs_converter \
#   --input_format=tf_saved_model \
#   --output_format=tfjs_graph_model \
#   saved_model/ tfjs_model/

# TF.js layers model: full Keras-like API in the browser
# TF.js graph model: lower-level, supports more ops

推論の最適化

低レイテンシの配備のためには、最適化を積み重ねましょう:プルーニング(小さい重みをゼロにし圧縮)、知識の蒸留(大きな教師のロジットに一致するよう小さい生徒を訓練)、量子化(int8/float16)、XLA コンパイル(演算の融合)です。各ステップにはトレードオフがあります — 常にターゲットのハードウェアでベンチマークしましょう。通常、精度を最良に保つのが蒸留で、最大のサイズの削減を与えるのが、プルーニング+量子化です。GPU/TPU でタダの 1.2〜2 倍の高速化のため、演算を融合するのが、XLA(jit_compile=True)です。

tensorflow
import tensorflow as tf

# knowledge distillation: train a small student to mimic a large teacher
def distill_loss(teacher_logits, student_logits, temperature=3.0):
    soft_targets = tf.nn.softmax(teacher_logits / temperature)
    soft_probs = tf.nn.log_softmax(student_logits / temperature)
    return tf.reduce_mean(
        tf.keras.losses.categorical_crossentropy(soft_targets, soft_probs, from_logits=True))

# XLA compilation (faster inference)
@tf.function(jit_compile=True)
def predict(x):
    return model(x)

# stack optimizations: prune + quantize + distill + XLA
# always benchmark latency and accuracy before/after each step
19

カスタム訓練ループ

基本のカスタムループ

完全な制御を与えてくれるのが、カスタムループです:勾配の操作、複数のモデル、カスタムの目的です。パターンが、GradientTape -> loss -> grads -> apply_gradients で、速度のために @tf.function で包みます。model.losses を忘れずに — これらは kernel_regularizer が加えた正則化の損失であり、主損失へ加えるべきです。ステートフルな Metric オブジェクトでメトリックを追跡し、各エポックで reset_state() を呼びましょう。fit より冗長ですが、何でも解き放ちます。

tensorflow
import tensorflow as tf

optimizer = tf.keras.optimizers.Adam(1e-3)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

train_loss = tf.keras.metrics.Mean(name='train_loss')
train_acc = tf.keras.metrics.SparseCategoricalAccuracy(name='train_acc')

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        logits = model(x, training=True)
        loss = loss_fn(y, logits)
        loss += sum(model.losses)
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    train_loss.update_state(loss)
    train_acc.update_state(y, logits)
    return loss

for epoch in range(epochs):
    for x, y in train_ds:
        train_step(x, y)
    print(f"epoch {epoch}: loss={train_loss.result():.4f} acc={train_acc.result():.4f}")
    train_loss.reset_state(); train_acc.reset_state()

カスタムループでの検証

検証は、training=False(dropout がオフで BatchNorm が実行統計を使います)で、勾配のテープやオプティマイザなしで、訓練を映し返します。train と val が混ざらないよう、val 用に別の Metric オブジェクトを使いましょう。速度のために、test_step を @tf.function で包みましょう。各エポックをログした後、すべてのメトリックをリセットしましょう。最良のモデルを保存するには、val_acc.result() を実行中の最良値と比較し、改善したら model.save() を呼びましょう。

tensorflow
import tensorflow as tf

val_loss = tf.keras.metrics.Mean(name='val_loss')
val_acc = tf.keras.metrics.SparseCategoricalAccuracy(name='val_acc')

@tf.function
def test_step(x, y):
    logits = model(x, training=False)
    loss = loss_fn(y, logits)
    val_loss.update_state(loss)
    val_acc.update_state(y, logits)

for epoch in range(epochs):
    for x, y in train_ds:
        train_step(x, y)
    for x, y in val_ds:
        test_step(x, y)
    print(f"epoch {epoch}: val_loss={val_loss.result():.4f} val_acc={val_acc.result():.4f}")
    train_loss.reset_state(); train_acc.reset_state()
    val_loss.reset_state(); val_acc.reset_state()

分散のカスタムループ

分散のカスタムループは、各 GPU でレプリカごとのステップを走らせるのが、strategy.run で、損失を集約するのが、strategy.reduce です。合計の勾配がグローバルバッチの勾配に一致するよう、レプリカごとの損失を num_replicas_in_sync で割りましょう(さもなければ、実効的な LR が GPU 数でスケールされます)。通常どおり勾配を適用しましょう — 内部で all-reduce を扱うのが、ストラテジーです。同じパターンが、MultiWorkerMirroredStrategy と TPUStrategy でも機能します。

tensorflow
import tensorflow as tf

strategy = tf.distribute.MirroredStrategy()

with strategy.scope():
    model = build_model()
    optimizer = tf.keras.optimizers.Adam(1e-3)
    loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

train_ds_dist = strategy.experimental_distribute_dataset(train_ds)

@tf.function
def distributed_train_step(x, y):
    def step_fn(x, y):
        with tf.GradientTape() as tape:
            logits = model(x, training=True)
            loss = loss_fn(y, logits)
            loss += sum(model.losses)
            loss /= strategy.num_replicas_in_sync
        grads = tape.gradient(loss, model.trainable_variables)
        optimizer.apply_gradients(zip(grads, model.trainable_variables))
        return loss
    per_replica_loss = strategy.run(step_fn, args=(x, y))
    return strategy.reduce(tf.distribute.ReduceOp.SUM, per_replica_loss, axis=None)

for epoch in range(epochs):
    for x, y in train_ds_dist:
        distributed_train_step(x, y)

GAN の訓練ループ

GAN は、2 つのモデルを敵対的に訓練します:generator が discriminator を欺こうとし、discriminator が偽物を検出しようとします。2 つの GradientTape(モデルごとに 1 つ)と 2 つのオプティマイザを使いましょう。GAN の訓練を安定させるのが、beta_1=0.5(デフォルトより低い)です。各ステップで discriminator と generator を訓練しましょう(か交互の比率で)。GAN は悪名高く不安定です — d_loss と g_loss を監視し、スペクトル正規化を使い、モード崩壊が起きたら、勾配罰付きの Wasserstein GAN を考えましょう。

tensorflow
import tensorflow as tf

generator = build_generator()
discriminator = build_discriminator()
g_opt = tf.keras.optimizers.Adam(1e-4, beta_1=0.5)
d_opt = tf.keras.optimizers.Adam(1e-4, beta_1=0.5)
bce = tf.keras.losses.BinaryCrossentropy(from_logits=True)

@tf.function
def train_gan_step(real_images):
    batch = tf.shape(real_images)[0]
    noise = tf.random.normal((batch, 100))
    with tf.GradientTape() as g_tape, tf.GradientTape() as d_tape:
        fake = generator(noise, training=True)
        real_logits = discriminator(real_images, training=True)
        fake_logits = discriminator(fake, training=True)
        d_loss = bce(tf.ones_like(real_logits), real_logits) + \
                 bce(tf.zeros_like(fake_logits), fake_logits)
        g_loss = bce(tf.ones_like(fake_logits), fake_logits)
    g_grads = g_tape.gradient(g_loss, generator.trainable_variables)
    d_grads = d_tape.gradient(d_loss, discriminator.trainable_variables)
    g_opt.apply_gradients(zip(g_grads, generator.trainable_variables))
    d_opt.apply_gradients(zip(d_grads, discriminator.trainable_variables))
    return g_loss, d_loss

勾配の蓄積

GradientTape が呼び出しをまたいだ勾配の合計を容易にサポートしないため、TF での本物の勾配の蓄積は厄介です — tf.Variables で勾配を手動で蓄積することになります。上の簡単な近似は、損失をスケールし毎ステップ勾配を適用します。これは SGD には似た効果を与えますが、Adam には同一ではありません(オプティマイザはより小さくノイズの多い勾配を見ます)。正確な蓄積のためには、persistent な変数で勾配を蓄積し、N ステップごとに適用しましょう。GPU メモリがバッチサイズを制限するときに主に有用です。

tensorflow
import tensorflow as tf

accum_steps = 4
optimizer = tf.keras.optimizers.Adam(1e-3)

@tf.function
def accumulated_train_step(x, y):
    with tf.GradientTape() as tape:
        logits = model(x, training=True)
        loss = loss_fn(y, logits) / accum_steps
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

# simple accumulation via averaging
for batch_idx, (x, y) in enumerate(train_ds):
    accumulated_train_step(x, y)
    # equivalent effective batch = accum_steps * batch_size
    # (Adam moments are updated every step, so this is an approximation)
20

パフォーマンスの最適化

tf.function

Python の関数を静的なグラフへトレースするのが、@tf.function です — GPU 上で速く、分散に必要です。入力シグネチャごとの最初の呼び出しがトレースし(遅く)、後の呼び出しがグラフを再利用します。tf.function の内側で、テンソルの値に依存する Python の制御フロー(if tensor > 0: ...)を避けましょう — 再トレースを強制します。tf.cond / tf.while_loop を使うか、shape/Python のリテラルだけに依存する Python の制御フローを使いましょう。再トレースを完全に防ぐのが、input_signature で、キャッシュを広げるのが、reduce_retracing=True です。

tensorflow
import tensorflow as tf

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        preds = model(x, training=True)
        loss = loss_fn(y, preds)
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

# first call traces the graph (slow), subsequent calls reuse it (fast)
train_step(x_batch, y_batch)

# experimental_relax_shapes allows retracing only when needed
@tf.function(reduce_retracing=True)
def fn(x): return model(x)

# input_signature pins the signature so no retracing
@tf.function(input_signature=[tf.TensorSpec([None, 784], tf.float32)])
def predict(x): return model(x)

XLA コンパイル

サブグラフを融合したカーネルへコンパイルし、起動のオーバーヘッドを減らし、演算をまたぐ最適化を可能にするのが、XLA(Accelerated Linear Algebra)です。その関数で XLA を引き起こすのが、tf.function 上の jit_compile=True です。計算重視のモデル(transformers、attention)に最も効果があり、I/O バウンドのモデルにはあまり役立ちません。コンパイルされた領域内の静的な shape を XLA は必要とします — 可変の shape は再コンパイルを引き起こします。shape の問題に当たったら、固定 shape へパディングしましょう。常にベンチマークしましょう — 小さいモデルでは、XLA が時々遅くなり得ます。

tensorflow
import tensorflow as tf

# JIT-compile a function with XLA (fuses ops for speed)
@tf.function(jit_compile=True)
def train_step(x, y):
    with tf.GradientTape() as tape:
        loss = loss_fn(y, model(x, training=True))
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

# enable XLA globally
tf.config.optimizer.set_jit(True)

# XLA fuses element-wise ops, reduces kernel launches,
# and can give 1.5-3x speedup on GPU/TPU
# especially effective for transformer / attention heavy models

入力パイプラインの最適化

GPU 訓練のボトルネックは、通常、モデルでなく入力パイプラインです。標準のパイプラインは、ロード後にキャッシュし、シャッフルし、並列に拡張を map し、バッチ化し、prefetch します。ディスクバウンドのワークロードのために、複数の TFRecord ファイルを並列に読むのが、interleave です。グラフの再トレースを強制する可変 shape の最後のバッチを避けるのが、drop_remainder=True です。自分のボトルネックを見つけるには、TF Profiler の Input Pipeline Analyzer を使いましょう。並列性と prefetch サイズを TF に自動選択させるのが、AUTOTUNE です。

tensorflow
import tensorflow as tf

# the canonical high-performance pipeline
ds = (tf.data.Dataset.from_tensor_slices((x, y))
      .cache()                                      # cache after loading
      .shuffle(10000)
      .map(augment, num_parallel_calls=tf.data.AUTOTUNE)
      .batch(32, drop_remainder=True)
      .prefetch(tf.data.AUTOTUNE))

# parallel file reading for TFRecord
files = tf.data.Dataset.list_files('data-*.tfrecord')
ds = files.interleave(
    tf.data.TFRecordDataset,
    cycle_length=4, num_parallel_calls=tf.data.AUTOTUNE)

# options for autotuning
options = tf.data.Options()
options.autotune.enabled = True
ds = ds.with_options(options)

混合精度と TF32

Tensor Core GPU で 2〜3 倍のスループットを与えるのが、混合精度(float16/bfloat16)です。さらに簡単なのが、TF32 です — Ampere+(A100、H100)で matmul のために透過的に使われる 19 ビットの仮数の形式で、最小限の精度損失で約 3 倍の高速化を与え、コードの変更やロススケーリングが不要です。最大速度のために両方を有効化しましょう。CUDA 11+ では TF32 がデフォルトでオンですが、明示的な制御のために TF がフラグを公開します。厳密な fp32 の再現性(科学技術計算)のためには、TF32 を無効化しましょう。

tensorflow
import tensorflow as tf

# mixed precision (float16 compute, float32 master)
tf.keras.mixed_precision.set_global_policy('mixed_float16')

# enable TF32 on Ampere+ (big matmul speedup, slight precision loss)
tf.config.experimental.enable_tensor_float_32_execution(True)

# TF32 uses 19-bit mantissa for matmul on A100/H100
# it's transparent — no code changes, no loss scaling
# gives ~3x matmul speedup with minimal accuracy impact

# check policy
print(tf.keras.mixed_precision.global_policy())
print('TF32:', tf.config.experimental.tensor_float_32_execution_enabled())

グラフの最適化

実行前に自動的に走る、TF のグラフの最適化器であるのが、Grappler です:定数畳み込み、レイアウトの最適化(cuDNN のための NCHW 対 NHWC)、演算の融合(リマッピング)、デッドコードの除去などです。これらはすべてデフォルトでオンです。デバッグのために特定の最適化を無効化するときだけ触れる必要があります。本番の速度のために Assert/CheckNumerics を取り除くのが、debug_stripper です。モデルが NHWC を指定しても、GPU 上の cuDNN conv のために自動的に NCHW を選ぶのが、レイアウトの最適化です。

tensorflow
import tensorflow as tf

# enable grappler (default graph optimizer)
tf.config.optimizer.set_jit(True)       # XLA
tf.config.optimizer.set_experimental_options({
    'disable_model_pruning': False,
    'disable_meta_optimizer': False,
    'layout_optimizer': True,           # optimize data layout (NCHW vs NHWC)
    'constant_folding': True,           # fold constants at build time
    'shape_optimization': True,
    'remapping': True,                  # fuse compatible ops
    'arithmetic_optimization': True,
    'loop_optimization': True,
    'dependency_optimization': True,
    'function_optimization': True,
    'debug_stripper': True,             # remove Assert/CheckNumerics
})

# all on by default — only set explicitly to disable specific ones

AutoGraph と制御フロー

tf.function の内側の Python の if/for/while を TF のグラフの演算(tf.cond / tf.while_loop)へ変換するのが、AutoGraph で、GPU 上で効率的に走ります。tf.data.Dataset を Python の「for」でループするのは問題ありません — トレース時に反復します。テンソルの値に依存する if/for(shape でなく)を避けましょう — 値が変わるたびに再トレースを強制します。テンソルの値上のランタイムの制御フローのためには、tf.cond と tf.while_loop を明示的に使うか、AutoGraph に任せましょう(処理しますが、変換は微妙であり得ます)。

tensorflow
import tensorflow as tf

# AutoGraph converts Python if/for/while into tf.cond / tf.while_loop
@tf.function
def fn(x):
    if x > 0:          # AutoGraph converts this
        return x * 2
    else:
        return x

@tf.function
def sum_loop(n):
    total = tf.constant(0)
    for i in tf.range(n):    # AutoGraph converts to tf.while_loop
        total += i
    return total

# Python-side (compile-time) loop vs TF-side (runtime) loop
@tf.function
def train_epoch(dataset):
    for x, y in dataset:   # Python iteration over dataset (fine)
        train_step(x, y)

# avoid data-dependent Python control flow
# if x.shape[0] > 10: ...  # OK (static shape)
# if tf.reduce_sum(x) > 0: ...  # forces retracing

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.