Yerleşik yöntemlerle eğitim ve değerlendirme

Koleksiyonlar ile düzeninizi koruyun İçeriği tercihlerinize göre kaydedin ve kategorilere ayırın.

TensorFlow.org'da görüntüleyin Google Colab'da çalıştırın Kaynağı GitHub'da görüntüleyin Not defterini indir

Kurmak

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

Tanıtım

Bu kılavuz kapakları eğitim, değerlendirme ve öngörü (çıkarsama) kullanılarak modelleri dahili (örneğin eğitim ve doğrulama için API'ler Model.fit() , Model.evaluate() ve Model.predict() ).

Eğer yararlanarak ilgilenen varsa fit() kendi eğitim aşaması fonksiyonunu belirtilirken, bkz neler olduğunu Özelleştirin fit() kılavuz .

Eğer sıfırdan kendi eğitim ve değerlendirme döngüler yazılı olarak ilgilenen varsa, kılavuzuna bakın "sıfırdan bir eğitim döngü yazma" .

Genel olarak, ister yerleşik döngüler kullanıyor, ister kendi döngülerinizi yazıyor olun, model eğitimi ve değerlendirmesi, her tür Keras modelinde kesinlikle aynı şekilde çalışır - Sıralı modeller, İşlevsel API ile oluşturulmuş modeller ve aracılığıyla sıfırdan yazılmış modeller. model alt sınıflaması

Bu kılavuz bizim kaplıdır dağıtılan eğitim kapsamaz çoklu GPU ve dağıtılan eğitim rehberi .

API'ye genel bakış: ilk uçtan uca örnek

Veri geçerken (veri hafızasına küçük ve uyan ise) veya modelin döngüler eğitim yerleşik, ya NumPy diziler kullanmalıdır tf.data Dataset nesneleri. Sonraki birkaç paragrafta, optimize edicilerin, kayıpların ve ölçümlerin nasıl kullanılacağını göstermek için MNIST veri kümesini NumPy dizileri olarak kullanacağız.

Aşağıdaki modeli ele alalım (burada, İşlevsel API ile inşa ediyoruz, ancak bu, Sıralı bir model veya alt sınıflı bir model de olabilir):

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)

Tipik uçtan uca iş akışı aşağıdakilerden oluşur:

  • Eğitim
  • Orijinal eğitim verilerinden oluşturulan bir bekleme setinde doğrulama
  • Test verileri üzerinde değerlendirme

Bu örnek için MNIST verilerini kullanacağız.

(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]

Eğitim yapılandırmasını belirliyoruz (optimizer, kayıp, metrikler):

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

Biz diyoruz fit() boyutu "toplu" içine veri dilimleme modeli eğitecek, batch_size ve sürekli belirli bir sayıda için tüm veri kümesini yineleme 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

Döndürülen history nesne eğitim sırasında kayıp değerlerinin ve metrik değerlerin bir rekoru kırdı:

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]}

Biz aracılığıyla deney verilerine modelini değerlendirmek 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)

Şimdi, bu iş akışının her bir parçasını ayrıntılı olarak inceleyelim.

compile() metodu: bir kayıp, metrikleri belirten ve bir iyileştirici

Bir model eğitmek için fit() , bir kayıp fonksiyonu, bir iyimserlik ve monitöre isteğe bağlı olarak bazı ölçümleri belirtmek gerekir.

Sen argümanları olarak modele bu geçmesine compile() yöntemiyle:

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

metrics argüman listesi olmamalıdır - modeliniz ölçütlerinin herhangi bir sayı olabilir.

Modelinizin birden fazla çıktısı varsa, her çıktı için farklı kayıplar ve metrikler belirtebilir ve her bir çıktının modelin toplam kaybına katkısını modüle edebilirsiniz. Sen çok girişli çok çıkışlı modeller bölümüne geçerek verilerdeki bu konuda daha fazla ayrıntı bulabilirsiniz.

Varsayılan ayarlardan memnunsanız, çoğu durumda optimize edici, kayıp ve ölçümlerin bir kısayol olarak dize tanımlayıcıları aracılığıyla belirtilebileceğini unutmayın:

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

Daha sonra tekrar kullanmak için model tanımımızı ve derleme adımımızı fonksiyonlara koyalım; onları bu kılavuzda farklı örneklerde birkaç kez arayacağız.

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

