TF2.0 API学习（Python）四 :tf.keras.Model使用简介和方法

tf2.0 模型API

1、tf.keras.Model

Model 通过训练和推理功能将图层分组为一个对象

1）使用“功能API”（从此处开始）Input，链接层调用以指定模型的前向传递，最后从输入和输出创建模型：

inputs = tf.keras.Input(shape=(3,))
x = tf.keras.layers.Dense(4, activation=tf.nn.relu)(inputs)
outputs = tf.keras.layers.Dense(5, activation=tf.nn.softmax)(x)
model = tf.keras.Model(inputs=inputs, outputs=outputs)

2）通过对Model类进行子类化：在这种情况下，应在中定义层，并在__init__中实现模型的前向传递call

import tensorflow as tf

class MyModel(tf.keras.Model):

  def __init__(self):
    super(MyModel, self).__init__()
    self.dense1 = tf.keras.layers.Dense(4, activation=tf.nn.relu)
    self.dense2 = tf.keras.layers.Dense(5, activation=tf.nn.softmax)

  def call(self, inputs):
    x = self.dense1(inputs)
    return self.dense2(x)

model = MyModel()

3）如果是subclass Model，则可以选择在中有一个training参数（布尔值）call，该参数可用于在训练和推理中指定不同的行为：
super(MyModel, self).init()这句是干嘛的呢？

import tensorflow as tf

class MyModel(tf.keras.Model):

  def __init__(self):
    super(MyModel, self).__init__()
    self.dense1 = tf.keras.layers.Dense(4, activation=tf.nn.relu)
    self.dense2 = tf.keras.layers.Dense(5, activation=tf.nn.softmax)
    self.dropout = tf.keras.layers.Dropout(0.5)

  def call(self, inputs, training=False):
    x = self.dense1(inputs)
    if training:
      x = self.dropout(x, training=training)
    return self.dense2(x)

model = MyModel()

4）模型属性：
metrics_names：返回所有输出的模型显示标签

inputs = tf.keras.layers.Input(shape=(3,))
outputs = tf.keras.layers.Dense(2)(inputs)
model = tf.keras.models.Model(inputs=inputs, outputs=outputs)
model.compile(optimizer="Adam", loss="mse", metrics=["mae"])
model.metrics_names
# ['loss', 'mean_absolute_error']

run_eagerly：
run_eagerly 可设置的属性，指示模型是否应热切运行。
热情地运行意味着您的模型将像Python代码一样一步一步地运行。您的模型运行速度可能较慢，但是通过逐步进入各个层调用，您应该可以更轻松地对其进行调试。
默认情况下，我们将尝试将您的模型编译为静态图，以提供最佳执行性能。

怎么开启呢

5）方法
model.compile()

compile(
    optimizer='rmsprop', loss=None, metrics=None
)

optimizer: 字符串（优化程序的名称）或优化程序实例
loss: 字符串（目标函数的名称），目标函数或 tf.keras.losses.Loss实例。
metrics: 模型在训练和测试期间要评估的指标列表。

model.evaluate()
返回测试模式下模型的损失值和指标值。
分批进行计算

evaluate(
    x=None, y=None, batch_size=None, verbose=1, sample_weight=None, steps=None,
    callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False,
    return_dict=False
)

x: 输入数据。它可能是：
Numpy数组（或类似数组的数组）或数组列表（如果模型具有多个输入）。
TensorFlow张量或张量列表（如果模型具有多个输入）。
如果模型已命名输入，则dict将输入名称映射到相应的数组/张量。
一个tf.data数据集。应该返回(inputs, targets)或 的元组(inputs, targets, sample_weights)。
生成器或keras.utils.Sequence返回(inputs, targets) 或(inputs, targets, sample_weights)。拆包行为迭代器类型（数据集，发电机，序列）的更详细的描述在给出Unpacking behavior for iterator-like inputs的部分Model.fit。

y:目标数据。像输入数据一样x，它可以是Numpy数组或TensorFlow张量。它应该与x （您不能有Numpy输入和张量目标，或者相反）保持一致。如果 x是数据集，生成器或keras.utils.Sequence实例，则y 不应指定（因为将从迭代器/数据集获取目标）。

batch_size: 整数或None。每批计算的样本数。如果未指定，则默认为32。如果数据是以数据集，生成器或实例的形式（因为它们生成批次），则不要指定.

verbose: 0或1。详细模式。0 =静音，1 =进度条。

model.fit
Trains the model for a fixed number of epochs (iterations on a dataset)

fit(
    x=None, y=None, batch_size=None, epochs=1, verbose=1, callbacks=None,
    validation_split=0.0, validation_data=None, shuffle=True, class_weight=None,
    sample_weight=None, initial_epoch=0, steps_per_epoch=None,
    validation_steps=None, validation_batch_size=None, validation_freq=1,
    max_queue_size=10, workers=1, use_multiprocessing=False
)

