class_docstr: Automatically monitor and logs learning rate for learning rate schedulers during training.
  
  Args:
      logging_interval: set to ``'epoch'`` or ``'step'`` to log ``lr`` of all optimizers
          at the same interval, set to ``None`` to log at individual interval
          according to the ``interval`` key of each scheduler. Defaults to ``None``.
      log_momentum: option to also log the momentum values of the optimizer, if the optimizer
          has the ``momentum`` or ``betas`` attribute. Defaults to ``False``.
  
  Raises:
      MisconfigurationException:
          If ``logging_interval`` is none of ``"step"``, ``"epoch"``, or ``None``.
  
  Example::
  
      >>> from lightning.pytorch import Trainer
      >>> from lightning.pytorch.callbacks import LearningRateMonitor
      >>> lr_monitor = LearningRateMonitor(logging_interval='step')
      >>> trainer = Trainer(callbacks=[lr_monitor])
  
  Logging names are automatically determined based on optimizer class name.
  In case of multiple optimizers of same type, they will be named ``Adam``,
  ``Adam-1`` etc. If a optimizer has multiple parameter groups they will
  be named ``Adam/pg1``, ``Adam/pg2`` etc. To control naming, pass in a
  ``name`` keyword in the construction of the learning rate schedulers.
  A ``name`` keyword can also be used for parameter groups in the
  construction of the optimizer.
  
  Example::
  
      def configure_optimizer(self):
          optimizer = torch.optim.Adam(...)
          lr_scheduler = {
              'scheduler': torch.optim.lr_scheduler.LambdaLR(optimizer, ...)
              'name': 'my_logging_name'
          }
          return [optimizer], [lr_scheduler]
  
  Example::
  
      def configure_optimizer(self):
          optimizer = torch.optim.SGD(
              [{
                  'params': [p for p in self.parameters()],
                  'name': 'my_parameter_group_name'
              }],
              lr=0.1
          )
          lr_scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, ...)
          return [optimizer], [lr_scheduler]
code: def on_train_batch_start(
      self, trainer: "pl.Trainer", *args: Any, **kwargs: Any
  ) -> None:
      if not trainer._logger_connector.should_update_logs:
          return
  
      if self.logging_interval != "epoch":
          interval = "step" if self.logging_interval is None else "any"
          latest_stat = self._extract_stats(trainer, interval)
  
          if latest_stat:
              for logger in trainer.loggers:
                  logger.log_metrics(
                      latest_stat,
                      step=trainer.fit_loop.epoch_loop._batches_that_stepped,
                  )
  
imports: import itertools
  from collections import defaultdict
  from typing import Any, DefaultDict, Dict, List, Literal, Optional, Set, Tuple, Type
  import torch
  from torch.optim.optimizer import Optimizer
  from typing_extensions import override
  import lightning.pytorch
  from lightning.pytorch.callbacks.callback import Callback
  from lightning.pytorch.utilities.exceptions import MisconfigurationException
  from lightning.pytorch.utilities.rank_zero import rank_zero_warn
  from lightning.pytorch.utilities.types import LRSchedulerConfig
label_desc: Use image node_id 3 for calling the LearningRateMonitor obj's underlying member method code with example usage: obj.on_train_batch_start(trainer) without return types