Birçok yerleşik optimize edici, kayıp ve ölçüm mevcuttur

Genel olarak, kendi kayıplarınızı, ölçümlerinizi veya optimize edicilerinizi sıfırdan oluşturmanız gerekmeyecek çünkü ihtiyacınız olan şey muhtemelen zaten Keras API'sinin bir parçası olacaktır:

Optimize ediciler:

  • SGD() (veya hızlanmadan)
  • RMSprop()
  • Adam()
  • vb.

kayıplar:

  • MeanSquaredError()
  • KLDivergence()
  • CosineSimilarity()
  • vb.

Metrikler:

  • AUC()
  • Precision()
  • Recall()
  • vb.

Özel kayıplar

Özel bir kayıp oluşturmanız gerekiyorsa, Keras bunu yapmanın iki yolunu sunar.

Birinci yöntem, giriş kabul eden bir işlevi oluşturma içerir y_true ve y_pred . Aşağıdaki örnek, gerçek veriler ile tahminler arasındaki ortalama karesel hatayı hesaplayan bir kayıp fonksiyonunu göstermektedir:

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>

Eğer yanında parametrelerinde götüren bir kayıp fonksiyonunu gerekiyorsa y_true ve y_pred , sen alt sınıf tf.keras.losses.Loss sınıf ve aşağıdaki iki yöntem uygulamak:

  • __init__(self) : parametrelerini kabul senin kaybı fonksiyonunun çağrı sırasında geçmek
  • call(self, y_true, y_pred) : Modelin kaybını hesaplamak için hedefler (y_true) ve model tahminler (y_pred) kullanın

Diyelim ki ortalama kare hatası kullanmak istiyorsunuz, ancak 0,5'ten uzak tahmin değerlerini teşvikten arındıracak ek bir terimle (kategorik hedeflerin tek sıcak kodlu olduğunu ve 0 ile 1 arasında değerler aldığını varsayıyoruz). Bu, modelin fazla kendinden emin olmaması için bir teşvik yaratır, bu da fazla takmayı azaltmaya yardımcı olabilir (denemeden işe yarayıp yaramadığını bilemeyiz!).

Bunu nasıl yapacağınız aşağıda açıklanmıştır:

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>

Özel metrikler

API parçası olmayan bir metrik gerekiyorsa, kolayca sınıflara göre özel metrik oluşturabilirsiniz tf.keras.metrics.Metric sınıfını. 4 yöntem uygulamanız gerekecek:

  • __init__(self) , hangi size metrik için durum değişkenleri yaratacaktır.
  • update_state(self, y_true, y_pred, sample_weight=None) hedefler y_true ve model tahminler durum değişkenlerini güncellemek için y_pred kullanır.
  • result(self) kesin sonuçları hesaplamak için durum değişkenlerini kullanır.
  • reset_state(self) metrik durumunu reinitializes.

Devlet güncelleme ve sonuçları hesaplama ayrı (tutulur update_state() ve result() bazı durumlarda, sonuçlar hesaplama çok pahalı olabilir çünkü sırasıyla) ve sadece periyodik yapılırdı.

İşte nasıl uygulanacağını gösteren basit bir örnek CategoricalTruePositives metrik birçok örnekler doğru belirli bir sınıfa ait olarak sınıflandırıldı nasıl sayar:

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>

Standart imzaya uymayan kayıpları ve ölçümleri işleme

Kayıpların ve metrik ezici çoğunluğu elde hesaplanabilir y_true ve y_pred nerede, y_pred ama hepsi değil - Modelinizin bir çıkıştır. Örneğin, bir düzenlileştirme kaybı yalnızca bir katmanın etkinleştirilmesini gerektirebilir (bu durumda hedef yoktur) ve bu etkinleştirme bir model çıktısı olmayabilir.

Bu gibi durumlarda, Arayabileceğin self.add_loss(loss_value) özel bir tabakanın çağrı yöntemiyle içinden. Bu şekilde eklenen Zararlar eğitim sırasında "ana" kayıp eklenebilmeniz (geçirilen birine compile() ). İşte aktivite düzenleme ekleyen basit bir örnek (aktivite düzenlemesinin tüm Keras katmanlarında yerleşik olduğunu unutmayın - bu katman yalnızca somut bir örnek sağlamak içindir):

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>

