የ Keras fit() ይጠበቃል እና የእርስዎን ሞዴል እርስዎ መንገድ ያግኙ

አጠቃላይ ግምገማ

• አግኙን
• አግኙን
• የመጀመሪያው ቀላል ምሳሌ
• ዝቅተኛ ደረጃ
• የ sample_weight እና class_weight አጠቃቀም
• የእርስዎን ግምገማ ደረጃ ለማረጋገጥ
• አግኙን: አንድ End-to-End GAN ለምሳሌ

አግኙን

አንተ የፈጠራ መግቢያ መጠቀም ይችላሉ.fit()ሁሉም ነገር ቀላል ይሰራል.

እርስዎ የእርስዎን የእርስዎን ስልጠና መስኮት ከታች መጻፍ አለብዎት, እርስዎ የGradientTapeእያንዳንዱ አነስተኛ ዝርዝር መቆጣጠሪያ ይጠቀሙ.

ነገር ግን አንድ ብጁ ስልጠና አጠቃቀም ያስፈልጋል, ነገር ግን በእርግጥ ከባድ ባህሪያት አጠቃቀም ይፈልጋሉ?fit()እንደ callbacks, የተመሠረተ የሽያጭ ድጋፍ, ወይም step fusing?

የ Keras Principle ነውprogressive disclosure of complexityበከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊነት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ተግባራዊ ፍላጎት በከፍተኛ ደረጃው ተግባራዊ ፍላጎት በከፍተኛ ደረጃ ላይ ማግኘት ይችላሉ.

እናንተ ምንድን የሚፈልጉት ጊዜfit()እርስዎ አለብዎትoverride the training step function of the Modelይህ አጠቃቀም ነው; ይህ አጠቃቀም ነውfit()እያንዳንዱ ውሂብ ማግኘት ይችላሉ.fit()እንደመሠረቱ - እና ይህ የእርስዎን የእርስዎን የመማር አግኝተዋል.

ይህ ሞዴል በ Functional API በመጠቀም ሞዴሎች ለመፍጠር አይችሉም.Sequentialሞዴሎች, Functional API ሞዴሎች, ወይም subclassed ሞዴሎች.

ይህ እንዴት ይሰራል ይመልከቱ.

አግኙን

የ TensorFlow 2.8 ወይም ከዚያ በላይ ያስፈልጋል.

import tensorflow as tf
from tensorflow import keras

የመጀመሪያው ቀላል ምሳሌ

አንድ ቀላል ለምሳሌ ይጀምራል:

• እኛ hard.Model subclasses አንድ አዲስ ክፍል ለመፍጠር.
• በ train_step (ወይም, ውሂብ) መሣሪያን ይቀበላሉ.
• የእርስዎ ግምገማዎች (እነዚህን ግምገማዎች) ወደ በአሁኑ መጠን ያውቃሉ.

አግኙን Argumentdataይህ የሙከራ ውሂብ እንደ ተስማሚ ሊሆን ይችላል:

• አንተ Numpy ቅርጸት ይሰጣል ከሆነ, fit (x, y, ...) ይደውሉ, ከዚያም ውሂብ ይሆናል tuple (x, y)
• አንድ tf.data.Dataset ይሰጣል ከሆነ, fit (dataset, ...) ይደውሉ, ከዚያም ውሂብ እያንዳንዱ batch ላይ በ dataset የተወሰነ ነገር ይሆናል.

በሽታ ውስጥ የtrain_stepመተግበሪያ ስርዓት, እኛ በተለምዶ የፈጠራ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ መተግበሪያ ጋር ተመሳሳይ ነው.we compute the loss via self.compute_loss()ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድ ከባድcompile().

ተመሳሳይ መንገድ ይደውሉmetric.update_state(y, y_pred)ከ Metricsself.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()optimizer ለመፍጠር:

• እኛ የእኛን ፍላጎት እና የ MAE ስኬት (የ __init__() ውስጥ) ለመከታተል Metric ስኬትዎችን ለመፍጠር ይጀምራል.
• እኛ አንድ ብጁ train_step() መተግበሪያ ይሰራል, ይህም እነዚህ ሜትሪኮች ሁኔታን (እነርሱ ላይ update_state() ይደውሉ), ከዚያም እነርሱን (በ result()) በመጠቀም ያግኙ, የእነርሱ አጠቃቀም አጠቃቀም መጠን, በ Progress bar ላይ ይመልከቱ, እና ማንኛውም ግምገማዎች ላይ ይመዝገቡ.
• በእያንዳንዱ ልምድ መካከል የእኛን ሜትሪክስ ላይ 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>

ድጋፍሻጋታ - ክብደትእናክብደት - Weight

እርስዎ የእኛን የመጀመሪያው መሠረታዊ ምሳሌም የሞዴል ክብደት ላይ ማንኛውም ዝርዝር አይነሰም.fit()ጥያቄዎችsample_weightእናclass_weightእርስዎ ብቻ የሚከተለውን ይሆናል:

• ከታች መለያ ከ sample_weight Unpack
• 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

አግኙን: አንድ End-to-End GAN ለምሳሌ

እርስዎ ከሁሉም ነገር ያውቃሉ, እርስዎ ከሁሉም ነገር ያውቃሉ.

ይበልጥ ይመልከቱ:

• አንድ ጄኔሬተር አውታረ መረብ 28x28x1 ፎቶዎችን ለመፍጠር ነው.
• የ 28x28x1 ፎቶዎችን ሁለት ደረጃዎች ("fake" እና "real"") ያካትታል.
• እያንዳንዱ ላይ አንድ optimizer.
• የክፍያዎችን ለመፍጠር የክፍያዎችን ይጠቀማል.

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",
)

እዚህ አንድ ባህሪያት-ተጨማሪ GAN ክፍል, overridingcompile()የ GAN አግኝተዋል እና በ 17 መስመሮች ውስጥ የ GAN አግኝተዋል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 ላይ የተመሠረተ ነው.