기본 제공 방법을 사용한 교육 및 평가

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() )을 model.predict() .

자신 만의 훈련 단계 함수를 지정하는 동안 fit() 활용 fit() 관심이 있다면 " fit() 에서 일어나는 일 사용자 지정" 가이드를 참조하십시오.

처음부터 자신의 교육 및 평가 루프를 작성하는 데 관심이있는 경우 "처음부터 교육 루프 작성" 가이드를 참조하십시오.

일반적으로 내장 루프를 사용하든 직접 작성하든 상관없이 모델 학습 및 평가는 모든 종류의 Keras 모델 (순차 모델, Functional API로 빌드 된 모델 및 처음부터 작성된 모델)에서 동일한 방식으로 엄격하게 작동합니다. 모델 서브 클래 싱.

이 가이드는 분산 교육을 다루지 않습니다. 분산 교육의 경우 다중 GPU 및 분산 교육 가이드를 참조하세요.

API 개요 : 첫 번째 엔드 투 엔드 예제

모델의 내장 학습 루프에 데이터를 전달할 때 NumPy 배열 (데이터가 작고 메모리에 맞는 경우) 또는 tf.data Dataset 객체를 tf.data Dataset 합니다 . 다음 몇 단락에서는 최적화 도구, 손실 및 메트릭을 사용하는 방법을 보여주기 위해 MNIST 데이터 세트를 NumPy 배열로 사용합니다.

다음 모델을 고려해 보겠습니다 (여기서는 Functional API로 빌드하지만 순차 모델 또는 하위 클래스 모델 일 수도 있음).

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

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

다음은 다음으로 구성된 일반적인 종단 간 워크 플로의 모습입니다.

• 훈련
• 원래 훈련 데이터에서 생성 된 홀드 아웃 세트에 대한 검증
• 테스트 데이터에 대한 평가

이 예에서는 MNIST 데이터를 사용합니다.

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

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

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

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

훈련 구성 (최적화 도구, 손실, 지표)을 지정합니다.

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

데이터를 "batch_size"크기의 "배치"로 분할하고 주어진 "epochs"수에 대해 전체 데이터 세트에 대해 반복적으로 반복하여 모델을 훈련시키는 fit() 호출합니다.

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.5821 - sparse_categorical_accuracy: 0.8361 - val_loss: 0.1893 - val_sparse_categorical_accuracy: 0.9483
Epoch 2/2
782/782 [==============================] - 2s 3ms/step - loss: 0.1676 - sparse_categorical_accuracy: 0.9500 - val_loss: 0.1631 - val_sparse_categorical_accuracy: 0.9488

반환 된 "history"개체는 학습 중 손실 값과 측정 항목 값의 기록을 보유합니다.

history.history

{'loss': [0.344687819480896, 0.15941613912582397],
 'sparse_categorical_accuracy': [0.9019200205802917, 0.9523000121116638],
 'val_loss': [0.1892719268798828, 0.1630939543247223],
 'val_sparse_categorical_accuracy': [0.9483000040054321, 0.9488000273704529]}

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.1750 - sparse_categorical_accuracy: 0.9460
test loss, test acc: [0.17500483989715576, 0.9459999799728394]
Generate predictions for 3 samples
predictions shape: (3, 10)

이제이 워크 플로의 각 부분을 자세히 검토해 보겠습니다.

compile() 메서드 : 손실, 메트릭 및 최적화 프로그램 지정

fit() 하여 모델을 훈련하려면 손실 함수, 최적화 프로그램 및 선택적으로 모니터링 할 일부 메트릭을 지정해야합니다.

compile() 메서드에 대한 인수로 모델에 전달합니다.

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

metrics 인수는 목록이어야합니다. 모델에는 여러 메트릭이있을 수 있습니다.

모델에 여러 출력이있는 경우 각 출력에 대해 서로 다른 손실 및 메트릭을 지정할 수 있으며 모델의 총 손실에 대한 각 출력의 기여도를 조정할 수 있습니다. 이에 대한 자세한 내용은 "다중 입력, 다중 출력 모델로 데이터 전달" 섹션에서 확인할 수 있습니다.

