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

آموزش و ارزیابی با روشهای داخلی

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

برپایی

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

معرفی

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

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

اگر شما در نوشتن آموزش و ارزیابی حلقه خود را از ابتدا علاقه مند، راهنمای ببینید "نوشتن یک حلقه آموزش از ابتدا" .

به طور کلی، چه از حلقه‌های داخلی استفاده می‌کنید یا خودتان را می‌نویسید، آموزش و ارزیابی مدل در همه مدل‌های Keras کاملاً یکسان عمل می‌کند - مدل‌های متوالی، مدل‌های ساخته شده با Functional API، و مدل‌هایی که از ابتدا نوشته شده‌اند. زیر طبقه بندی مدل

این راهنما می کند آموزش توزیع شده، است که در ما تحت پوشش را پوشش نمی دهد راهنمای چند پردازنده گرافیکی و آموزش های توزیع .

نمای کلی API: اولین مثال سرتاسر

هنگام عبور اطلاعات را به ساخته شده است در آموزش حلقه ها از یک مدل، شما هم باید با استفاده از آرایه نامپای (اگر اطلاعات شما کوچک و متناسب در حافظه است) و یا tf.data Dataset اشیاء. در چند پاراگراف بعدی، از مجموعه داده های MNIST به عنوان آرایه های NumPy استفاده خواهیم کرد تا نحوه استفاده از بهینه سازها، ضررها و معیارها را نشان دهیم.

بیایید مدل زیر را در نظر بگیریم (در اینجا، ما با Functional API ایجاد می کنیم، اما می تواند یک مدل ترتیبی یا یک مدل زیر کلاسی نیز باشد):

inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu", name="dense_1")(inputs)
x = layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = layers.Dense(10, activation="softmax", name="predictions")(x)

model = keras.Model(inputs=inputs, outputs=outputs)

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

  • آموزش
  • اعتبار سنجی در مجموعه نگهدارنده تولید شده از داده های آموزشی اصلی
  • ارزیابی بر روی داده های آزمون

برای این مثال از داده های MNIST استفاده خواهیم کرد.

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Preprocess the data (these are NumPy arrays)
x_train = x_train.reshape(60000, 784).astype("float32") / 255
x_test = x_test.reshape(10000, 784).astype("float32") / 255

y_train = y_train.astype("float32")
y_test = y_test.astype("float32")

# Reserve 10,000 samples for validation
x_val = x_train[-10000:]
y_val = y_train[-10000:]
x_train = x_train[:-10000]
y_train = y_train[:-10000]

ما پیکربندی آموزشی (بهینه ساز، ضرر، معیارها) را مشخص می کنیم:

model.compile(
    optimizer=keras.optimizers.RMSprop(),  # Optimizer
    # Loss function to minimize
    loss=keras.losses.SparseCategoricalCrossentropy(),
    # List of metrics to monitor
    metrics=[keras.metrics.SparseCategoricalAccuracy()],
)

ما پاسخ fit() ، که مدل با برش داده ها را به "دسته" اندازه آموزش خواهد batch_size ، و بارها و بارها تکرار بیش از کل مجموعه داده برای یک تعداد معین از epochs .

print("Fit model on training data")
history = model.fit(
    x_train,
    y_train,
    batch_size=64,
    epochs=2,
    # We pass some validation for
    # monitoring validation loss and metrics
    # at the end of each epoch
    validation_data=(x_val, y_val),
)
Fit model on training data
Epoch 1/2
782/782 [==============================] - 3s 3ms/step - loss: 0.3387 - sparse_categorical_accuracy: 0.9050 - val_loss: 0.1957 - val_sparse_categorical_accuracy: 0.9426
Epoch 2/2
782/782 [==============================] - 2s 3ms/step - loss: 0.1543 - sparse_categorical_accuracy: 0.9548 - val_loss: 0.1425 - val_sparse_categorical_accuracy: 0.9593

بازگشت history شی دارای سابقه از ارزش از دست دادن و مقادیر متریک در طول آموزش:

history.history
{'loss': [0.3386789858341217, 0.1543138176202774],
 'sparse_categorical_accuracy': [0.9050400257110596, 0.9548400044441223],
 'val_loss': [0.19569723308086395, 0.14253544807434082],
 'val_sparse_categorical_accuracy': [0.9426000118255615, 0.9592999815940857]}

ما ارزیابی مدل در داده ها از آزمون از طریق evaluate() :

# Evaluate the model on the test data using `evaluate`
print("Evaluate on test data")
results = model.evaluate(x_test, y_test, batch_size=128)
print("test loss, test acc:", results)

# Generate predictions (probabilities -- the output of the last layer)
# on new data using `predict`
print("Generate predictions for 3 samples")
predictions = model.predict(x_test[:3])
print("predictions shape:", predictions.shape)
Evaluate on test data
79/79 [==============================] - 0s 2ms/step - loss: 0.1414 - sparse_categorical_accuracy: 0.9569
test loss, test acc: [0.14140386879444122, 0.9569000005722046]
Generate predictions for 3 samples
predictions shape: (3, 10)

حال، بیایید هر قطعه از این گردش کار را با جزئیات مرور کنیم.

compile() روش: مشخص از دست دادن، متریک، و بهینه ساز

برای آموزش یک مدل با fit() ، شما نیاز به مشخص کردن یک تابع از دست دادن، بهینه ساز، و به صورت اختیاری، برخی از معیارهای به مانیتور.

شما از عبور از این به مدل به عنوان آرگومان به compile() روش:

model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(),
    metrics=[keras.metrics.SparseCategoricalAccuracy()],
)

metrics استدلال باید یک لیست باشد - مدل خود را می توانید هر تعداد از معیارهای دارند.

اگر مدل شما چندین خروجی دارد، می‌توانید تلفات و معیارهای مختلفی را برای هر خروجی مشخص کنید و می‌توانید سهم هر خروجی را در از دست دادن کل مدل تعدیل کنید. شما جزئیات بیشتر در مورد این در عبور داده به چند ورودی، خروجی چندگانه بخش مدل را پیدا

توجه داشته باشید که اگر از تنظیمات پیش‌فرض راضی هستید، در بسیاری از موارد بهینه‌ساز، ضرر و معیارها را می‌توان از طریق شناسه‌های رشته‌ای به عنوان میانبر مشخص کرد:

model.compile(
    optimizer="rmsprop",
    loss="sparse_categorical_crossentropy",
    metrics=["sparse_categorical_accuracy"],
)

برای استفاده مجدد بعدی، اجازه دهید تعریف مدل و مرحله کامپایل خود را در توابع قرار دهیم. ما آنها را چندین بار در نمونه های مختلف در این راهنما فراخوانی خواهیم کرد.

