Google I / O là một kết quả hoàn hảo! Cập nhật các phiên TensorFlow Xem phiên

Viết các cuộc gọi lại của riêng bạn

Xem trên TensorFlow.org Chạy trong Google Colab Xem nguồn trên GitHub Tải xuống sổ ghi chép

Giới thiệu

Gọi lại là một công cụ mạnh mẽ để tùy chỉnh hành vi của mô hình Keras trong quá trình đào tạo, đánh giá hoặc suy luận. Ví dụ như tf.keras.callbacks.TensorBoard để hình dung tiến trình đào tạo và kết quả với TensorBoard, hoặc tf.keras.callbacks.ModelCheckpoint định kỳ tiết kiệm mô hình của bạn trong thời gian đào tạo.

Trong hướng dẫn này, bạn sẽ tìm hiểu gọi lại Keras là gì, nó có thể làm gì và cách bạn có thể xây dựng lệnh gọi lại của riêng mình. Chúng tôi cung cấp một số bản demo về các ứng dụng gọi lại đơn giản để giúp bạn bắt đầu.

Thành lập

import tensorflow as tf
from tensorflow import keras

Tổng quan về các cuộc gọi lại của Keras

Tất cả các callbacks phân lớp các keras.callbacks.Callback lớp, và ghi đè lên một tập hợp các phương pháp được gọi là ở các giai đoạn khác nhau của đào tạo, thử nghiệm, và dự đoán. Các lệnh gọi lại rất hữu ích để xem các trạng thái bên trong và số liệu thống kê của mô hình trong quá trình đào tạo.

Bạn có thể vượt qua một danh sách các callbacks (như là đối số từ khóa callbacks ) các phương pháp mô hình sau:

Tổng quan về các phương thức gọi lại

Phương pháp toàn cầu

on_(train|test|predict)_begin(self, logs=None)

Gọi vào đầu fit / evaluate / predict .

on_(train|test|predict)_end(self, logs=None)

Gọi vào cuối fit / evaluate / predict .

Các phương pháp cấp lô để đào tạo / kiểm tra / dự đoán

on_(train|test|predict)_batch_begin(self, batch, logs=None)

Được gọi ngay trước khi xử lý một lô trong quá trình đào tạo / thử nghiệm / dự đoán.

on_(train|test|predict)_batch_end(self, batch, logs=None)

Được gọi khi kết thúc đào tạo / kiểm tra / dự đoán một đợt. Trong phương pháp này, logs là một dict chứa các kết quả số liệu.

Phương pháp cấp kỷ nguyên (chỉ đào tạo)

on_epoch_begin(self, epoch, logs=None)

Được gọi vào đầu kỷ nguyên trong quá trình đào tạo.

on_epoch_end(self, epoch, logs=None)

Được gọi vào cuối một kỷ nguyên trong quá trình đào tạo.

Một ví dụ cơ bản

Hãy xem một ví dụ cụ thể. Để bắt đầu, hãy nhập tensorflow và xác định một mô hình Keras tuần tự đơn giản:

# Define the Keras model to add callbacks to
def get_model():
    model = keras.Sequential()
    model.add(keras.layers.Dense(1, input_dim=784))
    model.compile(
        optimizer=keras.optimizers.RMSprop(learning_rate=0.1),
        loss="mean_squared_error",
        metrics=["mean_absolute_error"],
    )
    return model

Sau đó, tải dữ liệu MNIST để đào tạo và thử nghiệm từ API tập dữ liệu Keras:

# Load example MNIST data and pre-process it
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train = x_train.reshape(-1, 784).astype("float32") / 255.0
x_test = x_test.reshape(-1, 784).astype("float32") / 255.0

# Limit the data to 1000 samples
x_train = x_train[:1000]
y_train = y_train[:1000]
x_test = x_test[:1000]
y_test = y_test[:1000]

Bây giờ, hãy xác định một lệnh gọi lại tùy chỉnh đơn giản ghi nhật ký:

  • Khi fit / evaluate / predict lần khởi động và kết thúc
  • Khi mỗi kỷ nguyên bắt đầu và kết thúc
  • Khi mỗi đợt đào tạo bắt đầu và kết thúc
  • Khi mỗi đợt đánh giá (thử nghiệm) bắt đầu và kết thúc
  • Khi mỗi lô suy luận (dự đoán) bắt đầu và kết thúc
