翻译: 通过子类创建新层和模型 Making new layers and models via subclassing

1. 类Layer：状态（权重）和一些计算的组合

Keras 的核心抽象之一是类Layer。层封装状态（层的“权重”）和从输入到输出的转换（“调用”，层的前向传递）。

设置

import tensorflow as tf
from tensorflow import keras

这是一个密集连接的层。它有一个状态：变量w和b。

class Linear(keras.layers.Layer):
    def __init__(self, units=32, input_dim=32):
        super().__init__()
        w_init = tf.random_normal_initializer()
        self.w = tf.Variable(
            initial_value=w_init(shape=(input_dim, units), dtype="float32"),
            trainable=True,
        )
        b_init = tf.zeros_initializer()
        self.b = tf.Variable(
            initial_value=b_init(shape=(units,), dtype="float32"), trainable=True
        )

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

您可以通过在某些张量输入上调用它来使用一个层，就像 Python 函数一样。

x = tf.ones((2, 2))
linear_layer = Linear(4, 2)
y = linear_layer(x)
print(y)

tf.Tensor(
[[0.07264713 0.14730662 0.08933581 0.03730425]
 [0.07264713 0.14730662 0.08933581 0.03730425]], shape=(2, 4), dtype=float32)

请注意，权重w和b在设置为层属性后由层自动跟踪：

assert linear_layer.weights == [linear_layer.w, linear_layer.b]

请注意，您还可以使用更快的快捷方式为层添加权重：add_weight()方法：

class Linear(keras.layers.Layer):
    def __init__(self, units=32, input_dim=32):
        super().__init__()
        self.w = self.add_weight(
            shape=(input_dim, units), initializer="random_normal", trainable=True
        )
        self.b = self.add_weight(shape=(units,), initializer="zeros", trainable=True)

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b


x = tf.ones((2, 2))
linear_layer = Linear(4, 2)
y = linear_layer(x)
print(y)

tf.Tensor(
[[-0.02228201  0.04957826 -0.09935614 -0.01868932]
 [-0.02228201  0.04957826 -0.09935614 -0.01868932]], shape=(2, 4), dtype=float32)

2. 图层可以具有不可训练的权重

除了可训练的权重外，您还可以向层添加不可训练的权重。当您训练该层时，在反向传播期间不应考虑此类权重。

以下是添加和使用不可训练的权重的方法：

class ComputeSum(keras.layers.Layer):
    def __init__(self, input_dim):
        super().__init__()
        self.total = tf.Variable(initial_value=tf.zeros((input_dim,)), trainable=False)

    def call(self, inputs):
        self.total.assign_add(tf.reduce_sum(inputs, axis=0))
        return self.total


x = tf.ones((2, 2))
my_sum = ComputeSum(2)
y = my_sum(x)
print(y.numpy())
y = my_sum(x)
print(y.numpy())

[2. 2.]
[4. 4.]

它是 的一部分layer.weights，但它被归类为不可训练的权重：

print("weights:", len(my_sum.weights))
print("non-trainable weights:", len(my_sum.non_trainable_weights))

# It's not included in the trainable weights:
print("trainable_weights:", my_sum.trainable_weights)

weights: 1
non-trainable weights: 1
trainable_weights: []

3. 最佳实践：推迟权重创建，直到知道输入的形状

我们Linear上面的层采用了一个input_dim参数，用于计算权重的形状w和b，in， __init__()：

class Linear(keras.layers.Layer):
    def __init__(self, units=32, input_dim=32):
        super().__init__()
        self.w = self.add_weight(
            shape=(input_dim, units), initializer="random_normal", trainable=True
        )
        self.b = self.add_weight(shape=(units,), initializer="zeros", trainable=True)

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

在许多情况下，您可能事先不知道输入的大小，并且您希望在实例化层之后的某个时间知道该值时懒惰地创建权重。

在 Keras API 中，我们建议在build(self, inputs_shape)层的方法中创建层权重。像这样：

