一文上手Tensorflow2.0之tf.keras（三）

系列文章目录：

• Tensorflow2.0 介绍

  • Tensorflow 常见基本概念

  • 从1.x 到2.0 的变化

  • Tensorflow2.0 的架构

• Tensorflow2.0 的安装(CPU和GPU)

• Tensorflow2.0 使用

  • “tf.data” API

  • “tf.keras”API

• 使用GPU加速

  • 安装配置GPU环境

  • 使用Tensorflow-GPU

3 TensorFlow2.0使用

3.2 “tf.keras”API

Keras是一个基于Python编写的高层神经网络API，Keras强调用户友好性、模块化以及易扩展等，其后端可以采用TensorFlow、Theano以及CNTK，目前大多是以TensorFlow作为后端引擎。考虑到Keras优秀的特性以及它的受欢迎程度，TensorFlow将Keras的代码吸收了进来，并将其作为高级API提供给用户使用。“tf.keras”不强调原来Keras的后端可互换性，而是在符合Keras标准的基础上让其与TensorFlow结合的更紧密（例如支持TensorFlow的eager execution模式，支持“tf.data”，以及支持TPU训练等）。“tf.keras”提高了TensorFlow的易用性，同时也保持了TensorFlow的灵活性和性能。

1. 基本模型的搭建和训练

对于一些基本的网络模型，我们可以使用“tf.keras.Sequential”来创建，通过这种方式创建的模型又称为“顺序模型”，因为这种方式创建的模型是由多个网络层线性堆叠而成的。

首先导入需要的包：

import tensorflow as tf
from tensorflow.keras import layers

然后我们创建一个Sequential Model：

model = tf.keras.Sequential([
 # 添加一个有64个神经元的全连接层，“input_shape”为该层接受的输# 入数据的维度，“activation”指定该层所用的激活函数
 layers.Dense(64, activation='relu', input_shape=(32,)),
 # 添加第二个网络层
 layers.Dense(64, activation='relu'),
 # 添加一个softmax层作为输出层，该层有十个单元
 layers.Dense(10, activation='softmax'),
 ])

上面的代码中，我们在定义这个顺序模型的同时添加了相应的网络层，除此之外我们也可以使用“add”方法逐层的添加：

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

“tf.keras.layers”用于生成网络层，包括全连接层（tf.keras.layers.Dense()）、Dropout层(tf.keras.layers.Dropout)以及卷积网络层（例如二维卷积：tf.keras.layers.Conv2D）等等。创建好网络结构后，我们需要对网络进行编译：

model.compile(optimizer=tf.keras.optimizers.Adam(0.001),
 loss='categorical_crossentropy',
 metrics=['accuracy'])

在编译模型的时候我们需要设置一些必须的参数。例如“optimizer”用来指定我们想使用的优化器以及设定优化器的学习率。例如Adam优化器“tf.keras.optimizer.Adam”、SGD优化器“tf.keras.optimizer.SGD”等，在15行代码中我们使用了Adam优化器，并设置了学习率为“0.001”。

“loss”参数用来设置模型的损失函数（又称目标函数），例如均方误差损失函数（mean_squared_error）、对数损失函数（binary_crossentropy）以及多分类的对数损失函数（categorical_crossentropy）等等。

“metrics”用来设定模型的评价函数，模型的评价函数与损失函数相似，不过评价函数只用来显示给用户查看，并不用于模型的训练。除了自带的一些评价函数以外，我们还可以自定义评价函数。

编译好模型之后我们就可以开始训练了，这里我们使用numpy生成一组随机数作为训练数据：

import numpy as np

data = np.random.random((1000, 32))
labels = np.random.random((1000, 10))
print(data[0])
print(labels[0])

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

代码中我们随机生成了样本数据和类标。使用“model.fit”来执行模型的训练，其中参数“data”和“labels”分别为训练数据和类标，“epochs”为训练的回合数（一个回合即在全量数据集上训练一次），“batch_size”为训练过程中每一个批次数据的大小。输出结果如图1所示。

图1 输出结果

在训练模型的工程中，为了更好地调节参数，方便模型的选择和优化，我们通常会准备一个验证集，这里我们同样随机生成一个验证集：

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

model.fit(data, labels, epochs=2, batch_size=50,
 validation_data=(val_data, val_labels))

输出结果如图2所示：