Sen kullanarak, metrik değerleri giriş için aynı şeyi yapabilirsiniz 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>

Gelen Fonksiyonel API , ayrıca çağırabilirsiniz model.add_loss(loss_tensor) veya model.add_metric(metric_tensor, name, aggregation) .

İşte basit bir örnek:

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>

Eğer aracılığıyla kayıpları geçtiğinde Not o add_loss() , bu çağrı mümkün hale compile() model zaten en aza indirmek için bir kayıp olduğundan, bir kayıp fonksiyonu olmadan.

Aşağıdaki düşünün LogisticEndpoint katmanı: Bu girişler hedefleri ve logits olarak alır ve üzerinden bir crossentropy kaybını izler add_loss() . Ayrıca yoluyla sınıflandırma doğruluğunu izler 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)

Bir olmadan derlenmiş iki girişlerin (girdi verileri ve hedefleri), bir modelde kullanabilirsiniz loss böyle argüman:

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>

Çok girişli modelleri eğitme hakkında daha fazla bilgi için bölüm çoklu giriş, çoklu çıkış modellerine veri geçirilmesi bkz.

Bir doğrulama bekletme setini otomatik olarak ayırma

Gördüğünü birinci uç uca örnekte, kullanılan validation_data NumPy diziler bir demet için bağımsız değişkeni (x_val, y_val) her dönemin sonunda bir doğrulama kaybı ve doğrulama ölçümlerini değerlendirilmesi için modele.

Burada başka bir seçenek: argüman validation_split verir doğrulama için eğitim verilerinin otomatik olarak yedek parça için. Bağımsız değişken değeri 0, daha yüksek bir sayı olarak ayarlanır ve Örneğin 1 'den daha düşük olmalıdır, böylece doğrulama için rezerve edilecek veri kısmını temsil validation_split=0.2 araçları "doğrulama için veri% 20", ve validation_split=0.6 araçları "doğrulama için veri% 60".

Doğrulama hesaplanır yolu ile alınan dizilerin son x% numune alarak bir fit() herhangi bir karma önce çağrı.

Not yalnızca kullanabileceği validation_split zaman NumPy verilerle eğitimi.

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 Veri Kümelerinden eğitim ve değerlendirme

Son birkaç paragraf olarak, kayıpları, ölçümleri ve optimize nasıl işleneceğini gördüm ve nasıl kullanılacağı gördüğüm validation_data ve validation_split içinde argümanları fit() , veri NumPy diziler olarak geçirildiğinde.

Verileriniz şeklinde giriyor şimdi durumda bir göz atalım tf.data.Dataset nesne.

tf.data API hızlı ve ölçeklenebilir bir şekilde yaparız yükleme için TensorFlow 2.0 kamu ve önişleme veri kümesidir.

Oluşturma konusunda tam bir kılavuz için Datasets , bkz tf.data belgelerine .

Bir geçebilir Dataset yöntemleri doğrudan örneğini fit() , evaluate() ve 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}

Veri Kümesinin her dönemin sonunda sıfırlandığını ve böylece bir sonraki dönemde yeniden kullanılabileceğini unutmayın.

Bu DataSet gruplar belirli sayıda yalnızca eğitim çalıştırmak istiyorsanız, sen geçebilir steps_per_epoch birçok eğitim sonraki dönemin geçmeden önce bu DataSet kullanarak çalışmalıdır modeli adımları nasıl belirtir argüman.

Bunu yaparsanız, veri kümesi her dönemin sonunda sıfırlanmaz, bunun yerine sonraki partileri çizmeye devam ederiz. Veri kümesi sonunda veri tükenecektir (sonsuz döngülü bir veri kümesi olmadığı sürece).

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>

Doğrulama veri kümesi kullanma

Bir geçebilir Dataset olarak örneğini validation_data içinde argüman 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>

Her dönemin sonunda model, doğrulama veri kümesi üzerinde yinelenecek ve doğrulama kaybı ve doğrulama ölçütlerini hesaplayacaktır.

Yalnızca bu veri kümesi dan partileri belirli sayıda doğrulama çalıştırmak istiyorsanız, sen geçebilir validation_steps birçok doğrulama doğrulama kesintiye ve bir sonraki dönemin geçmeden önce doğrulama veri kümesi ile çalışmalıdır modeli adımları nasıl belirtir argüman:

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>