class CustomCallback(keras.callbacks.Callback):
    def on_train_begin(self, logs=None):
        keys = list(logs.keys())
        print("Starting training; got log keys: {}".format(keys))

    def on_train_end(self, logs=None):
        keys = list(logs.keys())
        print("Stop training; got log keys: {}".format(keys))

    def on_epoch_begin(self, epoch, logs=None):
        keys = list(logs.keys())
        print("Start epoch {} of training; got log keys: {}".format(epoch, keys))

    def on_epoch_end(self, epoch, logs=None):
        keys = list(logs.keys())
        print("End epoch {} of training; got log keys: {}".format(epoch, keys))

    def on_test_begin(self, logs=None):
        keys = list(logs.keys())
        print("Start testing; got log keys: {}".format(keys))

    def on_test_end(self, logs=None):
        keys = list(logs.keys())
        print("Stop testing; got log keys: {}".format(keys))

    def on_predict_begin(self, logs=None):
        keys = list(logs.keys())
        print("Start predicting; got log keys: {}".format(keys))

    def on_predict_end(self, logs=None):
        keys = list(logs.keys())
        print("Stop predicting; got log keys: {}".format(keys))

    def on_train_batch_begin(self, batch, logs=None):
        keys = list(logs.keys())
        print("...Training: start of batch {}; got log keys: {}".format(batch, keys))

    def on_train_batch_end(self, batch, logs=None):
        keys = list(logs.keys())
        print("...Training: end of batch {}; got log keys: {}".format(batch, keys))

    def on_test_batch_begin(self, batch, logs=None):
        keys = list(logs.keys())
        print("...Evaluating: start of batch {}; got log keys: {}".format(batch, keys))

    def on_test_batch_end(self, batch, logs=None):
        keys = list(logs.keys())
        print("...Evaluating: end of batch {}; got log keys: {}".format(batch, keys))

    def on_predict_batch_begin(self, batch, logs=None):
        keys = list(logs.keys())
        print("...Predicting: start of batch {}; got log keys: {}".format(batch, keys))

    def on_predict_batch_end(self, batch, logs=None):
        keys = list(logs.keys())
        print("...Predicting: end of batch {}; got log keys: {}".format(batch, keys))

Hãy thử nó ra:

model = get_model()
model.fit(
    x_train,
    y_train,
    batch_size=128,
    epochs=1,
    verbose=0,
    validation_split=0.5,
    callbacks=[CustomCallback()],
)

res = model.evaluate(
    x_test, y_test, batch_size=128, verbose=0, callbacks=[CustomCallback()]
)

res = model.predict(x_test, batch_size=128, callbacks=[CustomCallback()])

Starting training; got log keys: []
Start epoch 0 of training; got log keys: []
...Training: start of batch 0; got log keys: []
...Training: end of batch 0; got log keys: ['loss', 'mean_absolute_error']
...Training: start of batch 1; got log keys: []
...Training: end of batch 1; got log keys: ['loss', 'mean_absolute_error']
...Training: start of batch 2; got log keys: []
...Training: end of batch 2; got log keys: ['loss', 'mean_absolute_error']
...Training: start of batch 3; got log keys: []
...Training: end of batch 3; got log keys: ['loss', 'mean_absolute_error']
Start testing; got log keys: []
...Evaluating: start of batch 0; got log keys: []
...Evaluating: end of batch 0; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 1; got log keys: []
...Evaluating: end of batch 1; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 2; got log keys: []
...Evaluating: end of batch 2; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 3; got log keys: []
...Evaluating: end of batch 3; got log keys: ['loss', 'mean_absolute_error']
Stop testing; got log keys: ['loss', 'mean_absolute_error']
End epoch 0 of training; got log keys: ['loss', 'mean_absolute_error', 'val_loss', 'val_mean_absolute_error']
Stop training; got log keys: ['loss', 'mean_absolute_error', 'val_loss', 'val_mean_absolute_error']
Start testing; got log keys: []
...Evaluating: start of batch 0; got log keys: []
...Evaluating: end of batch 0; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 1; got log keys: []
...Evaluating: end of batch 1; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 2; got log keys: []
...Evaluating: end of batch 2; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 3; got log keys: []
...Evaluating: end of batch 3; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 4; got log keys: []
...Evaluating: end of batch 4; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 5; got log keys: []
...Evaluating: end of batch 5; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 6; got log keys: []
...Evaluating: end of batch 6; got log keys: ['loss', 'mean_absolute_error']
...Evaluating: start of batch 7; got log keys: []
...Evaluating: end of batch 7; got log keys: ['loss', 'mean_absolute_error']
Stop testing; got log keys: ['loss', 'mean_absolute_error']
Start predicting; got log keys: []
...Predicting: start of batch 0; got log keys: []
...Predicting: end of batch 0; got log keys: ['outputs']
...Predicting: start of batch 1; got log keys: []
...Predicting: end of batch 1; got log keys: ['outputs']
...Predicting: start of batch 2; got log keys: []
...Predicting: end of batch 2; got log keys: ['outputs']
...Predicting: start of batch 3; got log keys: []
...Predicting: end of batch 3; got log keys: ['outputs']
...Predicting: start of batch 4; got log keys: []
...Predicting: end of batch 4; got log keys: ['outputs']
...Predicting: start of batch 5; got log keys: []
...Predicting: end of batch 5; got log keys: ['outputs']
...Predicting: start of batch 6; got log keys: []
...Predicting: end of batch 6; got log keys: ['outputs']
...Predicting: start of batch 7; got log keys: []
...Predicting: end of batch 7; got log keys: ['outputs']
Stop predicting; got log keys: []