class Linear(keras.layers.Layer):
    def __init__(self, units=32):
        super().__init__()
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer="random_normal",
            trainable=True,
        )
        self.b = self.add_weight(
            shape=(self.units,), initializer="random_normal", trainable=True
        )

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

您层的方法__call__()将在第一次调用时自动运行构建。您现在有了一个惰性层，因此更易于使用：

# At instantiation, we don't know on what inputs this is going to get called
linear_layer = Linear(32)

# The layer's weights are created dynamically the first time the layer is called
y = linear_layer(x)

build()如上所示单独实施可以很好地将仅创建一次权重与在每次调用中使用权重分开。然而，对于一些高级自定义层，将状态创建和计算分开可能变得不切实际。允许层实现者将权重创建推迟到第一个__call__()，但需要注意以后的调用使用相同的权重。此外，由于 call()很可能是在 a 中首次执行tf.function，因此发生在其中的任何变量创建__call__()都应包装在 a 中tf.init_scope。

4. 层是可递归组合的

如果您将一个 Layer 实例分配为另一个 Layer 的属性，则外层将开始跟踪由内层创建的权重。

我们建议在方法中创建这样的子层__init__()，并将其留给第一个__call__()触发建立它们的权重。

class MLPBlock(keras.layers.Layer):
    def __init__(self):
        super().__init__()
        self.linear_1 = Linear(32)
        self.linear_2 = Linear(32)
        self.linear_3 = Linear(1)

    def call(self, inputs):
        x = self.linear_1(inputs)
        x = tf.nn.relu(x)
        x = self.linear_2(x)
        x = tf.nn.relu(x)
        return self.linear_3(x)


mlp = MLPBlock()
y = mlp(tf.ones(shape=(3, 64)))  # The first call to the `mlp` will create the weights
print("weights:", len(mlp.weights))
print("trainable weights:", len(mlp.trainable_weights))

weights: 6
trainable weights: 6

5. 方法add_loss()_

在编写call()层的方法时，您可以创建稍后在编写训练循环时要使用的损失张量。这可以通过调用来实现self.add_loss(value)：

# A layer that creates an activity regularization loss
class ActivityRegularizationLayer(keras.layers.Layer):
    def __init__(self, rate=1e-2):
        super().__init__()
        self.rate = rate

    def call(self, inputs):
        self.add_loss(self.rate * tf.reduce_mean(inputs))
        return inputs

请注意，它add_loss()可以获取普通 TensorFlow 操作的结果。这里不需要调用Loss对象。

这些损失（包括任何内层产生的损失）可以通过 layer.losses. call()此属性在每个顶层层的开始处重置，因此layer.losses始终包含在最后一次前向传递期间创建的损失值。

class OuterLayer(keras.layers.Layer):
    def __init__(self):
        super().__init__()
        self.activity_reg = ActivityRegularizationLayer(1e-2)

    def call(self, inputs):
        return self.activity_reg(inputs)


layer = OuterLayer()
assert len(layer.losses) == 0  # No losses yet since the layer has never been called

_ = layer(tf.zeros(1, 1))
assert len(layer.losses) == 1  # We created one loss value

# `layer.losses` gets reset at the start of each __call__
_ = layer(tf.zeros(1, 1))
assert len(layer.losses) == 1  # This is the loss created during the call above

此外，该loss属性还包含为任何内层的权重创建的正则化损失：

class OuterLayerWithKernelRegularizer(keras.layers.Layer):
    def __init__(self):
        super().__init__()
        self.dense = keras.layers.Dense(
            32, kernel_regularizer=tf.keras.regularizers.l2(1e-3)
        )

    def call(self, inputs):
        return self.dense(inputs)


layer = OuterLayerWithKernelRegularizer()
_ = layer(tf.zeros((1, 1)))

# This is `1e-3 * sum(layer.dense.kernel ** 2)`,
# created by the `kernel_regularizer` above.
print(layer.losses)

[<tf.Tensor: shape=(), dtype=float32, numpy=0.0024072158>]

在编写训练循环时应考虑这些损失，如下所示：

# Instantiate an optimizer.
optimizer = tf.keras.optimizers.SGD(learning_rate=1e-3)
loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)