Doğrulama veri kümesinin her kullanımdan sonra sıfırlanacağını unutmayın (böylece çağdan çağa her zaman aynı örnekler üzerinde değerlendirme yapacaksınız).

Bağımsız değişken validation_split (eğitim verileri bir uzatma grubunun üretilmesi) gelen eğitim sırasında desteklenmez Dataset bu özelliği ile, genel olarak mümkün değildir endeksi yeteneği veri setlerinin örnekleri gerektirdiği için, nesneler Dataset API.

Desteklenen diğer giriş biçimleri

NumPy diziler, istekli tensörlerin ve TensorFlow yanında Datasets , bu Pandalar dataframes kullanarak Keras modeli eğitmek mümkündür, ya da Python jeneratörlerden verilerin ve etiketlerin verim toplu halde.

Özellikle, keras.utils.Sequence sınıf teklifler basit arayüz-çoklu işlem farkında ve karıştırılan olabilir edilir Python veri jeneratörleri inşa etmek.

Genel olarak şunları kullanmanızı öneririz:

  • Verileriniz küçükse ve belleğe sığıyorsa NumPy giriş verileri
  • Dataset Eğer büyük veri kümelerini varsa ve dağıtılan eğitim yapmak gerekirse nesneleri
  • Sequence size büyük veri kümelerini varsa ve (eğer veri yükleme veya ön düzenleme için harici kütüphaneleri itimat eğer örneğin) TensorFlow içinde yapılamaz özel Python tarafın çalışmasında çok yapmak gerekirse itiraz ediyor.

Bir kullanma keras.utils.Sequence girdi olarak nesne

keras.utils.Sequence iki önemli özelliklere sahip bir Python jeneratör elde etmek alt sınıf bir yardımcı programdır:

  • Çoklu işlem ile iyi çalışır.
  • Bu karıştırılan olabilir (örn geçerken shuffle=True içinde fit() ).

Bir Sequence iki yöntem uygulamak gerekir:

  • __getitem__
  • __len__

Yöntem __getitem__ tam bir toplu döndürmelidir. Eğer dönemini arasında veri kümesini değiştirmek isterseniz, uygulayabilir on_epoch_end .

İşte hızlı bir örnek:

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)

Numune ağırlığını ve sınıf ağırlığını kullanma

Varsayılan ayarlarla, bir örneğin ağırlığına, veri kümesindeki frekansına göre karar verilir. Örnekleme frekansından bağımsız olarak verileri ağırlıklandırmanın iki yöntemi vardır:

  • sınıf ağırlıkları
  • Örnek ağırlıklar

sınıf ağırlıkları

Bu bir sözlük ileterek ayarlanır class_weight için argüman Model.fit() . Bu sözlük, sınıf indekslerini bu sınıfa ait örnekler için kullanılması gereken ağırlıkla eşler.

Bu, yeniden örnekleme yapmadan sınıfları dengelemek veya belirli bir sınıfa daha fazla önem veren bir modeli eğitmek için kullanılabilir.

Sınıf "0" Verilerinizde sınıfında "1" olarak temsil yarısı ise Örneğin, şunu kullanabilirsiniz Model.fit(..., class_weight={0: 1., 1: 0.5}) .

Sınıf #5'in (MNIST veri kümesindeki "5" rakamıdır) doğru sınıflandırmasına daha fazla önem vermek için sınıf ağırlıklarını veya örnek ağırlıkları kullandığımız bir NumPy örneği.

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>

Örnek ağırlıklar

İnce taneli kontrol için veya bir sınıflandırıcı oluşturmuyorsanız, "örnek ağırlıkları" kullanabilirsiniz.

  • NumPy verilerinden eğitim Zaman: Pass sample_weight için argüman Model.fit() .
  • Dan eğitim yaparken tf.data veya Yineleyici başka tür: Verim (input_batch, label_batch, sample_weight_batch) demetler.

"Numune ağırlıkları" dizisi, toplam kaybın hesaplanmasında bir partideki her numunenin ne kadar ağırlığa sahip olması gerektiğini belirten bir sayı dizisidir. Dengesiz sınıflandırma problemlerinde yaygın olarak kullanılır (nadir görülen sınıflara daha fazla ağırlık verilmesi fikri).