x: 输入数据。它可能是：
Numpy数组（或类似数组的数组）或数组列表（如果模型具有多个输入）。
TensorFlow张量或张量列表（如果模型具有多个输入）。
如果模型已命名输入，则dict将输入名称映射到相应的数组/张量。
一个tf.data数据集。应该返回(inputs, targets)或 的元组(inputs, targets, sample_weights)。
生成器或keras.utils.Sequence返回(inputs, targets) 或(inputs, targets, sample_weights)。下面给出了迭代器类型（数据集，生成器，序列）的拆包行为的更详细描述。

y: 目标数据。像输入数据一样x，它可以是Numpy数组或TensorFlow张量。它应该与x（您不能有Numpy输入和张量目标，或者相反）保持一致。如果x是keras.utils.Sequence，y则不应该指定，生成器或实例（因为将从中获取目标x）。

batch_size: 整数或None。每个梯度更新的样本数。如果未指定，则默认为32。如果数据是以数据集，生成器或实例的形式（因为它们生成批次），则不要指定。 batch_sizebatch_sizekeras.utils.Sequence

epochs: 整数。训练模型的时期数。时期是整个x和所y 提供数据的迭代。请注意，在与结合， 应理解为“最后时期”。不会针对给出的多次迭代训练模型，而只是对到达索引的时期进行训练。

model.load_weights
从TensorFlow或HDF5权重文件加载所有层权重。

load_weights(
    filepath, by_name=False, skip_mismatch=False
)

filepath: 字符串，要加载的权重文件的路径。对于TensorFlow格式的重量文件，这是文件前缀（与传递给的相同save_weights）。
by_name: 布尔值，是按名称还是按拓扑顺序加载权重。TensorFlow格式的重量文件仅支持拓扑加载。
skip_mismatch: 布尔值，是否跳过权重数量不匹配或权重形状不匹配的图层的加载（仅当时有效by_name=True）。

返回值：
当以TensorFlow格式加载重量文件时，返回与相同的状态对象tf.train.Checkpoint.restore。建立图形时，恢复操作会在网络建立后立即自动运行（第一次调用从继承的用户定义类时Model（如果已经建立，则立即调用））。
以HDF5格式加载权重时，返回None。

model.predict
生成输入样本的输出预测。
计算是分批进行的。此方法专为在大规模输入中的性能而设计。对于适合一批的少量输入，__call__建议直接使用以加快执行速度（例如） model(x)，或者model(x, training=False)如果您有诸如tf.keras.layers.BatchNormalization在推理过程中表现不同的图层 。另外，请注意以下事实：测试损失不受噪声和压降等正则化层的影响

predict(
    x, batch_size=None, verbose=0, steps=None, callbacks=None, max_queue_size=10,
    workers=1, use_multiprocessing=False
)

x 输入样本。它可能是：
Numpy数组（或类似数组的数组）或数组列表（如果模型具有多个输入）。
TensorFlow张量或张量列表（如果模型具有多个输入）。
一个tf.data数据集。
生成器或keras.utils.Sequence实例。拆包行为迭代器类型（数据集，发电机，序列）的更详细的描述在给出Unpacking behavior for iterator-like inputs的部分Model.fit。

batch_size 整数或None。每批样品数。如果未指定，batch_size则默认为32。batch_size如果数据是以数据集，生成器或keras.utils.Sequence实例的形式（因为它们生成批次），则不要指定。

verbose 详细模式，0或1。

steps 宣布预测回合完成之前的步骤总数（样本批次）。忽略默认值None。如果x是tf.data 数据集且steps为None，predict则将运行直到输入数据集用完为止。

model.save
将模型保存到Tensorflow SavedModel或单个HDF5文件。

save(
    filepath, overwrite=True, include_optimizer=True, save_format=None,
    signatures=None, options=None, save_traces=True
)

filepath 字符串，PathLike，SavedModel的路径或保存模型的H5文件。
overwrite 是否以静默方式覆盖目标位置上的任何现有文件，或向用户提供手动提示。
include_optimizer 如果为True，则将优化器的状态保存在一起。
save_format 无论是’tf’或’h5’，是否对模型保存到Tensorflow SavedModel或HDF5。在TF 2.X中默认为’tf’，在TF 1.X中默认为’h5’。

from keras.models import load_model

model.save('my_model.h5')  # creates a HDF5 file 'my_model.h5'
del model  # deletes the existing model

