Geekly articles weekly

Keras审查TensorFlow



Tensorflow.org提供的概述指南的翻译。 本指南将为您提供Keras入门的基础知识。 阅读需要10分钟。

导入tf.keras


tf.keras是TensorFlow Keras API规范的实现。 这是用于构建和训练模型的高级API，包括对TensorFlow特定功能的一流支持，例如急切执行 ， tf.data管道和Estimators 。 tf.keras使TensorFlow的使用更加轻松，而又不牺牲灵活性和性能。

首先，将tf.keras作为TensorFlow设置的一部分导入：

 from __future__ import absolute_import, division, print_function, unicode_literals import tensorflow as tf from tensorflow import keras

tf.keras可以执行任何与tf.keras兼容的代码，但请记住：

  • TensorFlow最新发行版中的tf.keras版本可能与PyPI中最新的keras版本不同。 查看tf.keras.__version__ 。
  • 保存模型权重时， tf.keras默认情况下以检查点格式执行此操作。 传递save_format='h5'参数以使用HDF5（或在文件.h5添加.h5扩展.h5 ）。

建立一个简单的模型


顺序模型


在Keras中，您收集用于构建模型的 图层 。 模型是（通常）层图。 最常见的模型类型是层堆栈： tf.keras.Sequential模型。

我们构建一个简单的完全连接的网络（即多层感知器）：

 from tensorflow.keras import layers model = tf.keras.Sequential() #       64 : model.add(layers.Dense(64, activation='relu')) #   : model.add(layers.Dense(64, activation='relu')) #   softmax  10 : model.add(layers.Dense(10, activation='softmax'))

自定义图层


可以使用多种tf.keras.layers图层。 它们大多数使用通用的参数构造函数：

  • activation ：设置图层的激活功能。 此参数指定内置函数或被调用对象的名称。 该参数没有默认值。
  • kernel_initializer和bias_initializer ：创建层权重（核心和移位）的初始化方案。 此参数可以是名称或被调用对象。 默认的初始化程序是"Glorot uniform" 。
  • kernel_regularizer和bias_regularizer ：添加到层权重（核心和移位）的正则化方案，例如L1或L2正则化。 默认情况下，未设置正则化。

以下tf.keras.layers.Dense层实例的示例使用构造函数参数：

 #    : layers.Dense(64, activation='sigmoid') # : layers.Dense(64, activation=tf.keras.activations.sigmoid) #     L1   0.01    : layers.Dense(64, kernel_regularizer=tf.keras.regularizers.l1(0.01)) #     L2   0.01    : layers.Dense(64, bias_regularizer=tf.keras.regularizers.l2(0.01)) #        : layers.Dense(64, kernel_initializer='orthogonal') #        2.0: layers.Dense(64, bias_initializer=tf.keras.initializers.Constant(2.0))

培训与评估


训练设置


构建模型后，通过调用compile方法配置学习过程：

 model = tf.keras.Sequential([ #     64   : layers.Dense(64, activation='relu', input_shape=(32,)), #  : layers.Dense(64, activation='relu'), #   softmax  10 : layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='categorical_crossentropy', metrics=['accuracy'])

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

  • optimizer ：此对象定义培训过程。 将tf.keras.optimizers模块中的优化程序实例（例如tf.keras.optimizers.Adam或tf.keras.optimizers.SGD 。 如果只想使用默认选项，则还可以使用诸如'adam'或'sgd'关键字指定优化器。
  • loss ：此功能在学习过程中被最小化。 其中常见的变化是标准误差（ mse ）， categorical_crossentropy和binary_crossentropy 。 损失函数可以通过名称指定，也可以通过从tf.keras.losses模块传递被调用的对象来tf.keras.losses 。
  • metrics ：用于监视培训。 这些是字符串名称或来自tf.keras.metrics模块的称为对象。
  • 此外，为确保模型得到了正确的训练和评估，请检查是否已将参数run_eagerly=True传递给编译器

接下来，我们将看到一些用于训练的模型配置示例：

 #       . model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='mse', # mean squared error metrics=['mae']) # mean absolute error #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.01), loss=tf.keras.losses.CategoricalCrossentropy(), metrics=[tf.keras.metrics.CategoricalAccuracy()])

从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接受三个重要参数：

  • epochs ：学习分为*时代*。 这个时代是所有输入数据的一次迭代（这是小批量完成的）。
  • batch_size ：传输NumPy数据时，模型将数据分成较小的块（批），并在训练期间在这些块上进行迭代。 该数字表示每个数据块的大小。 请记住，如果记录总数未除以批处理大小，则最后一个块可能会更小。
  • validation_data ：在对模型进行原型制作时，您希望轻松地在验证数据上跟踪其性能。 使用此参数传递输入数据和标签的元组，可使模型在每个时代结束时传输的数据的输出模式下显示损失函数和度量的值。

这是使用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))