# Iterate over the batches of a dataset.
for x_batch_train, y_batch_train in train_dataset:
  with tf.GradientTape() as tape:
    logits = layer(x_batch_train)  # Logits for this minibatch
    # Loss value for this minibatch
    loss_value = loss_fn(y_batch_train, logits)
    # Add extra losses created during this forward pass:
    loss_value += sum(model.losses)

  grads = tape.gradient(loss_value, model.trainable_weights)
  optimizer.apply_gradients(zip(grads, model.trainable_weights))

有关编写训练循环的详细指南，请参阅
。

这些损失也可以无缝地工作fit()（它们会自动求和并添加到主要损失中，如果有的话）：

import numpy as np

inputs = keras.Input(shape=(3,))
outputs = ActivityRegularizationLayer()(inputs)
model = keras.Model(inputs, outputs)

# If there is a loss passed in `compile`, the regularization
# losses get added to it
model.compile(optimizer="adam", loss="mse")
model.fit(np.random.random((2, 3)), np.random.random((2, 3)))

# It's also possible not to pass any loss in `compile`,
# since the model already has a loss to minimize, via the `add_loss`
# call during the forward pass!
model.compile(optimizer="adam")
model.fit(np.random.random((2, 3)), np.random.random((2, 3)))

1/1 [==============================] - 0s 52ms/step - loss: 0.0717
1/1 [==============================] - 0s 23ms/step - loss: 0.0069

<keras.callbacks.History at 0x7fa01c68f7f0>

6. 方法add_metric()_

与 类似add_loss()，层也有一种add_metric()在训练期间跟踪数量移动平均值的方法。

考虑以下层：“物流端点”层。它以预测和目标作为输入，计算它通过 跟踪的损失add_loss()，并计算它通过 跟踪的精度标量 add_metric()。

class LogisticEndpoint(keras.layers.Layer):
    def __init__(self, name=None):
        super().__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)

以这种方式跟踪的指标可通过以下方式访问layer.metrics：

layer = LogisticEndpoint()

targets = tf.ones((2, 2))
logits = tf.ones((2, 2))
y = layer(targets, logits)

print("layer.metrics:", layer.metrics)
print("current accuracy value:", float(layer.metrics[0].result()))

layer.metrics: [<keras.metrics.BinaryAccuracy object at 0x7fa01c640850>]
current accuracy value: 1.0

就像 for 一样add_loss()，这些指标由以下人员跟踪fit()：

inputs = keras.Input(shape=(3,), name="inputs")
targets = keras.Input(shape=(10,), name="targets")
logits = keras.layers.Dense(10)(inputs)
predictions = LogisticEndpoint(name="predictions")(targets, logits)

model = keras.Model(inputs=[inputs, targets], outputs=predictions)
model.compile(optimizer="adam")

data = {
    
    
    "inputs": np.random.random((3, 3)),
    "targets": np.random.random((3, 10)),
}
model.fit(data)

1/1 [==============================] - 0s 126ms/step - loss: 0.7173 - binary_accuracy: 0.0000e+00

<keras.callbacks.History at 0x7fa01c695820>

7. 您可以选择在图层上启用序列化

如果您需要将自定义层作为功能模型的一部分进行序列化 ，您可以选择实现一个get_config() 方法：

class Linear(keras.layers.Layer):
    def __init__(self, units=32):
        super().__init__()
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer="random_normal",
            trainable=True,
        )
        self.b = self.add_weight(
            shape=(self.units,), initializer="random_normal", trainable=True
        )

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

    def get_config(self):
        return {
    
    "units": self.units}


# Now you can recreate the layer from its config:
layer = Linear(64)
config = layer.get_config()
print(config)
new_layer = Linear.from_config(config)

{'units': 64}

请注意，init()基Layer类的方法采用一些关键字参数，特别是 a name和 a dtype。将这些参数传递给父类__init__()并将它们包含在层配置中是一种很好的做法：