Việc sử dụng logs dict

Các logs dict chứa giá trị mất mát, và tất cả các số liệu ở phần cuối của một lô hoặc thời đại. Ví dụ bao gồm mất mát và sai số tuyệt đối trung bình.

class LossAndErrorPrintingCallback(keras.callbacks.Callback):
    def on_train_batch_end(self, batch, logs=None):
        print(
            "Up to batch {}, the average loss is {:7.2f}.".format(batch, logs["loss"])
        )

    def on_test_batch_end(self, batch, logs=None):
        print(
            "Up to batch {}, the average loss is {:7.2f}.".format(batch, logs["loss"])
        )

    def on_epoch_end(self, epoch, logs=None):
        print(
            "The average loss for epoch {} is {:7.2f} "
            "and mean absolute error is {:7.2f}.".format(
                epoch, logs["loss"], logs["mean_absolute_error"]
            )
        )


model = get_model()
model.fit(
    x_train,
    y_train,
    batch_size=128,
    epochs=2,
    verbose=0,
    callbacks=[LossAndErrorPrintingCallback()],
)

res = model.evaluate(
    x_test,
    y_test,
    batch_size=128,
    verbose=0,
    callbacks=[LossAndErrorPrintingCallback()],
)

Up to batch 0, the average loss is   30.79.
Up to batch 1, the average loss is  459.11.
Up to batch 2, the average loss is  314.68.
Up to batch 3, the average loss is  237.97.
Up to batch 4, the average loss is  191.76.
Up to batch 5, the average loss is  160.95.
Up to batch 6, the average loss is  138.74.
Up to batch 7, the average loss is  124.85.
The average loss for epoch 0 is  124.85 and mean absolute error is    6.00.
Up to batch 0, the average loss is    5.13.
Up to batch 1, the average loss is    4.66.
Up to batch 2, the average loss is    4.71.
Up to batch 3, the average loss is    4.66.
Up to batch 4, the average loss is    4.69.
Up to batch 5, the average loss is    4.56.
Up to batch 6, the average loss is    4.77.
Up to batch 7, the average loss is    4.77.
The average loss for epoch 1 is    4.77 and mean absolute error is    1.75.
Up to batch 0, the average loss is    5.73.
Up to batch 1, the average loss is    5.04.
Up to batch 2, the average loss is    5.10.
Up to batch 3, the average loss is    5.14.
Up to batch 4, the average loss is    5.37.
Up to batch 5, the average loss is    5.24.
Up to batch 6, the average loss is    5.22.
Up to batch 7, the average loss is    5.16.

Sử dụng self.model thuộc tính

Ngoài việc tiếp nhận thông tin đăng nhập khi một trong những phương pháp của họ được gọi là, callbacks được tiếp cận với mô hình kết hợp với vòng hiện hành đào tạo / đánh giá / suy luận: self.model .

