TensorFlow2——Keras概述

 

1、导入 tf.keras

tf.keras是TensorFlow对Keras API规范的实现。这是一个用于构建和训练模型的高级API，其中包括对TensorFlow特定功能的一级支持，例如 eager execution, tf.data和估计器。tf.keras使TensorFlow更易于使用，而不牺牲灵活性和性能。

import tensorflow as tf
from tensorflow import keras

 

2、建立一个简单的模型

Sequential model

在Keras中，可以组装层来构建模型。模型通常是一个层次图。最常见的模型类型是一堆层：tf.keras.Sequential模型。
构建一个简单、完全连接的网络（即多层感知器）：

model = tf.keras.Sequential()
# Adds a densely-connected layer with 64 units to the model:
model.add(layers.Dense(64, activation='relu'))
# Add another:
model.add(layers.Dense(64, activation='relu'))
# Add an output layer with 10 output units:
model.add(layers.Dense(10))

Configure the layers

有许多tf.keras.layers可用。大多数都有一些共同的构造函数参数：

1. activation：设置层的激活函数。默认情况下，不使用激活。
2. kernel_initializer 和 bias_initializer：创建层权重（kernel和bias）的初始化方案。kernel_initializer默认为“Glorot uniform”，而bias_initializer默认为零。
3. kernel_regularizer 和 bias_regularizer：应用层的权重（kernel和bias）的正则化方案，如L1或L2正则化。默认情况下，不应用正则化。

# Create a relu layer:
layers.Dense(64, activation='relu')
# Or:
layers.Dense(64, activation=tf.nn.relu)

# A linear layer with L1 regularization of factor 0.01 applied to the kernel matrix:
layers.Dense(64, kernel_regularizer=tf.keras.regularizers.l1(0.01))

# A linear layer with L2 regularization of factor 0.01 applied to the bias vector:
layers.Dense(64, bias_regularizer=tf.keras.regularizers.l2(0.01))

# A linear layer with a kernel initialized to a random orthogonal matrix:
layers.Dense(64, kernel_initializer='orthogonal')

# A linear layer with a bias vector initialized to 2.0s:
layers.Dense(64, bias_initializer=tf.keras.initializers.Constant(2.0))

 

3、训练和评估

设置训练

模型建立后，通过调用编译方法配置其学习过程：

model = tf.keras.Sequential([
# Adds a densely-connected layer with 64 units to the model:
layers.Dense(64, activation='relu', input_shape=(32,)),
# Add another:
layers.Dense(64, activation='relu'),
# Add an output layer with 10 output units:
layers.Dense(10)])

model.compile(optimizer=tf.keras.optimizers.Adam(0.01),
              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

tf.keras.Model.compile 有三个重要参数：

1. optimizer：这个对象指定训练过程。从tf.keras.optimizers模块传递优化器实例，如tf.keras.optimizers.Adam或tf.keras.optimizers.SGD。如果只想使用默认参数，还可以通过字符串（如“adam”或“sgd”）指定优化器。
2. loss：优化过程中最小化的函数。常见的选择包括均方误差（mse）、分类交叉熵（categorical_crossentropy）和二元交叉熵（binary_crossentropy）。损失函数是通过名称指定的，或者通过从tf.keras.Loss模块传递一个可调用对象来指定的。
3. metrics：用于监控训练。这些是tf.keras.metrics模块中的字符串名或可调用项。
4. 此外，为了确保模型训练并急切地求值，您可以确保将run_eagerly=True作为要编译的参数传递。

以下是为训练配置模型的几个示例：

# Configure a model for mean-squared error regression.
model.compile(optimizer=tf.keras.optimizers.Adam(0.01),
              loss='mse',       # mean squared error
              metrics=['mae'])  # mean absolute error

# Configure a model for categorical classification.
model.compile(optimizer=tf.keras.optimizers.RMSprop(0.01),
              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

使用NumPy数据训练

对于小数据集，使用内存中的NumPy数组来训练和评估模型。使用 fit 方法，模型与训练数据“拟合”：

import numpy as np

data = np.random.random((1000, 32))
labels = np.random.random((1000, 10))

model.fit(data, labels, epochs=10, batch_size=32)

tf.keras.Model.fit 有三个重要参数：

1. epochs：训练分为epochs。一个epoch是对整个输入数据的一次迭代（这是在较小的批处理中完成的）。
2. batch_size：当传递NumPy数据时，模型将数据分割成较小的批，并在训练期间在这些批上迭代。此整数指定每个批的大小。请注意，如果样本总数不能除以批次大小，则最后一批可能会更小。
3. validation_data：在对模型进行原型设计时，希望能够轻松地监视模型在某些验证数据上的性能。传递这个参数（输入和标签的元组）允许模型在每个epoch结束时以推理模式显示传递数据的loss和metrics。

import numpy as np

data = np.random.random((1000, 32))
labels = np.random.random((1000, 10))

val_data = np.random.random((100, 32))
val_labels = np.random.random((100, 10))

model.fit(data, labels, epochs=10, batch_size=32,
          validation_data=(val_data, val_labels))

使用tf.data数据集训练

使用Datasets API扩展到大型数据集或多设备训练。将tf.data.Dataset实例传递给fit方法：

# Instantiates a toy dataset instance:
dataset = tf.data.Dataset.from_tensor_slices((data, labels))
dataset = dataset.batch(32)

model.fit(dataset, epochs=10)

这里由于数据集已经生成为批数据，因此此代码段不需要batch_size。

同样的，使用验证（validation）的情况为：

dataset = tf.data.Dataset.from_tensor_slices((data, labels))
dataset = dataset.batch(32)

val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels))
val_dataset = val_dataset.batch(32)