class Linear(keras.layers.Layer):
    def __init__(self, units=32, **kwargs):
        super().__init__(**kwargs)
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer="random_normal",
            trainable=True,
        )
        self.b = self.add_weight(
            shape=(self.units,), initializer="random_normal", trainable=True
        )

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

    def get_config(self):
        config = super().get_config()
        config.update({
    
    "units": self.units})
        return config


layer = Linear(64)
config = layer.get_config()
print(config)
new_layer = Linear.from_config(config)

{'name': 'linear_8', 'trainable': True, 'dtype': 'float32', 'units': 64}

如果在从其配置反序列化图层时需要更大的灵活性，您还可以重写from_config()类方法。这是以下的基本实现from_config()：

def from_config(cls, config):
  return cls(**config)

指南。

8. 方法中的特权training参数call()

一些层，特别是BatchNormalizationlayer 和Dropout layer，在训练和推理过程中有不同的行为。对于这样的层，标准做法是training在方法中公开一个（布尔）参数call()。

通过在 中公开此参数call()，您可以启用内置训练和评估循环（例如fit()）以在训练和推理中正确使用该层。

class CustomDropout(keras.layers.Layer):
    def __init__(self, rate, **kwargs):
        super().__init__(**kwargs)
        self.rate = rate

    def call(self, inputs, training=None):
        if training:
            return tf.nn.dropout(inputs, rate=self.rate)
        return inputs

8.1 方法中的特权mask参数call()

支持的另一个特权参数call()是mask参数。

您会在所有 Keras RNN 层中找到它。掩码是一个布尔张量（输入中每个时间步一个布尔值），用于在处理时间序列数据时跳过某些输入时间步。

当前一层生成掩码时，Keras 会自动将正确的mask参数传递给支持它的层。call()Mask-generating 层是Embedding 配置了的层mask_zero=True，和Masking层。

要了解有关掩码以及如何编写启用掩码的层的更多信息，请查看指南 “
”。

8.2 The Class Model

通常，您将使用该类Layer来定义内部计算块，并将使用该类Model来定义外部模型——您将训练的对象。

例如，在 ResNet50 模型中，您将有几个 ResNet 块子类化Layer，一个Model包含整个 ResNet50 网络。

该类Model具有与 相同的 API Layer，但有以下区别：

• 它公开了内置的训练、评估和预测循环 ( model.fit(), model.evaluate(), model.predict())。
• 它通过属性公开其内层列表model.layers。
• 它公开保存和序列化 API（save()，save_weights()…）

实际上，该类Layer对应于我们在文献中称为“层”（如“卷积层”或“循环层”）或“块”（如“ResNet 块”或“Inception 块”） .

同时，该类Model对应于文献中称为“模型”（如“深度学习模型”）或“网络”（如“深度神经网络”）的内容。

因此，如果您想知道“我应该使用Layerclass 还是Modelclass？”，问问自己：我需要调用fit()它吗？我需要打电话吗save() ？如果是这样，请继续Model。如果不是（因为你的类只是更大系统中的一个块，或者因为你自己编写培训和保存代码），请使用Layer.

例如，我们可以采用上面的 mini-resnet 示例，并使用它来构建一个Model我们可以使用 进行训练fit()并可以使用 保存的网络 save_weights()：

class ResNet(tf.keras.Model):

    def __init__(self, num_classes=1000):
        super().__init__()
        self.block_1 = ResNetBlock()
        self.block_2 = ResNetBlock()
        self.global_pool = layers.GlobalAveragePooling2D()
        self.classifier = Dense(num_classes)

    def call(self, inputs):
        x = self.block_1(inputs)
        x = self.block_2(x)
        x = self.global_pool(x)
        return self.classifier(x)


resnet = ResNet()
dataset = ...
resnet.fit(dataset, epochs=10)
resnet.save(filepath)

9. 把它们放在一起：一个端到端的例子

以下是您到目前为止所学到的内容：

• ALayer封装一个状态（在__init__()或中创建build()）和一些计算（在 中定义call()）。
• 层可以递归嵌套以创建新的、更大的计算块。
• 层可以创建和跟踪损失（通常是正则化损失）以及指标，通过add_loss()和add_metric()
• 外部容器，即您要训练的东西，是一个Model. AModel就像一个Layer，但增加了训练和序列化实用程序。