Dưới đây là số ít trong những điều bạn có thể làm với self.model trong một callback:

  • Set self.model.stop_training = True để đào tạo ngay lập tức ngắt.
  • Siêu tham số đột biến của tôi ưu hoa (có sẵn như self.model.optimizer ), chẳng hạn như self.model.optimizer.learning_rate .
  • Lưu mô hình vào các khoảng thời gian.
  • Ghi đầu ra của model.predict() trên một vài mẫu thử nghiệm vào cuối mỗi thời đại, để sử dụng như một kiểm tra sanity trong đào tạo.
  • Trích xuất hình ảnh trực quan của các tính năng trung gian ở cuối mỗi kỷ nguyên, để theo dõi những gì mô hình đang học theo thời gian.
  • Vân vân.

Hãy xem điều này hoạt động trong một vài ví dụ.

Ví dụ về các ứng dụng gọi lại Keras

Dừng lại sớm với mức lỗ tối thiểu

Đây đầu tiên ví dụ chương trình tạo ra một Callback mà dừng đào tạo khi mức tối thiểu sự mất mát đã đạt tới, bằng cách thiết lập thuộc tính self.model.stop_training (boolean). Tùy chọn, bạn có thể cung cấp một cuộc tranh cãi patience để xác định có bao nhiêu thời đại chúng ta nên chờ đợi trước khi dừng lại sau khi đã đạt đến một mức tối thiểu của địa phương.

tf.keras.callbacks.EarlyStopping cung cấp một thực hiện đầy đủ hơn và nói chung.

import numpy as np


class EarlyStoppingAtMinLoss(keras.callbacks.Callback):
    """Stop training when the loss is at its min, i.e. the loss stops decreasing.

  Arguments:
      patience: Number of epochs to wait after min has been hit. After this
      number of no improvement, training stops.
  """

    def __init__(self, patience=0):
        super(EarlyStoppingAtMinLoss, self).__init__()
        self.patience = patience
        # best_weights to store the weights at which the minimum loss occurs.
        self.best_weights = None

    def on_train_begin(self, logs=None):
        # The number of epoch it has waited when loss is no longer minimum.
        self.wait = 0
        # The epoch the training stops at.
        self.stopped_epoch = 0
        # Initialize the best as infinity.
        self.best = np.Inf

    def on_epoch_end(self, epoch, logs=None):
        current = logs.get("loss")
        if np.less(current, self.best):
            self.best = current
            self.wait = 0
            # Record the best weights if current results is better (less).
            self.best_weights = self.model.get_weights()
        else:
            self.wait += 1
            if self.wait >= self.patience:
                self.stopped_epoch = epoch
                self.model.stop_training = True
                print("Restoring model weights from the end of the best epoch.")
                self.model.set_weights(self.best_weights)

    def on_train_end(self, logs=None):
        if self.stopped_epoch > 0:
            print("Epoch %05d: early stopping" % (self.stopped_epoch + 1))


model = get_model()
model.fit(
    x_train,
    y_train,
    batch_size=64,
    steps_per_epoch=5,
    epochs=30,
    verbose=0,
    callbacks=[LossAndErrorPrintingCallback(), EarlyStoppingAtMinLoss()],
)

Up to batch 0, the average loss is   34.62.
Up to batch 1, the average loss is  405.62.
Up to batch 2, the average loss is  282.27.
Up to batch 3, the average loss is  215.95.
Up to batch 4, the average loss is  175.32.
The average loss for epoch 0 is  175.32 and mean absolute error is    8.59.
Up to batch 0, the average loss is    8.86.
Up to batch 1, the average loss is    7.31.
Up to batch 2, the average loss is    6.51.
Up to batch 3, the average loss is    6.71.
Up to batch 4, the average loss is    6.24.
The average loss for epoch 1 is    6.24 and mean absolute error is    2.06.
Up to batch 0, the average loss is    4.83.
Up to batch 1, the average loss is    5.05.
Up to batch 2, the average loss is    4.71.
Up to batch 3, the average loss is    4.41.
Up to batch 4, the average loss is    4.48.
The average loss for epoch 2 is    4.48 and mean absolute error is    1.68.
Up to batch 0, the average loss is    5.84.
Up to batch 1, the average loss is    5.73.
Up to batch 2, the average loss is    7.24.
Up to batch 3, the average loss is   10.34.
Up to batch 4, the average loss is   15.53.
The average loss for epoch 3 is   15.53 and mean absolute error is    3.20.
Restoring model weights from the end of the best epoch.
Epoch 00004: early stopping
<keras.callbacks.History at 0x7fd0843bf510>