图2 增加验证集后的输出结果

和图1相比，这里多了“val_loss”和“val_accuracy”，分别为验证集上的损失和准确率。

上面的例子中我们直接在NumPy数据上训练的模型，我们也可以使用“tf.data”将其转为“Dataset”后再传递给模型去训练：

# 创建训练集Dataset
dataset = tf.data.Dataset.from_tensor_slices((data, labels))
dataset = dataset.batch(50)
# 创建验证集Dataset
val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels))
val_dataset = val_dataset.batch(50)

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

模型训练好之后，我们希望用测试集去对模型进行评估，这里我们可以使用“model.evaluate”对模型进行评估：

# 模型评估，测试集为NumPy数据
model.evaluate(data, labels, batch_size=50)
# 模型评估，测试集为Dataset数据
model.evaluate(dataset, steps=30)

结果如图3所示：

图3 模型评估结果

最后我们可以使用“model.predict”对新的数据进行预测：

result = model.predict(data, batch_size=50)
print(result[0])

结果如图4所示：

图4 使用训练好的模型预测新的数据

2. 搭建高级模型

（1）函数式API

对于一些基本的网络结构，我们可以使用“tf.keras.Sequential”来搭建，但更多的时候我们面临的是一些比较复杂的网络结构。例如模型可能有多输入或多输出，模型中的一些网络层需要共享等等。对于这种网络模型的结构较为复杂的情况，我们需要使用到函数式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'])
# 训练模型
model.fit(data, labels, epochs=2, batch_size=50)

（2）实现自定义的模型类和网络层

通过继承“tf.keras.Model”和“tf.keras.layers.Layer”我们可以实现自定义的模型类以及网络层，这为我们构建自己的网络结构提供了非常好的灵活性。例如我们定义一个简单的前馈网络模型：

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)

我们需要在“__init__”方法中定义好我们模型中所有的网络层，并作为模型类的属性。在“call”方法中我们可以定义模型的正向传递过程。之后就可以调用这个模型。

model = MyModel(num_classes=10)
# 编译模型
model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001),
 loss='categorical_crossentropy',
 metrics=['accuracy'])
# 训练模型
model.fit(data, labels, batch_size=50, epochs=5)

以上是我们自定义一个简单的网络模型的例子，通过继承“tf.keras.layers.Layer”类我们还可以实现自定义的网络层。事实上除了研究人员，对于绝大多数用户来说，我们一般不会需要自定义模型类或网络层。

3. 回调函数

回调函数会在模型的训练阶段被执行，可以用来自定义模型训练期间的一些行为，例如输出模型内部的状态等。我们可以自己编写回调函数也可以使用内置的一些函数，例如：

• tf.keras.callbacks.ModelCheckpoint：定期保存模型。

• tf.keras.callbacks.LearningRateScheduler：动态的改变学习率。

• tf.keras.callbacks.EarlyStopping：当模型在验证集上的性能不再提升时终止训练。

• tf.keras.callbacks.TensorBoard：使用TensorBoard来监测模型。

回调函数的使用方式如下：

callbacks = [
 # 当验证集上的损失“val_loss”连续两个训练回合（epoch）都没有变化，则提前结束训练
 tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'),
 # 使用TensorBoard保存训练的记录，保存到“./logs”目录中
 tf.keras.callbacks.TensorBoard(log_dir='./logs')
]
model.fit(data, labels, batch_size=50, epochs=5, callbacks=callbacks,
 validation_data=(val_data, val_labels))

4. 模型的保存和恢复

我们可以使用“model.save()”和“tf.keras.models.load_model()”来保存和加载由“tf.keras”训练的模型：

# 创建一个简单的模型
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')
# 加载保存的模型
model = tf.keras.models.load_model('my_model')

通过“model.save()”保存的是一个完整的模型信息，包括模型的权重以及结构等。除了保存完整的模型，我们还可以单独保存模型的权重信息或者模型的结构。

# 将模型的权重参数保存为HDF5文件
model.save_weights('my_model.h5', save_format='h5')
# 重新加载
model.load_weights('my_model.h5')

# 将模型的结构保存为JSON文件
json_string = model.to_json()

欢迎关注磐创博客资源汇总站：

http://docs.panchuang.net/

欢迎关注PyTorch官方中文教程站：

http://pytorch.panchuang.net/