def get_uncompiled_model():
    inputs = keras.Input(shape=(784,), name="digits")
    x = layers.Dense(64, activation="relu", name="dense_1")(inputs)
    x = layers.Dense(64, activation="relu", name="dense_2")(x)
    outputs = layers.Dense(10, activation="softmax", name="predictions")(x)
    model = keras.Model(inputs=inputs, outputs=outputs)
    return model


def get_compiled_model():
    model = get_uncompiled_model()
    model.compile(
        optimizer="rmsprop",
        loss="sparse_categorical_crossentropy",
        metrics=["sparse_categorical_accuracy"],
    )
    return model

بسیاری از بهینه سازها، تلفات و معیارهای داخلی در دسترس هستند

به طور کلی، شما مجبور نخواهید بود که ضرر، معیارها یا بهینه سازهای خود را از ابتدا ایجاد کنید، زیرا آنچه شما نیاز دارید احتمالاً بخشی از Keras API است:

بهینه سازها:

  • SGD() (با یا بدون حرکت)
  • RMSprop()
  • Adam()
  • و غیره.

تلفات:

  • MeanSquaredError()
  • KLDivergence()
  • CosineSimilarity()
  • و غیره.

معیارهای:

  • AUC()
  • Precision()
  • Recall()
  • و غیره.

ضررهای سفارشی

اگر نیاز به ایجاد ضرر سفارشی دارید، Keras دو راه برای این کار ارائه می دهد.

روش اول شامل ایجاد یک تابع است که ورودی می پذیرد y_true و y_pred . مثال زیر یک تابع ضرر را نشان می دهد که میانگین مربعات خطا را بین داده های واقعی و پیش بینی ها محاسبه می کند:

def custom_mean_squared_error(y_true, y_pred):
    return tf.math.reduce_mean(tf.square(y_true - y_pred))


model = get_uncompiled_model()
model.compile(optimizer=keras.optimizers.Adam(), loss=custom_mean_squared_error)

# We need to one-hot encode the labels to use MSE
y_train_one_hot = tf.one_hot(y_train, depth=10)
model.fit(x_train, y_train_one_hot, batch_size=64, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 0.0162
<keras.callbacks.History at 0x7ff8881ba250>

اگر شما نیاز به یک تابع از دست دادن که طول می کشد در پارامترهای کنار y_true و y_pred ، شما می توانید زیر مجموعه tf.keras.losses.Loss کلاس و پیاده سازی از دو روش زیر:

  • __init__(self) : قبول پارامترهایی را در طول تماس تابع ضرر خود را
  • call(self, y_true, y_pred) : با استفاده از اهداف (y_true) و پیش بینی مدل (y_pred) برای محاسبه افت مدل

فرض کنید می‌خواهید از میانگین مجذور خطا استفاده کنید، اما با یک عبارت اضافه شده که مقادیر پیش‌بینی دور از 0.5 را از بین می‌برد (فرض می‌کنیم که اهداف طبقه‌بندی یک کدگذاری شده هستند و مقادیری بین 0 و 1 می‌گیرند). این انگیزه ای برای مدل ایجاد می کند که خیلی مطمئن نباشد، که ممکن است به کاهش بیش از حد برازش کمک کند (تا زمانی که تلاش نکنیم نمی دانیم که کار می کند یا خیر!).

در اینجا نحوه انجام آن آمده است:

class CustomMSE(keras.losses.Loss):
    def __init__(self, regularization_factor=0.1, name="custom_mse"):
        super().__init__(name=name)
        self.regularization_factor = regularization_factor

    def call(self, y_true, y_pred):
        mse = tf.math.reduce_mean(tf.square(y_true - y_pred))
        reg = tf.math.reduce_mean(tf.square(0.5 - y_pred))
        return mse + reg * self.regularization_factor


model = get_uncompiled_model()
model.compile(optimizer=keras.optimizers.Adam(), loss=CustomMSE())

y_train_one_hot = tf.one_hot(y_train, depth=10)
model.fit(x_train, y_train_one_hot, batch_size=64, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 0.0388
<keras.callbacks.History at 0x7ff8882130d0>

معیارهای سفارشی

اگر شما نیاز به یک متریک است که بخشی از API نیست، شما به راحتی می توانید معیارهای سفارشی توسط subclassing ایجاد tf.keras.metrics.Metric کلاس. شما باید 4 روش را پیاده سازی کنید:

  • __init__(self) ، که در آن شما متغیرهای حالت برای متریک را ایجاد کنید.
  • update_state(self, y_true, y_pred, sample_weight=None) ، که با استفاده از اهداف y_true و پیش بینی مدل y_pred برای به روز رسانی متغیرهای حالت.
  • result(self) ، که با استفاده متغیرهای حالت برای محاسبه نتایج نهایی.
  • reset_state(self) ، که reinitializes دولت از متریک.

به روز رسانی دولت و نتایج محاسبات جداگانه (در نگه داشته update_state() و result() ، به ترتیب) چرا که در برخی موارد، محاسبه نتایج ممکن است بسیار گران قیمت و فقط به صورت دوره ای انجام می شود.

اینجا یک مثال ساده نشان میدهد که چگونه برای پیاده سازی یک است CategoricalTruePositives متریک که تعداد بسیاری از نمونه های صحیح و متعلق به یک کلاس داده شده طبقه بندی شدند:

class CategoricalTruePositives(keras.metrics.Metric):
    def __init__(self, name="categorical_true_positives", **kwargs):
        super(CategoricalTruePositives, self).__init__(name=name, **kwargs)
        self.true_positives = self.add_weight(name="ctp", initializer="zeros")

    def update_state(self, y_true, y_pred, sample_weight=None):
        y_pred = tf.reshape(tf.argmax(y_pred, axis=1), shape=(-1, 1))
        values = tf.cast(y_true, "int32") == tf.cast(y_pred, "int32")
        values = tf.cast(values, "float32")
        if sample_weight is not None:
            sample_weight = tf.cast(sample_weight, "float32")
            values = tf.multiply(values, sample_weight)
        self.true_positives.assign_add(tf.reduce_sum(values))

    def result(self):
        return self.true_positives

    def reset_state(self):
        # The state of the metric will be reset at the start of each epoch.
        self.true_positives.assign(0.0)


model = get_uncompiled_model()
model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(),
    metrics=[CategoricalTruePositives()],
)
model.fit(x_train, y_train, batch_size=64, epochs=3)
Epoch 1/3
782/782 [==============================] - 2s 3ms/step - loss: 0.3404 - categorical_true_positives: 45217.0000
Epoch 2/3
782/782 [==============================] - 2s 3ms/step - loss: 0.1588 - categorical_true_positives: 47606.0000
Epoch 3/3
782/782 [==============================] - 2s 3ms/step - loss: 0.1168 - categorical_true_positives: 48278.0000
<keras.callbacks.History at 0x7ff8880a3610>

رسیدگی به ضررها و معیارهایی که با امضای استاندارد مطابقت ندارند

اکثریت قریب به اتفاق از ضرر و زیان و معیارهای را می توان از محاسبه y_true و y_pred ، که در آن y_pred خروجی مدل خود را است - اما نه همه آنها. به عنوان مثال، از دست دادن منظم ممکن است فقط به فعال سازی یک لایه نیاز داشته باشد (هیچ هدفی در این مورد وجود ندارد)، و این فعال سازی ممکن است یک خروجی مدل نباشد.

در چنین مواردی، شما می توانید پاسخ self.add_loss(loss_value) از داخل روش تماس از یک لایه سفارشی. تلفات اضافه شده در این راه از در طول آموزش به از دست دادن "اصلی" اضافه شده (یک به تصویب رسید به compile() ). در اینجا یک مثال ساده آورده شده است که منظم‌سازی فعالیت را اضافه می‌کند (توجه داشته باشید که منظم‌سازی فعالیت در تمام لایه‌های Keras تعبیه شده است -- این لایه فقط به خاطر ارائه یک مثال ملموس است):

class ActivityRegularizationLayer(layers.Layer):
    def call(self, inputs):
        self.add_loss(tf.reduce_sum(inputs) * 0.1)
        return inputs  # Pass-through layer.


inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu", name="dense_1")(inputs)

# Insert activity regularization as a layer
x = ActivityRegularizationLayer()(x)

x = layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = layers.Dense(10, name="predictions")(x)

model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
)