Kullanılan ağırlıklar ve sıfır olduğunda, dizi kaybı işlevi (tamamen kaybına yol bazı numunelerin katkı atılması) için bir maske olarak kullanılabilir.

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>

İşte eşleşen var Dataset örneği:

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>

Verileri çok girişli, çok çıkışlı modellere geçirme

Önceki örneklerde, tek bir giriş (şekilli bir tensör bir modeli dikkate edildi (764,) ) ve tek bir çıkış (şekilli bir tahmini tensör (10,) ). Peki ya birden fazla girdisi veya çıktısı olan modeller?

Şeklinde bir görüntü girişi, aşağıdaki model göz önünde (32, 32, 3) (diğer bir deyişle en (height, width, channels) ) ve şekilli bir zaman serisi, giriş (None, 10) (en olduğu (timesteps, features) ). Bizim modeli Bu girişlerin kombinasyonundan hesaplanır iki çıkışa sahip olacaktır: bir "puan" (şekil (1,) ) ve (şekil beş sınıfları üzerinde bir olasılık dağılımı (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]
)

Burada ne yaptığımızı açıkça görebilmeniz için bu modeli çizelim (çizimde gösterilen şekillerin numune başına şekiller yerine toplu şekiller olduğuna dikkat edin).

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

png

Derleme zamanında, kayıp fonksiyonlarını bir liste halinde ileterek farklı çıktılara farklı kayıplar belirtebiliriz:

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

Modele sadece tek bir kayıp fonksiyonu iletseydik, her çıktıya aynı kayıp fonksiyonu uygulanırdı (ki bu burada uygun değildir).

Aynı şekilde metrikler için:

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()],
    ],
)

Çıktı katmanlarımıza isimler verdiğimiz için, çıktı başına kayıpları ve ölçümleri bir dict ile de belirtebiliriz:

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'den fazla çıktınız varsa, açık adların ve diktelerin kullanılmasını öneririz.

Bu kullanarak, (örneğin, bir sınıf kaybının önemini 2 katına vererek, ayrıcalık bizim örneğimizde "skor" kayıp isteyebilirsiniz) farklı çıkış özgü kayıpları farklı ağırlıklar vermek mümkündür loss_weights argüman:

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

Bu çıktılar tahmin amaçlıysa ancak eğitim amaçlı değilse, belirli çıktılar için bir kayıp hesaplamamayı da seçebilirsiniz:

# 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()},
)

Çoklu giriş ya da çoklu çıkış modeline veri geçen fit() derleme bir kayıp fonksiyonunu belirlemek gibi benzer bir şekilde çalışır: 1 ile NumPy dizilerin listelerini (geçebilir: 1 eşleme bir kayıp fonksiyonunu alınan çıktılara ) ya da NumPy diziler çıkış adları haritalama 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>

İşte Dataset kullanım durumu: Biz NumPy diziler için ne yaptığını, benzer şekilde Dataset dicts bir başlığın dönmelidir.

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>

Geri aramaları kullanma

Keras'taki geri aramalar, eğitim sırasında farklı noktalarda çağrılan nesnelerdir (bir çağın başlangıcında, bir yığının sonunda, bir çağın sonunda, vb.). Aşağıdakiler gibi belirli davranışları uygulamak için kullanılabilirler:

  • Eğitim sırasında farklı noktalarda doğrulama yapmak (yerleşik dönem başına doğrulamanın ötesinde)
  • Modeli düzenli aralıklarla veya belirli bir doğruluk eşiğini aştığında kontrol etme
  • Eğitim plato gibi göründüğünde modelin öğrenme oranını değiştirme
  • Antrenman plato yapıyor gibi göründüğünde üst katmanların ince ayarını yapmak
  • Eğitim bittiğinde veya belirli bir performans eşiği aşıldığında e-posta veya anlık mesaj bildirimleri gönderme
  • Vb.

Callbacks geçirme ifadenize liste olarak geçirilebilir 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>

Birçok yerleşik geri arama mevcuttur

Keras'ta halihazırda mevcut olan birçok yerleşik geri arama vardır, örneğin:

  • ModelCheckpoint : Periyodik modelini kaydedin.
  • EarlyStopping : Dur eğitim eğitim doğrulama ölçümleri iyileştirilmesi artık olduğunda.
  • TensorBoard : görüntülendi olabilir periyodik yazma modeli günlükleri TensorBoard (bölüm "Görselleştirme" içinde daha fazla ayrıntı).
  • CSVLogger : bir CSV dosyası kaybı ve ölçülerine veriler akışları.
  • vb.