# returns a compiled model
# identical to the previous one
model = load_model('my_model.h5'

model. save_weights
保存所有图层权重。

基于自save_format 变量以HDF5或TensorFlow格式保存。

以HDF5格式保存时，重量文件具有：

layer_names （属性），字符串列表（模型层的有序名称）。
对于每一个层，group命名layer.name
对于每个这样的图层组，一个group属性weight_names，一个字符串列表（该图层的权重张量的有序名称）。
对于图层中的每个权重，一个存储权重值的数据集，以权重张量命名。

save_weights(
    filepath, overwrite=True, save_format=None, options=None
)

filepath 字符串或PathLike，用于将权重保存到的文件的路径。当以TensorFlow格式保存时，这是用于检查点文件的前缀（会生成多个文件）。请注意，“。h5”后缀导致权重以HDF5格式保存。
overwrite 是否以静默方式覆盖目标位置上的任何现有文件，或向用户提供手动提示。
save_format “ tf”或“ h5”。一filepath，如果在“.h5’或” .keras’结尾将默认为HDF5save_format是None。否则 None默认为“ tf”。
options tf.train.CheckpointOptions指定用于保存权重的选项的 可选对象。

model.summary
打印网络的字符串摘要。

2、tf.keras.optimizers.Adam

tf.keras.optimizers.Adam(
    learning_rate=0.001
    name='Adam'
)

learning_rate 一Tensor，浮点值，或者一个时间表，是一个 tf.keras.optimizers.schedules.LearningRateSchedule，或者调用不带任何参数，并返回实际值来使用，学习率。默认值为0.001。
name 应用渐变时创建的操作的可选名称。默认为"Adam"。

3、tf.summary.create_file_writer

为给定的日志目录创建摘要文件编写器。

tf.summary.create_file_writer(
    logdir, max_queue=None, flush_millis=None, filename_suffix=None, name=None
)

logdir 一个字符串，指定要在其中写入事件文件的目录。
返回一个SummaryWriter对象。

4、tf.GradientTape

记录自动微分操作

tf.GradientTape(
    persistent=False, watch_accessed_variables=True
)

例子

1）计算y = x * x.在x = 3.0处的梯度

x = tf.constant(3.0)
with tf.GradientTape() as g:
  g.watch(x)
  y = x * x
dy_dx = g.gradient(y, x)
print(dy_dx)
sess = tf.Session()
print(sess.run(dy_dx))

Tensor("AddN_3:0", shape=(), dtype=float32)
6.0

2）可以嵌套GradientTapes以计算高阶导数。 例如，

x = tf.constant(5.0)
with tf.GradientTape() as g:
  g.watch(x)
  with tf.GradientTape() as gg:
    gg.watch(x)
    y = x * x
  dy_dx = gg.gradient(y, x)  # dy_dx = 2 * x
d2y_dx2 = g.gradient(dy_dx, x)  # d2y_dx2 = 2

print(dy_dx)
print(d2y_dx2)
sess = tf.Session()
print(sess.run(dy_dx), sess.run(d2y_dx2))

Tensor("AddN_6:0", shape=(), dtype=float32)
Tensor("AddN_7:0", shape=(), dtype=float32)
10.0 2.0

3）默认情况下，只要调用GradientTape.gradient（）方法，就会释放GradientTape拥有的资源。 要在同一计算上计算多个梯度，请创建一个持久梯度带。 当GradientTape被垃圾回收时，释放资源时，这允许多次调用gradient（）方法。 例如：

x = tf.constant(3.0)
with tf.GradientTape(persistent=True) as g:
  g.watch(x)
  y = x * x
  z = y * y
dz_dx = g.gradient(z, x)  # (4*x^3 at x = 3)
print(dz_dx)

dy_dx = g.gradient(y, x)
print(dy_dx)

sess = tf.Session()
print(sess.run(dz_dx), sess.run(dy_dx))

Tensor("AddN_12:0", shape=(), dtype=float32)
Tensor("AddN_13:0", shape=(), dtype=float32)
108.0 6.0

方法：

1）gradient
使用在此磁带上下文中记录的操作计算梯度。

gradient(
    target, sources, output_gradients=None,
    unconnected_gradients=tf.UnconnectedGradients.NONE
)

target：要微分的张量或变量的列表或嵌套结构。
sources：张量或变量的列表或嵌套结构。 target将对sources中的元素作微分运算。
返回：张量的列表或嵌套结构（或IndexedSlices或None），源中每个元素一个。 返回的结构与源的结构相同。

2）watch
确保此磁带正在跟踪这个张量。

watch(
    tensor
)

5、打印Tensor的值

x = tf.constant(3.0)
sess = tf.Session()
print(sess.run(x))
# 3.0

6、tf.Variable

该Variable()构造函数需要为变量，其可以是一个初始值Tensor的任何类型和形状。此初始值定义变量的类型和形状。构造后，变量的类型和形状是固定的。可以使用分配方法之一更改该值。

tf.Variable(
initial_value=None, trainable=None, dtype=None
)

v = tf.Variable(1.)
v.assign(2.)
v.assign_add(0.5)

参数：
initial_value: 将Tensor，或Python对象转换为一个Tensor，这是该变量的初始值。除非设置为False，否则初始值必须具有指定的形状。也可以是不带参数的可调用对象，被调用时将返回初始值。在这种情况下，必须指定。（请注意，必须先将init_ops.py中的初始化函数绑定到形状，然后才能在此处使用。） validate_shapedtype
trainable：如果为True，则GradientTapes自动监视此变量的使用。默认为True，除非synchronization被设置为 ，在这种情况下，默认为。 ON_READFalse
dtype：如果设置，则initial_value将转换为给定类型。如果为 None，则将保留数据类型（如果为张量），或者将决定。 initial_valueconvert_to_tensor

7、tf.keras.layers.InputLayer

tf.keras.layers.InputLayer(
input_shape=None
)
通常建议不要通过直接使用来使用功能层API Input（创建InputLayer）InputLayer
将InputLayer与Keras顺序模型一起使用时，可以通过将input_shape参数移到InputLayer之后的第一层来跳过它