# The displayed loss will be much higher than before
# due to the regularization component.
model.fit(x_train, y_train, batch_size=64, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 2.4545
<keras.callbacks.History at 0x7ff87c53f310>

شما می توانید همین کار را برای ورود به سیستم مقادیر متریک، با استفاده از انجام add_metric() :

class MetricLoggingLayer(layers.Layer):
    def call(self, inputs):
        # The `aggregation` argument defines
        # how to aggregate the per-batch values
        # over each epoch:
        # in this case we simply average them.
        self.add_metric(
            keras.backend.std(inputs), name="std_of_activation", aggregation="mean"
        )
        return inputs  # Pass-through layer.


inputs = keras.Input(shape=(784,), name="digits")
x = layers.Dense(64, activation="relu", name="dense_1")(inputs)

# Insert std logging as a layer.
x = MetricLoggingLayer()(x)

x = layers.Dense(64, activation="relu", name="dense_2")(x)
outputs = layers.Dense(10, name="predictions")(x)

model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(
    optimizer=keras.optimizers.RMSprop(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
)
model.fit(x_train, y_train, batch_size=64, epochs=1)
782/782 [==============================] - 2s 2ms/step - loss: 0.3461 - std_of_activation: 0.9929
<keras.callbacks.History at 0x7ff87c3d5bd0>

در API کاربردی ، شما همچنین می توانید تماس بگیرید model.add_loss(loss_tensor) ، و یا model.add_metric(metric_tensor, name, aggregation) .

در اینجا یک مثال ساده آورده شده است:

inputs = keras.Input(shape=(784,), name="digits")
x1 = layers.Dense(64, activation="relu", name="dense_1")(inputs)
x2 = layers.Dense(64, activation="relu", name="dense_2")(x1)
outputs = layers.Dense(10, name="predictions")(x2)
model = keras.Model(inputs=inputs, outputs=outputs)

model.add_loss(tf.reduce_sum(x1) * 0.1)

model.add_metric(keras.backend.std(x1), name="std_of_activation", aggregation="mean")

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
)
model.fit(x_train, y_train, batch_size=64, epochs=1)
782/782 [==============================] - 2s 3ms/step - loss: 2.4647 - std_of_activation: 0.0017
<keras.callbacks.History at 0x7ff87c216f90>

توجه داشته باشید که زمانی که شما تصویب زیان از طریق add_loss() ، ممکن است به پاسخ شود compile() بدون تابع از دست دادن، از مدل در حال حاضر، از دست دادن برای به حداقل رساندن.

در بر داشت زیر را در نظر بگیرید LogisticEndpoint لایه: آن را به عنوان ورودی اهداف و logits طول می کشد، و آن آهنگ از دست دادن crossentropy طریق add_loss() . همچنین این آهنگ دقت طبقه بندی از طریق add_metric() .

class LogisticEndpoint(keras.layers.Layer):
    def __init__(self, name=None):
        super(LogisticEndpoint, self).__init__(name=name)
        self.loss_fn = keras.losses.BinaryCrossentropy(from_logits=True)
        self.accuracy_fn = keras.metrics.BinaryAccuracy()

    def call(self, targets, logits, sample_weights=None):
        # Compute the training-time loss value and add it
        # to the layer using `self.add_loss()`.
        loss = self.loss_fn(targets, logits, sample_weights)
        self.add_loss(loss)

        # Log accuracy as a metric and add it
        # to the layer using `self.add_metric()`.
        acc = self.accuracy_fn(targets, logits, sample_weights)
        self.add_metric(acc, name="accuracy")

        # Return the inference-time prediction tensor (for `.predict()`).
        return tf.nn.softmax(logits)

شما می توانید آن را در یک مدل با دو ورودی (داده های ورودی و اهداف)، وارد شده بدون استفاده loss استدلال، مثل این:

import numpy as np

inputs = keras.Input(shape=(3,), name="inputs")
targets = keras.Input(shape=(10,), name="targets")
logits = keras.layers.Dense(10)(inputs)
predictions = LogisticEndpoint(name="predictions")(logits, targets)

model = keras.Model(inputs=[inputs, targets], outputs=predictions)
model.compile(optimizer="adam")  # No loss argument!

data = {
    "inputs": np.random.random((3, 3)),
    "targets": np.random.random((3, 10)),
}
model.fit(data)
1/1 [==============================] - 0s 414ms/step - loss: 0.9889 - binary_accuracy: 0.0000e+00
<keras.callbacks.History at 0x7ff87c0848d0>

برای کسب اطلاعات بیشتر در مورد آموزش مدل چند ورودی، به بخش عبور داده به چند ورودی، مدل های چند خروجی.

جداسازی خودکار مجموعه نگهدارنده اعتبارسنجی

در مثال اول پایان به پایان تو را دیدم، ما با استفاده از validation_data استدلال به تصویب یک تاپل از آرایه نامپای (x_val, y_val) به مدل برای ارزیابی از دست دادن اعتبار و معیارهای اعتبار سنجی در پایان هر دوره.

در اینجا یکی دیگر از گزینه است: استدلال validation_split اجازه می دهد تا شما را به بخش به طور خودکار ذخیره داده های آموزشی خود را برای اعتبار. مقدار آرگومان نشان دهنده بخشی از داده ها به برای اعتبار سنجی محفوظ می باشد، پس از آن باید به یک شماره بالاتر از 0 تنظیم و پایین تر از 1. به عنوان مثال، validation_split=0.2 یعنی "استفاده 20 درصد از داده ها را برای اعتبار سنجی"، و validation_split=0.6 یعنی "استفاده 60 درصد از داده ها را برای اعتبار سنجی".

راه اعتبار محاسبه شده است با در نظر گرفتن٪ نمونه و زمان آخرین x از آرایه های دریافت شده توسط fit() تماس، قبل از هر گونه برروی آن بکشید.

توجه داشته باشید که شما فقط می توانید استفاده کنید validation_split در هنگام آموزش با داده های نامپای.

model = get_compiled_model()
model.fit(x_train, y_train, batch_size=64, validation_split=0.2, epochs=1)
625/625 [==============================] - 2s 3ms/step - loss: 0.3682 - sparse_categorical_accuracy: 0.8957 - val_loss: 0.2276 - val_sparse_categorical_accuracy: 0.9301
<keras.callbacks.History at 0x7ff81c680890>

آموزش و ارزیابی از مجموعه داده tf.data

در چند پاراگراف گذشته، شما را دیده ام چگونه که مسئولیت رسیدگی زیان، متریک، و بهینه، و شما را دیده ام چگونه به استفاده از validation_data و validation_split استدلال در fit() ، هنگامی که اطلاعات خود را به صورت آرایه نامپای منتقل می شود.

اکنون بیایید نگاهی به مورد را که در آن داده های خود را می آید در قالب یک tf.data.Dataset شی.

tf.data API مجموعه ای از تاسیسات در TensorFlow 2.0 برای بارگیری و داده از پیش پردازش در راه است که سریع و مقیاس پذیر است.

برای یک راهنمای کامل در مورد ایجاد Datasets ، ببینید مستندات tf.data .

شما می توانید یک پاس Dataset به عنوان مثال به طور مستقیم به روش fit() ، evaluate() ، و predict() :

model = get_compiled_model()

# First, let's create a training Dataset instance.
# For the sake of our example, we'll use the same MNIST data as before.
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
# Shuffle and slice the dataset.
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

# Now we get a test dataset.
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))
test_dataset = test_dataset.batch(64)

