Tensorflow-Keras教程

1.Keras简介

Keras是一个用于构建和训练深度学习模型的高级API。 它用于快速原型设计,高级研究和生产,具有三个主要优点:

  • 用户友好

    Keras具有针对常见用例优化的简单,一致的界面。 它为用户错误提供清晰且可操作的反馈

  • 模块化和可组合

    Keras模型是通过将可配置的构建块连接在一起而制定的,几乎没有限制。

  • 易于扩展

编写自定义构建块以表达研究的新想法。 创建新图层,损失函数并开发最先进的模型。

1.1 导入 tf.keras

tf.keras是 Keras API 在TensorFlow 里的实现。这是一个高级API,用于构建和训练模型,同时兼容 TensorFlow 的绝大部分功能,比如,eager execution, tf.data模块及 Estimators。 tf.keras使得 TensorFlow 更容易使用,且保持 TF 的灵活性和性能。
首先需要在您的代码开始时导入tf.keras:

import tensorflow as tf
from tensorflow import keras

tf.keras可以运行任何与Keras兼容的代码,但请记住:

  • 最新TensorFlow版本中的tf.keras版本可能与PyPI的最新keras版本不同。 检查tf.keras.version。

  • 保存模型的权重时,tf.keras默认为 checkpoint 格式。 通过save_format ='h5’使用HDF5。

2. 构建一个简单的模型

2.1 Sequential model

在Keras中,您可以组装图层来构建模型。 模型(通常)是图层图。 最常见的模型类型是一堆层:tf.keras.Sequential 模型。
构建一个简单的全连接网络(即多层感知器):

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

2.2 Configure the layers

在 tf.keras.layers 中有很多层,下面是一些通用的构造函数的参数:

  • activation:设置层的激活函数。 此参数由内置函数的名称或可调用对象指定。 默认情况下,不应用任何激活。

  • kernel_initializer 和 bias_initializer:设置层创建时,权重和偏差的初始化方法。指定方法:名称 或 可调用对象。默认为"Glorot uniform" initializer。

  • kernel_regularizer 和 bias_regularizer:设置层的权重、偏差的正则化方法。比如:L1 或 L2 正则。默认为空。

以下实例化tf.keras。 layers.Dense图层使用构造函数参数:

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

# A linear layer with L1 regularization of factor 0.01 applied to the kernel matrix:
layers.Dense(64, kernel_regularizer=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=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=keras.initializers.constant(2.0))

3. Train and evaluate

3.1 Set up training

构建模型后,通过调用compile方法配置其训练过程:

model.compile(optimizer=tf.train.AdamOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

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

  • optimizer:训练过程的优化方法。此参数通过 tf.train 模块的优化方法的实例来指定,比如:AdamOptimizer, RMSPropOptimizer, GradientDescentOptimizer。

  • loss:训练过程中使用的损失函数(通过最小化损失函数来训练模型)。 常见的选择包括:均方误差(mse),categorical_crossentropy和binary_crossentropy。 损失函数由名称或通过从tf.keras.losses模块传递可调用对象来指定。

  • metrics:训练过程中,监测的指标(Used to monitor training)。

指定方法:名称 或 可调用对象 from the tf.keras.metrics 模块。

以下显示了配置培训模型的几个示例:

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

# Configure a model for categorical classification.
model.compile(optimizer=tf.train.RMSPropOptimizer(0.01),
              loss=keras.losses.categorical_crossentropy,
              metrics=[keras.metrics.categorical_accuracy])

3.2 Input NumPy data

对于小的数据集,可以直接使用 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 有三个重要的参数:

  • epochs:训练多少轮。(小批量)

  • batch_size:当传递NumPy数据时,模型将数据分成较小的批次,并在训练期间迭代这些批次。 此整数指定每个批次的大小。 请注意,如果样本总数不能被批量大小整除,则最后一批可能会更小。

  • validation_data:在对模型进行原型设计时,您希望轻松监控其在某些验证数据上的性能。 传递这个参数 - 输入和标签的元组 - 允许模型在每个epoch的末尾以传递数据的推理模式显示损失和度量。

这是使用validation_data的示例:

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))

3.3 Input tf.data datasets

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

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

# Don't forget to specify `steps_per_epoch` when calling `fit` on a dataset.
model.fit(dataset, epochs=10, steps_per_epoch=30)

这里,fit方法使用steps_per_epoch参数 - 这是模型在移动到下一个epoch之前运行的训练步数。 由于数据集生成批量数据,因此此代码段不需要batch_size。
Dataset API 也可以用于验证:

dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32).repeat() val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels)) val_dataset = val_dataset.batch(32).repeat() model.fit(dataset, epochs=10, steps_per_epoch=30, validation_data=val_dataset, validation_steps=3)

