TensorFlow2.0 Guide 官方教程-学习笔记1-Keras overview

---

一、导入TensorFlow库，并使用Keras接口

from __future__ import absolute_import, division, print_function, unicode_literals

import tensorflow as tf

from tensorflow import keras

二、创建模型

创建一个简单的序列模型Sequential Model

from tensorflow.keras import layers

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 a softmax layer with 10 output units:
model.add(layers.Dense(10, activation='softmax'))

三、配置神经网络模型中层的属性

大部分层（tf.keras.layers）有许多相同的构造属性，以下是3个重要的配置属性：
1.激活函数（activation）：设置层的激活函数，此参数由内置函数的名称或可调用对象指定，默认情况下，不应用激活。
2.初始化层权重（kernel_initializer和bias_initializer）：此参数是名称或可调用对象，默认为‘Glorot uniform’初始化器。
3.正则化层的权重（kernel_regularizer和bias_regularizer）：如L1和L2正则化，默认情况下，不应用正则化。

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

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

四、模型的训练和评估

通过调用‘compile’方法来配置模型的学习过程，tf.keras.Model.compile有三个重要的属性：
1.optimizer（优化器）：此对象指定训练过程，从tf.keras.optimizers模块传递优化器实例。例如：‘tf.keras.potimators.adam’或‘tf.keras.optimizers.SGD’,如果只想使用默认参数，还可以通过字符串指定优化器，比如’adam’或’sgd’。
2.loss（代价函数）:在优化过程中不断的最小化。常见的选择有均方差（mse），categorical_crossentropy和binary_crossentropy。代价函数通过名称或tf.keras.losses模块中传递可调用对象来指定。
3.metrics：这些是来自tf.keras.metrics模块的字符串或可调用项。
4.另外，为了确保快速地训练和评估模型，我们可以确保传递‘run_eagerly=True’作为一个参数来编译（compile）

# 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(),
              metrics=[tf.keras.metrics.CategoricalAccuracy()])

五、模型的训练数据

5.1Numpy 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有三个重要的属性：
1.epochs：训练是按照代（epoch）来划分，epoch是对整个输入数据的一次迭代（这是在较小的批中完成的）
2.batch_size：当传递Numpy数据时，模型将数据分割成更小的批，并在训练期间迭代这些批，如果此整数不能被样本总数整除，那么最后一批可能会比‘batch_size’小。
3.validation_data：在构建原型时，你希望在某些验证数据上方便监视它的性能。传递这个参数（输入和标签的元组）允许模型在每个epoch结束时以推理模式显示传递数据的损失和度量。

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

5.2使用tf.data数据集训练。使用‘Dataset API’扩展到大型数据集或多设备训练。使用方法：传递一个‘tf.data.Dataset’实例到‘fit’方法。由于数据集生产批量数据，所以使用tf.data时不需要batch_size。‘Dataset’也可用于验证。

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)

六、评价和预测（Evaluate and predict）：

tf.keras.Model.evaluate和tf.keras.Model.predict方法可以使用‘Numpy data’和‘tf.data.Dataset’.

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

输出预测：

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

输出形式是一个Numpy数组

七.模型的保存和恢复

7.1 仅保存和恢复模型的权重值

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

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

默认情况下，模型的权重保存在‘TensorFlow checkpoint’文件格式，也可以保存为‘Keras HDF5’格式。

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

7.2仅保存模型的配置

模型的可保存配置—这样可以序列化模型架构而不需要任何权重。保存的配置可以重新创建和初始化相同的模型，甚至不需要定义原始模型的代码。（注意：子类化的模型不能序列化因为他们的价格是python代码在调用方法体中定义的）Keras支持JSON和YAML序列化格式:

# Serialize a model to JSON format
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格式，这一步操作需要先按照pyyaml

yaml_string = model.to_yaml()
print(yaml_string)

从YAML中重新创建模型

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

7.3 保存整个模型

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

# Create a simple model
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)


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

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

---

使用‘Keras functional API’创建复杂模型，如：
1.多输入模型
2.多输出模型
3.带有共享层的模型（同一层被调用多次）
有以下几个特点：
1.层实例是可调用的，并返回一个张量
2.输入张量和输出张量用于定义‘tf.keras.Model’实例
3.这种模型的训练和序列模型的一样

利用‘Keras functional 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, activation='softmax')(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='categorical_crossentropy',
              metrics=['accuracy'])

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

模型的子类化：
1.通过子类化tf.keras.Model和定义你自己的前向传递来构建一个完全可定制的模型。在‘init’方法中创建层，并将它们设置为类实例的属性。在调用方法中定义正向传递。
2.当启用了立即执行时，模型的子类化特别有用，因为它允许强制地编写正向传递。
3.虽然模型的子类化提供了很强的灵活性，但它也增加了复杂度以及产生错误的可能性，所以如果可以推荐使用‘Keras functional 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
    # Define your layers here.
    self.dense_1 = layers.Dense(32, activation='relu')
    self.dense_2 = 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)

将子类化的模型实例化：

model = MyModel(num_classes=10)

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

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

创建定制化的层，通过子类化tf.keras.layers.Layer和执行下面这些方法：
1.‘init’：选择性地定义这层的子层。
2.‘build’：给层创建权重，增加权重使用‘add_weight’的方法。
3.‘call’：定义前向传播
4.也可以通过执行‘get_config’方法和‘from_config’类方法，序列化层。

下面是一个自定义层的例子，它实现了一个带有kernel矩阵的输入矩阵：

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)

创建一个使用刚刚定制的层的模型：

model = tf.keras.Sequential([
    MyLayer(10),
    layers.Activation('softmax')])

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

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

自定义回调
回调是传递给模型的对象，用于在训练期间自定义和扩展其行为。您可以编写自己的自定义回调，或者使用内置的’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’传递到Model.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))