3.4 优化器 (Optimizers)

文档摘要

3.4 优化器 (Optimizers) TensorFlow Keras 优化器 (Optimizers) 详解在深度学习中，优化器是训练神经网络的关键组成部分。它们负责调整模型的权重，以最小化损失函数，从而提高模型的准确性和泛化能力。TensorFlow Keras 提供了多种内置优化器，以及自定义优化器的能力，使得模型训练更加灵活和高效。优化器的作用优化器的核心作用是：计算梯度：利用反向传播算法，计算损失函数关于模型参数的梯度。更新参数：根据计算出的梯度，按照一定的规则更新模型参数，以降低损失函数的值。不同的优化器采用不同的更新规则，这些规则通常基于梯度的大小、方向，以及历史梯度的信息。 Keras 内置优化器 Keras 提供了多种常用的优化器，可以通过模块访问。

3.4 优化器 (Optimizers)

TensorFlow Keras 优化器 (Optimizers) 详解

在深度学习中，优化器是训练神经网络的关键组成部分。它们负责调整模型的权重，以最小化损失函数，从而提高模型的准确性和泛化能力。TensorFlow Keras 提供了多种内置优化器，以及自定义优化器的能力，使得模型训练更加灵活和高效。

1. 优化器的作用

优化器的核心作用是：

计算梯度： 利用反向传播算法，计算损失函数关于模型参数的梯度。
更新参数： 根据计算出的梯度，按照一定的规则更新模型参数，以降低损失函数的值。

不同的优化器采用不同的更新规则，这些规则通常基于梯度的大小、方向，以及历史梯度的信息。

2. Keras 内置优化器

Keras 提供了多种常用的优化器，可以通过 tf.keras.optimizers 模块访问。以下是一些常用的优化器：

SGD (Stochastic Gradient Descent): 随机梯度下降，是最基础的优化器。
Adam: 自适应矩估计，结合了动量和 RMSProp 的优点，是目前最常用的优化器之一。
RMSProp (Root Mean Square Propagation): 均方根传播，通过调整每个参数的学习率来加速收敛。
Adagrad (Adaptive Gradient Algorithm): 自适应梯度算法，根据参数的历史梯度调整学习率，适合处理稀疏数据。
AdamW: Adam 的改进版本，通过解耦权重衰减，提高了模型的泛化能力。
Nadam (Nesterov-accelerated Adaptive Moment Estimation): 结合了 Adam 和 Nesterov 动量，通常具有更快的收敛速度。
Ftrl (Follow the Regularized Leader): 适用于大规模稀疏数据的在线学习。

3. 优化器的使用

在 Keras 中，可以通过以下方式使用优化器：

在 model.compile() 中指定：


import tensorflow as tf
model = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(10, activation='softmax')
])
# 使用 Adam 优化器，学习率为 0.001
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

先创建优化器对象，再在 model.compile() 中指定：


# 创建 Adam 优化器对象
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-07)
model.compile(optimizer=optimizer,
              loss='categorical_crossentropy',
              metrics=['accuracy'])

这种方式可以更灵活地配置优化器的参数。

4. 优化器参数详解

不同的优化器具有不同的参数，以下是一些常见参数的说明：

learning_rate (或 lr): 学习率，控制每次参数更新的步长。
momentum: 动量，用于加速梯度下降，并防止陷入局部最小值。
rho: RMSProp 中的衰减率。
epsilon: 为了数值稳定而添加到分母的一个小值，防止除以零。
beta_1: Adam 中的一阶矩估计的指数衰减率。
beta_2: Adam 中的二阶矩估计的指数衰减率。
decay: 学习率衰减，用于在训练过程中逐渐降低学习率。
clipnorm: 梯度裁剪，用于限制梯度的最大范数，防止梯度爆炸。
clipvalue: 梯度裁剪，用于限制梯度的最大值和最小值，防止梯度爆炸。
weight_decay: 权重衰减，用于防止过拟合。

5. 优化器选择策略

选择合适的优化器取决于具体的任务和数据集。一般来说，可以遵循以下原则：

Adam: 通常是首选，因为它具有良好的收敛速度和性能。
RMSProp: 适用于处理非平稳目标函数。
SGD: 如果计算资源有限，或者需要更精细的控制，可以尝试 SGD。
Adagrad: 适用于处理稀疏数据，但可能过早停止学习。

在实际应用中，通常需要尝试不同的优化器和参数组合，并通过验证集来评估模型的性能，最终选择最佳的优化器。

6. 学习率调度器 (Learning Rate Scheduler)

学习率调度器是一种在训练过程中动态调整学习率的技术。它可以帮助模型更快地收敛，并提高模型的泛化能力。Keras 提供了多种内置的学习率调度器，可以通过 tf.keras.callbacks 模块访问。

常见的学习率调度器包括：

tf.keras.callbacks.LearningRateScheduler: 基于一个函数来动态调整学习率。
tf.keras.callbacks.ReduceLROnPlateau: 当验证集损失不再下降时，降低学习率。
tf.keras.optimizers.schedules.ExponentialDecay: 指数衰减学习率。
tf.keras.optimizers.schedules.PiecewiseConstantDecay: 分段常数衰减学习率。
tf.keras.optimizers.schedules.PolynomialDecay: 多项式衰减学习率。