model.fit(dataset, epochs=10,
          validation_data=val_dataset)

评估和预测

tf.keras.Model.evaluate和tf.keras.Model.predict方法可以使用NumPy数据和tf.data.Dataset。

以下是如何评估所提供数据的推理模型的loss和metrics：

# With Numpy arrays
data = np.random.random((1000, 32))
labels = np.random.random((1000, 10))

model.evaluate(data, labels, batch_size=32)

# With a Dataset
dataset = tf.data.Dataset.from_tensor_slices((data, labels))
dataset = dataset.batch(32)

model.evaluate(dataset)

以下是预测最后一层作为NumPy数组提供的数据的输出：

result = model.predict(data, batch_size=32)
print(result.shape)

 

4、建立复杂模型

The Functional API

tf.keras.Sequential模型是一个简单的层堆栈，不能表示任意模型。使用Keras functional API构建复杂的模型拓扑，例如：

1. 多输入模型
2. 多输出模型
3. 具有共享层的模型（同一层称为多次）
4. 具有非顺序数据流的模型（如剩余连接）

使用函数式API构建模型的工作方式如下：

1. 层实例是可调用的，并返回一个张量。
2. 输入张量和输出张量用于定义tf.keras.Model实例。
3. 这个模型就像序列模型一样被训练。

以下示例使用函数式API构建一个简单的、完全连接的网络：

inputs = tf.keras.Input(shape=(32,))  # Returns an input placeholder

# A layer instance is callable on a tensor, and returns a tensor.
x = layers.Dense(64, activation='relu')(inputs)
x = layers.Dense(64, activation='relu')(x)
predictions = layers.Dense(10)(x)

实例化给定输入和输出的模型。

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

# The compile step specifies the training configuration.
model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001),
              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

# Trains for 5 epochs
model.fit(data, labels, batch_size=32, epochs=5)

Model subclassing

通过子类化tf.keras.model并定义自己的forward pass，构建一个完全可定制的模型。在初始化方法中创建层，并将它们设置为类实例的属性。在call方法中定义forward pass。

当启用eager execution时，模型子类化特别有用，因为它允许强制写入前向传递。

注意：如果需要模型始终以命令方式运行，则可以在调用super构造函数时设置dynamic=True。

下面的示例显示了一个子类tf.keras.Model，它使用了一个不必强制运行的自定义前向传递：

class MyModel(tf.keras.Model):
  def __init__(self, num_classes=10):
    super(MyModel, self).__init__(name='my_model')
    self.num_classes = num_classes
    # Define your layers here.
    self.dense_1 = layers.Dense(32, activation='relu')
    self.dense_2 = layers.Dense(num_classes)

  def call(self, inputs):
    # Define your forward pass here,
    # using layers you previously defined (in `__init__`).
    x = self.dense_1(inputs)
    return self.dense_2(x)

实例化新模型类：

model = MyModel(num_classes=10)

# The compile step specifies the training configuration.
model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001),
              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

# Trains for 5 epochs.
model.fit(data, labels, batch_size=32, epochs=5)

Custom layers

通过子类化tf.keras.layers.Layer创建自定义层并实施以下方法：

1. __init__：可选地定义此层要使用的子层。
2. build：创建层的权重。使用“add_weight”方法添加权重。
3. call：定义向前传递。
4. 或者，可以通过实现get_config方法和from_config类方法序列化层。

下面是一个自定义层的示例，它使用内核矩阵实现输入的matmul：

class MyLayer(layers.Layer):

  def __init__(self, output_dim, **kwargs):
    self.output_dim = output_dim
    super(MyLayer, self).__init__(**kwargs)

  def build(self, input_shape):
    # Create a trainable weight variable for this layer.
    self.kernel = self.add_weight(name='kernel',
                                  shape=(input_shape[1], self.output_dim),
                                  initializer='uniform',
                                  trainable=True)

  def call(self, inputs):
    return tf.matmul(inputs, self.kernel)

  def get_config(self):
    base_config = super(MyLayer, self).get_config()
    base_config['output_dim'] = self.output_dim
    return base_config

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

 