3.4 Evaluate and predict

tf.keras.Model.evaluate 和 tf.keras.Model.predict 方法能够使用 NumPy 数据 和 tf.data.Dataset 数据。
要评估所提供数据的推理模式损失和指标:

model.evaluate(x, y, batch_size=32)

model.evaluate(dataset, steps=30)

并且作为NumPy数组,预测所提供数据的推断中最后一层的输出:

model.predict(x, batch_size=32)

model.predict(dataset, steps=30)

4. Build advanced models

4.1 Functional API

tf.keras.Sequential 模型只适用于多层简单堆叠网络,不能表示复杂模型。使用 Keras functional API 可以构建有复杂拓扑结构的模型。比如:

  • 多输入模型(Multi-input models)

  • 多输出模型(Multi-output models)

  • 有共享层的模型(Models with shared layers (the same layer called several times))

  • 具有非顺序数据流的模型(Models with non-sequential data flows (e.g. residual connections))

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

  1. 层实例可调用并返回张量。

  2. 输入 tensors 和输出 tensors 被用来定义一个 tf.keras.Model 实例

  3. 这个模型的训练就像Sequential模型一样。

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

inputs = keras.Input(shape=(32,))  # Returns a placeholder tensor

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

# Instantiate the model given inputs and outputs.
model = keras.Model(inputs=inputs, outputs=predictions)

# The compile step specifies the training configuration.
model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

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

4.2 Model subclassing

通过继承tf.keras.Model并定义自己的前向传递来构建完全可自定义的模型。 在init方法中创建图层并将它们设置为类实例的属性。 在call方法中定义正向传递。

当启用eager执行时,模型子类化特别有用,因为可以强制写入正向传递。

提示:为工作使用正确的API。 虽然模型子类化提供了灵活性,但其代价是更高的复杂性和更多的用户错误机会。 如果可能,请选择功能API。

以下示例显示了使用自定义正向传递的子类tf.keras.Model:

class MyModel(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 = keras.layers.Dense(32, activation='relu')
        self.dense_2 = keras.layers.Dense(num_classes, activation='sigmoid')

    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)

  def compute_output_shape(self, input_shape):
      # You need to override this function if you want to use the subclassed model
      # as part of a functional-style model.
      # Otherwise, this method is optional.
      shape = tf.TensorShape(input_shape).as_list()
      shape[-1] = self.num_classes
      return tf.TensorShape(shape)


# Instantiates the subclassed model.
model = MyModel(num_classes=10)

# The compile step specifies the training configuration.
model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

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

4.3 自定义 layers

通过继承tf.keras.layers.Layer并实现以下方法来创建自定义层:

  • build:创建图层的权重。 使用add_weight方法添加权重。

  • call:定义前向传播过程。

  • compute_output_shape:指定在给定输入形状的情况下如何计算图层的输出形状。

  • 或者,可以通过实现get_config方法和from_config类方法来序列化层。

这里有一个自定义 layer 的例子,该 layer 将输入和一个矩阵进行相乘:

class MyLayer(keras.layers.Layer):

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

    def build(self, input_shape):
        shape = tf.TensorShape((input_shape[1], self.output_dim))
        # Create a trainable weight variable for this layer.
       self.kernel = self.add_weight(name='kernel',
                                    shape=shape,
                                    initializer='uniform',
                                    trainable=True)
    # Be sure to call this at the end
    super(MyLayer, self).build(input_shape)

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

    def compute_output_shape(self, input_shape):
        shape = tf.TensorShape(input_shape).as_list()
        shape[-1] = self.output_dim
        return tf.TensorShape(shape)

    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)

# Create a model using the custom layer
model = keras.Sequential([MyLayer(10),
                          keras.layers.Activation('softmax')])

# The compile step specifies the training configuration
model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

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

5. 回调(Callbacks)

回调是传递给模型的对象,用于在训练期间自定义和扩展其行为。 您可以编写自己的自定义回调,或使用包含以下内置的tf.keras.callbacks:

  • tf.keras.callbacks.ModelCheckpoint:定期保存checkpoints。

  • tf.keras.callbacks.LearningRateScheduler:动态改变学习速率。

  • tf.keras.callbacks.EarlyStopping:当验证集上的性能不再提高时,终止训练。

  • tf.keras.callbacks.TensorBoard:使用TensorBoard 监测模型的行为。

要使用tf.keras.callbacks.Callback,请将其传递给模型的fit方法:

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

6. Save and restore

6.1 Weights only

使用 tf.keras.Model.save_weights 来保存和加载模型的 weights:

# Save weights to a TensorFlow Checkpoint file
model.save_weights('./my_model')