示例：使用 ReduceLROnPlateau 调度器


import tensorflow as tf
# 创建模型
model = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(10, activation='softmax')
])
# 创建 Adam 优化器
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
# 编译模型
model.compile(optimizer=optimizer,
              loss='categorical_crossentropy',
              metrics=['accuracy'])
# 创建 ReduceLROnPlateau 调度器
reduce_lr = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1,
                                     patience=10, min_lr=0.00001)
# 训练模型，并使用调度器
model.fit(x_train, y_train, epochs=50, batch_size=32,
          validation_data=(x_val, y_val), callbacks=[reduce_lr])

在这个例子中，ReduceLROnPlateau 调度器会监控验证集损失 (val_loss)，当验证集损失在 10 个 epoch 内没有下降时，会将学习率降低 10 倍 (factor=0.1)，直到学习率达到最小值 0.00001 (min_lr=0.00001)。

7. 自定义优化器

除了使用 Keras 内置的优化器，还可以自定义优化器。自定义优化器需要继承 tf.keras.optimizers.Optimizer 类，并实现 apply_gradients 方法。

示例：自定义一个简单的动量优化器


import tensorflow as tf
class MomentumOptimizer(tf.keras.optimizers.Optimizer):
    def __init__(self, learning_rate=0.01, momentum=0.9, name='MomentumOptimizer', **kwargs):
        super(MomentumOptimizer, self).__init__(name, **kwargs)
        self._learning_rate = self._build_learning_rate(learning_rate)
        self._momentum = momentum
    def build(self, var_list):
        super().build(var_list)
        self._momentums = []
        for var in var_list:
            self._momentums.append(self.add_weight(
                shape=var.shape,
                initializer=tf.keras.initializers.zeros,
                trainable=False,
                name=var.name.split(':')[0] + '/momentum'
            ))
    def apply_gradients(self, grads_and_vars, name=None):
        grads, vars = list(zip(*grads_and_vars))
        momentums = self._momentums
        for i, grad in enumerate(grads):
            momentums[i].assign(self._momentum * momentums[i] - self._learning_rate * grad)
            vars[i].assign_add(momentums[i])
        return tf.group(*[v.assign_add(m) for v, m in zip(vars, momentums)])
    def get_config(self):
        config = super(MomentumOptimizer, self).get_config()
        config.update({
            'learning_rate': self._learning_rate.numpy(),
            'momentum': self._momentum
        })
        return config

在这个例子中，MomentumOptimizer 继承了 tf.keras.optimizers.Optimizer 类，并实现了 apply_gradients 方法。apply_gradients 方法根据梯度和动量来更新模型参数。get_config 方法用于序列化优化器的配置。

8. 代码示例：不同优化器的比较


import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
# 生成一些模拟数据
num_samples = 100
X = np.linspace(-5, 5, num_samples)
Y = 0.5 * X**2 + np.random.normal(0, 1, num_samples)
# 将数据转换为 TensorFlow 张量
X = tf.constant(X, dtype=tf.float32)
Y = tf.constant(Y, dtype=tf.float32)
# 定义模型
def build_model():
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(1, kernel_initializer='random_normal', bias_initializer='zeros')
    ])
    return model
# 定义训练函数
def train_model(model, optimizer, learning_rate, epochs=100):
    model.compile(optimizer=optimizer(learning_rate=learning_rate), loss='mse')
    history = model.fit(X, Y, epochs=epochs, verbose=0)
    return history
# 定义不同的优化器和学习率
optimizers = {
    'SGD': tf.keras.optimizers.SGD,
    'Adam': tf.keras.optimizers.Adam,
    'RMSprop': tf.keras.optimizers.RMSprop
}
learning_rates = {
    'SGD': 0.01,
    'Adam': 0.01,
    'RMSprop': 0.01
}
# 训练模型并记录损失
histories = {}
for name, optimizer in optimizers.items():
    model = build_model()
    history = train_model(model, optimizer, learning_rates[name])
    histories[name] = history
# 绘制损失曲线
plt.figure(figsize=(10, 6))
for name, history in histories.items():
    plt.plot(history.history['loss'], label=name)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Comparison of Optimizers')
plt.legend()
plt.grid(True)
plt.show()

这个例子比较了 SGD、Adam 和 RMSProp 三种优化器在同一个数据集上的性能。通过绘制损失曲线，可以直观地看到不同优化器的收敛速度和最终损失值。

9. 优化器选择的流程图

总结

优化器是深度学习模型训练的关键。Keras 提供了多种内置优化器，以及自定义优化器的能力。选择合适的优化器和学习率调度器可以帮助模型更快地收敛，并提高模型的泛化能力。在实际应用中，需要根据具体的任务和数据集，尝试不同的优化器和参数组合，并通过验证集来评估模型的性能，最终选择最佳的优化器。

作者与出处

原作者：灏天文库

来源：灏天文库

原文： https://aiknowledge.cn/collection/219-tensorflow%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0%E5%AE%9E%E6%88%98%E6%95%99%E7%A8%8B

整理：灏天文库整理

由灏天文库平台收录，内容或由平台用户上传，仅供学习交流