5、Callbacks

callback是传递给模型以在训练期间自定义和扩展其行为的对象。可以编写自己的自定义回调，或者使用内置的tf.keras.callbacks包括：

1. tf.keras.callbacks.ModelCheckpoint：定期保存模型的检查点。
2. tf.keras.callbacks.LearningRateScheduler：动态更改学习速率。
3. tf.keras.callbacks.EarlyStopping：验证性能停止改善时中断训练。
4. tf.keras.callbacks.TensorBoard：使用TensorBoard监视模型的行为。

使用tf.keras.callbacks.Callback，将其传递到模型的fit方法：

callbacks = [
  # Interrupt training if `val_loss` stops improving for over 2 epochs
  tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'),
  # Write TensorBoard logs to `./logs` directory
  tf.keras.callbacks.TensorBoard(log_dir='./logs')
]
model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks,
          validation_data=(val_data, val_labels))

 

6、保存和恢复

只保存权重值

保存和加载模型的权值使用 tf.keras.Model.save_weights：

model = tf.keras.Sequential([
layers.Dense(64, activation='relu', input_shape=(32,)),
layers.Dense(10)])

model.compile(optimizer=tf.keras.optimizers.Adam(0.001),
              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

# method 1
# Save weights to a TensorFlow Checkpoint file
model.save_weights('./weights/my_model')
# Restore the model's state,
# this requires a model with the same architecture.
model.load_weights('./weights/my_model')

# method 2
# Save weights to a HDF5 file
model.save_weights('my_model.h5', save_format='h5')
# Restore the model's state
model.load_weights('my_model.h5')

只保存模型配置

模型的配置可以保存，这将序列化模型体系结构，而不使用任何权重。即使没有定义原始模型的代码，保存的配置也可以重新创建和初始化同一模型。Keras支持JSON和YAML序列化格式：

import json
import pprint

# Serialize a model to JSON format
json_string = model.to_json()
print(json_string)
pprint.pprint(json.loads(json_string))
fresh_model = tf.keras.models.model_from_json(json_string)

# Serialize a model to YAML format
yaml_string = model.to_yaml()
print(yaml_string)
fresh_model = tf.keras.models.model_from_yaml(yaml_string)

保存完整的模型

整个模型可以保存到包含权重值、模型配置甚至优化器配置的文件中。这允许您检查模型，并在以后从完全相同的状态恢复训练，而无需访问原始代码。

# Create a simple model
model = tf.keras.Sequential([
  layers.Dense(10, activation='relu', input_shape=(32,)),
  layers.Dense(10)
])
model.compile(optimizer='rmsprop',
              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])
model.fit(data, labels, batch_size=32, epochs=5)


# Save entire model to a HDF5 file
model.save('my_model')

# Recreate the exact same model, including weights and optimizer.
model = tf.keras.models.load_model('my_model')

 

7、Eager execution

Eager execution是一个命令式编程环境，它可以立即评估操作。Keras 不是必需的，但由 tf.keras 支持并且对检查程序和调试很有用。

所有的 tf.keras 模型构建APIs与Eager execution兼容。虽然可以使用Sequential和函数APIs，但Eager execution尤其有利于模型子类化和构建自定义层，这些APIs要求您将前向传递编写为代码（而不是通过组装现有层来创建模型的APIs）。

 

8、分布式（GPUs）

使用tf.distribute.Strategy，tf.keras 模型可以在多个gpu上运行。这个API在多个GPUs上提供分布式训练，几乎不改变现有代码。

目前，tf.distribute.MirroredStrategy 是唯一受支持的分发策略。MirroredStrategy 在一台机器上使用all-reduce进行同步训练的图内复制。要使用distribute.Strategy ，需要将优化器实例化、模型构造和编译嵌套在Strategy的.scope（）中，然后对模型进行训练。

下面的示例将tf.keras.Model分布在一台计算机上的多个GPUs上。

首先，在分布式策略范围内定义一个模型：

strategy = tf.distribute.MirroredStrategy()

with strategy.scope():
  model = tf.keras.Sequential()
  model.add(layers.Dense(16, activation='relu', input_shape=(10,)))
  model.add(layers.Dense(1))

  optimizer = tf.keras.optimizers.SGD(0.2)

  model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
                optimizer=optimizer)

model.summary()

接下来，像往常一样对模型进行数据训练：

x = np.random.random((1024, 10))
y = np.random.randint(2, size=(1024, 1))
x = tf.cast(x, tf.float32)
dataset = tf.data.Dataset.from_tensor_slices((x, y))
dataset = dataset.shuffle(buffer_size=1024).batch(32)

model.fit(dataset, epochs=1)

 

9、参考资料

https://tensorflow.google.cn/guide/keras/overview?hl=zh_cn#save_the_entire_model_in_one_file