keras开发文档 4：内置方法的训练和评估_(x_train, y_train), (x_test, y_test), min_pixel_va

设置

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
1
2
3

介绍

本指南涵盖使用内置API进行训练和验证时的训练，评估和预测（推断）模型（例如model.fit（），model.evaluate（），model.predict（））。

如果您有兴趣在指定自己的训练步骤函数时利用fit（），请参阅指南“自定义fit（）中发生的事情”。

如果您有兴趣从头开始编写自己的训练和评估循环，请参阅指南“从头开始编写训练循环”。

通常，无论您是使用内置循环还是编写自己的循环，模型训练和评估都在每种Keras模型中严格按照相同的方式工作-顺序模型，使用Functional API构建的模型以及通过模型子类化从头开始编写的模型。

本指南不涉及分布式训练。 有关分布式训练，请参阅我们的多GPU和分布式训练指南。

API概述：第一个端到端示例

将数据传递到模型的内置训练循环时，应该使用NumPy数组（如果数据很小并且适合内存）或tf.data数据集对象。 在接下来的几段中，我们将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)
1
2
3
4
5
6

这是典型的端到端工作流的样子，包括：

• 训练
• 根据原始训练数据生成的保留集进行验证
• 测试数据评估
  在此示例中，我们将使用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]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

我们指定训练配置（优化器，损失，指标）：

model.compile(
    optimizer=keras.optimizers.RMSprop(),  # Optimizer
    # Loss function to minimize
    loss=keras.losses.SparseCategoricalCrossentropy(),
    # List of metrics to monitor
    metrics=[keras.metrics.SparseCategoricalAccuracy()],
)
1
2
3
4
5
6
7

我们调用fit（），它将通过将数据切成大小为“ batch_size”的“批”，然后在给定数量的“历元”内重复遍历整个数据集来训练模型。

print("Fit model on training data")
history = model.fit(
    x_train,
    y_train,
    batch_size=64,
    epochs=2,
    # We pass some validation for
    # monitoring validation loss and metrics
    # at the end of each epoch
    validation_data=(x_val, y_val),
)
1
2
3
4
5
6
7
8
9
10
11

返回的“历史”对象保留训练期间的损失值和度量值的记录：

history.history
1

我们通过 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)
1
2
3
4
5
6
7
8
9
10

现在，让我们详细审查此工作流程的每一部分。

compile（）方法：指定损失，指标和优化器( loss, metrics, and an optimizer)

要使用fit（）训练模型，您需要指定损失函数，优化器以及可选的一些要监视的指标。

您将它们作为compile（）方法的参数传递给模型：

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

metrics参数应为列表-您的模型可以具有任意数量的度量。

如果模型具有多个输出，则可以为每个输出指定不同的损失和指标，并且可以调制每个输出对模型总损失的贡献。 您可以在“将数据传递到多输入，多输出模型”部分中找到有关此内容的更多详细信息。

请注意，如果您对默认设置感到满意，那么在许多情况下，可以通过字符串标识符将优化器，损失和指标指定为快捷方式：

model.compile(
    optimizer="rmsprop",
    loss="sparse_categorical_crossentropy",
    metrics=["sparse_categorical_accuracy"],
)
1
2
3
4
5

为了以后的重用，让我们在函数中放入模型定义和编译步骤。 我们将在本指南的不同示例中多次调用它们。

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

提供许多内置的优化器，损失和指标

通常，您不必从头开始创建自己的损失，指标或优化程序，因为所需的可能已经是Keras API的一部分：

优化器：

• SGD() (with or without momentum)

• RMSprop()

• Adam()

• etc.
  损失：

• MeanSquaredError()

• KLDivergence()

• CosineSimilarity()

• etc.
  指标(Metrics:)：

• AUC()

• Precision()

• Recall()

• etc.

自定义损失

使用Keras提供两种方式来提供自定义损失。 第一个示例创建一个接受输入y_true和y_pred的函数。 以下示例显示了一个损失函数，该函数计算实际数据和预测之间的均方误差：

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


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

# We need to one-hot encode the labels to use MSE
y_train_one_hot = tf.one_hot(y_train, depth=10)
model.fit(x_train, y_train_one_hot, batch_size=64, epochs=1)
1
2
3
4
5
6
7
8
9
10

如果您需要一个损失函数，该函数需要使用y_true和y_pred旁边的参数，则可以对tf.keras.losses.Loss类进行子类化，并实现以下两种方法：

• __init __（self）：接受在损失函数调用期间传递的参数
• call（self，y_true，y_pred）：使用目标（y_true）和模型预测（y_pred）计算模型的损失
  假设您要使用均方误差，但是要加上一个附加项，它会消除激励值远非0.5的动机（我们假设分类目标是一键编码的，且取值介于0到1之间）。 这激励了模型不要过于自信，这可能有助于减少过度拟合（在尝试之前，我们不知道它是否有效！）。

这是您的处理方式：

    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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

自定义指标

如果需要不属于API的指标，则可以通过将tf.keras.metrics.Metric类作为子类来轻松创建自定义指标。 您将需要实现4种方法：