# Restore the model's state,
# this requires a model with the same architecture.
model.load_weights('my_model')

默认情况下,这会以 TensorFlow checkpoint 格式保存模型的 weights。weights 也可以保存为 HDF5 格式(Keras 默认的保存格式):

# 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')

6.2 Configuration only

一个模型的 configuration 可以被保存,序列化过程中不包含任何 weights。保存的 configuration 可以用来重新创建、初始化出相同的模型,即使没有模型原始的定义代码。Keras 支持 JSON,YAML 序列化格式:

# Serialize a model to JSON format
json_string = model.to_json()

# Recreate the model (freshly initialized)
fresh_model = keras.models.model_from_json(json_string)

# Serializes a model to YAML format
yaml_string = model.to_yaml()

# Recreate the model
fresh_model = keras.models.model_from_yaml(yaml_string)

注意:子类模型不可序列化,因为它们的体系结构由调用方法体中的Python代码定义。

6.3 Entire model

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

# Create a trivial model
model = keras.Sequential([
    keras.layers.Dense(10, activation='softmax', input_shape=(32,)),
    keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='rmsprop',
                loss='categorical_crossentropy',
                metrics=['accuracy'])
model.fit(data, targets, batch_size=32, epochs=5)

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

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

7. Eager execution

Eager execution是一个必要的编程环境,可以立即评估操作。 这对于Keras不是必需的,但是由tf.keras支持,对于检查程序和调试很有用。
tf.keras 里所有的模型构建 API 兼容 eager execution。并且,在编写 model subclassing 和 custom layers 时使用 eager execution
虽然可以使用Sequential和函数式API,但是eager execution尤其有利于模型子类化和构建自定义层 - 需要您将正向传递作为代码编写的API(而不是通过组合现有层来创建模型的API)。

请看 eager execution guide 里的例子:使用 Keras models with custom training loops and tf.GradientTape。

8. Distribution

8.1 Estimators

Estimators API 被用来在分布时环境训练模型。Estimator API 旨在大型数据集的分布式训练,该 API 能够导出工业生产可用的模型。

一个 tf.keras.Model 可以用 tf.estimator API 来训练(通过 tf.keras.estimator.model_to_estimator 将模型转为一个 tf.estimator.Estimator 对象)。详情见 Creating Estimators from Keras models。

model = keras.Sequential([layers.Dense(10,activation='softmax'),
                          layers.Dense(10,activation='softmax')])

model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

estimator = keras.estimator.model_to_estimator(model)

注意: 可以通过开启 eager execution 来调试 Estimator input functions、检查数据。

8.2 Multiple GPUs

tf.keras 模型可以使用 tf.contrib.distribute.DistributionStrategy 在多个 GPU 上运行。此API在多个GPU上提供分布式培训,几乎不对现有代码进行任何更改。

当前,tf.contrib.distribute.MirroredStrategy 是唯一支持的分布式策略。MirroredStrategy 对图进行复制,以同步的方式训练,并且梯度最后聚集在一个机器上。 为了使用 DistributionStrategy with Keras,首先用 tf.keras.estimator.model_to_estimator 将 tf.keras.Model 转化为一个 tf.estimator.Estimator,然后训练转化来的estimator。
以下示例在单个计算机上的多个GPU之间分发tf.keras.Model。
首先,定义一个简单的模型:

model = keras.Sequential()
model.add(keras.layers.Dense(16, activation='relu', input_shape=(10,)))
model.add(keras.layers.Dense(1, activation='sigmoid'))

optimizer = tf.train.GradientDescentOptimizer(0.2)

model.compile(loss='binary_crossentropy', optimizer=optimizer)
model.summary()

定义输入pipeline。 input_fn返回一个tf.data.Dataset对象,用于在多个设备之间分配数据 - 每个设备处理输入批处理的一部分。

def input_fn():
    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.repeat(10)
    dataset = dataset.batch(32)
    return dataset

接下来,创建一个 tf.estimator.RunConfig 并设置 train_distribute 参数为 tf.contrib.distribute.MirroredStrategy 实例。当创建 MirroredStrategy 时,你可以指定一个设备列表 或 通过 num_gpus 参数设置 GPU 的数量。默认使用所有的 GPU。如下所示:

strategy = tf.contrib.distribute.MirroredStrategy()
config = tf.estimator.RunConfig(train_distribute=strategy)

将 Keras model 转为一个 tf.estimator.Estimator 实例。

keras_estimator = keras.estimator.model_to_estimator(
    keras_model=model,
    config=config,
    model_dir='/tmp/model_dir')

最后,通过提供input_fn和steps参数来训练Estimator实例:

keras_estimator.train(input_fn=input_fn, steps=10)

9. 最后

Sample

相关推荐
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页