# Since the dataset already takes care of batching,
# we don't pass a `batch_size` argument.
model.fit(train_dataset, epochs=3)

# You can also evaluate or predict on a dataset.
print("Evaluate")
result = model.evaluate(test_dataset)
dict(zip(model.metrics_names, result))
Epoch 1/3
782/782 [==============================] - 2s 3ms/step - loss: 0.3372 - sparse_categorical_accuracy: 0.9047
Epoch 2/3
782/782 [==============================] - 2s 3ms/step - loss: 0.1596 - sparse_categorical_accuracy: 0.9523
Epoch 3/3
782/782 [==============================] - 2s 3ms/step - loss: 0.1171 - sparse_categorical_accuracy: 0.9655
Evaluate
157/157 [==============================] - 0s 2ms/step - loss: 0.1211 - sparse_categorical_accuracy: 0.9648
{'loss': 0.12107347697019577,
 'sparse_categorical_accuracy': 0.9648000001907349}

توجه داشته باشید که Dataset در پایان هر دوره تنظیم مجدد می شود، بنابراین می توان از آن در دوره بعدی استفاده مجدد کرد.

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

اگر این کار را انجام دهید، مجموعه داده در پایان هر دوره تنظیم مجدد نمی شود، در عوض ما فقط به ترسیم دسته های بعدی ادامه می دهیم. در نهایت داده‌های مجموعه داده تمام می‌شود (مگر اینکه یک مجموعه داده با حلقه بی‌نهایت باشد).

model = get_compiled_model()

# Prepare the training dataset
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

# Only use the 100 batches per epoch (that's 64 * 100 samples)
model.fit(train_dataset, epochs=3, steps_per_epoch=100)
Epoch 1/3
100/100 [==============================] - 1s 3ms/step - loss: 0.7937 - sparse_categorical_accuracy: 0.7894
Epoch 2/3
100/100 [==============================] - 0s 3ms/step - loss: 0.3699 - sparse_categorical_accuracy: 0.8938
Epoch 3/3
100/100 [==============================] - 0s 3ms/step - loss: 0.3155 - sparse_categorical_accuracy: 0.9061
<keras.callbacks.History at 0x7ff81c587e90>

استفاده از مجموعه داده اعتبارسنجی

شما می توانید یک پاس Dataset به عنوان مثال به عنوان validation_data استدلال در fit() :

model = get_compiled_model()

# Prepare the training dataset
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

# Prepare the validation dataset
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(64)

model.fit(train_dataset, epochs=1, validation_data=val_dataset)
782/782 [==============================] - 3s 3ms/step - loss: 0.3380 - sparse_categorical_accuracy: 0.9035 - val_loss: 0.2015 - val_sparse_categorical_accuracy: 0.9405
<keras.callbacks.History at 0x7ff81c30e450>

در پایان هر دوره، مدل بر روی مجموعه داده اعتبار سنجی تکرار می شود و معیارهای از دست دادن اعتبار و اعتبارسنجی را محاسبه می کند.

اگر شما می خواهید برای اجرای اعتبار تنها در تعداد خاصی از دسته از این مجموعه داده، شما می توانید عبور validation_steps استدلال، که مشخص میکند که چگونه بسیاری از اعتبار سنجی مراحل مدل باید با مجموعه داده های اعتبار سنجی قبل از ایجاد وقفه در اعتبار سنجی و حرکت به دوران بعدی را اجرا کنید:

model = get_compiled_model()

# Prepare the training dataset
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

# Prepare the validation dataset
val_dataset = tf.data.Dataset.from_tensor_slices((x_val, y_val))
val_dataset = val_dataset.batch(64)

model.fit(
    train_dataset,
    epochs=1,
    # Only run validation using the first 10 batches of the dataset
    # using the `validation_steps` argument
    validation_data=val_dataset,
    validation_steps=10,
)
782/782 [==============================] - 3s 3ms/step - loss: 0.3369 - sparse_categorical_accuracy: 0.9036 - val_loss: 0.2953 - val_sparse_categorical_accuracy: 0.9187
<keras.callbacks.History at 0x7ff81c30e310>

توجه داشته باشید که مجموعه داده اعتبارسنجی پس از هر بار استفاده مجدداً تنظیم می شود (به طوری که شما همیشه در حال ارزیابی نمونه های مشابه از دوره به دوره هستید).

استدلال validation_split (تولید مجموعه ای holdout از داده های آموزشی) پشتیبانی نمی هنگامی که آموزش از Dataset اشیاء، از آنجایی که این قابلیت نیاز به توانایی به صفحه اول نمونه از مجموعه داده، که ممکن است به طور کلی نمی با Dataset API.

سایر فرمت های ورودی پشتیبانی می شود

