1、简介
在KerasTuner中,HyperModel类提供了一种方便的方式来在可重用对象中定义搜索空间。你可以通过重写HyperModel.build()方法来定义和进行模型的超参数调优。为了对训练过程进行超参数调优(例如,通过选择适当的批处理大小、训练轮数或数据增强设置),程序员可以重写HyperModel.fit()方法,在该方法中你可以访问:
- hp对象,它是keras_tuner.HyperParameters的一个实例
- 由HyperModel.build()构建的模型
在“开始使用KerasTuner”一文的“调整模型训练”部分中给出了一个基本示例。
2、自定义训练循环的超参数调优
本文将通过重写HyperModel.fit()方法来子类化HyperModel类,并编写一个自定义训练循环。如果你想了解如何使用Keras编写一个自定义训练循环,可以参考指南《从零开始编写训练循环》。
首先,我们导入所需的库,并为训练和验证创建数据集。在这里,我们仅使用随机数据作为演示目的。
import keras_tuner
import tensorflow as tf
import keras
import numpy as np
x_train = np.random.rand(1000, 28, 28, 1)
y_train = np.random.randint(0, 10, (1000, 1))
x_val = np.random.rand(1000, 28, 28, 1)
y_val = np.random.randint(0, 10, (1000, 1))
接着,我们将HyperModel类子类化为MyHyperModel。在MyHyperModel.build()中,我们构建一个简单的Keras模型来进行10个不同类别的图像分类。MyHyperModel.fit()接受几个参数,其签名如下所示:
def fit(self, hp, model, x, y, validation_data, callbacks=None, **kwargs):
hp
参数用于定义超参数。
model
参数是由 MyHyperModel.build()
返回的模型。
x
, y
, 和 validation_data
都是自定义参数。稍后我们将通过调用 tuner.search(x=x, y=y, validation_data=(x_val, y_val))
来传递我们的数据给它们。你可以定义任意数量的这些参数并给它们自定义的名称。
callbacks
参数原本是为了与 model.fit()
一起使用的。KerasTuner 在其中放置了一些有用的 Keras 回调,例如,在模型最佳轮次时保存模型的回调。
在自定义训练循环中,我们将手动调用这些回调。但在调用它们之前,我们需要使用以下代码将我们的模型分配给它们,以便它们可以访问模型以进行保存。
for callback in callbacks:
callback.model = model
在这个例子中,我们只调用了回调的 on_epoch_end() 方法来帮助我们保存模型的最佳状态。如果需要,你也可以调用其他回调方法。如果你不需要保存模型,那么你就不需要使用回调。
在自定义训练循环中,我们将通过将NumPy数据包装成tf.data.Dataset来调优数据集的批处理大小。请注意,你也可以在这里调优任何预处理步骤。此外,我们还调优了优化器的学习率。
我们将使用验证损失作为模型的评估指标。为了计算平均验证损失,我们将使用keras.metrics.Mean(),它在批次之间平均验证损失。我们需要返回验证损失,以便Tuner可以记录它。
class MyHyperModel(keras_tuner.HyperModel):
def build(self, hp):
"""Builds a convolutional model."""
inputs = keras.Input(shape=(28, 28, 1))
x = keras.layers.Flatten()(inputs)
x = keras.layers.Dense(
units=hp.Choice("units", [32, 64, 128]), activation="relu"
)(x)
outputs = keras.layers.Dense(10)(x)
return keras.Model(inputs=inputs, outputs=outputs)
def fit(self, hp, model, x, y, validation_data, callbacks=None, **kwargs):
# Convert the datasets to tf.data.Dataset.
batch_size = hp.Int("batch_size", 32, 128, step=32, default=64)
train_ds = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(
batch_size
)
validation_data = tf.data.Dataset.from_tensor_slices(validation_data).batch(
batch_size
)
# Define the optimizer.
optimizer = keras.optimizers.Adam(
hp.Float("learning_rate", 1e-4, 1e-2, sampling="log", default=1e-3)
)
loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)
# The metric to track validation loss.
epoch_loss_metric = keras.metrics.Mean()
# Function to run the train step.
@tf.function
def run_train_step(images, labels):
with tf.GradientTape() as tape:
logits = model(images)
loss = loss_fn(labels, logits)
# Add any regularization losses.
if model.losses:
loss += tf.math.add_n(model.losses)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
# Function to run the validation step.
@tf.function
def run_val_step(images, labels):
logits = model(images)
loss = loss_fn(labels, logits)
# Update the metric.
epoch_loss_metric.update_state(loss)
# Assign the model to the callbacks.
for callback in callbacks:
callback.set_model(model)
# Record the best validation loss value
best_epoch_loss = float("inf")
# The custom training loop.
for epoch in range(2):
print(f"Epoch: {epoch}")
# Iterate the training data to run the training step.
for images, labels in train_ds:
run_train_step(images, labels)
# Iterate the validation data to run the validation step.
for images, labels in validation_data:
run_val_step(images, labels)
# Calling the callbacks after epoch.
epoch_loss = float(epoch_loss_metric.result().numpy())
for callback in callbacks:
# The "my_metric" is the objective passed to the tuner.
callback.on_epoch_end(epoch, logs={"my_metric": epoch_loss})
epoch_loss_metric.reset_state()
print(f"Epoch loss: {epoch_loss}")
best_epoch_loss = min(best_epoch_loss, epoch_loss)
# Return the evaluation metric value.
return best_epoch_loss
现在,我们可以初始化Tuner了。在这里,我们使用Objective("my_metric", "min")
作为需要最小化的指标。目标名称应该与你在传递给回调的on_epoch_end()
方法的日志中使用的键一致。回调需要使用日志中的这个值来找到最佳的epoch以保存模型的检查点。
换句话说,当你自定义训练循环并决定在每个epoch结束时记录一些指标时,你需要确保你传递给on_epoch_end()
方法的日志中包含一个键(例如"my_metric"
),该键与你在Tuner中定义的Objective的名称相匹配。这样,Tuner就可以使用这个指标来跟踪模型性能的变化,并决定何时保存最佳的模型检查点。
在上面的例子中,如果我们在每个epoch结束时计算了验证损失,并将其作为"val_loss"
键传递给on_epoch_end()
方法,那么我们需要在初始化Tuner时使用Objective("val_loss", "min")
,因为我们的目标是找到具有最小验证损失的epoch。
tuner = keras_tuner.RandomSearch(
objective=keras_tuner.Objective("my_metric", "min"),
max_trials=2,
hypermodel=MyHyperModel(),
directory="results",
project_name="custom_training",
overwrite=True,
)
我们通过将我们在MyHyperModel.fit()方法的签名中定义的参数传递给tuner.search()来开始搜索。
tuner.search(x=x_train, y=y_train, validation_data=(x_val, y_val))
最后,我们可以检索结果。
在Keras Tuner中,一旦tuner.search()方法执行完毕,你就可以从Tuner对象中检索最佳模型、最佳超参数配置以及搜索结果的历史记录。这些结果可以帮助你理解模型性能如何随着超参数的变化而变化,并为你提供最佳的模型配置以进行进一步的应用或部署。
通常,你可以使用tuner.get_best_models()来获取一个或多个最佳模型,使用tuner.get_best_hyperparameters()来获取最佳超参数配置,以及使用tuner.results_summary()来查看搜索结果的摘要。
best_hps = tuner.get_best_hyperparameters()[0]
print(best_hps.values)
best_model = tuner.get_best_models()[0]
best_model.summary()
3、总结
使用Keras Tuner进行自定义训练循环超参数调优的过程可以大致分为以下几个步骤:
3.1. 安装Keras Tuner
首先,确保你已经安装了Keras Tuner库。可以使用pip进行安装:
pip install keras-tuner
3.2. 定义继承自keras_tuner.HyperModel的类
你需要定义一个继承自keras_tuner.HyperModel
的类,并在其中定义build
和fit
方法。
build
方法:用于定义模型的架构,并使用hp
参数设置超参数的搜索空间。fit
方法:用于模型的训练过程,它接受hp
参数以及训练数据和其他必要的参数。
import tensorflow as tf
from tensorflow.keras import layers
from keras_tuner import HyperModel
class MyHyperModel(HyperModel):
def build(self, hp):
model = tf.keras.Sequential()
# 示例:定义含可调参数的全连接层
hp_units = hp.Int('units', min_value=32, max_value=512, step=32)
model.add(layers.Dense(units=hp_units, activation='relu'))
# ... 其他层 ...
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
return model
def fit(self, hp, x_train, y_train, **kwargs):
model = self.build(hp)
model.fit(x_train, y_train, epochs=10, **kwargs)
# 假设这里只进行一轮训练作为示例,实际中可能需要多轮
return {'loss': model.evaluate(x_train, y_train)[0], 'accuracy': model.evaluate(x_train, y_train)[1]}
3.3. 准备数据和回调
准备好你的训练数据和验证数据,以及可能需要的回调函数(如模型保存、早停等)。
3.4. 使用Tuner进行搜索
实例化你的Tuner类(如RandomSearch
、Hyperband
等),并传入你的HyperModel
、数据以及搜索的目标(如最小化验证损失)。
from keras_tuner import RandomSearch
tuner = RandomSearch(
MyHyperModel(),
objective='val_loss',
max_trials=10, # 搜索的最大试验次数
executions_per_trial=3, # 每个试验的重复次数
directory='my_dir', # 结果保存目录
project_name='my_project'
)
tuner.search(x_train, y_train,
validation_data=(x_val, y_val),
epochs=10, # 注意这里的epochs仅用于fit方法中的一轮训练
callbacks=[...]) # 可能的回调,如ModelCheckpoint
3.5. 检索结果
搜索完成后,你可以从Tuner对象中检索最佳模型、最佳超参数配置以及搜索结果的历史记录。
best_hps = tuner.get_best_hyperparameters(num_trials=1)[0]
print(f'Best hyperparameters: {best_hps.values}')
best_model = tuner.get_best_models(num_models=1)[0]
# 使用best_model进行预测或进一步评估
3.6. 可视化结果
Keras Tuner提供了丰富的可视化支持,你可以使用TensorBoard等工具来查看搜索过程的详细结果。
使用Keras Tuner进行自定义训练循环的超参数调优涉及安装Keras Tuner库,定义继承自HyperModel的类并实现其build和fit方法,准备训练数据和验证数据以及可能的回调。随后,实例化Tuner类并传入定义的HyperModel和数据,开始搜索最佳超参数组合。搜索完成后,可以通过Tuner的接口检索到最佳的超参数和模型。整个调优过程中需要注意设置合理的搜索空间、试验次数,并使用独立的验证集来评估模型性能,最后可以利用可视化工具查看调优结果。