如何在keras 自定义学习率

keras中提供了几种学习率的设置，其中自定义学习率可以通过回调函数实现。

1. LearningRateScheduler

keras.callbacks.LearningRateScheduler(schedule)

该回调函数是学习率调度器

参数：

参数	说明
schedule	函数，该函数以epoch号为参数（从0算起的整数），返回一个新学习率（浮点数）

代码

import keras.backend as K
from keras.callbacks import LearningRateScheduler
 
def scheduler(epoch):
    # 每隔100个epoch，学习率减小为原来的1/10
    if epoch % 100 == 0 and epoch != 0:
        lr = K.get_value(model.optimizer.lr)
        K.set_value(model.optimizer.lr, lr * 0.1)
        print("lr changed to {}".format(lr * 0.1))
    return K.get_value(model.optimizer.lr)
 
reduce_lr = LearningRateScheduler(scheduler)
model.fit(train_x, train_y, batch_size=32, epochs=300, callbacks=[reduce_lr])

具体的应用效果：

import tensorflow as tf
import tensorflow.keras
import numpy as np
import os
import tensorflow.keras.backend as K
from tensorflow.keras.callbacks import LearningRateScheduler


def scheduler(epoch):
    # 每隔1个epoch，学习率减小为原来的1/10
    if epoch % 1 == 0 and epoch != 0:
        lr = K.get_value(model.optimizer.lr)
        K.set_value(model.optimizer.lr, lr * 0.1)
        print("lr changed to {}".format(lr * 0.1))
    return K.get_value(model.optimizer.lr)

def load_mnist(path):
    """加载本地下载好的mnist数据集"""
    f = np.load(path)
    x_train, y_train = f['x_train'], f['y_train']
    x_test, y_test = f['x_test'], f['y_test']
    f.close()
    return (x_train, y_train), (x_test, y_test)

reduce_lr = LearningRateScheduler(scheduler)
(x_train, y_train), (x_test, y_test) = load_mnist("mnist.npz")
x_train, x_test = x_train / 255.0, x_test / 255.0  # 将样本从整数转换为浮点数

# 利用tf.keras.Sequential容器封装网络层，前一层网络的输出默认作为下一层的输入
model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(128, activation='relu'),  # 创建一层网络，设置输出节点数为128，激活函数类型为Relu
    tf.keras.layers.Dropout(0.2),  # 在训练中每次更新时， 将输入单元的按比率随机设置为 0， 这有助于防止过拟合
    tf.keras.layers.Dense(10, activation='softmax')])  # Dense层就是所谓的全连接神经网络层

model.summary()

# 为训练选择优化器和损失函数：
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

log_dir = os.path.join("logs")
# print(log_dir)
if not os.path.exists(log_dir):
    os.mkdir(log_dir)
# 定义TensorBoard对象.histogram_freq 如果设置为0，则不会计算直方图。
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)

# TensorBoard对象作为回调传给model.fit方法
model.fit(x_train, y_train, epochs=8, validation_data=(x_test, y_test), callbacks=[tensorboard_callback,reduce_lr])

model.save_weights('weight/my_weights', save_format='tf')  # 保存模型

2.ReduceLROnPlateau

keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=10, verbose=0, mode='auto', epsilon=0.0001, cooldown=0, min_lr=0)

当评价指标不在提升时，减少学习率

当学习停滞时，减少2倍或10倍的学习率常常能获得较好的效果。该回调函数检测指标的情况，如果在patience个epoch中看不到模型性能提升，则减少学习率

参数:

参数	说明
monitor	被监测的量
factor	每次减少学习率的因子，学习率将以lr = lr*factor的形式被减少
patience	当patience个epoch过去而模型性能不提升时，学习率减少的动作会被触发
mode	‘auto’，‘min’，‘max’之一，在min模式下，如果检测值触发学习率减少。在max模式下，当检测值不再上升则触发学习率减少。
epsilon	阈值，用来确定是否进入检测值的“平原区”
cooldown	学习率减少后，会经过cooldown个epoch才重新进行正常操作
min_lr	学习率的下限

代码：

from keras.callbacks import ReduceLROnPlateau
reduce_lr = ReduceLROnPlateau(monitor='val_loss', patience=10, mode='auto')
model.fit(train_x, train_y, batch_size=32, epochs=300, validation_split=0.1, callbacks=[reduce_lr])

3.重载optimizers.schedules.LearningRateSchedule

LearningRateSchedule 可以作为一个学习率优化器使用。他们可以通过tf.keras.optimizers.schedules.serialize和 tf.keras.optimizers.schedules.deserialize进行序列化和反序列化。
注意此种方法要保存整个模型时，需要重写get_config方法。
见 NotImplementedError: Learning rate schedule must override get_config

代码

class CosineAnnealSchedule(optimizers.schedules.LearningRateSchedule):
    def __init__(self, epoch, train_step, lr_max, lr_min, warmth_rate=0.2):
        """
        学习率调节函数
        :param epoch: 训练轮次
        :param train_step: 一轮训练次数
        :param lr_max: 最大学习率
        :param lr_min: 最小学习率
        :param warmth_rate: 预热轮次的占比
        """
        super(CosineAnnealSchedule, self).__init__()

        self.total_step = epoch * train_step
        self.warm_step = self.total_step * warmth_rate
        self.lr_max = lr_max
        self.lr_min = lr_min

    @tf.function
    def __call__(self, step):
        if step < self.warm_step:
            lr = self.lr_max / self.warm_step * step
        else:
            lr = self.lr_min + 0.5 * (self.lr_max - self.lr_min) * (
                    1.0 + tf.cos((step - self.warm_step) / self.total_step * np.pi)
            )

        return lr
learning_rate = CosineAnnealSchedule(cfg.epochs, train_steps, cfg.lr, cfg.lr / 1e+4)
optimizer = optimizers.Adam(learning_rate=learning_rate)
model.compile(optimizer=optimizer, loss=yolo_loss)