این صفحه به‌وسیله ‏Cloud Translation API‏ ترجمه شده است.
Switch to English

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

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

برپایی

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

معرفی

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

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

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

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

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

بررسی اجمالی API: اولین مثال پایان به انتها

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

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

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" و تکرار مکرر کل مجموعه داده برای تعداد معینی از "دوره ها" ، مدل را آموزش می دهد.

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 [==============================] - 2s 2ms/step - loss: 0.3425 - sparse_categorical_accuracy: 0.9034 - val_loss: 0.1827 - val_sparse_categorical_accuracy: 0.9478
Epoch 2/2
782/782 [==============================] - 2s 2ms/step - loss: 0.1618 - sparse_categorical_accuracy: 0.9513 - val_loss: 0.1282 - val_sparse_categorical_accuracy: 0.9651

شی object "history" برگشتی سابقه ای از مقادیر افت و مقادیر متریک را در حین آموزش نگهداری می کند:

history.history
{'loss': [0.3424801528453827, 0.16180744767189026],
 'sparse_categorical_accuracy': [0.903439998626709, 0.9512799978256226],
 'val_loss': [0.18268445134162903, 0.12816601991653442],
 'val_sparse_categorical_accuracy': [0.9477999806404114, 0.9650999903678894]}

ما مدل را بر اساس داده های آزمون از طریق 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 1ms/step - loss: 0.1310 - sparse_categorical_accuracy: 0.9637
test loss, test acc: [0.1309928148984909, 0.963699996471405]
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

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

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

بهینه سازها:

  • 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 [==============================] - 1s 1ms/step - loss: 0.0168

<tensorflow.python.keras.callbacks.History at 0x7f75581d56a0>

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

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

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

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

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 [==============================] - 1s 2ms/step - loss: 0.0390

<tensorflow.python.keras.callbacks.History at 0x7f7558184c88>

سنجه های سفارشی

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

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