Lập kế hoạch tỷ lệ học tập

Trong ví dụ này, chúng tôi chỉ ra cách Gọi lại tùy chỉnh có thể được sử dụng để thay đổi động tốc độ học của trình tối ưu hóa trong quá trình đào tạo.

Xem callbacks.LearningRateScheduler cho một triển khai tổng quát hơn.

class CustomLearningRateScheduler(keras.callbacks.Callback):
    """Learning rate scheduler which sets the learning rate according to schedule.

  Arguments:
      schedule: a function that takes an epoch index
          (integer, indexed from 0) and current learning rate
          as inputs and returns a new learning rate as output (float).
  """

    def __init__(self, schedule):
        super(CustomLearningRateScheduler, self).__init__()
        self.schedule = schedule

    def on_epoch_begin(self, epoch, logs=None):
        if not hasattr(self.model.optimizer, "lr"):
            raise ValueError('Optimizer must have a "lr" attribute.')
        # Get the current learning rate from model's optimizer.
        lr = float(tf.keras.backend.get_value(self.model.optimizer.learning_rate))
        # Call schedule function to get the scheduled learning rate.
        scheduled_lr = self.schedule(epoch, lr)
        # Set the value back to the optimizer before this epoch starts
        tf.keras.backend.set_value(self.model.optimizer.lr, scheduled_lr)
        print("\nEpoch %05d: Learning rate is %6.4f." % (epoch, scheduled_lr))


LR_SCHEDULE = [
    # (epoch to start, learning rate) tuples
    (3, 0.05),
    (6, 0.01),
    (9, 0.005),
    (12, 0.001),
]


def lr_schedule(epoch, lr):
    """Helper function to retrieve the scheduled learning rate based on epoch."""
    if epoch < LR_SCHEDULE[0][0] or epoch > LR_SCHEDULE[-1][0]:
        return lr
    for i in range(len(LR_SCHEDULE)):
        if epoch == LR_SCHEDULE[i][0]:
            return LR_SCHEDULE[i][1]
    return lr


model = get_model()
model.fit(
    x_train,
    y_train,
    batch_size=64,
    steps_per_epoch=5,
    epochs=15,
    verbose=0,
    callbacks=[
        LossAndErrorPrintingCallback(),
        CustomLearningRateScheduler(lr_schedule),
    ],
)

Epoch 00000: Learning rate is 0.1000.
Up to batch 0, the average loss is   26.55.
Up to batch 1, the average loss is  435.15.
Up to batch 2, the average loss is  298.00.
Up to batch 3, the average loss is  225.91.
Up to batch 4, the average loss is  182.66.
The average loss for epoch 0 is  182.66 and mean absolute error is    8.16.

Epoch 00001: Learning rate is 0.1000.
Up to batch 0, the average loss is    7.30.
Up to batch 1, the average loss is    6.22.
Up to batch 2, the average loss is    6.76.
Up to batch 3, the average loss is    6.37.
Up to batch 4, the average loss is    5.98.
The average loss for epoch 1 is    5.98 and mean absolute error is    2.01.

Epoch 00002: Learning rate is 0.1000.
Up to batch 0, the average loss is    4.23.
Up to batch 1, the average loss is    4.56.
Up to batch 2, the average loss is    4.81.
Up to batch 3, the average loss is    4.63.
Up to batch 4, the average loss is    4.67.
The average loss for epoch 2 is    4.67 and mean absolute error is    1.73.

Epoch 00003: Learning rate is 0.0500.
Up to batch 0, the average loss is    6.24.
Up to batch 1, the average loss is    5.62.
Up to batch 2, the average loss is    5.48.
Up to batch 3, the average loss is    5.09.
Up to batch 4, the average loss is    4.68.
The average loss for epoch 3 is    4.68 and mean absolute error is    1.77.