• __init __（self），您将在其中创建度量标准的状态变量。
• update_state（self，y_true，y_pred，sample_weight = None），它使用目标y_true和模型预测y_pred更新状态变量。
• result（self），它使用状态变量来计算最终结果。
• reset_states（self），用于重新初始化指标的状态。
  状态更新和结果计算保持分开（分别在update_state（）和result（）中），因为在某些情况下，结果计算可能会非常昂贵，并且只能定期执行。

这是一个简单的示例，显示了如何实现CategoricalTruePositives指标，该指标计算将多少样本正确分类为属于给定类别的样本：

    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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

处理不符合标准签名的损失和指标

可以从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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

您可以使用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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在Functional API中，您还可以调用model.add_loss（loss_tensor）或model.add_metric（metric_tensor，名称，聚合）。

这是一个简单的例子：

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

请注意，当您通过add_loss（）传递损失时，可以在没有损失函数的情况下调用compile（），因为该模型已经具有最小化的损失。

考虑以下LogisticEndpoint层：它以目标和logit作为输入，并通过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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

您可以在具有两个输入（输入数据和目标）的模型中使用它，而无需损失参数即可进行编译，如下所示：

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15

有关训练多输入模型的更多信息，请参阅将数据传递到多输入，多输出模型部分。

自动区分验证保留集

在您看到的第一个端到端示例中，我们使用了validation_data参数将NumPy数组（x_val，y_val）的元组传递给模型，以在每个时期结束时评估验证损失和验证指标。

这是另一个选择：参数validate_split允许您自动保留部分训练数据以供验证。参数值表示要保留用于验证的数据部分，因此应将其设置为大于0且小于1的数字。例如，validation_split = 0.2表示“使用20％的数据进行验证”，并且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)
1
2

来自tf.data数据集的训练和评估

在过去的几段中，您已经了解了如何处理损失，指标和优化程序，并且已经了解了如何将数据作为NumPy数组传递时如何合适地使用validation_data和validation_split参数。

现在让我们看一下数据以tf.data.Dataset对象形式出现的情况。

tf.data API是TensorFlow 2.0中的一组实用程序，用于以快速且可扩展的方式加载和预处理数据。

有关创建数据集的完整指南，请参阅tf.data文档。

您可以将Dataset实例直接传递给fit（），evaluate（）和predict（）方法：

model = get_compiled_model()

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

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

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

# You can also evaluate or predict on a dataset.
print("Evaluate")
result = model.evaluate(test_dataset)
dict(zip(model.metrics_names, result))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

请注意，数据集会在每个时期结束时重置，因此可以在下一个时期重复使用。

如果您只想对来自此数据集的特定批次进行训练，则可以传递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)
1
2
3
4
5
6
7
8

使用验证数据集

您可以在fit（）中将Dataset实例作为validation_data参数传递：

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)
1
2
3
4
5
6
7
8
9
10
11

在每个时期结束时，模型将遍历验证数据集并计算验证损失和验证指标。

如果只想对该数据集中的特定批次运行验证，则可以传递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,
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

请注意，验证数据集将在每次使用后重置（因此您将始终在同一时期之间评估相同的样本）。

从Dataset 对象进行训练时，不支持参数validation_split（从训练数据生成保留集），因为此功能需要索引数据集样本的能力，而这通常是Dataset API不可能实现的。

支持其他输入格式

除了NumPy数组，渴望的张量和TensorFlow数据集外，还可以使用Pandas数据框或从生成大量数据和标签的Python生成器中训练Keras模型。

特别是，keras.utils.Sequence类提供了一个简单的接口来构建Python数据生成器，该数据生成器可识别多处理并且可以改组。

通常，我们建议您使用：

• NumPy输入数据（如果您的数据很小并且适合内存）
• 数据集对象（如果您有大型数据集，并且需要进行分布式培训）
• 如果您的数据集很大，并且需要执行很多自定义的Python端处理（这在TensorFlow中无法完成），则可以对对象进行排序（例如，如果您依赖外部库进行数据加载或预处理）。

使用keras.utils.Sequence对象作为输入

keras.utils.Sequence是一个实用程序，您可以将其子类化以获得具有两个重要属性的Python生成器：

• 它适用于多处理。

• 可以将其随机播放（例如，在fit（）中传递shuffle = True时）。
  序列必须实现两种方法：

• getitem

• len
  __getitem__方法应返回完整的批处理。如果要在各个时期之间修改数据集，则可以实现on_epoch_end。

这是一个简单的例子：

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

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

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

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

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

sequence = CIFAR10Sequence(filenames, labels, batch_size)
model.fit(sequence, epochs=10)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

使用样本加权和类别加权

在默认设置下，样品的权重由其在数据集中的频率决定。 有两种方法可以对数据进行加权，而与采样频率无关：

• Class权重
• Sample权重

Class权重

这是通过将字典传递给Model.fit（）的class_weight参数来设置的。 该词典将类别索引映射到应用于属于该类别的样本的权重。

这可用于平衡类而不重采样，或用于训练对特定类更为重视的模型。

例如，如果类“ 0”是数据中类“ 1”的一半，则可以使用Model.fit（…，class_weight = {0：1.，1：0.5}）。