Bkz geri aramaları belgelerine tam listesi için.

Kendi geri aramanızı yazma

Sen taban sınıfı uzatarak özel geri arama oluşturabilir keras.callbacks.Callback . Bir geri arama sınıf özellik sayesinde ilişkili modeline erişimi olan self.model .

Okumak için emin olun , özel geri aramalar yazmaya komple rehber .

Eğitim sırasında toplu iş başına kayıp değerlerinin bir listesini kaydetmeye ilişkin basit bir örnek:

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

Kontrol noktası modelleri

Modelinizi nispeten büyük veri kümelerinde eğitirken, modelinizin kontrol noktalarını sık aralıklarla kaydetmek çok önemlidir.

Bunu başarmak için en kolay yolu ile ModelCheckpoint callback'inde:

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 geri arama hata toleransını uygulamak için kullanılabilir: vaka eğitimde modelin son kaydedilen durumundan yeniden başlatma eğitimi yeteneği rastgele kesintiye uğrar. İşte temel bir örnek:

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>

Ayrıca, modelleri kaydetmek ve geri yüklemek için kendi geri aramanızı yazın.

Serileştirme ve tasarrufuna yönelik tam bir kılavuz için, bkz tasarrufu ve Modeller seri için rehber .

Öğrenme oranı çizelgelerini kullanma

Derin öğrenme modellerini eğitirken yaygın bir kalıp, eğitim ilerledikçe öğrenmeyi kademeli olarak azaltmaktır. Bu genellikle "öğrenme hızı düşüşü" olarak bilinir.

Öğrenme azalma programı statik (mevcut dönemin veya mevcut parti indeksinin bir fonksiyonu olarak önceden sabitlenir) veya dinamik (modelin mevcut davranışına, özellikle doğrulama kaybına yanıt veren) olabilir.

Bir optimize ediciye bir zamanlama geçirme

Kolayca gibi bir zamanlama nesnesi ileterek statik öğrenme hızı çürüme programını kullanabilirsiniz learning_rate sizin optimizer içinde argüman:

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)

Çeşitli dahili içinde programları mevcuttur: ExponentialDecay , PiecewiseConstantDecay , PolynomialDecay ve InverseTimeDecay .

Dinamik bir öğrenme oranı çizelgesi uygulamak için geri aramaları kullanma

Optimize edicinin doğrulama ölçümlerine erişimi olmadığından, dinamik bir öğrenme oranı çizelgesi (örneğin, doğrulama kaybı artık iyileşmediğinde öğrenme oranını azaltmak) bu zamanlama nesneleriyle gerçekleştirilemez.

Ancak, geri aramaların doğrulama ölçümleri dahil tüm ölçümlere erişimi vardır! Böylece, optimize edicideki mevcut öğrenme oranını değiştiren bir geri arama kullanarak bu modeli elde edebilirsiniz. Aslında bu bile yerleşik olarak ReduceLROnPlateau callback'inde.

Eğitim sırasında kayıp ve ölçümleri görselleştirme

Eğitim sırasında modelinize bir göz tutmak için en iyi yolu kullanmaktır TensorBoard - Eğer size sağladığı yerel çalışabileceği tarayıcı tabanlı bir uygulama:

  • Eğitim ve değerlendirme için kayıp ve metriklerin canlı grafikleri
  • (isteğe bağlı olarak) Katman aktivasyonlarınızın histogramlarının görselleştirmeleri
  • (isteğe bağlı olarak) gömme alanlarının 3D görselleştirme sizin tarafından öğrenilen Embedding katmanları

TensorFlow'u pip ile kurduysanız, komut satırından TensorBoard'u başlatabilmeniz gerekir:

tensorboard --logdir=/full_path_to_your_logs

TensorBoard geri aramasını kullanma

Bir Keras modeli ile TensorBoard kullanımı en kolay yolu, fit() yöntemi olup TensorBoard geri arama.

En basit durumda, geri aramanın günlükleri nereye yazmasını istediğinizi belirtmeniz yeterlidir ve hazırsınız:

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>

Daha fazla bilgi için, bkz belgelerine TensorBoard geri arama .