Epoch 00004: Learning rate is 0.0500.
Up to batch 0, the average loss is    3.38.
Up to batch 1, the average loss is    3.83.
Up to batch 2, the average loss is    3.53.
Up to batch 3, the average loss is    3.64.
Up to batch 4, the average loss is    3.76.
The average loss for epoch 4 is    3.76 and mean absolute error is    1.54.

Epoch 00005: Learning rate is 0.0500.
Up to batch 0, the average loss is    3.62.
Up to batch 1, the average loss is    3.79.
Up to batch 2, the average loss is    3.75.
Up to batch 3, the average loss is    3.83.
Up to batch 4, the average loss is    4.37.
The average loss for epoch 5 is    4.37 and mean absolute error is    1.65.

Epoch 00006: Learning rate is 0.0100.
Up to batch 0, the average loss is    6.73.
Up to batch 1, the average loss is    6.13.
Up to batch 2, the average loss is    5.11.
Up to batch 3, the average loss is    4.57.
Up to batch 4, the average loss is    4.21.
The average loss for epoch 6 is    4.21 and mean absolute error is    1.61.

Epoch 00007: Learning rate is 0.0100.
Up to batch 0, the average loss is    3.37.
Up to batch 1, the average loss is    3.83.
Up to batch 2, the average loss is    3.80.
Up to batch 3, the average loss is    3.50.
Up to batch 4, the average loss is    3.31.
The average loss for epoch 7 is    3.31 and mean absolute error is    1.42.

Epoch 00008: Learning rate is 0.0100.
Up to batch 0, the average loss is    5.33.
Up to batch 1, the average loss is    4.84.
Up to batch 2, the average loss is    4.02.
Up to batch 3, the average loss is    3.87.
Up to batch 4, the average loss is    3.85.
The average loss for epoch 8 is    3.85 and mean absolute error is    1.53.

Epoch 00009: Learning rate is 0.0050.
Up to batch 0, the average loss is    1.84.
Up to batch 1, the average loss is    2.75.
Up to batch 2, the average loss is    3.16.
Up to batch 3, the average loss is    3.52.
Up to batch 4, the average loss is    3.34.
The average loss for epoch 9 is    3.34 and mean absolute error is    1.43.

Epoch 00010: Learning rate is 0.0050.
Up to batch 0, the average loss is    2.36.
Up to batch 1, the average loss is    2.91.
Up to batch 2, the average loss is    2.63.
Up to batch 3, the average loss is    2.93.
Up to batch 4, the average loss is    3.17.
The average loss for epoch 10 is    3.17 and mean absolute error is    1.36.

Epoch 00011: Learning rate is 0.0050.
Up to batch 0, the average loss is    3.32.
Up to batch 1, the average loss is    3.02.
Up to batch 2, the average loss is    2.96.
Up to batch 3, the average loss is    2.80.
Up to batch 4, the average loss is    2.92.
The average loss for epoch 11 is    2.92 and mean absolute error is    1.32.

Epoch 00012: Learning rate is 0.0010.
Up to batch 0, the average loss is    4.11.
Up to batch 1, the average loss is    3.70.
Up to batch 2, the average loss is    3.89.
Up to batch 3, the average loss is    3.76.
Up to batch 4, the average loss is    3.45.
The average loss for epoch 12 is    3.45 and mean absolute error is    1.44.

Epoch 00013: Learning rate is 0.0010.
Up to batch 0, the average loss is    3.38.
Up to batch 1, the average loss is    3.34.
Up to batch 2, the average loss is    3.26.
Up to batch 3, the average loss is    3.56.
Up to batch 4, the average loss is    3.62.
The average loss for epoch 13 is    3.62 and mean absolute error is    1.44.

Epoch 00014: Learning rate is 0.0010.
Up to batch 0, the average loss is    2.48.
Up to batch 1, the average loss is    2.38.
Up to batch 2, the average loss is    2.76.
Up to batch 3, the average loss is    2.63.
Up to batch 4, the average loss is    2.66.
The average loss for epoch 14 is    2.66 and mean absolute error is    1.29.
<keras.callbacks.History at 0x7fd08446c290>

Gọi lại Keras tích hợp

Hãy chắc chắn để kiểm tra callbacks Keras hiện bằng cách đọc các tài liệu API . Các ứng dụng bao gồm đăng nhập vào CSV, lưu mô hình, hiển thị số liệu trong TensorBoard và hơn thế nữa!