علاوه بر آرایه نامپای، تانسورها مشتاق، و TensorFlow Datasets ، این امکان برای آموزش یک مدل Keras با استفاده از dataframes پانداها، و یا از ژنراتور پایتون که دسته عملکرد داده و برچسب.

به طور خاص، keras.utils.Sequence کلاس ارائه می دهد یک رابط کاربری ساده به ساخت ژنراتور داده پایتون که مولتی آگاه است و می تواند جای بده.

به طور کلی توصیه می کنیم از موارد زیر استفاده کنید:

  • اگر داده های شما کوچک است و در حافظه جا می شود، داده های ورودی NumPy را وارد کنید
  • Dataset اشیاء اگر شما مجموعه داده های بزرگ و شما نیاز به انجام این آموزش توزیع
  • Sequence اشیاء اگر شما مجموعه داده های بزرگ و شما نیاز به انجام بسیاری از سفارشی پردازش پایتون سمت که می تواند در TensorFlow انجام شود (به عنوان مثال اگر شما به کتابخانه های خارجی برای بارگذاری داده ها و یا از پیش پردازش تکیه).

با استفاده از یک keras.utils.Sequence شی به عنوان ورودی

keras.utils.Sequence نرم افزاری است که شما می توانید زیر مجموعه برای به دست آوردن یک ژنراتور پایتون با دو ویژگی مهم است:

  • با چند پردازش خوب کار می کند.
  • می توان آن را حوصلگی (به عنوان مثال در هنگام عبور shuffle=True در fit() ).

Sequence باید دو روش پیاده سازی:

  • __getitem__
  • __len__

روش __getitem__ باید یک دسته کامل بازگشت. اگر می خواهید تغییر دهید مجموعه داده های خود را بین دوره، شما ممکن است پیاده سازی on_epoch_end .

در اینجا یک مثال سریع آورده شده است:

from skimage.io import imread
from skimage.transform import resize
import numpy as np

# Here, `filenames` is list of path to the images
# and `labels` are the associated labels.

class CIFAR10Sequence(Sequence):
    def __init__(self, filenames, labels, batch_size):
        self.filenames, self.labels = filenames, labels
        self.batch_size = batch_size

    def __len__(self):
        return int(np.ceil(len(self.filenames) / float(self.batch_size)))

    def __getitem__(self, idx):
        batch_x = self.filenames[idx * self.batch_size:(idx + 1) * self.batch_size]
        batch_y = self.labels[idx * self.batch_size:(idx + 1) * self.batch_size]
        return np.array([
            resize(imread(filename), (200, 200))
               for filename in batch_x]), np.array(batch_y)

sequence = CIFAR10Sequence(filenames, labels, batch_size)
model.fit(sequence, epochs=10)

با استفاده از وزن نمونه و وزن کلاس

با تنظیمات پیش‌فرض، وزن نمونه با فراوانی آن در مجموعه داده تعیین می‌شود. دو روش برای وزن دهی داده ها، مستقل از فراوانی نمونه وجود دارد:

  • اوزان کلاس
  • وزن نمونه

اوزان کلاس

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

این می تواند برای متعادل کردن کلاس ها بدون نمونه گیری مجدد، یا آموزش مدلی که به یک کلاس خاص اهمیت بیشتری می دهد استفاده شود.

برای مثال، اگر کلاس "0" نیم است به عنوان به عنوان کلاس "1" در داده های خود را نشان داده، شما می توانید با استفاده از Model.fit(..., class_weight={0: 1., 1: 0.5}) .

در اینجا یک مثال NumPy است که در آن از وزن کلاس یا وزن نمونه استفاده می کنیم تا به طبقه بندی صحیح کلاس #5 اهمیت بیشتری بدهیم (که رقم "5" در مجموعه داده MNIST است).

import numpy as np

class_weight = {
    0: 1.0,
    1: 1.0,
    2: 1.0,
    3: 1.0,
    4: 1.0,
    # Set weight "2" for class "5",
    # making this class 2x more important
    5: 2.0,
    6: 1.0,
    7: 1.0,
    8: 1.0,
    9: 1.0,
}

print("Fit with class weight")
model = get_compiled_model()
model.fit(x_train, y_train, class_weight=class_weight, batch_size=64, epochs=1)
Fit with class weight
782/782 [==============================] - 2s 3ms/step - loss: 0.3708 - sparse_categorical_accuracy: 0.9032
<keras.callbacks.History at 0x7ff80c7ddd10>

وزن نمونه

برای کنترل ریزدانه، یا اگر در حال ساخت طبقه بندی نیستید، می توانید از "وزن نمونه" استفاده کنید.

  • هنگامی که آموزش از داده نامپای: رمز عبور sample_weight آرگومان به Model.fit() .
  • زمانی که آموزش از tf.data یا هر نوع دیگر از تکرار: عملکرد (input_batch, label_batch, sample_weight_batch) چندتایی ها.

آرایه "وزن نمونه" آرایه ای از اعداد است که مشخص می کند هر نمونه در یک دسته چه مقدار وزنی باید در محاسبه تلفات کل داشته باشد. معمولاً در مسائل طبقه‌بندی نامتعادل استفاده می‌شود (ایده این است که به کلاس‌هایی که به ندرت دیده می‌شوند وزن بیشتری بدهیم).

هنگامی که وزن استفاده شده و صفر هستند، آرایه می تواند به عنوان یک ماسک برای از دست دادن عملکرد (به طور کامل دور سهم نمونه خاص به از دست رفتن کل) استفاده می شود.

sample_weight = np.ones(shape=(len(y_train),))
sample_weight[y_train == 5] = 2.0

print("Fit with sample weight")
model = get_compiled_model()
model.fit(x_train, y_train, sample_weight=sample_weight, batch_size=64, epochs=1)
Fit with sample weight
782/782 [==============================] - 2s 3ms/step - loss: 0.3806 - sparse_categorical_accuracy: 0.9000
<keras.callbacks.History at 0x7ff80c650350>

در اینجا یک تطبیق است Dataset به عنوان مثال:

sample_weight = np.ones(shape=(len(y_train),))
sample_weight[y_train == 5] = 2.0

# Create a Dataset that includes sample weights
# (3rd element in the return tuple).
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train, sample_weight))

# Shuffle and slice the dataset.
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

model = get_compiled_model()
model.fit(train_dataset, epochs=1)
782/782 [==============================] - 3s 3ms/step - loss: 0.3588 - sparse_categorical_accuracy: 0.9070
<keras.callbacks.History at 0x7ff80c51cb50>

انتقال داده به مدل های چند ورودی و چند خروجی

در مثال قبلی، ما با توجه به مدل با یک ورودی تک (یک تانسور شکل شد (764,) ) و یک خروجی واحد (یک تانسور پیش بینی شکل (10,) ). اما در مورد مدل هایی که چندین ورودی یا خروجی دارند چطور؟