기본 설정에 만족하면 대부분의 경우 최적화 프로그램, 손실 및 메트릭을 문자열 식별자를 통해 바로 가기로 지정할 수 있습니다.

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

나중에 재사용 할 수 있도록 모델 정의를 입력하고 함수에 단계를 컴파일 해 보겠습니다. 이 가이드의 여러 예에서 여러 번 호출 할 것입니다.

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


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

많은 내장 최적화 도구, 손실 및 메트릭을 사용할 수 있습니다.

일반적으로 필요한 것은 이미 Keras API의 일부일 가능성이 높으므로 자신의 손실, 메트릭 또는 최적화 프로그램을 처음부터 새로 만들 필요가 없습니다.

최적화 도구 :

• SGD() (운동량 포함 또는 제외)
• RMSprop()
• Adam()
• 기타

사상자 수:

• MeanSquaredError()
• KLDivergence()
• CosineSimilarity()
• 기타

측정 항목 :

• AUC()
• Precision()
• Recall()
• 기타

맞춤 손실

Keras에 사용자 지정 손실을 제공하는 방법에는 두 가지가 있습니다. 첫 번째 예제는 y_true 및 y_pred 입력을 y_true 함수를 만듭니다. 다음 예는 실제 데이터와 예측 간의 평균 제곱 오차를 계산하는 손실 함수를 보여줍니다.

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.0265

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

y_true 및 y_pred 옆의 매개 변수를받는 손실 함수가 필요한 경우 tf.keras.losses.Loss 클래스를 하위 클래스로 만들고 다음 두 가지 메서드를 구현할 수 있습니다.

• __init__(self) : 손실 함수를 호출하는 동안 전달할 매개 변수를받습니다.
• call(self, y_true, y_pred) : 대상 (y_true) 및 모델 예측 (y_pred)을 사용하여 모델의 손실을 계산합니다.

평균 제곱 오차를 사용하고 싶지만 0.5에서 멀리 떨어진 예측 값의 인센티브를 해제하는 추가 용어를 사용한다고 가정 해 보겠습니다 (범주 형 대상이 원-핫 인코딩되고 0과 1 사이의 값을 취한다고 가정합니다). 이것은 모델이 너무 자신감을 가지지 않도록 인센티브를 생성하여 과적 합을 줄이는 데 도움이 될 수 있습니다 (시도 할 때까지 작동하는지 알 수 없습니다!).

방법은 다음과 같습니다.

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

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


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

y_train_one_hot = tf.one_hot(y_train, depth=10)
model.fit(x_train, y_train_one_hot, batch_size=64, epochs=1)

782/782 [==============================] - 2s 2ms/step - loss: 0.0485

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

맞춤 측정 항목

API의 일부가 아닌 지표가 필요한 경우 tf.keras.metrics.Metric 클래스를 하위 클래스로 지정하여 사용자 지정 지표를 쉽게 만들 수 있습니다. 네 가지 방법을 구현해야합니다.

• __init__(self) , 여기서 지표에 대한 상태 변수를 생성합니다.
• update_state(self, y_true, y_pred, sample_weight=None) , 대상 y_true 및 모델 예측 y_pred를 사용하여 상태 변수를 업데이트합니다.
• result(self) , 상태 변수를 사용하여 최종 결과를 계산합니다.
• reset_states(self) , 측정 항목의 상태를 다시 초기화합니다.

