Mantenha as Keras Fit () e treine seu modelo do seu jeito

Visão geral do conteúdo

• Introdução
• Configurar
• Um primeiro exemplo simples
• Indo de nível inferior
• Sample_weight & Class_weight de suporte
• Fornecendo sua própria etapa de avaliação
• Encerrando: um exemplo de ponta a ponta

Introdução

Quando você está fazendo aprendizado supervisionado, você pode usar fit() E tudo funciona bem.

Quando você precisa escrever seu próprio loop de treinamento do zero, você pode usar o GradientTape e assumir o controle de todos os pequenos detalhes.

Mas e se você precisar de um algoritmo de treinamento personalizado, mas ainda deseja se beneficiar dos recursos convenientes de fit()como retornos de chamada, suporte de distribuição interno ou fusão de etapas?

Um princípio central de Keras é Divulgação progressiva da complexidade. Você sempre deve poder entrar em fluxos de trabalho de nível inferior de uma maneira gradual. Você não deve cair de um penhasco se a funcionalidade de alto nível não corresponder exatamente ao seu caso de uso. Você deve obter mais controle sobre os pequenos detalhes, mantendo uma quantidade proporcional de conveniência de alto nível.

Quando você precisa personalizar o que fit() você deveria substituir a função da etapa de treinamento do Model aula. Esta é a função que é chamada por fit() para cada lote de dados. Você será capaz de ligar fit() Como sempre – e estará executando seu próprio algoritmo de aprendizado.

Observe que esse padrão não impede que você construa modelos com a API funcional. Você pode fazer isso, esteja você está construindo Sequential Modelos, modelos funcionais de API ou modelos subclassificados.

Vamos ver como isso funciona.

Configurar

Requer Tensorflow 2.8 ou posterior.

import tensorflow as tf
from tensorflow import keras

Um primeiro exemplo simples

Vamos começar de um exemplo simples:

• Criamos uma nova classe que subclasses keras.Model.
• Acabamos de substituir o método train_step(self, data).
• Retornamos um nomes de métricas de mapeamento de dicionário (incluindo a perda) ao seu valor atual.

O argumento de entrada data é o que é passado para se encaixar como dados de treinamento:

• Se você passa matrizes numpy, ligando fit(x, y, ...)então data será a tupla (x, y)
• Se você passar um tf.data.Datasetligando fit(dataset, ...)então data será o que é rendido por dataset em cada lote.

No corpo do train_step Método, implementamos uma atualização regular de treinamento, semelhante ao que você já está familiarizado. Importante, Nós calculamos a perda via self.compute_loss()que envolve as funções de perda (s) que foram passadas para compile().

Da mesma forma, chamamos metric.update_state(y, y_pred) em métricas de self.metricspara atualizar o estado das métricas que foram aprovadas em compile()e nós consultamos resultados de self.metrics no final para recuperar seu valor atual.

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}

Vamos tentar isso:

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

Indo de nível inferior

Naturalmente, você pode simplesmente pular passando uma função de perda em compile()e, em vez disso, faça tudo manualmente em train_step. Da mesma forma para métricas.

Aqui está um exemplo de nível inferior, que só usa compile() Para configurar o otimizador:

• Começamos criando Metric Instâncias para rastrear nossa perda e uma pontuação MAE (em __init__()).
• Nós implementamos um costume train_step() Isso atualiza o estado dessas métricas (ligando update_state() neles), então consulte -os (via result()) para retornar seu valor médio atual, a ser exibido pela barra de progresso e passar para qualquer retorno de chamada.
• Observe que precisaríamos ligar reset_states() Em nossas métricas entre cada época! Caso contrário, ligando result() Retornaria uma média desde o início do treinamento, enquanto geralmente trabalhamos com médias por epococismo. Felizmente, a estrutura pode fazer isso por nós: basta listar qualquer métrica que você queira redefinir no metrics propriedade do modelo. O modelo vai ligar reset_states() em qualquer objeto listado aqui no início de cada fit() época ou no início de uma chamada para evaluate().

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

Apoio sample_weight & class_weight

Você deve ter notado que nosso primeiro exemplo básico não fez nenhuma menção à ponderação da amostra. Se você quiser apoiar o fit() argumentos sample_weight e class_weightvocê simplesmente faria o seguinte:

• Desembore sample_weight do data argumento
• Passe para compute_loss & update_state (Claro, você também pode aplicá -lo manualmente se não confiar compile() para perdas e métricas)
• É isso.

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

Fornecendo sua própria etapa de avaliação

E se você quiser fazer o mesmo para chamadas para model.evaluate()? Então você substituiria test_step da mesma maneira. Aqui está o que parece:

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

Encerrando: um exemplo de ponta a ponta

Vamos percorrer um exemplo de ponta a ponta que aproveita tudo o que você acabou de aprender.

Vamos considerar:

• Uma rede geradora destinada a gerar imagens 28x28x1.
• Uma rede discriminadora destinada a classificar imagens 28x28x1 em duas classes (“Fake” e “Real”).
• Um otimizador para cada um.
• Uma função de perda para treinar o discriminador.

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

Aqui está uma classe GaN completa, substituindo compile() para usar sua própria assinatura e implementar todo o algoritmo GaN em 17 linhas em 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(),
        }

Vamos testá-lo:

# 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 
11490434/11490434 [==============================] - 0s 0us/step
100/100 [==============================] - 8s 15ms/step - d_loss: 0.4372 - g_loss: 0.8775

As idéias por trás do aprendizado profundo são simples, então por que sua implementação deve ser dolorosa?