مدل زیر، که دارای یک ورودی تصویر از شکل در نظر بگیرید (32, 32, 3) (که در (height, width, channels) ) و یک ورودی سری زمانی شکل (None, 10) (که در (timesteps, features) ). مدل ما خواهد دو خروجی محاسبه شده از ترکیبی از این ورودی را داشته باشد: "نمره" (شکل (1,) ) و یک توزیع احتمال پنج کلاس (شکل (5,) ).

image_input = keras.Input(shape=(32, 32, 3), name="img_input")
timeseries_input = keras.Input(shape=(None, 10), name="ts_input")

x1 = layers.Conv2D(3, 3)(image_input)
x1 = layers.GlobalMaxPooling2D()(x1)

x2 = layers.Conv1D(3, 3)(timeseries_input)
x2 = layers.GlobalMaxPooling1D()(x2)

x = layers.concatenate([x1, x2])

score_output = layers.Dense(1, name="score_output")(x)
class_output = layers.Dense(5, name="class_output")(x)

model = keras.Model(
    inputs=[image_input, timeseries_input], outputs=[score_output, class_output]
)

بیایید این مدل را رسم کنیم، تا بتوانید به وضوح ببینید که ما در اینجا چه می‌کنیم (توجه داشته باشید که اشکال نشان‌داده‌شده در نمودار، به‌جای شکل‌های هر نمونه، اشکال دسته‌ای هستند).

keras.utils.plot_model(model, "multi_input_and_output_model.png", show_shapes=True)

png

در زمان کامپایل، می‌توانیم تلفات متفاوتی را برای خروجی‌های مختلف، با ارسال توابع ضرر به‌عنوان یک لیست مشخص کنیم:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[keras.losses.MeanSquaredError(), keras.losses.CategoricalCrossentropy()],
)

اگر فقط یک تابع ضرر را به مدل منتقل کنیم، همان تابع ضرر برای هر خروجی اعمال می شود (که در اینجا مناسب نیست).

به همین ترتیب برای معیارها:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[keras.losses.MeanSquaredError(), keras.losses.CategoricalCrossentropy()],
    metrics=[
        [
            keras.metrics.MeanAbsolutePercentageError(),
            keras.metrics.MeanAbsoluteError(),
        ],
        [keras.metrics.CategoricalAccuracy()],
    ],
)

از آنجایی که ما به لایه های خروجی خود نام دادیم، می توانیم تلفات و معیارهای هر خروجی را نیز از طریق یک دستور مشخص کنیم:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss={
        "score_output": keras.losses.MeanSquaredError(),
        "class_output": keras.losses.CategoricalCrossentropy(),
    },
    metrics={
        "score_output": [
            keras.metrics.MeanAbsolutePercentageError(),
            keras.metrics.MeanAbsoluteError(),
        ],
        "class_output": [keras.metrics.CategoricalAccuracy()],
    },
)

اگر بیش از 2 خروجی دارید، توصیه می کنیم از نام ها و دستورات صریح استفاده کنید.

این امکان وجود دارد به وزن های مختلف به زیان های مختلف خروجی خاص (به عنوان مثال، ممکن است به افتخار آرزو "نمره" از دست دادن در مثال ما، با دادن به 2x اهمیت دست دادن کلاس)، با استفاده از loss_weights استدلال:

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss={
        "score_output": keras.losses.MeanSquaredError(),
        "class_output": keras.losses.CategoricalCrossentropy(),
    },
    metrics={
        "score_output": [
            keras.metrics.MeanAbsolutePercentageError(),
            keras.metrics.MeanAbsoluteError(),
        ],
        "class_output": [keras.metrics.CategoricalAccuracy()],
    },
    loss_weights={"score_output": 2.0, "class_output": 1.0},
)

همچنین می توانید انتخاب کنید که ضرر را برای خروجی های خاص محاسبه نکنید، اگر این خروجی ها برای پیش بینی هستند اما برای آموزش نیستند:

# List loss version
model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[None, keras.losses.CategoricalCrossentropy()],
)

# Or dict loss version
model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss={"class_output": keras.losses.CategoricalCrossentropy()},
)

عبور داده به چند ورودی و یا مدل چند خروجی در fit() کار می کند در روشی مشابه به عنوان تعیین یک تابع از دست دادن در کامپایل: به خروجی که یک تابع از دست دادن دریافت 1 نگاشت: شما می توانید لیست آرایه نامپای (با 1 عبور ) و یا dicts نقشه برداری نام خروجی به آرایه نامپای.

model.compile(
    optimizer=keras.optimizers.RMSprop(1e-3),
    loss=[keras.losses.MeanSquaredError(), keras.losses.CategoricalCrossentropy()],
)

# Generate dummy NumPy data
img_data = np.random.random_sample(size=(100, 32, 32, 3))
ts_data = np.random.random_sample(size=(100, 20, 10))
score_targets = np.random.random_sample(size=(100, 1))
class_targets = np.random.random_sample(size=(100, 5))

# Fit on lists
model.fit([img_data, ts_data], [score_targets, class_targets], batch_size=32, epochs=1)

# Alternatively, fit on dicts
model.fit(
    {"img_input": img_data, "ts_input": ts_data},
    {"score_output": score_targets, "class_output": class_targets},
    batch_size=32,
    epochs=1,
)
4/4 [==============================] - 2s 9ms/step - loss: 5.6917 - score_output_loss: 0.1031 - class_output_loss: 5.5886
4/4 [==============================] - 0s 6ms/step - loss: 4.4108 - score_output_loss: 0.0999 - class_output_loss: 4.3109
<keras.callbacks.History at 0x7ff80c3b4110>

در اینجا است Dataset مورد استفاده: به طور مشابه به عنوان آنچه که ما برای آرایه نامپای انجام داد، Dataset باید یک تاپل از dicts بازگشت.

train_dataset = tf.data.Dataset.from_tensor_slices(
    (
        {"img_input": img_data, "ts_input": ts_data},
        {"score_output": score_targets, "class_output": class_targets},
    )
)
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

model.fit(train_dataset, epochs=1)
2/2 [==============================] - 0s 21ms/step - loss: 4.2451 - score_output_loss: 0.0993 - class_output_loss: 4.1458
<keras.callbacks.History at 0x7ff80c3ed450>

استفاده از تماس های برگشتی