경우에 따라 결과 계산이 매우 비싸고 주기적으로 만 수행되기 때문에 상태 업데이트 및 결과 계산은 별도로 유지됩니다 (각각 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 [==============================] - 3s 2ms/step - loss: 0.5801 - categorical_true_positives: 22009.8493
Epoch 2/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1717 - categorical_true_positives: 23861.7190
Epoch 3/3
782/782 [==============================] - 2s 2ms/step - loss: 0.1200 - categorical_true_positives: 24233.9246

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

표준 서명에 맞지 않는 손실 및 메트릭 처리

압도적 대부분의 손실 및 측정 항목은 y_true 및 y_pred 에서 계산할 수 있습니다. 여기서 y_pred 는 모델의 출력입니다. 그러나 그들 모두는 아닙니다. 예를 들어, 정규화 손실은 레이어의 활성화 만 요구할 수 있으며 (이 경우에는 타겟이 없음)이 활성화는 모델 출력이 아닐 수 있습니다.

이러한 경우 사용자 정의 레이어의 호출 메서드 내부에서 self.add_loss(loss_value) 를 호출 할 수 있습니다. 이런 식으로 추가 된 손실은 훈련 중에 "주된"손실에 추가됩니다 ( compile() 전달 된 손실). 다음은 활동 정규화를 추가하는 간단한 예입니다 (활동 정규화는 모든 Keras 레이어에 내장되어 있습니다.이 레이어는 구체적인 예를 제공하기위한 것입니다).

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


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

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

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

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

# The displayed loss will be much higher than before
# due to the regularization component.
model.fit(x_train, y_train, batch_size=64, epochs=1)

782/782 [==============================] - 2s 2ms/step - loss: 3.2794

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

add_metric() 사용하여 메트릭 값을 로깅 할 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.5627 - std_of_activation: 0.9609

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

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 [==============================] - 2s 2ms/step - loss: 3.6785 - std_of_activation: 0.0020

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

add_loss() 를 통해 손실을 전달하면 모델에 이미 최소화 할 손실이 있으므로 손실 함수없이 compile() 을 호출 할 수 있습니다.

다음 LogisticEndpoint 계층을 고려하십시오. 입력 대상 및 로짓으로 취하고 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 260ms/step - loss: 1.0546 - binary_accuracy: 0.0000e+00

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

다중 입력 모델 학습에 대한 자세한 내용은 다중 입력, 다중 출력 모델에 데이터 전달 섹션을 참조하십시오.

검증 홀드 아웃 세트 자동 설정

첫 번째 엔드 투 엔드 예제에서 validation_data 인수를 사용하여 NumPy 배열 (x_val, y_val) 의 튜플을 모델에 전달하여 각 (x_val, y_val) 때 유효성 검사 손실 및 유효성 검사 메트릭을 평가했습니다.

또 다른 옵션이 있습니다. validation_split 인수를 사용하면 validation_split 을 위해 학습 데이터의 일부를 자동으로 예약 할 수 있습니다. 인수 값은 유효성 검사를 위해 예약 할 데이터의 비율을 나타내므로 0보다 크고 1보다 작은 숫자로 설정해야합니다. 예를 들어 validation_split=0.2 는 "유효성 검사를 위해 데이터의 20 % 사용"을 의미합니다. validation_split=0.6 은 " validation_split=0.6 을 위해 데이터의 60 % 사용"을 의미합니다.

유효성 검사가 계산되는 방식은 임의의 셔플 링 전에 fit 호출에서 수신 한 배열의 마지막 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 [==============================] - 2s 3ms/step - loss: 0.6332 - sparse_categorical_accuracy: 0.8232 - val_loss: 0.2352 - val_sparse_categorical_accuracy: 0.9284

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

tf.data 데이터 세트의 교육 및 평가

지난 몇 단락에서 손실, 측정 항목 및 최적화 프로그램을 처리하는 방법을 살펴 보았고 데이터가 NumPy 배열로 전달 될 때 validation_data 및 validation_split 인수를 적합하게 사용하는 방법을 살펴 보았습니다.

이제 데이터가tf.data.Dataset 객체의 형태로 제공되는 경우를 살펴 보겠습니다.

tf.data API는 빠르고 확장 가능한 방식으로 데이터를로드하고 사전 처리하기위한 TensorFlow 2.0의 유틸리티 세트입니다.

Datasets 생성에 대한 전체 가이드는 tf.data 문서를 참조하세요.

Dataset 인스턴스를 fit() , evaluate() 및 predict() 메서드 fit() 직접 전달할 수 있습니다.

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.5405 - sparse_categorical_accuracy: 0.8524
Epoch 2/3
782/782 [==============================] - 2s 3ms/step - loss: 0.1624 - sparse_categorical_accuracy: 0.9517
Epoch 3/3
782/782 [==============================] - 2s 3ms/step - loss: 0.1150 - sparse_categorical_accuracy: 0.9660
Evaluate
157/157 [==============================] - 0s 2ms/step - loss: 0.1337 - sparse_categorical_accuracy: 0.9583

{'loss': 0.13374954462051392, 'sparse_categorical_accuracy': 0.958299994468689}

데이터 세트는 각 에포크가 끝날 때 재설정되므로 다음 에포크에서 다시 사용할 수 있습니다.

이 데이터 세트의 특정 배치 수에 대해서만 학습을 실행하려면 다음 세대로 이동하기 전에이 데이터 세트를 사용하여 모델이 실행해야하는 학습 단계 수를 지정하는 steps_per_epoch 인수를 전달할 수 있습니다.

이렇게하면 데이터 세트가 각 세대가 끝날 때 재설정되지 않고 대신 다음 배치를 계속 그립니다. 데이터 세트는 결국 데이터가 부족합니다 (무한 반복 데이터 세트가 아닌 경우).

model = get_compiled_model()

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

# Only use the 100 batches per epoch (that's 64 * 100 samples)
model.fit(train_dataset, epochs=3, steps_per_epoch=100)

Epoch 1/3
100/100 [==============================] - 1s 3ms/step - loss: 1.2317 - sparse_categorical_accuracy: 0.6776
Epoch 2/3
100/100 [==============================] - 0s 2ms/step - loss: 0.3834 - sparse_categorical_accuracy: 0.8949
Epoch 3/3
100/100 [==============================] - 0s 3ms/step - loss: 0.3568 - sparse_categorical_accuracy: 0.8912

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

유효성 검사 데이터 세트 사용

fit() 에서 validation_data 인수로 Dataset 인스턴스를 전달할 수 있습니다.

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.5587 - sparse_categorical_accuracy: 0.8436 - val_loss: 0.1735 - val_sparse_categorical_accuracy: 0.9517

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

각 세대가 끝날 때 모델은 유효성 검사 데이터 세트를 반복하고 유효성 검사 손실 및 유효성 검사 메트릭을 계산합니다.

이 데이터 세트에서 특정 수의 배치에 대해서만 유효성 검사를 실행하려면 validation_steps 인수를 전달하면됩니다.이 인수는 유효성 검사를 중단하고 다음 세대로 이동하기 전에 유효성 검사 데이터 세트로 모델이 실행해야하는 유효성 검사 단계 수를 지정합니다.

model = get_compiled_model()

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

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

model.fit(
    train_dataset,
    epochs=1,
    # Only run validation using the first 10 batches of the dataset
    # using the `validation_steps` argument
    validation_data=val_dataset,
    validation_steps=10,
)

782/782 [==============================] - 3s 3ms/step - loss: 0.5708 - sparse_categorical_accuracy: 0.8453 - val_loss: 0.2911 - val_sparse_categorical_accuracy: 0.9312

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

유효성 검사 데이터 세트는 매번 사용할 때마다 재설정되므로 항상 동일한 샘플에 대해 에포크를 평가하게됩니다.

이 기능을 사용하려면 일반적으로 Dataset API에서 불가능한 데이터 세트의 샘플을 인덱싱 할 수있는 기능이 필요하기 때문에 validation_split (학습 데이터에서 홀드 아웃 집합 생성) 인수는 Dataset 객체에서 학습 할 때 지원되지 않습니다.

지원되는 기타 입력 형식

NumPy 배열, eager tensor 및 TensorFlow Datasets 외에도 Pandas 데이터 프레임을 사용하거나 데이터 및 레이블 배치를 생성하는 Python 생성기에서 Keras 모델을 학습시킬 수 있습니다.

특히 keras.utils.Sequence 클래스는 다중 처리를 인식하고 keras.utils.Sequence 수있는 Python 데이터 생성기를 빌드하기위한 간단한 인터페이스를 제공합니다.

일반적으로 다음을 사용하는 것이 좋습니다.

• 데이터가 작고 메모리에 맞는 경우 NumPy 입력 데이터
• 대규모 데이터 세트가 있고 분산 학습을 수행해야하는 경우 Dataset 객체
• 대용량 데이터 세트가 있고 TensorFlow에서 수행 할 수없는 많은 커스텀 Python 측 처리를 수행해야하는 경우 (예 : 데이터로드 또는 사전 처리를 위해 외부 라이브러리에 의존하는 경우) 객체를 Sequence 합니다.

keras.utils.Sequence 객체를 입력으로 사용

keras.utils.Sequence 는 두 가지 중요한 속성이있는 Python 생성기를 얻기 위해 하위 클래스를 만들 수있는 유틸리티입니다.

• 다중 처리와 잘 작동합니다.
• 셔플 될 수 있습니다 (예 : fit() 에서 shuffle=True 전달시).

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)