使用tf.data数据集进行训练


使用Datasets API可以扩展大型数据库或在多个设备上进行训练。 将tf.data.Dataset的实例传递给fit方法：

 #    : dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.fit(dataset, epochs=10)

由于Dataset批量提供数据，因此这段代码不需要batch_size参数。

数据集还可用于验证：

 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 。

您可以通过以下方式估算输出模式下的损失以及所提供数据的指标：

 #   Numpy data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.evaluate(data, labels, batch_size=32) #   dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.evaluate(dataset)

以下是如何以NumPy数组的形式针对提供的数据在输出模式下预测最后一级的输出：

建立复杂的模型


功能性API


tf.keras.Sequential模型是一个简单的层堆栈，您无法想象其中的任意模型。 使用Keras功能API构建复杂的模型拓扑，例如：

  • 多种输入模型
  • 具有多个输出的模型
  • 具有公共层的模型（同一层被多次调用），
  • 数据流不一致的模型（例如残差关系）。

使用功能性API构建模型的工作方式如下：

  1. 图层实例是可调用的，并返回张量。
  2. 输入和输出张量用于确定tf.keras.Model的实例
  3. 该模型的训练就像“顺序”模型一样。

以下示例使用功能性API构建简单的完全连接的网络：

 inputs = tf.keras.Input(shape=(32,)) #    #        . x = layers.Dense(64, activation='relu')(inputs) x = layers.Dense(64, activation='relu')(x) predictions = layers.Dense(10, activation='softmax')(x)

使用这些输入和输出创建模型的实例。

 model = tf.keras.Model(inputs=inputs, outputs=predictions) #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5  model.fit(data, labels, batch_size=32, epochs=5)

子类化模型


使用子类tf.keras.Model并定义您自己的直接分布来创建完全可定制的模型。 在__init__方法中创建图层，并将其设置为类实例的属性。 在call方法中定义直接传播。

在启用急切执行时，对模型进行子类化特别有用，因为它使您能够强制性地编写直接分布。

注意：如果希望模型始终按命令执行，则可以在调用super构造函数时将dynamic=True设置dynamic=True 。
关键点：使用正确的API即可工作。 尽管对模型进行子类化可以提供灵活性，但是您必须为模型付出更多的复杂性和更大的自定义错误可能性。 如果可能，请选择功能性API。
以下示例显示了使用自定义直接分发的子类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 #    . self.dense_1 = layers.Dense(32, activation='relu') self.dense_2 = layers.Dense(num_classes, activation='sigmoid') def call(self, inputs): #     , #      ( `__init__`). x = self.dense_1(inputs) return self.dense_2(x)

创建新模型类的实例：

 model = MyModel(num_classes=10) #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5 . model.fit(data, labels, batch_size=32, epochs=5)

自定义图层


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

  • __init__ ：可选地指定要在该层中使用的子层。
  • * build ：创建图层权重。 使用add_weight方法添加权重
  • call ：定义直接分配。
  • （可选）可以通过实现get_config方法和from_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): #       . 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)

使用您的自定义层创建模型：

 model = tf.keras.Sequential([ MyLayer(10), layers.Activation('softmax')]) #      model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5 . model.fit(data, labels, batch_size=32, epochs=5)

科尔贝基


