コンテンツ概要 
 
 
 
 
 
 
 
 導入 セットアップ 最初のシンプルな例 低いレベルへ sample_weight & class_weight をサポートする 自分の評価ステップを作る Wrapping up: an end-to-end GAN example 導入 監督された学習を行うとき、あなたは使用することができます。 全てが順調に機能する。 fit() あなた自身のトレーニングループをゼロから書く必要がある場合、あなたは そして、あらゆる小さな細部をコントロールする。 GradientTape しかし、カスタムトレーニングアルゴリズムが必要ですが、まだ便利な機能から恩恵を受けたい場合はどうですか? callbacks、 built-in distribution support、 or step fusion など。 fit() Kerasの基本原則は、 あなたは常に低レベルのワークフローに徐々にアクセスできるはずです。高レベルの機能が正確にあなたの使用例に合致しない場合、あなたは崖から落ちてはいけません。 progressive disclosure of complexity あなたが何をカスタマイズする必要があるとき DOES, YOU SHOULD   タイトル: This is the function called すべてのデータのバッチについて、あなたはそれから呼び出せるようになります。 いつものように - それはあなた自身の学習アルゴリズムを実行するでしょう。 fit() override the training step function of the Model fit() fit() このパターンは、Functional API を使用してモデルを構築することを妨げないことに注意してください。 機能 API モデル、またはサブクラスモデル Sequential それがどのように機能するか見てみましょう。 セットアップ TensorFlow 2.8 以降が必要です。 import tensorflow as tf
from tensorflow import keras
 最初のシンプルな例 簡単な例から始めましょう: 
 
 
 
 keras.Model をサブクラスする新しいクラスを作成します。 メソッド train_step (self, data) を使います。 辞書マッピングメトリック名(損失を含む)を現在の値に返します。 入力論点 is what gets passed to fit as training data: トレーニングデータとして適合されるもの: data 
 
 
 If you pass Numpy array, by calling fit(x, y, ...), then data will be the tuple (x, y) tf.data.Dataset を渡す場合、fit(dataset, ...)を呼び出すと、データは各バッチでデータセットによって生成されるものになります。 In the body of the この方法では、あなたがすでに知っているものと同様に、定期的なトレーニングアップデートを実施します。   負けてしまった人(ひと)が負けてしまった。 . train_step we compute the loss via self.compute_loss() compile() 同様に、我々は呼ぶ Metrics from , to update the state of the metrics that were passed in に移行されたメトリックの状態を更新する , and we look for results from 最終的には現在の価値を回収します。 metric.update_state(y, y_pred) self.metrics compile() self.metrics 
class CustomModel(keras.Model):
    def train_step(self, data):
        # Unpack the data. Its structure depends on your model and
        # on what you pass to `fit()`.
        x, y = data

        with tf.GradientTape() as tape:
            y_pred = self(x, training=True)  # Forward pass
            # Compute the loss value
            # (the loss function is configured in `compile()`)
            loss = self.compute_loss(y=y, y_pred=y_pred)

        # Compute gradients
        trainable_vars = self.trainable_variables
        gradients = tape.gradient(loss, trainable_vars)
        # Update weights
        self.optimizer.apply_gradients(zip(gradients, trainable_vars))
        # Update metrics (includes the metric that tracks the loss)
        for metric in self.metrics:
            if metric.name == "loss":
                metric.update_state(loss)
            else:
                metric.update_state(y, y_pred)
        # Return a dict mapping metric names to current value
        return {m.name: m.result() for m in self.metrics}
 これを試してみよう: import numpy as np

# Construct and compile an instance of CustomModel
inputs = keras.Input(shape=(32,))
outputs = keras.layers.Dense(1)(inputs)
model = CustomModel(inputs, outputs)
model.compile(optimizer="adam", loss="mse", metrics=["mae"])

# Just use `fit` as usual
x = np.random.random((1000, 32))
y = np.random.random((1000, 1))
model.fit(x, y, epochs=3)
 Epoch 1/3