샘플 가중치 및 클래스 가중치 사용

기본 설정을 사용하면 샘플의 가중치가 데이터 세트의 빈도에 의해 결정됩니다. 샘플 빈도에 관계없이 데이터에 가중치를 부여하는 두 가지 방법이 있습니다.

• 클래스 가중치
• 샘플 가중치

클래스 가중치

이는 Model.fit() 의 class_weight 인수에 사전을 전달하여 설정됩니다. 이 사전은 클래스 인덱스를이 클래스에 속하는 샘플에 사용해야하는 가중치에 매핑합니다.

이것은 리샘플링없이 클래스의 균형을 맞추거나 특정 클래스에 더 중요한 모델을 훈련시키는 데 사용할 수 있습니다.

예를 들어, 클래스 "0"이 데이터에서 클래스 "1"로 표시된 절반 인 경우 Model.fit(..., class_weight={0: 1., 1: 0.5}) 있습니다.

다음은 클래스 가중치 또는 샘플 가중치를 사용하여 클래스 # 5 (MNIST 데이터 세트의 숫자 "5")의 올바른 분류에 더 많은 중요성을 부여하는 NumPy 예제입니다.

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.6531 - sparse_categorical_accuracy: 0.8268

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

샘플 가중치

세밀한 제어를 위해 또는 분류기를 작성하지 않는 경우 "샘플 가중치"를 사용할 수 있습니다.