Callback در Keras اشیایی هستند که در نقاط مختلف در طول آموزش (در شروع یک دوره، در پایان یک دسته، در پایان یک دوره و غیره) فراخوانی می شوند. می توان از آنها برای اجرای رفتارهای خاصی استفاده کرد، مانند:

  • انجام اعتبارسنجی در نقاط مختلف در طول آموزش (فراتر از اعتبار سنجی داخلی در هر دوره)
  • بررسی مدل در فواصل زمانی منظم یا زمانی که از آستانه دقت خاصی فراتر رود
  • تغییر نرخ یادگیری مدل زمانی که به نظر می رسد آموزش در حال افزایش است
  • هنگام تمرین به نظر می رسد که انجام دادن تنظیم دقیق لایه های بالایی انجام شود
  • ارسال ایمیل یا اعلان‌های پیام فوری زمانی که آموزش به پایان می‌رسد یا زمانی که از آستانه عملکرد خاصی فراتر رفته است
  • و غیره.

تماس مجدد می تواند به عنوان یک لیست برای تماس خود را به تصویب fit() :

model = get_compiled_model()

callbacks = [
    keras.callbacks.EarlyStopping(
        # Stop training when `val_loss` is no longer improving
        monitor="val_loss",
        # "no longer improving" being defined as "no better than 1e-2 less"
        min_delta=1e-2,
        # "no longer improving" being further defined as "for at least 2 epochs"
        patience=2,
        verbose=1,
    )
]
model.fit(
    x_train,
    y_train,
    epochs=20,
    batch_size=64,
    callbacks=callbacks,
    validation_split=0.2,
)
Epoch 1/20
625/625 [==============================] - 2s 3ms/step - loss: 0.3725 - sparse_categorical_accuracy: 0.8939 - val_loss: 0.2314 - val_sparse_categorical_accuracy: 0.9321
Epoch 2/20
625/625 [==============================] - 2s 3ms/step - loss: 0.1805 - sparse_categorical_accuracy: 0.9471 - val_loss: 0.2012 - val_sparse_categorical_accuracy: 0.9379
Epoch 3/20
625/625 [==============================] - 2s 3ms/step - loss: 0.1346 - sparse_categorical_accuracy: 0.9603 - val_loss: 0.1651 - val_sparse_categorical_accuracy: 0.9505
Epoch 4/20
625/625 [==============================] - 2s 3ms/step - loss: 0.1065 - sparse_categorical_accuracy: 0.9684 - val_loss: 0.1510 - val_sparse_categorical_accuracy: 0.9571
Epoch 5/20
625/625 [==============================] - 2s 3ms/step - loss: 0.0884 - sparse_categorical_accuracy: 0.9734 - val_loss: 0.1505 - val_sparse_categorical_accuracy: 0.9538
Epoch 6/20
625/625 [==============================] - 2s 3ms/step - loss: 0.0746 - sparse_categorical_accuracy: 0.9778 - val_loss: 0.1508 - val_sparse_categorical_accuracy: 0.9575
Epoch 00006: early stopping
<keras.callbacks.History at 0x7ff80c64cad0>

بسیاری از تماس های داخلی موجود هستند

بسیاری از تماس‌های داخلی موجود در Keras وجود دارد، مانند:

  • ModelCheckpoint : دوره مدل را نجات دهد.
  • EarlyStopping : آموزش توقف در هنگام آموزش است و دیگر بهبود معیارهای اعتبار سنجی است.
  • TensorBoard : مدل سیاهههای مربوط دوره نوشتن که می تواند در تجسم TensorBoard (جزئیات بیشتر در بخش "تجسم").
  • CSVLogger : جریان داده از دست دادن و معیارهای یک فایل CSV.
  • و غیره.

را ببینید مستندات تماس مجدد برای لیست کامل.

نوشتن پاسخ تماس خود را

شما می توانید مخاطبین سفارشی با گسترش کلاس پایه ایجاد keras.callbacks.Callback . مخاطبین دسترسی به مدل مرتبط با آن از طریق اموال کلاس دارای self.model .

اطمینان حاصل کنید که به خواندن راهنمای کامل برای نوشتن از تماس های سفارشی .

در اینجا یک مثال ساده برای ذخیره لیستی از مقادیر از دست دادن هر دسته در طول آموزش آورده شده است:

class LossHistory(keras.callbacks.Callback):
    def on_train_begin(self, logs):
        self.per_batch_losses = []

    def on_batch_end(self, batch, logs):
        self.per_batch_losses.append(logs.get("loss"))

مدل های ایست بازرسی

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

ساده ترین راه برای رسیدن به این هدف با ModelCheckpoint پاسخ به تماس:

model = get_compiled_model()

callbacks = [
    keras.callbacks.ModelCheckpoint(
        # Path where to save the model
        # The two parameters below mean that we will overwrite
        # the current checkpoint if and only if
        # the `val_loss` score has improved.
        # The saved model name will include the current epoch.
        filepath="mymodel_{epoch}",
        save_best_only=True,  # Only save a model if `val_loss` has improved.
        monitor="val_loss",
        verbose=1,
    )
]
model.fit(
    x_train, y_train, epochs=2, batch_size=64, callbacks=callbacks, validation_split=0.2
)
Epoch 1/2
613/625 [============================>.] - ETA: 0s - loss: 0.3693 - sparse_categorical_accuracy: 0.8972
Epoch 00001: val_loss improved from inf to 0.23508, saving model to mymodel_1
2021-11-12 20:11:50.182298: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: mymodel_1/assets
625/625 [==============================] - 3s 4ms/step - loss: 0.3660 - sparse_categorical_accuracy: 0.8979 - val_loss: 0.2351 - val_sparse_categorical_accuracy: 0.9273
Epoch 2/2
620/625 [============================>.] - ETA: 0s - loss: 0.1659 - sparse_categorical_accuracy: 0.9507
Epoch 00002: val_loss improved from 0.23508 to 0.16898, saving model to mymodel_2
INFO:tensorflow:Assets written to: mymodel_2/assets
625/625 [==============================] - 2s 3ms/step - loss: 0.1657 - sparse_categorical_accuracy: 0.9507 - val_loss: 0.1690 - val_sparse_categorical_accuracy: 0.9482
<keras.callbacks.History at 0x7ff8b577cc90>

ModelCheckpoint پاسخ به تماس را می توان برای پیاده سازی تحمل خطا: توانایی آموزش راه اندازی مجدد از آخرین وضعیت ذخیره شده از مدل در آموزش مورد می شود به طور تصادفی قطع شده است. در اینجا یک مثال اساسی آورده شده است:

import os

# Prepare a directory to store all the checkpoints.
checkpoint_dir = "./ckpt"
if not os.path.exists(checkpoint_dir):
    os.makedirs(checkpoint_dir)


def make_or_restore_model():
    # Either restore the latest model, or create a fresh one
    # if there is no checkpoint available.
    checkpoints = [checkpoint_dir + "/" + name for name in os.listdir(checkpoint_dir)]
    if checkpoints:
        latest_checkpoint = max(checkpoints, key=os.path.getctime)
        print("Restoring from", latest_checkpoint)
        return keras.models.load_model(latest_checkpoint)
    print("Creating a new model")
    return get_compiled_model()