32/32 [==============================] - 3s 2ms/step - loss: 1.6446
Epoch 2/3
32/32 [==============================] - 0s 2ms/step - loss: 0.7554
Epoch 3/3
32/32 [==============================] - 0s 2ms/step - loss: 0.3924
<keras.src.callbacks.History at 0x7fef5c11ba30>
 低いレベルへ もちろん、あなたは単に損失関数を通り過ぎることができます。 代わりに、全てを イン メトリックも同様です。 compile() マニュアル train_step 以下は、低レベルの例で、使用するだけです。 最適化を設定するには: compile() 
 
 
 
 We start by creating   instances to track our loss and a MAE score (in  ). Metric __init__() 私たちは、これらのメトリックの状態を更新するカスタム train_step() を実装します(それらに update_state() を呼び出して)、それらをクエリします(結果())を通じて、現在の平均値を返します。 要するに、reset_states() を各時代間のメトリックに呼び出す必要があることに注意してください! 要するに、reset_states() を呼び出すと、トレーニングの開始以来の平均値が返されますが、我々は通常、per-epoch 平均値で作業します。 幸いなことに、フレームワークは私たちのためにそれを行うことができます: あなたがモデルのメトリック属性にリセットしたいメトリックをリストするだけです. モデルは、それぞれの fit() 時代の開始時にここにリストされたオブジェクトに reset_states() を呼び出します。 
class CustomModel(keras.Model):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.loss_tracker = keras.metrics.Mean(name="loss")
        self.mae_metric = keras.metrics.MeanAbsoluteError(name="mae")

    def train_step(self, data):
        x, y = data

        with tf.GradientTape() as tape:
            y_pred = self(x, training=True)  # Forward pass
            # Compute our own loss
            loss = keras.losses.mean_squared_error(y, y_pred)

        # Compute gradients
        trainable_vars = self.trainable_variables
        gradients = tape.gradient(loss, trainable_vars)

        # Update weights
        self.optimizer.apply_gradients(zip(gradients, trainable_vars))

        # Compute our own metrics
        self.loss_tracker.update_state(loss)
        self.mae_metric.update_state(y, y_pred)
        return {"loss": self.loss_tracker.result(), "mae": self.mae_metric.result()}

    @property
    def metrics(self):
        # We list our `Metric` objects here so that `reset_states()` can be
        # called automatically at the start of each epoch
        # or at the start of `evaluate()`.
        # If you don't implement this property, you have to call
        # `reset_states()` yourself at the time of your choosing.
        return [self.loss_tracker, self.mae_metric]


# Construct an instance of CustomModel
inputs = keras.Input(shape=(32,))
outputs = keras.layers.Dense(1)(inputs)
model = CustomModel(inputs, outputs)

# We don't pass a loss or metrics here.
model.compile(optimizer="adam")

# Just use `fit` as usual -- you can use callbacks, etc.
x = np.random.random((1000, 32))
y = np.random.random((1000, 1))
model.fit(x, y, epochs=5)
 Epoch 1/5
32/32 [==============================] - 0s 2ms/step - loss: 0.3240 - mae: 0.4583
Epoch 2/5
32/32 [==============================] - 0s 2ms/step - loss: 0.2416 - mae: 0.3984
Epoch 3/5
32/32 [==============================] - 0s 2ms/step - loss: 0.2340 - mae: 0.3919
Epoch 4/5
32/32 [==============================] - 0s 2ms/step - loss: 0.2274 - mae: 0.3870
Epoch 5/5
32/32 [==============================] - 0s 2ms/step - loss: 0.2197 - mae: 0.3808
<keras.src.callbacks.History at 0x7fef3c130b20>
 応援 & サンプル=体重 クラス=体重 サンプル=体重 クラス=体重 あなたは、私たちの最初の基本的な例がサンプル重量について何も言及していないことに気づいたかもしれません。 論点 そして , you would simply do the following: あなたは単に次のことをします。 fit() sample_weight class_weight 
 
 
 
 Unpack sample_weight from the data argument. データアルゴリズムから sample_weightをパックする compute_loss & update_state に転送します(もちろん、損失とメトリクスを compile() に頼らない場合は手動で適用することもできます)。 それがそれ。 
class CustomModel(keras.Model):
    def train_step(self, data):
        # Unpack the data. Its structure depends on your model and
        # on what you pass to `fit()`.
        if len(data) == 3:
            x, y, sample_weight = data
        else:
            sample_weight = None
            x, y = data

        with tf.GradientTape() as tape:
            y_pred = self(x, training=True)  # Forward pass
            # Compute the loss value.
            # The loss function is configured in `compile()`.
            loss = self.compute_loss(
                y=y,
                y_pred=y_pred,
                sample_weight=sample_weight,
            )

        # Compute gradients
        trainable_vars = self.trainable_variables
        gradients = tape.gradient(loss, trainable_vars)

        # Update weights
        self.optimizer.apply_gradients(zip(gradients, trainable_vars))

        # Update the metrics.
        # Metrics are configured in `compile()`.
        for metric in self.metrics:
            if metric.name == "loss":
                metric.update_state(loss)
            else:
                metric.update_state(y, y_pred, sample_weight=sample_weight)

        # Return a dict mapping metric names to current value.
        # Note that it will include the loss (tracked in self.metrics).
        return {m.name: m.result() for m in self.metrics}