Kolbek是转移到模型的对象，用于在训练期间自定义和扩展其行为。 您可以编写自己的自定义回调或使用内置的tf.keras.callbacks ，其中包括：

tf.keras.callbacks.ModelCheckpoint ：定期保存模型断点。
tf.keras.callbacks.LearningRateScheduler ：动态更改学习步骤。
tf.keras.callbacks.EarlyStopping ：当验证结果停止改善时，停止训练。
tf.keras.callbacks.TensorBoard:使用tf.keras.callbacks.TensorBoard:监视模型行为
张量板

要使用tf.keras.callbacks.Callback ，请将其传递给fit模型方法：

 callbacks = [ #    `val_loss`     2  tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'), #   TensorBoard   `./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))

保存和还原


仅保存重量值


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

 model = tf.keras.Sequential([ layers.Dense(64, activation='relu', input_shape=(32,)), layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='categorical_crossentropy', metrics=['accuracy']) 

 #     TensorFlow Checkpoint model.save_weights('./weights/my_model') #    #        . model.load_weights('./weights/my_model')

默认情况下，模型权重以TensorFlow检查点格式保存。 权重也可以Keras HDF5格式保存（Keras通用实现的默认值）：

 #     HDF5 model.save_weights('my_model.h5', save_format='h5') #    model.load_weights('my_model.h5')

仅保存模型配置


可以保存模型的配置-这无需任何权重就可以序列化模型的体系结构。 即使没有代码定义原始模型，保存的配置也可以还原和初始化相同的模型。 Keras支持JSON和YAML序列化格式：

 #     JSON json_string = model.to_json() json_string 

 import json import pprint pprint.pprint(json.loads(json_string))

从JSON还原模型（重新初始化）：

 fresh_model = tf.keras.models.model_from_json(json_string)

将模型序列化为YAML需要在导入TensorFlow之前安装`pyyaml`：

 yaml_string = model.to_yaml() print(yaml_string)

从YAML还原模型：

 fresh_model = tf.keras.models.model_from_yaml(yaml_string)

注意：子类模型不可序列化，因为其体系结构是由`call`方法主体中的Python代码定义的。

将整个模型保存在一个文件中


整个模型可以保存到包含权重值，模型配置甚至优化器配置的文件中。 这将使您可以设置模型断点，并在以后即使不访问源代码也可以从完全相同的位置继续进行训练。

 #    model = tf.keras.Sequential([ layers.Dense(10, activation='softmax', input_shape=(32,)), layers.Dense(10, activation='softmax') ]) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(data, labels, batch_size=32, epochs=5) #      HDF5 model.save('my_model.h5') #         . model = tf.keras.models.load_model('my_model.h5')

急于执行


急切的执行是必须立即执行操作的命令式编程环境。 tf.keras不需要此功能，但tf.keras支持tf.keras ，这对于检查程序和调试很有用。

`tf.keras` API的所有构建模型都与热切执行兼容。 尽管可以使用`Sequential`和功能性API，但是在对模型进行子类化和构建自定义层时，急切执行特别有用-这些API要求您以代码形式编写直接分发（而不是通过组装现有层来创建模型的API）。

经销


多个GPU


tf.keras模型可以使用tf.distribute.Strategy在多个GPU上运行。 该API提供了跨多个GPU的分布式学习，而对现有代码的更改很少甚至没有更改。

当前， tf.distribute.MirroredStrategy唯一受支持的分发策略。 MirroredStrategy复制图
一台机器上使用全归约同步学习。 要使用` distribute.Strategy ，请将模型的优化器安装，设计和编译嵌套在` Strategy .scope() `中，然后训练模型。

以下示例在同一台计算机上的多个GPU之间分配tf.keras.Model 。

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

 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, activation='sigmoid')) optimizer = tf.keras.optimizers.SGD(0.2) model.compile(loss='binary_crossentropy', 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)

经过验证后，翻译也将出现在Tensorflow.org上。 如果您想参与将Tensorflow.org网站的文档翻译成俄语，请以个人身份或评论联系。 任何更正或评论表示赞赏。

Source: https://habr.com/ru/post/zh-CN482126/

More articles:


All Articles