به روزرسانی وضعیت و محاسبه نتایج جداگانه نگه داشته می شوند (به update_state() در 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_states(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 [==============================] - 1s 2ms/step - loss: 0.3429 - categorical_true_positives: 45146.0000
Epoch 2/3
782/782 [==============================] - 1s 2ms/step - loss: 0.1560 - categorical_true_positives: 47637.0000
Epoch 3/3
782/782 [==============================] - 1s 2ms/step - loss: 0.1155 - categorical_true_positives: 48237.0000

<tensorflow.python.keras.callbacks.History at 0x7f755801bfd0>

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

اکثر قریب به اتفاق تلفات و معیارها را می توان از 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 [==============================] - 1s 2ms/step - loss: 2.4756

<tensorflow.python.keras.callbacks.History at 0x7f75501e1f98>

برای ثبت مقادیر متریک می توانید همین کار را با استفاده از 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 [==============================] - 1s 2ms/step - loss: 0.3493 - std_of_activation: 0.9813

<tensorflow.python.keras.callbacks.History at 0x7f75500321d0>

در Functional 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 [==============================] - 1s 2ms/step - loss: 2.5230 - std_of_activation: 0.0020

<tensorflow.python.keras.callbacks.History at 0x7f74ec71d828>

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

لایه LogisticEndpoint زیر را در نظر بگیرید: این به عنوان ورودی ها را هدف قرار می دهد و logits است ، و از طریق add_loss() از دست دادن 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 1ms/step - loss: 0.9344 - binary_accuracy: 0.0000e+00

<tensorflow.python.keras.callbacks.History at 0x7f7558339f28>

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

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

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

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

نحوه محاسبه اعتبارسنجی با گرفتن آخرین x٪ نمونه از آرایه های دریافت شده توسط فراخوان مناسب ، قبل از هرگونه تغییر وضعیت است.

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

model = get_compiled_model()
model.fit(x_train, y_train, batch_size=64, validation_split=0.2, epochs=1)
625/625 [==============================] - 1s 2ms/step - loss: 0.3753 - sparse_categorical_accuracy: 0.8927 - val_loss: 0.2252 - val_sparse_categorical_accuracy: 0.9344

<tensorflow.python.keras.callbacks.History at 0x7f755826f160>

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

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

بیایید اکنون به پرونده ای که داده های شما به شکل یک شی tf.data.Dataset می آید ، 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 2ms/step - loss: 0.3404 - sparse_categorical_accuracy: 0.9048
Epoch 2/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1596 - sparse_categorical_accuracy: 0.9529
Epoch 3/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1165 - sparse_categorical_accuracy: 0.9658
Evaluate
157/157 [==============================] - 0s 1ms/step - loss: 0.1147 - sparse_categorical_accuracy: 0.9659

{'loss': 0.11471886932849884,
 'sparse_categorical_accuracy': 0.9659000039100647}

توجه داشته باشید که 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 [==============================] - 0s 2ms/step - loss: 0.8448 - sparse_categorical_accuracy: 0.7734
Epoch 2/3
100/100 [==============================] - 0s 2ms/step - loss: 0.3912 - sparse_categorical_accuracy: 0.8922
Epoch 3/3
100/100 [==============================] - 0s 2ms/step - loss: 0.3399 - sparse_categorical_accuracy: 0.9011

<tensorflow.python.keras.callbacks.History at 0x7f74ec5cf7f0>

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

شما می توانید یک نمونه Dataset به عنوان آرگومان validation_data in 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 [==============================] - 2s 2ms/step - loss: 0.3384 - sparse_categorical_accuracy: 0.9032 - val_loss: 0.1752 - val_sparse_categorical_accuracy: 0.9518

<tensorflow.python.keras.callbacks.History at 0x7f74ec4d2ba8>

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

اگر می خواهید اعتبار سنجی را فقط روی تعداد مشخصی از مجموعه های این مجموعه داده اجرا کنید ، می توانید آرگومان 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 [==============================] - 2s 2ms/step - loss: 0.3503 - sparse_categorical_accuracy: 0.9021 - val_loss: 0.3226 - val_sparse_categorical_accuracy: 0.9156

<tensorflow.python.keras.callbacks.History at 0x7f74ec4caa58>

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

استدلال validation_split (تولید مجموعه ای از اطلاعات مربوط به آموزش) هنگام آموزش از اشیا Dataset پشتیبانی نمی شود ، زیرا این ویژگی به توانایی نمایه سازی نمونه های مجموعه داده ها نیاز دارد ، که به طور کلی با API Dataset امکان پذیر نیست.

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

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

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

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

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

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

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

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

یک Sequence باید دو روش را اجرا کند:

  • __getitem__
  • __len__

روش __getitem__ باید یک دسته کامل را برگرداند. اگر می خواهید مجموعه داده خود را بین دوره ها اصلاح کنید ، می توانید on_epoch_end پیاده سازی 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 2ms/step - loss: 0.3729 - sparse_categorical_accuracy: 0.9025

<tensorflow.python.keras.callbacks.History at 0x7f74ec265358>

وزن های نمونه

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

  • هنگام آموزش از داده های NumPy: آرگومان sample_weight را به Model.fit() .
  • هنگام آموزش از tf.data یا هر نوع تکرار کننده دیگر: (input_batch, label_batch, sample_weight_batch) Yield (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 2ms/step - loss: 0.3837 - sparse_categorical_accuracy: 0.8984

<tensorflow.python.keras.callbacks.History at 0x7f74ec11afd0>

در اینجا یک مثال منطبق با 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 [==============================] - 2s 2ms/step - loss: 0.3792 - sparse_categorical_accuracy: 0.9030

<tensorflow.python.keras.callbacks.History at 0x7f74d47f2208>

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

در مثال های قبلی ، ما مدلی را در نظر گرفتیم که دارای یک ورودی واحد (تنسور شکل (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 خروجی دارید ، استفاده از نامهای واضح و صریح را توصیه می کنیم.

می توان به ضررهای مختلف خاص خروجی ، وزنه های مختلفی داد (به عنوان مثال ، ممکن است بخواهیم با از دست دادن اهمیت 2 برابر اهمیت از دست دادن کلاس ، ضرر "نمره" را در مثال خود loss_weights ) ، با استفاده از آرگومان 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()},
)

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

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 [==============================] - 0s 6ms/step - loss: 20.0184 - score_output_loss: 0.5383 - class_output_loss: 19.4800
4/4 [==============================] - 0s 4ms/step - loss: 17.7266 - score_output_loss: 0.3122 - class_output_loss: 17.4145

<tensorflow.python.keras.callbacks.History at 0x7f755022feb8>

در اینجا مورد استفاده از Dataset وجود دارد: به طور مشابه کاری که برای آرایه های NumPy انجام دادیم ، Dataset باید یک دسته از موارد را برگرداند.

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 8ms/step - loss: 17.2156 - score_output_loss: 0.2522 - class_output_loss: 16.9634

<tensorflow.python.keras.callbacks.History at 0x7f75c56c1128>

استفاده از پاسخگویی

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

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

تماس ها را می توان به عنوان لیستی به تماس شما منتقل کرد تا 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 [==============================] - 1s 2ms/step - loss: 0.3816 - sparse_categorical_accuracy: 0.8913 - val_loss: 0.2325 - val_sparse_categorical_accuracy: 0.9304
Epoch 2/20
625/625 [==============================] - 1s 2ms/step - loss: 0.1773 - sparse_categorical_accuracy: 0.9477 - val_loss: 0.2088 - val_sparse_categorical_accuracy: 0.9343
Epoch 3/20
625/625 [==============================] - 1s 2ms/step - loss: 0.1293 - sparse_categorical_accuracy: 0.9606 - val_loss: 0.1515 - val_sparse_categorical_accuracy: 0.9568
Epoch 4/20
625/625 [==============================] - 1s 2ms/step - loss: 0.1009 - sparse_categorical_accuracy: 0.9700 - val_loss: 0.1376 - val_sparse_categorical_accuracy: 0.9607
Epoch 5/20
625/625 [==============================] - 1s 2ms/step - loss: 0.0821 - sparse_categorical_accuracy: 0.9747 - val_loss: 0.1533 - val_sparse_categorical_accuracy: 0.9545
Epoch 6/20
625/625 [==============================] - 1s 2ms/step - loss: 0.0704 - sparse_categorical_accuracy: 0.9794 - val_loss: 0.1319 - val_sparse_categorical_accuracy: 0.9616
Epoch 00006: early stopping

<tensorflow.python.keras.callbacks.History at 0x7f74d46abdd8>

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

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

اسناد برگشت تماس را برای لیست کامل مشاهده کنید.

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

با گسترش کلاس پایه keras.callbacks.Callback می توانید یک تماس keras.callbacks.Callback سفارشی ایجاد کنید. یک تماس self.model از طریق ویژگی 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 به 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
608/625 [============================>.] - ETA: 0s - loss: 0.3797 - sparse_categorical_accuracy: 0.8940
Epoch 00001: val_loss improved from inf to 0.23986, saving model to mymodel_1
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: mymodel_1/assets
625/625 [==============================] - 2s 3ms/step - loss: 0.3765 - sparse_categorical_accuracy: 0.8949 - val_loss: 0.2399 - val_sparse_categorical_accuracy: 0.9276
Epoch 2/2
606/625 [============================>.] - ETA: 0s - loss: 0.1758 - sparse_categorical_accuracy: 0.9474
Epoch 00002: val_loss improved from 0.23986 to 0.19765, saving model to mymodel_2
INFO:tensorflow:Assets written to: mymodel_2/assets
625/625 [==============================] - 2s 3ms/step - loss: 0.1751 - sparse_categorical_accuracy: 0.9477 - val_loss: 0.1976 - val_sparse_categorical_accuracy: 0.9409

<tensorflow.python.keras.callbacks.History at 0x7f7550171f28>

برای اجرای تحمل خطا می توان از 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
  94/1563 [>.............................] - ETA: 3s - loss: 0.9261 - sparse_categorical_accuracy: 0.7420INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.90/assets
 192/1563 [==>...........................] - ETA: 6s - loss: 0.6734 - sparse_categorical_accuracy: 0.8097INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.66/assets
 292/1563 [====>.........................] - ETA: 6s - loss: 0.5676 - sparse_categorical_accuracy: 0.8390INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.56/assets
 393/1563 [======>.......................] - ETA: 6s - loss: 0.5077 - sparse_categorical_accuracy: 0.8543INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.51/assets
 490/1563 [========>.....................] - ETA: 5s - loss: 0.4665 - sparse_categorical_accuracy: 0.8652INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.46/assets
 589/1563 [==========>...................] - ETA: 5s - loss: 0.4356 - sparse_categorical_accuracy: 0.8735INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.43/assets
 690/1563 [============>.................] - ETA: 4s - loss: 0.4077 - sparse_categorical_accuracy: 0.8813INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.41/assets
 791/1563 [==============>...............] - ETA: 4s - loss: 0.3883 - sparse_categorical_accuracy: 0.8873INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.39/assets
 892/1563 [================>.............] - ETA: 3s - loss: 0.3715 - sparse_categorical_accuracy: 0.8921INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.37/assets
 992/1563 [==================>...........] - ETA: 3s - loss: 0.3569 - sparse_categorical_accuracy: 0.8964INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.36/assets
1092/1563 [===================>..........] - ETA: 2s - loss: 0.3444 - sparse_categorical_accuracy: 0.8994INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.34/assets
1194/1563 [=====================>........] - ETA: 2s - loss: 0.3315 - sparse_categorical_accuracy: 0.9025INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.33/assets
1293/1563 [=======================>......] - ETA: 1s - loss: 0.3217 - sparse_categorical_accuracy: 0.9056INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.32/assets
1383/1563 [=========================>....] - ETA: 1s - loss: 0.3145 - sparse_categorical_accuracy: 0.9077INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.31/assets
1478/1563 [===========================>..] - ETA: 0s - loss: 0.3057 - sparse_categorical_accuracy: 0.9102INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.30/assets
1563/1563 [==============================] - 9s 6ms/step - loss: 0.2996 - sparse_categorical_accuracy: 0.9119

<tensorflow.python.keras.callbacks.History at 0x7f74ec20d668>

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

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

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

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

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

گذراندن برنامه به یک بهینه ساز

با گذراندن یک شی schedule برنامه به عنوان آرگومان 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 .

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

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

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

تجسم ضرر و معیارها در حین آموزش

بهترین روش برای مراقبت از مدل در حین آموزش ، استفاده از TensorBoard است ، یک برنامه مبتنی بر مرورگر که می توانید به صورت محلی اجرا کنید و به شما امکان می دهد:

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

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

tensorboard --logdir=/full_path_to_your_logs

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

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

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

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)
<tensorflow.python.keras.callbacks.TensorBoard at 0x7f74ec5179e8>

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