# Construct and compile an instance of CustomModel
inputs = keras.Input(shape=(32,))
outputs = keras.layers.Dense(1)(inputs)
model = CustomModel(inputs, outputs)
model.compile(optimizer="adam", loss="mse", metrics=["mae"])

# You can now use sample_weight argument
x = np.random.random((1000, 32))
y = np.random.random((1000, 1))
sw = np.random.random((1000, 1))
model.fit(x, y, sample_weight=sw, epochs=3)
 Epoch 1/3
32/32 [==============================] - 0s 2ms/step - loss: 0.1298
Epoch 2/3
32/32 [==============================] - 0s 2ms/step - loss: 0.1179
Epoch 3/3
32/32 [==============================] - 0s 2ms/step - loss: 0.1121
<keras.src.callbacks.History at 0x7fef3c168100>
 自分の評価ステップを作る 呼び出しに対して同じことをしたい場合は、 その後、あなたはオーバーレードするでしょう。 似たような感じで、こんな感じです: model.evaluate() test_step 
class CustomModel(keras.Model):
    def test_step(self, data):
        # Unpack the data
        x, y = data
        # Compute predictions
        y_pred = self(x, training=False)
        # Updates the metrics tracking the loss
        self.compute_loss(y=y, y_pred=y_pred)
        # Update the metrics.
        for metric in self.metrics:
            if metric.name != "loss":
                metric.update_state(y, y_pred)
        # Return a dict mapping metric names to current value.
        # Note that it will include the loss (tracked in self.metrics).
        return {m.name: m.result() for m in self.metrics}


# Construct an instance of CustomModel
inputs = keras.Input(shape=(32,))
outputs = keras.layers.Dense(1)(inputs)
model = CustomModel(inputs, outputs)
model.compile(loss="mse", metrics=["mae"])

# Evaluate with our custom test_step
x = np.random.random((1000, 32))
y = np.random.random((1000, 1))
model.evaluate(x, y)
 32/32 [==============================] - 0s 1ms/step - loss: 0.9028
0.9028095006942749
 Wrapping up: an end-to-end GAN example あなたが今学んだすべてを活用する端から端の例を歩いてみましょう。 考えてみよう: 
 
 
 
 
 ジェネレーターネットワークは28x28x1の画像を生成することを目的とした。 差別ネットワークは、28x28x1の画像を2つのクラス(「偽」と「本物」)に分類することを意図した。 それぞれのための最適化 差別者を訓練するための損失機能。 
from tensorflow.keras import layers

# Create the discriminator
discriminator = keras.Sequential(
    [
        keras.Input(shape=(28, 28, 1)),
        layers.Conv2D(64, (3, 3), strides=(2, 2), padding="same"),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(128, (3, 3), strides=(2, 2), padding="same"),
        layers.LeakyReLU(alpha=0.2),
        layers.GlobalMaxPooling2D(),
        layers.Dense(1),
    ],
    name="discriminator",
)

# Create the generator
latent_dim = 128
generator = keras.Sequential(
    [
        keras.Input(shape=(latent_dim,)),
        # We want to generate 128 coefficients to reshape into a 7x7x128 map
        layers.Dense(7 * 7 * 128),
        layers.LeakyReLU(alpha=0.2),
        layers.Reshape((7, 7, 128)),
        layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding="same"),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2DTranspose(128, (4, 4), strides=(2, 2), padding="same"),
        layers.LeakyReLU(alpha=0.2),
        layers.Conv2D(1, (7, 7), padding="same", activation="sigmoid"),
    ],
    name="generator",
)
 Here's a feature-complete GAN class, overriding 独自の署名を使用し、GANアルゴリズム全体を17行で実装する。 : compile() train_step 