• NumPy 데이터에서 학습하는 경우 : sample_weight 인수를 Model.fit() 합니다.
• tf.data 또는 다른 종류의 반복기에서 훈련 할 때 : Yield (input_batch, label_batch, sample_weight_batch) 튜플.

"샘플 가중치"배열은 총 손실을 계산할 때 배치의 각 샘플이 가져야하는 가중치를 지정하는 숫자 배열입니다. 불균형 분류 문제에서 일반적으로 사용됩니다 (드물게 보이지 않는 클래스에 더 많은 가중치를 부여하는 아이디어).

사용 된 가중치가 1과 0 인 경우 배열을 손실 함수의 마스크 로 사용할 수 있습니다 (전체 손실에 대한 특정 샘플의 기여도를 완전히 버림).

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.6471 - sparse_categorical_accuracy: 0.8342

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

다음은 일치하는 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 3ms/step - loss: 0.6161 - sparse_categorical_accuracy: 0.8486

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

다중 입력, 다중 출력 모델에 데이터 전달

이전 예에서는 단일 입력 (형상 텐서 (764,) )과 단일 출력 (형상 예측 텐서 (10,) )이있는 모델을 고려했습니다. 그러나 여러 입력 또는 출력이있는 모델은 어떻습니까?

모양의 이미지 입력 (32, 32, 3) (즉 (height, width, channels) )과 모양의 시계열 입력 (None, 10) (즉 (timesteps, features) )이있는 다음 모델을 고려하십시오. 우리의 모델은 이러한 입력의 조합에서 계산 된 두 개의 출력을 가질 것입니다 : "점수"(모양 (1,) )와 5 개 클래스 (모양 (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)

컴파일 타임에 손실 함수를 목록으로 전달하여 다른 출력에 다른 손실을 지정할 수 있습니다.

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

출력 레이어에 이름을 부여 했으므로 dict를 통해 출력 당 손실 및 메트릭을 지정할 수도 있습니다.

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 개 이상의 출력이있는 경우 명시적인 이름과 사전을 사용하는 것이 좋습니다.

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 [==============================] - 2s 12ms/step - loss: 19.3697 - score_output_loss: 1.3639 - class_output_loss: 18.0058
4/4 [==============================] - 0s 6ms/step - loss: 17.6548 - score_output_loss: 0.7146 - class_output_loss: 16.9402

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

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 29ms/step - loss: 17.3215 - score_output_loss: 0.5076 - class_output_loss: 16.8139

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

콜백 사용

Keras의 콜백은 학습 중 (에포크 시작시, 배치 종료시, 에포크 종료시 등) 다른 지점에서 호출되며 다음과 같은 동작을 구현하는 데 사용할 수있는 객체입니다.

• 훈련 중 다른 지점에서 유효성 검사 수행 (기본 제공 에포크 별 유효성 검사 이상)
• 정기적으로 또는 특정 정확도 임계 값을 초과 할 때 모델 체크 포인트
• 훈련이 정체되는 것처럼 보일 때 모델의 학습률 변경
• 훈련이 정체되는 것처럼 보일 때 최상위 계층의 미세 조정 수행
• 교육이 종료되거나 특정 성능 임계 값이 초과 된 경우 이메일 또는 인스턴트 메시지 알림 보내기
• 기타.

콜백은 fit() 호출에 목록으로 전달할 수 있습니다.

model = get_compiled_model()

callbacks = [
    keras.callbacks.EarlyStopping(
        # Stop training when `val_loss` is no longer improving
        monitor="val_loss",
        # "no longer improving" being defined as "no better than 1e-2 less"
        min_delta=1e-2,
        # "no longer improving" being further defined as "for at least 2 epochs"
        patience=2,
        verbose=1,
    )
]
model.fit(
    x_train,
    y_train,
    epochs=20,
    batch_size=64,
    callbacks=callbacks,
    validation_split=0.2,
)

Epoch 1/20
625/625 [==============================] - 2s 3ms/step - loss: 0.6313 - sparse_categorical_accuracy: 0.8207 - val_loss: 0.2313 - val_sparse_categorical_accuracy: 0.9307
Epoch 2/20
625/625 [==============================] - 2s 3ms/step - loss: 0.1827 - sparse_categorical_accuracy: 0.9459 - val_loss: 0.1989 - val_sparse_categorical_accuracy: 0.9410
Epoch 3/20
625/625 [==============================] - 2s 3ms/step - loss: 0.1298 - sparse_categorical_accuracy: 0.9619 - val_loss: 0.1561 - val_sparse_categorical_accuracy: 0.9529
Epoch 4/20
625/625 [==============================] - 2s 2ms/step - loss: 0.0977 - sparse_categorical_accuracy: 0.9713 - val_loss: 0.1434 - val_sparse_categorical_accuracy: 0.9576
Epoch 5/20
625/625 [==============================] - 2s 3ms/step - loss: 0.0799 - sparse_categorical_accuracy: 0.9755 - val_loss: 0.1364 - val_sparse_categorical_accuracy: 0.9614
Epoch 6/20
625/625 [==============================] - 2s 3ms/step - loss: 0.0648 - sparse_categorical_accuracy: 0.9806 - val_loss: 0.1351 - val_sparse_categorical_accuracy: 0.9617
Epoch 00006: early stopping

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

많은 내장 콜백을 사용할 수 있습니다.

• ModelCheckpoint : 주기적으로 모델을 저장합니다.
• EarlyStopping : 훈련이 더 이상 검증 지표를 개선하지 않을 때 훈련을 중지합니다.
• TensorBoard : 시각화 할 수 있습니다 정기적으로 쓰기 모델 로그 TensorBoard (섹션 "시각화"에서 자세한 내용).
• CSVLogger : 손실 및 메트릭 데이터를 CSV 파일로 스트리밍합니다.
• 기타

전체 목록은 콜백 문서 를 참조하십시오.

자신 만의 콜백 작성

기본 클래스 keras.callbacks.Callback 을 확장하여 사용자 지정 콜백을 만들 수 있습니다. 콜백은 self.model 클래스 속성을 통해 연결된 모델에 액세스 할 수 있습니다.

맞춤 콜백 작성에 대한 전체 가이드 를 읽어보세요.

다음은 훈련 중에 배치 별 손실 값 목록을 저장하는 간단한 예입니다.

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

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

체크 포인트 모델

비교적 큰 데이터 세트에서 모델을 학습하는 경우 모델의 체크 포인트를 빈번한 간격으로 저장하는 것이 중요합니다.

이를 달성하는 가장 쉬운 방법은 ModelCheckpoint 콜백을 사용하는 것입니다.

model = get_compiled_model()

callbacks = [
    keras.callbacks.ModelCheckpoint(
        # Path where to save the model
        # The two parameters below mean that we will overwrite
        # the current checkpoint if and only if
        # the `val_loss` score has improved.
        # The saved model name will include the current epoch.
        filepath="mymodel_{epoch}",
        save_best_only=True,  # Only save a model if `val_loss` has improved.
        monitor="val_loss",
        verbose=1,
    )
]
model.fit(
    x_train, y_train, epochs=2, batch_size=64, callbacks=callbacks, validation_split=0.2
)

Epoch 1/2
625/625 [==============================] - 2s 3ms/step - loss: 0.6208 - sparse_categorical_accuracy: 0.8258 - val_loss: 0.2241 - val_sparse_categorical_accuracy: 0.9326

Epoch 00001: val_loss improved from inf to 0.22410, saving model to mymodel_1
INFO:tensorflow:Assets written to: mymodel_1/assets
Epoch 2/2
625/625 [==============================] - 2s 3ms/step - loss: 0.1820 - sparse_categorical_accuracy: 0.9470 - val_loss: 0.1621 - val_sparse_categorical_accuracy: 0.9497

Epoch 00002: val_loss improved from 0.22410 to 0.16212, saving model to mymodel_2
INFO:tensorflow:Assets written to: mymodel_2/assets

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

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: 1.4324 - sparse_categorical_accuracy: 0.5773INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.96/assets
 193/1563 [==>...........................] - ETA: 5s - loss: 1.1162 - sparse_categorical_accuracy: 0.6814INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.69/assets
 290/1563 [====>.........................] - ETA: 6s - loss: 0.9546 - sparse_categorical_accuracy: 0.7298INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.57/assets
 395/1563 [======>.......................] - ETA: 6s - loss: 0.8447 - sparse_categorical_accuracy: 0.7617INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.51/assets
 493/1563 [========>.....................] - ETA: 6s - loss: 0.7744 - sparse_categorical_accuracy: 0.7817INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.47/assets
 598/1563 [==========>...................] - ETA: 5s - loss: 0.7186 - sparse_categorical_accuracy: 0.7973INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.44/assets
 696/1563 [============>.................] - ETA: 5s - loss: 0.6778 - sparse_categorical_accuracy: 0.8086INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.42/assets
 794/1563 [==============>...............] - ETA: 4s - loss: 0.6445 - sparse_categorical_accuracy: 0.8178INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.40/assets
 898/1563 [================>.............] - ETA: 4s - loss: 0.6146 - sparse_categorical_accuracy: 0.8260INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.38/assets
 995/1563 [==================>...........] - ETA: 3s - loss: 0.5907 - sparse_categorical_accuracy: 0.8326INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.36/assets
1095/1563 [====================>.........] - ETA: 2s - loss: 0.5693 - sparse_categorical_accuracy: 0.8385INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.35/assets
1196/1563 [=====================>........] - ETA: 2s - loss: 0.5503 - sparse_categorical_accuracy: 0.8437INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.34/assets
1297/1563 [=======================>......] - ETA: 1s - loss: 0.5334 - sparse_categorical_accuracy: 0.8484INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.33/assets
1391/1563 [=========================>....] - ETA: 1s - loss: 0.5193 - sparse_categorical_accuracy: 0.8523INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.32/assets
1497/1563 [===========================>..] - ETA: 0s - loss: 0.5050 - sparse_categorical_accuracy: 0.8563INFO:tensorflow:Assets written to: ./ckpt/ckpt-loss=0.31/assets
1563/1563 [==============================] - 11s 6ms/step - loss: 0.4966 - sparse_categorical_accuracy: 0.8586

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

또한 모델 저장 및 복원을위한 자체 콜백 작성을 호출합니다.

직렬화 및 저장에 대한 전체 가이드는 모델 저장 및 직렬화 가이드를 참조하세요.

학습률 일정 사용

딥 러닝 모델을 훈련 할 때 일반적인 패턴은 훈련이 진행됨에 따라 점차적으로 학습을 줄이는 것입니다. 이것은 일반적으로 "학습률 감소"로 알려져 있습니다.

학습 붕괴 일정은 정적 (현재 시대 또는 현재 배치 인덱스의 함수로 미리 고정됨)이거나 동적 (모델의 현재 동작, 특히 검증 손실에 대한 응답) 일 수 있습니다.

최적화 프로그램에 일정 전달

최적화 프로그램에서 learning_rate 인수로 schedule 객체를 전달하여 정적 학습률 감소 일정을 쉽게 사용할 수 있습니다.

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

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

ExponentialDecay , PiecewiseConstantDecay , PolynomialDecay , InverseTimeDecay 몇 가지 기본 제공 일정을 사용할 수 있습니다.

콜백을 사용하여 동적 학습률 일정 구현

최적화 프로그램이 유효성 검사 메트릭에 액세스 할 수 없기 때문에 이러한 일정 개체로 동적 학습률 일정 (예 : 유효성 검사 손실이 더 이상 개선되지 않을 때 학습률 감소)을 달성 할 수 없습니다.

그러나 콜백은 유효성 검사 메트릭을 포함한 모든 메트릭에 액세스 할 수 있습니다! 따라서 최적화 프로그램의 현재 학습률을 수정하는 콜백을 사용하여이 패턴을 얻을 수 있습니다. 사실, 이것은 ReduceLROnPlateau 콜백으로 내장되어 있습니다.

훈련 중 손실 및 메트릭 시각화

학습 중에 모델을 주시하는 가장 좋은 방법은 다음을 제공하는 로컬에서 실행할 수있는 브라우저 기반 애플리케이션 인 TensorBoard 를 사용하는 것입니다.

• 교육 및 평가를위한 손실 및 메트릭의 라이브 플롯
• (선택 사항) 레이어 활성화의 히스토그램 시각화
• (선택 사항) Embedding 레이어에서 학습 한 임베딩 공간의 3D 시각화

pip와 함께 TensorFlow를 설치 한 경우 명령 줄에서 TensorBoard를 시작할 수 있습니다.

tensorboard --logdir=/full_path_to_your_logs

TensorBoard 콜백 사용

Keras 모델 및 fit 메서드와 함께 TensorBoard를 사용하는 가장 쉬운 방법은 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 0x7fb21c22deb8>

자세한 내용 은 TensorBoard 콜백 문서를 참조하세요.