这是一个NumPy示例，其中我们使用类权重或样本权重来更加重视5类（在MNIST数据集中的数字“ 5”）的正确分类。

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Sample 权重

为了进行细粒度控制，或者如果您不构建分类器，则可以使用“样本权重”。

从NumPy数据进行训练时：将sample_weight参数传递给Model.fit（）。
从tf.data或任何其他迭代器进行训练时：Yield（input_batch，label_batch，sample_weight_batch）元组。
“样品权重”阵列是一个数字阵列，用于指定批次中每个样品在计算总损失时应具有的权重。 它通常用于不平衡的分类问题（其想法是将更多的权重分配给鲜为人知的类）。

当所使用的权重为1和0时，该数组可用作损失函数的mask（完全丢弃某些样本对总损失的贡献）。

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)
1
2
3
4
5
6

这是一个匹配的数据集示例：

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)
1
2
3
4
5
6
7
8
9
10
11
12

将数据传递到多输入，多输出模型

在前面的示例中，我们考虑的模型具有单个输入（形状的张量（764，））和单个输出（形状的预测张量（10，））。 但是具有多个输入或输出的模型呢？

考虑以下模型，该模型具有形状为（32、32、3）（即（高度，宽度，通道））的图像输入和形状为（None，10）（即（时间步长，特征））的时间序列输入。 我们的模型将具有根据这些输入的组合计算出的两个输出：“得分”（形状（1，））和五类（形状（5，））的概率分布。

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

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

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

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

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

model = keras.Model(
    inputs=[image_input, timeseries_input], outputs=[score_output, class_output]
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

让我们绘制这个模型，以便您可以清楚地看到我们在这里做什么（请注意，图中显示的形状是批处理形状，而不是按样本的形状）。

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

在编译时，通过将损失函数作为列表传递，我们可以为不同的输出指定不同的损失：

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

如果我们仅将单个损失函数传递给模型，则将相同的损失函数应用于每个输出（此处不合适）。

同样对于指标：

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()],
    ],
)
1
2
3
4
5
6
7
8
9
10
11

由于我们将名称命名为输出层，因此我们还可以通过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()],
    },
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

如果您有两个以上的输出，我们建议使用显式名称和字典。

可以使用loss_weights参数为不同的特定于输出的损失赋予不同的权重（例如，在我们的示例中，我们可能希望通过赋予类损失的重要性2倍来赋予“得分”损失以特权）：

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},
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

您还可以选择不为某些输出计算损失，如果这些输出仅用于预测而不是训练：

# 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()},
)
1
2
3
4
5
6
7
8
9
10
11

以合适的方式将数据传递给多输入或多输出模型的方式与在编译中指定损失函数的方式类似：您可以传递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,
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这是数据集的用例：与我们对NumPy数组所做的类似，数据集应返回一个字典元组。

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)
1
2
3
4
5
6
7
8
9

使用回调

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,
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

许多内置的回调可用

• 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"))
1
2
3
4
5
6

检查点模型

在相对较大的数据集上训练模型时，至关重要的是要定期保存模型的检查点。

最简单的方法是使用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
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

您还调用了自己的回调函数来保存和恢复模型。

有关序列化和保存的完整指南，请参见模型的保存和序列化指南。

使用学习率时间表(learning rate schedules)

训练深度学习模型的常见模式是随着训练的进行逐渐减少学习。 这通常称为“学习率衰减”。

学习衰减时间表可以是静态的（根据当前纪元或当前批次索引预先确定），也可以是动态的（响应于模型的当前行为，尤其是验证损失）。

将时间表传递给优化器

通过将计划对象作为优化器中的learning_rate参数传递，您可以轻松使用静态学习率衰减计划：

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

optimizer = keras.optimizers.RMSprop(learning_rate=lr_schedule)
1
2
3
4
5
6

有几个内置的时间表：ExponentialDecay，PiecewiseConstantDecay，PolynomialDecay和InverseTimeDecay。

使用回调实现动态学习率计划

由于优化程序无法访问验证指标，因此无法使用这些计划对象来实现动态学习率计划（例如，当验证损失不再改善时降低学习率）。

但是，回调确实可以访问所有指标，包括验证指标！ 因此，您可以通过使用回调来修改优化程序上的当前学习率，从而实现此模式。 实际上，它甚至是作为ReduceLROnPlateau回调内置的。

可视化训练期间的损失和指标

在训练期间密切关注模型的最佳方法是使用TensorBoard，这是一个基于浏览器的应用程序，您可以在本地运行该程序，为您提供：

• 实时损失图以及用于训练和评估的指标
  -（可选）可视化图层激活的直方图
  -（可选）您的嵌入层学习的嵌入空间的3D可视化
  如果您已通过pip安装了TensorFlow，则应该能够从命令行启动TensorBoard：

tensorboard --logdir=/full_path_to_your_logs
1

使用TensorBoard回调

将TensorBoard与Keras模型一起使用和fit方法的最简单方法是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)
1
2
3
4
5
6

有关更多信息，请参见TensorBoard回调的文档。

参考文献

• Training & evaluation with the built-in methods