class GAN(keras.Model):
    def __init__(self, discriminator, generator, latent_dim):
        super().__init__()
        self.discriminator = discriminator
        self.generator = generator
        self.latent_dim = latent_dim
        self.d_loss_tracker = keras.metrics.Mean(name="d_loss")
        self.g_loss_tracker = keras.metrics.Mean(name="g_loss")

    def compile(self, d_optimizer, g_optimizer, loss_fn):
        super().compile()
        self.d_optimizer = d_optimizer
        self.g_optimizer = g_optimizer
        self.loss_fn = loss_fn

    def train_step(self, real_images):
        if isinstance(real_images, tuple):
            real_images = real_images[0]
        # Sample random points in the latent space
        batch_size = tf.shape(real_images)[0]
        random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim))

        # Decode them to fake images
        generated_images = self.generator(random_latent_vectors)

        # Combine them with real images
        combined_images = tf.concat([generated_images, real_images], axis=0)

        # Assemble labels discriminating real from fake images
        labels = tf.concat(
            [tf.ones((batch_size, 1)), tf.zeros((batch_size, 1))], axis=0
        )
        # Add random noise to the labels - important trick!
        labels += 0.05 * tf.random.uniform(tf.shape(labels))

        # Train the discriminator
        with tf.GradientTape() as tape:
            predictions = self.discriminator(combined_images)
            d_loss = self.loss_fn(labels, predictions)
        grads = tape.gradient(d_loss, self.discriminator.trainable_weights)
        self.d_optimizer.apply_gradients(
            zip(grads, self.discriminator.trainable_weights)
        )

        # Sample random points in the latent space
        random_latent_vectors = tf.random.normal(shape=(batch_size, self.latent_dim))

        # Assemble labels that say "all real images"
        misleading_labels = tf.zeros((batch_size, 1))

        # Train the generator (note that we should *not* update the weights
        # of the discriminator)!
        with tf.GradientTape() as tape:
            predictions = self.discriminator(self.generator(random_latent_vectors))
            g_loss = self.loss_fn(misleading_labels, predictions)
        grads = tape.gradient(g_loss, self.generator.trainable_weights)
        self.g_optimizer.apply_gradients(zip(grads, self.generator.trainable_weights))

        # Update metrics and return their value.
        self.d_loss_tracker.update_state(d_loss)
        self.g_loss_tracker.update_state(g_loss)
        return {
            "d_loss": self.d_loss_tracker.result(),
            "g_loss": self.g_loss_tracker.result(),
        }
 テストドライブしてみよう: 
# Prepare the dataset. We use both the training & test MNIST digits.
batch_size = 64
(x_train, _), (x_test, _) = keras.datasets.mnist.load_data()
all_digits = np.concatenate([x_train, x_test])
all_digits = all_digits.astype("float32") / 255.0
all_digits = np.reshape(all_digits, (-1, 28, 28, 1))
dataset = tf.data.Dataset.from_tensor_slices(all_digits)
dataset = dataset.shuffle(buffer_size=1024).batch(batch_size)

gan = GAN(discriminator=discriminator, generator=generator, latent_dim=latent_dim)
gan.compile(
    d_optimizer=keras.optimizers.Adam(learning_rate=0.0003),
    g_optimizer=keras.optimizers.Adam(learning_rate=0.0003),
    loss_fn=keras.losses.BinaryCrossentropy(from_logits=True),
)

# To limit the execution time, we only train on 100 batches. You can train on
# the entire dataset. You will need about 20 epochs to get nice results.
gan.fit(dataset.take(100), epochs=1)
 Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11490434/11490434 [==============================] - 0s 0us/step
100/100 [==============================] - 8s 15ms/step - d_loss: 0.4372 - g_loss: 0.8775
<keras.src.callbacks.History at 0x7feee42ff190>
 深い学習の背後にあるアイデアは単純なので、なぜ実行が苦痛になるのでしょうか。 
 
 最初はTensorFlowのウェブサイトに掲載され、この記事はここに新しいタイトルの下に表示され、CC BY 4.0でライセンスを受けています。 最初はTensorFlowのウェブサイトに掲載され、この記事はここに新しいタイトルの下に表示され、CC BY 4.0でライセンスを受けています。 TensorFlowについて

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

このオーディオは、ストーリーの元の言語で制作されています。

Keep Keras fit() and Train Your Model Your Way シングル

About Author

コメント

ラベル

この記事は

Related Stories

HackerNoon ライティングコンテストで優勝したいですか? #crypto-api コンテスト優勝者のおすすめはこちら

暗号通貨の成長: 効果的なユーザーペルソナの作成

目に見えない層: ユーザーインタビューがかけがえのない資産である理由

タップして稼ぐ：テレグラムはソラナより先に次の100億人の暗号通貨ユーザーを獲得する可能性がある

HackerNoon ライティングコンテストで優勝したいですか? #crypto-api コンテスト優勝者のおすすめはこちら

暗号通貨の成長: 効果的なユーザーペルソナの作成

目に見えない層: ユーザーインタビューがかけがえのない資産である理由

タップして稼ぐ：テレグラムはソラナより先に次の100億人の暗号通貨ユーザーを獲得する可能性がある

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps