کمک به حفاظت از دیواره بزرگ مرجانی با TensorFlow در Kaggle اضافه کردن چالش

آنچه در Model.fit اتفاق می افتد را سفارشی کنید

مشاهده در TensorFlow.org در Google Colab اجرا شود مشاهده منبع در GitHub دانلود دفترچه یادداشت

معرفی

هنگامی که شما در حال انجام یادگیری نظارت، شما می توانید با استفاده از fit() و همه چیز کار می کند هموار.

هنگامی که شما نیاز به ارسال حلقه های آموزشی خود را از ابتدا، شما می توانید با استفاده از GradientTape و کنترل هر جزئیات کمی.

اما اگر شما نیاز به یک الگوریتم آموزش سفارشی، اما شما هنوز هم می خواهید به نفع از ویژگی های مناسب از fit() ، مانند تماس مجدد، ساخته شده در پشتیبانی توزیع، و یا گام آمیخته شدن؟

یک اصل اساسی از Keras ارائه تدریجی پیچیدگی است. همیشه باید بتوانید به صورت تدریجی وارد جریان های کاری سطح پایین تر شوید. اگر عملکرد سطح بالا دقیقاً با مورد استفاده شما مطابقت ندارد، نباید از صخره سقوط کنید. شما باید بتوانید کنترل بیشتری بر روی جزئیات کوچک به دست آورید و در عین حال میزان مناسبی از راحتی در سطح بالا را حفظ کنید.

هنگامی که شما نیاز به سفارشی کردن آنچه fit() ، در آنصورت باید تابع پله آموزش نادیده گرفتن Model کلاس. این تابع است که توسط به نام fit() برای هر دسته ای از داده ها. بعد از آن شما قادر خواهید بود برای تماس باشد fit() به طور معمول - و از آن خواهد شد در حال اجرا الگوریتم یادگیری خود را.

توجه داشته باشید که این الگو مانع از ساخت مدل با Functional API نمی شود. شما می توانید این کار را انجام خواه در حال ایجاد Sequential مدل، مدل های API کاربردی، و یا مدل های subclassed.

بیایید ببینیم که چگونه کار می کند.

برپایی

به TensorFlow 2.2 یا بالاتر نیاز دارد.

import tensorflow as tf
from tensorflow import keras

اولین مثال ساده

بیایید از یک مثال ساده شروع کنیم:

  • ما ایجاد یک کلاس جدید است که زیر کلاس keras.Model .
  • ما فقط نادیده گرفتن روش train_step(self, data) .
  • ما یک فرهنگ لغت نگاشت نام متریک (از جمله ضرر) را به مقدار فعلی آنها برمی گردانیم.

استدلال ورودی data است چه می شود به تصویب رسید به عنوان داده های آموزشی مناسب:

  • اگر شما تصویب آرایه نامپای، با تماس fit(x, y, ...) ، پس از آن data خواهد شد تاپل (x, y)
  • اگر شما یک پاس tf.data.Dataset ، با تماس fit(dataset, ...) ، پس از آن data خواهد شد چه می شود توسط همراه داشت dataset در هر دسته ای.

در بدن از train_step روش، یک به روز رسانی به طور منظم آموزش، شبیه به آنچه شما در حال حاضر با آن آشنا هستند اجرا می کنند. مهمتر، ما محاسبه از دست دادن از طریق self.compiled_loss ، که کاری ادامه داده اند از دست دادن (ES) تابع () که به تصویب رسیده بود، compile() .

به طور مشابه، ما پاسخ self.compiled_metrics.update_state(y, y_pred) برای به روز رسانی دولت از معیارهای که در تصویب شد 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.compiled_loss(y, y_pred, regularization_losses=self.losses)

        # 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)
        self.compiled_metrics.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 [==============================] - 1s 2ms/step - loss: 0.9909 - mae: 0.8601
Epoch 2/3
32/32 [==============================] - 0s 2ms/step - loss: 0.4363 - mae: 0.5345
Epoch 3/3
32/32 [==============================] - 0s 2ms/step - loss: 0.2906 - mae: 0.4311
<keras.callbacks.History at 0x7f5ad1ca1090>

رفتن به سطوح پایین تر

به طور طبیعی، شما فقط می تواند جست و خیز عبور از یک تابع از دست دادن در compile() ، و به جای انجام همه چیز را به صورت دستی در train_step . به همین ترتیب برای معیارها.

