根据Keras的作者，正确的方法是将TensorBoard回调子类化：

from keras import backend as K
from keras.callbacks import TensorBoard

class LRTensorBoard(TensorBoard):
    # add other arguments to __init__ if you need
    def __init__(self, log_dir, **kwargs):
        super().__init__(log_dir=log_dir, **kwargs)

    def on_epoch_end(self, epoch, logs=None):
        logs = logs or {}
        logs.update({'lr': K.eval(self.model.optimizer.lr)})
        super().on_epoch_end(epoch, logs)

然后将其作为callbacks参数的一部分传递给model.fit（来自Finncent Price）：

model.fit(x=..., y=..., callbacks=[LRTensorBoard(log_dir="/tmp/tb_log")])

注意，tf的当前夜间版本（2.5 -可能更早）使用LearningRateSchedule的学习率会自动添加到tensorboard的日志中。以下解决方案仅在您以其他方式调整学习率时才是必要的-例如。通过ReduceLROnPlateau或LearningRateScheduler（与LearningRateSchedule不同）回调。
虽然扩展tf.keras.callbacks.TensorBoard是一个可行的选择，但我更喜欢组合而不是子类化。

class LearningRateLogger(tf.keras.callbacks.Callback):
    def __init__(self):
        super().__init__()
        self._supports_tf_logs = True

    def on_epoch_end(self, epoch, logs=None):
        if logs is None or "learning_rate" in logs:
            return
        logs["learning_rate"] = self.model.optimizer.lr

这允许我们组合多个类似的回调，并在多个其他回调中使用记录的学习率（例如，如果你添加一个CSVLogger，它也应该把学习率值写入文件）。
然后在model.fit中

model.fit(
    callbacks=[
        LearningRateLogger(),
        # other callbacks that update `logs`
        tf.keras.callbacks.TensorBoard(path),
        # other callbacks that use updated logs, e.g. CSVLogger
    ],
    **kwargs
)

你给了优化器两次代码，而不是TensorBoard回调。无论如何，我没有找到在TensorBoard上显示学习率的方法。我在训练结束后绘制它，从History对象中获取数据：

nb_epoch = len(history1.history['loss'])
learning_rate=history1.history['lr']
xc=range(nb_epoch)
plt.figure(3,figsize=(7,5))
plt.plot(xc,learning_rate)
plt.xlabel('num of Epochs')
plt.ylabel('learning rate')
plt.title('Learning rate')
plt.grid(True)
plt.style.use(['seaborn-ticks'])

图表如下所示：LR plot
对不起，这不是你想问的问题，但可能会有帮助。

class XTensorBoard(TensorBoard):
    def on_epoch_begin(self, epoch, logs=None):
        # get values
        lr = float(K.get_value(self.model.optimizer.lr))
        decay = float(K.get_value(self.model.optimizer.decay))
        # computer lr
        lr = lr * (1. / (1 + decay * epoch))
        K.set_value(self.model.optimizer.lr, lr)

    def on_epoch_end(self, epoch, logs=None):
        logs = logs or {}
        logs['lr'] = K.get_value(self.model.optimizer.lr)
        super().on_epoch_end(epoch, logs)

callbacks_list = [XTensorBoard('./logs')]
model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=20, batch_size=32, verbose=2, callbacks=callbacks_list)

lr curve in tensorboard

对于tensorflor 2.5，如果你有一些自定义的学习率函数：

class LearningRateLogger(tf.keras.callbacks.Callback):
def __init__(self, log_dir):
    super().__init__()
    self._supports_tf_logs = True
    self.log_dir = log_dir
    
def set_model(self, model):                                                                                                                                                                                                                                       
    self.model = model                                                                                                                                                                                                                                            
    self.sess = tf.compat.v1.keras.backend.get_session()
    self.writer = tf.summary.create_file_writer(self.log_dir)

def on_epoch_end(self, epoch, logs=None):
    if logs is None or "learning_rate" in logs:
        return
    logs["learning_rate"] = self.model.optimizer.lr
    logs.update({'learning_rate': self.model.optimizer.lr})
    self._write_logs(logs, epoch)
    
def _write_logs(self, logs, index):

    with self.writer.as_default():                                                                                                                                                                                                                               
        for name, value in logs.items():                                                                                                                                                                                                                              
            if name in ['batch', 'size']:                                                                                                                                                                                                                             
                continue                                                                                                                                                                                                                    
            if isinstance(value, np.ndarray):
                tf.summary.scalar(name, value.item(), step=index)                                                                                                                                                                                                             
            else:
                tf.summary.scalar(name, value, step=index)
    
        self.writer.flush()

然后在您的model.fit中调用回调：

model.fit(x=..., y=..., callbacks=[LearningRateLogger(log_dir="/path/to/folder/where/tensorboard/is/logging")])

只要确保ReduceLROnPlateau回调在回调列表中位于TensorBoard回调之前。然后，您将看到每个epoch都有一个lr度量记录到TensorBoard。