model = make_or_restore_model()
callbacks = [
    # This callback saves a SavedModel every 100 batches.
    # We include the training loss in the saved model name.
    keras.callbacks.ModelCheckpoint(
        filepath=checkpoint_dir + "/ckpt-loss={loss:.2f}", save_freq=100
    )
]
model.fit(x_train, y_train, epochs=1, callbacks=callbacks)
Creating a new model
  88/1563 [>.............................] - ETA: 3s - loss: 1.1203 - sparse_categorical_accuracy: 0.6911INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=1.04/assets
 185/1563 [==>...........................] - ETA: 6s - loss: 0.7768 - sparse_categorical_accuracy: 0.7858INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.75/assets
 286/1563 [====>.........................] - ETA: 6s - loss: 0.6382 - sparse_categorical_accuracy: 0.8211INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.63/assets
 383/1563 [======>.......................] - ETA: 6s - loss: 0.5584 - sparse_categorical_accuracy: 0.8433INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.55/assets
 484/1563 [========>.....................] - ETA: 6s - loss: 0.5032 - sparse_categorical_accuracy: 0.8578INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.50/assets
 586/1563 [==========>...................] - ETA: 5s - loss: 0.4644 - sparse_categorical_accuracy: 0.8684INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.46/assets
 685/1563 [============>.................] - ETA: 5s - loss: 0.4356 - sparse_categorical_accuracy: 0.8762INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.43/assets
 783/1563 [==============>...............] - ETA: 5s - loss: 0.4127 - sparse_categorical_accuracy: 0.8825INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.41/assets
 883/1563 [===============>..............] - ETA: 4s - loss: 0.3958 - sparse_categorical_accuracy: 0.8868INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.39/assets
 985/1563 [=================>............] - ETA: 3s - loss: 0.3766 - sparse_categorical_accuracy: 0.8918INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.38/assets
1086/1563 [===================>..........] - ETA: 3s - loss: 0.3624 - sparse_categorical_accuracy: 0.8958INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.36/assets
1184/1563 [=====================>........] - ETA: 2s - loss: 0.3498 - sparse_categorical_accuracy: 0.8994INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.35/assets
1283/1563 [=======================>......] - ETA: 1s - loss: 0.3383 - sparse_categorical_accuracy: 0.9029INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.34/assets
1386/1563 [=========================>....] - ETA: 1s - loss: 0.3265 - sparse_categorical_accuracy: 0.9058INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.33/assets
1485/1563 [===========================>..] - ETA: 0s - loss: 0.3184 - sparse_categorical_accuracy: 0.9081INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.32/assets
1563/1563 [==============================] - 11s 7ms/step - loss: 0.3122 - sparse_categorical_accuracy: 0.9097
<keras.callbacks.History at 0x7ff8b53e1dd0>

شما تماس می‌گیرید همچنین برای ذخیره و بازیابی مدل‌ها، پاسخ تماس خود را بنویسید.

برای یک راهنمای کامل در ترتیب و صرفه جویی در، نگاه کنید به راهنمای صرفه جویی در و serialize کردن مدل .

استفاده از جدول نرخ یادگیری

یک الگوی رایج هنگام آموزش مدل های یادگیری عمیق، کاهش تدریجی یادگیری با پیشرفت آموزش است. این به طور کلی به عنوان "نزول نرخ یادگیری" شناخته می شود.

برنامه کاهش یادگیری می تواند ایستا (از قبل ثابت شده، به عنوان تابعی از دوره فعلی یا شاخص دسته ای فعلی) یا پویا (در پاسخ به رفتار فعلی مدل، به ویژه از دست دادن اعتبار) باشد.

انتقال یک برنامه به یک بهینه ساز

شما به راحتی می توانید با استفاده از یک برنامه پوسیدگی نرخ آموزشی ایستا با گذراندن یک شی برنامه به عنوان learning_rate استدلال در بهینه ساز خود قرار دهید:

initial_learning_rate = 0.1
lr_schedule = keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate, decay_steps=100000, decay_rate=0.96, staircase=True
)

optimizer = keras.optimizers.RMSprop(learning_rate=lr_schedule)

چند ساخته شده در برنامه موجود است: ExponentialDecay ، PiecewiseConstantDecay ، PolynomialDecay و InverseTimeDecay .

استفاده از تماس‌های برگشتی برای اجرای برنامه زمان‌بندی نرخ یادگیری پویا

یک زمان‌بندی نرخ یادگیری پویا (به عنوان مثال، کاهش نرخ یادگیری زمانی که از دست دادن اعتبارسنجی دیگر بهبود نمی‌یابد) را نمی‌توان با این اشیاء زمان‌بندی به دست آورد، زیرا بهینه‌ساز به معیارهای اعتبارسنجی دسترسی ندارد.

با این حال، تماس‌های برگشتی به همه معیارها، از جمله معیارهای اعتبارسنجی، دسترسی دارند! بنابراین می‌توانید با استفاده از یک فراخوانی که نرخ یادگیری فعلی را در بهینه‌ساز تغییر می‌دهد، به این الگو دست پیدا کنید. در واقع، این است که حتی ساخته شده است در به عنوان ReduceLROnPlateau پاسخ به تماس.

تجسم ضرر و معیارها در طول تمرین

بهترین راه برای نگه داشتن چشم در مدل خود را در طول آموزش است که استفاده از TensorBoard - یک برنامه مبتنی بر مرورگر است که شما می توانید به صورت محلی اجرا که شما فراهم می کند با:

  • نمودارهای زنده از دست دادن و معیارهایی برای آموزش و ارزیابی
  • (اختیاری) تجسم هیستوگرام های فعال سازی لایه شما
  • (اختیاری) 3D تصویری از فضاهای تعبیه دست های خود را Embedding لایه

اگر TensorFlow را با پیپ نصب کرده اید، باید بتوانید TensorBoard را از خط فرمان راه اندازی کنید:

tensorboard --logdir=/full_path_to_your_logs

با استفاده از پاسخ به تماس TensorBoard

ساده ترین راه برای استفاده از TensorBoard با یک مدل Keras و fit() روش است TensorBoard پاسخ به تماس.

در ساده‌ترین حالت، فقط محل مورد نظر را برای نوشتن گزارش‌های مربوط به callback مشخص کنید، و می‌توانید بروید:

keras.callbacks.TensorBoard(
    log_dir="/full_path_to_your_logs",
    histogram_freq=0,  # How often to log histogram visualizations
    embeddings_freq=0,  # How often to log embedding visualizations
    update_freq="epoch",
)  # How often to write logs (default: once per epoch)
<keras.callbacks.TensorBoard at 0x7ff88c8c04d0>

برای اطلاعات بیشتر، نگاه کنید به اسناد و مدارک برای TensorBoard پاسخ به تماس .