让我们将所有这些东西放在一个端到端的示例中：我们将实现一个变分自动编码器 (VAE)。我们将在 MNIST 数字上训练它。

我们的 VAE 将是 的子类Model，构建为子类的层的嵌套组合Layer。它将具有正则化损失（KL 散度）。

from tensorflow.keras import layers


class Sampling(layers.Layer):
    """Uses (z_mean, z_log_var) to sample z, the vector encoding a digit."""

    def call(self, inputs):
        z_mean, z_log_var = inputs
        batch = tf.shape(z_mean)[0]
        dim = tf.shape(z_mean)[1]
        epsilon = tf.keras.backend.random_normal(shape=(batch, dim))
        return z_mean + tf.exp(0.5 * z_log_var) * epsilon


class Encoder(layers.Layer):
    """Maps MNIST digits to a triplet (z_mean, z_log_var, z)."""

    def __init__(self, latent_dim=32, intermediate_dim=64, name="encoder", **kwargs):
        super().__init__(name=name, **kwargs)
        self.dense_proj = layers.Dense(intermediate_dim, activation="relu")
        self.dense_mean = layers.Dense(latent_dim)
        self.dense_log_var = layers.Dense(latent_dim)
        self.sampling = Sampling()

    def call(self, inputs):
        x = self.dense_proj(inputs)
        z_mean = self.dense_mean(x)
        z_log_var = self.dense_log_var(x)
        z = self.sampling((z_mean, z_log_var))
        return z_mean, z_log_var, z


class Decoder(layers.Layer):
    """Converts z, the encoded digit vector, back into a readable digit."""

    def __init__(self, original_dim, intermediate_dim=64, name="decoder", **kwargs):
        super().__init__(name=name, **kwargs)
        self.dense_proj = layers.Dense(intermediate_dim, activation="relu")
        self.dense_output = layers.Dense(original_dim, activation="sigmoid")

    def call(self, inputs):
        x = self.dense_proj(inputs)
        return self.dense_output(x)


class VariationalAutoEncoder(keras.Model):
    """Combines the encoder and decoder into an end-to-end model for training."""

    def __init__(
        self,
        original_dim,
        intermediate_dim=64,
        latent_dim=32,
        name="autoencoder",
        **kwargs
    ):
        super().__init__(name=name, **kwargs)
        self.original_dim = original_dim
        self.encoder = Encoder(latent_dim=latent_dim, intermediate_dim=intermediate_dim)
        self.decoder = Decoder(original_dim, intermediate_dim=intermediate_dim)

    def call(self, inputs):
        z_mean, z_log_var, z = self.encoder(inputs)
        reconstructed = self.decoder(z)
        # Add KL divergence regularization loss.
        kl_loss = -0.5 * tf.reduce_mean(
            z_log_var - tf.square(z_mean) - tf.exp(z_log_var) + 1
        )
        self.add_loss(kl_loss)
        return reconstructed

让我们在 MNIST 上编写一个简单的训练循环：

original_dim = 784
vae = VariationalAutoEncoder(original_dim, 64, 32)

optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
mse_loss_fn = tf.keras.losses.MeanSquaredError()

loss_metric = tf.keras.metrics.Mean()

(x_train, _), _ = tf.keras.datasets.mnist.load_data()
x_train = x_train.reshape(60000, 784).astype("float32") / 255

train_dataset = tf.data.Dataset.from_tensor_slices(x_train)
train_dataset = train_dataset.shuffle(buffer_size=1024).batch(64)

epochs = 2

