class_docstr: Sets the learning rate of each parameter group to follow a linear warmup schedule between warmup_start_lr and
  base_lr followed by a cosine annealing schedule between base_lr and eta_min.
  
  .. warning::
      It is recommended to call :func:`.step()` for :class:`LinearWarmupCosineAnnealingLR`
      after each iteration as calling it after each epoch will keep the starting lr at
      warmup_start_lr for the first epoch which is 0 in most cases.
  
  .. warning::
      passing epoch to :func:`.step()` is being deprecated and comes with an EPOCH_DEPRECATION_WARNING.
      It calls the :func:`_get_closed_form_lr()` method for this scheduler instead of
      :func:`get_lr()`. Though this does not change the behavior of the scheduler, when passing
      epoch param to :func:`.step()`, the user should call the :func:`.step()` function before calling
      train and validation methods.
  
  Example:
      >>> from torch import nn
      >>> from torch.optim import Adam
      >>> layer = nn.Linear(10, 1)
      >>> optimizer = Adam(layer.parameters(), lr=0.02)
      >>> scheduler = LinearWarmupCosineAnnealingLR(optimizer, warmup_epochs=10, max_epochs=40)
      >>> #
      >>> # the default case
      >>> for epoch in range(40):
      ...     # train(...)
      ...     # validate(...)
      ...     scheduler.step()
      >>> #
      >>> # passing epoch param case
      >>> for epoch in range(40):
      ...     scheduler.step(epoch)
      ...     # train(...)
      ...     # validate(...)
docstr: Compute learning rate using chainable form of the scheduler.
docstr_tok: ["Compute","learning","rate","using","chainable","form","of","the","scheduler","."]
code: def get_lr(self) -> List[float]:
      """Compute learning rate using chainable form of the scheduler."""
      if not self._get_lr_called_within_step:
          warnings.warn(
              "To get the last learning rate computed by the scheduler, "
              "please use `get_last_lr()`.",
              UserWarning,
          )
  
      if self.last_epoch == self.warmup_epochs:
          return self.base_lrs
      if self.last_epoch == 0:
          return [self.warmup_start_lr] * len(self.base_lrs)
      if self.last_epoch < self.warmup_epochs:
          return [
              group["lr"]
              + (base_lr - self.warmup_start_lr)
              / (self.warmup_epochs - 1)
              for base_lr, group in zip(
                  self.base_lrs, self.optimizer.param_groups
              )
          ]
      if (self.last_epoch - 1 - self.max_epochs) % (
          2 * (self.max_epochs - self.warmup_epochs)
      ) == 0:
          return [
              group["lr"]
              + (base_lr - self.eta_min)
              * (
                  1
                  - math.cos(
                      math.pi / (self.max_epochs - self.warmup_epochs)
                  )
              )
              / 2
              for base_lr, group in zip(
                  self.base_lrs, self.optimizer.param_groups
              )
          ]
  
      return [
          (
              1
              + math.cos(
                  math.pi
                  * (self.last_epoch - self.warmup_epochs)
                  / (self.max_epochs - self.warmup_epochs)
              )
          )
          / (
              1
              + math.cos(
                  math.pi
                  * (self.last_epoch - self.warmup_epochs - 1)
                  / (self.max_epochs - self.warmup_epochs)
              )
          )
          * (group["lr"] - self.eta_min)
          + self.eta_min
          for group in self.optimizer.param_groups
      ]
  
file_path: lightning-flash/src/flash/core/optimizers/lr_scheduler.py
imports: import math
  import warnings
  from typing import List
  from torch.optim import Optimizer
  from torch.optim.lr_scheduler import _LRScheduler
  from flash.core.utilities.imports import _TOPIC_CORE_AVAILABLE
label_desc: Use image node_id 2 for calling the LinearWarmupCosineAnnealingLR obj's underlying member method code with example usage: obj.get_lr() and returns: unknown, self, unknown, unknown, unknown