در اینجا یک مثال سطح پایین تر، که تنها با استفاده از compile() برای پیکربندی بهینه ساز:

  • ما با ایجاد شروع Metric موارد به پیگیری از دست دادن ما و نمره MAE.
  • ما سفارشی پیاده سازی train_step() که به روز رسانی دولت از این معیارهای (از طریق تماس با update_state() بر روی آنها)، سپس پرس و جو آنها را (از طریق result() ) برای بازگشت به ارزش متوسط فعلی خود را، به توسط نوار پیشرفت و به نمایش داده می شود ارسال به هر پاسخ تماس.
  • توجه داشته باشید که ما نیاز به پاسخ reset_states() در معیارهای ما بین هر دوره! در غیر این صورت فراخوانی result() می از زمان شروع آموزش متوسط بازگشت، در حالی که ما معمولا کار با هر دوره به طور متوسط. خوشبختانه، چارچوب می تواند برای ما انجام این کار: فقط لیست هر متریک شما می خواهید برای تنظیم مجدد در metrics اموال از مدل. این مدل پاسخ reset_states() بر روی هر شی در اینجا ذکر شده در ابتدای هر fit() عصر و یا در آغاز یک تماس به evaluate() .
loss_tracker = keras.metrics.Mean(name="loss")
mae_metric = keras.metrics.MeanAbsoluteError(name="mae")


class CustomModel(keras.Model):
    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
        loss_tracker.update_state(loss)
        mae_metric.update_state(y, y_pred)
        return {"loss": loss_tracker.result(), "mae": 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 [loss_tracker, 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 passs 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 1ms/step - loss: 1.5969 - mae: 1.1523
Epoch 2/5
32/32 [==============================] - 0s 1ms/step - loss: 0.7352 - mae: 0.7310
Epoch 3/5
32/32 [==============================] - 0s 1ms/step - loss: 0.3830 - mae: 0.4999
Epoch 4/5
32/32 [==============================] - 0s 1ms/step - loss: 0.2809 - mae: 0.4215
Epoch 5/5
32/32 [==============================] - 0s 1ms/step - loss: 0.2590 - mae: 0.4058
<keras.callbacks.History at 0x7f5ad1b62c50>

حمایت از sample_weight و class_weight

شاید متوجه شده باشید که اولین مثال اولیه ما هیچ اشاره ای به وزن نمونه نکرده است. اگر شما می خواهید برای حمایت از fit() استدلال sample_weight و class_weight ، شما به سادگی می خواهم زیر را انجام دهید:

  • باز کردن sample_weight از data استدلال
  • تصویب آن را به compiled_loss و compiled_metrics (البته، شما همچنین می تواند فقط آن را اعمال دستی اگر شما بر روی تکیه نمی 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.compiled_loss(
                y,
                y_pred,
                sample_weight=sample_weight,
                regularization_losses=self.losses,
            )

        # 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()`.
        self.compiled_metrics.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.1365 - mae: 0.4196
Epoch 2/3
32/32 [==============================] - 0s 2ms/step - loss: 0.1285 - mae: 0.4068
Epoch 3/3
32/32 [==============================] - 0s 2ms/step - loss: 0.1212 - mae: 0.3971
<keras.callbacks.History at 0x7f5ad1ba64d0>

ارائه مرحله ارزیابی خود

اگر شما می خواهید برای انجام همان برای تماس به 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.compiled_loss(y, y_pred, regularization_losses=self.losses)
        # Update the metrics.
        self.compiled_metrics.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: 2.7584 - mae: 1.5920
[2.758362054824829, 1.59201979637146]

جمع بندی: یک مثال GAN سرتاسر

بیایید از طریق یک مثال انتها به انتها که از همه چیزهایی که به تازگی یاد گرفته اید استفاده می کند.

بیایید در نظر بگیریم:

  • یک شبکه مولد برای تولید تصاویر 28x28x1.
  • یک شبکه تفکیک کننده به منظور طبقه بندی تصاویر 28x28x1 به دو کلاس ("جعلی" و "واقعی").
  • برای هر کدام یک بهینه ساز
  • یک تابع ضرر برای آموزش متمایز کننده.
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 از ویژگی های کامل است، فارغ از compile() استفاده از امضا خود را دارد، و اجرای کل الگوریتم GAN در 17 خط در train_step :

class GAN(keras.Model):
    def __init__(self, discriminator, generator, latent_dim):
        super(GAN, self).__init__()
        self.discriminator = discriminator
        self.generator = generator
        self.latent_dim = latent_dim

    def compile(self, d_optimizer, g_optimizer, loss_fn):
        super(GAN, self).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))
        return {"d_loss": d_loss, "g_loss": g_loss}

بیایید آن را آزمایش کنیم:

# 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)
100/100 [==============================] - 3s 11ms/step - d_loss: 0.4031 - g_loss: 0.9305
<keras.callbacks.History at 0x7f5ad1b37c50>

ایده های پشت یادگیری عمیق ساده هستند، پس چرا اجرای آنها باید دردناک باشد؟