# Iterate over epochs.
for epoch in range(epochs):
    print("Start of epoch %d" % (epoch,))

    # Iterate over the batches of the dataset.
    for step, x_batch_train in enumerate(train_dataset):
        with tf.GradientTape() as tape:
            reconstructed = vae(x_batch_train)
            # Compute reconstruction loss
            loss = mse_loss_fn(x_batch_train, reconstructed)
            loss += sum(vae.losses)  # Add KLD regularization loss

        grads = tape.gradient(loss, vae.trainable_weights)
        optimizer.apply_gradients(zip(grads, vae.trainable_weights))

        loss_metric(loss)

        if step % 100 == 0:
            print("step %d: mean loss = %.4f" % (step, loss_metric.result()))

Start of epoch 0
step 0: mean loss = 0.3313
step 100: mean loss = 0.1258
step 200: mean loss = 0.0993
step 300: mean loss = 0.0893
step 400: mean loss = 0.0843
step 500: mean loss = 0.0809
step 600: mean loss = 0.0788
step 700: mean loss = 0.0771
step 800: mean loss = 0.0760
step 900: mean loss = 0.0750
Start of epoch 1
step 0: mean loss = 0.0747
step 100: mean loss = 0.0740
step 200: mean loss = 0.0735
step 300: mean loss = 0.0730
step 400: mean loss = 0.0727
step 500: mean loss = 0.0723
step 600: mean loss = 0.0720
step 700: mean loss = 0.0717
step 800: mean loss = 0.0715
step 900: mean loss = 0.0712

请注意，由于 VAE 是子类化的Model，因此它具有内置的训练循环。所以你也可以这样训练它：

vae = VariationalAutoEncoder(784, 64, 32)

optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)

vae.compile(optimizer, loss=tf.keras.losses.MeanSquaredError())
vae.fit(x_train, x_train, epochs=2, batch_size=64)

Epoch 1/2
938/938 [==============================] - 1s 1ms/step - loss: 0.0746
Epoch 2/2
938/938 [==============================] - 1s 1ms/step - loss: 0.0676

<keras.callbacks.History at 0x7fa01c48a250>

10. 超越面向对象开发：函数式 API

这个例子对你来说是不是太面向对象开发了？您还可以使用Functional API构建模型。重要的是，选择一种或另一种风格并不妨碍您利用以另一种风格编写的组件：您始终可以混合搭配。

Sampling例如，下面的函数式 API 示例重用了我们在上面示例中定义的同一层：

original_dim = 784
intermediate_dim = 64
latent_dim = 32

# Define encoder model.
original_inputs = tf.keras.Input(shape=(original_dim,), name="encoder_input")
x = layers.Dense(intermediate_dim, activation="relu")(original_inputs)
z_mean = layers.Dense(latent_dim, name="z_mean")(x)
z_log_var = layers.Dense(latent_dim, name="z_log_var")(x)
z = Sampling()((z_mean, z_log_var))
encoder = tf.keras.Model(inputs=original_inputs, outputs=z, name="encoder")

# Define decoder model.
latent_inputs = tf.keras.Input(shape=(latent_dim,), name="z_sampling")
x = layers.Dense(intermediate_dim, activation="relu")(latent_inputs)
outputs = layers.Dense(original_dim, activation="sigmoid")(x)
decoder = tf.keras.Model(inputs=latent_inputs, outputs=outputs, name="decoder")

# Define VAE model.
outputs = decoder(z)
vae = tf.keras.Model(inputs=original_inputs, outputs=outputs, name="vae")

# Add KL divergence regularization loss.
kl_loss = -0.5 * tf.reduce_mean(z_log_var - tf.square(z_mean) - tf.exp(z_log_var) + 1)
vae.add_loss(kl_loss)

# Train.
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
vae.compile(optimizer, loss=tf.keras.losses.MeanSquaredError())
vae.fit(x_train, x_train, epochs=3, batch_size=64)

Epoch 1/3
938/938 [==============================] - 1s 1ms/step - loss: 0.0746
Epoch 2/3
938/938 [==============================] - 1s 1ms/step - loss: 0.0676
Epoch 3/3
938/938 [==============================] - 1s 1ms/step - loss: 0.0676

<keras.callbacks.History at 0x7fa01c2f76a0>

有关更多信息，请务必阅读
。

参考

https://keras.io/guides/making_new_layers_and_models_via_subclassing/