TensorFlow "tf.keras"API的应用

Keras 是一个基于 Python 编写的高层神经网络 API,强调用户友好性、模块化及易扩展等,其后端可以采用 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

然后,创建一个顺序模型:
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= 'softmmx'))

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

在编译模型的时候需要设置一些必需参数,例如“optimizers”用来指定我们想使用的优化器及设定优化器的学习率,如 Adam 优化器“tf.keras.optimizer.Adam”、SGD 优化器“tf.keras.optimizer.SGD”等,在上述第 1 行代码中使用的是 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)

第 2 行和第 3 行代码随机生成样本数据和类标。第 6 行代码使用“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 = tf.data.Dataset.from_tensor_slices((data, labels))
dataset = dataset.batch(50)
#创建验证集
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):
        #使用"__int__"方法中定义的网络层来构造网络的前馈过程
        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()