docs: def create_lr_scheduler_with_warmup(lr_scheduler, warmup_start_value, warmup_end_value, warmup_duration,
                                      save_history=False,
                                      output_simulated_values=None):
      """
      Helper method to create a LR scheduler with a linear warm-up.
  
      Args:
          lr_scheduler (ParamScheduler or subclass of `torch.optim.lr_scheduler._LRScheduler`): LR scheduler after
              the warm-up.
          warmup_start_value (float): LR start value of the warm-up phase.
          warmup_end_value (float): LR end value of the warm-up phase.
          warmup_duration (int): warm-up phase duration, number of events.
          save_history (bool, optional): whether to log the parameter values to
              `engine.state.param_history`, (default=False).
          output_simulated_values (list, optional): optional output of simulated LR values.
              If output_simulated_values is a list of None, e.g. `[None] * 100`, after the execution it will be filled
              by 100 simulated LR values.
  
      Returns:
          ConcatScheduler: LR scheduler with linear warm-up.
  
  
      .. code-block:: python
  
          torch_lr_scheduler = ExponentialLR(optimizer=optimizer, gamma=0.98)
          lr_values = [None] * 100
          scheduler = create_lr_scheduler_with_warmup(torch_lr_scheduler,
                                                      warmup_start_value=0.0, warmup_end_value=0.1, warmup_duration=10,
                                                      output_simulated_values=lr_values)
          lr_values = np.array(lr_values)
          # Plot simulated values
          plt.plot(lr_values[:, 0], lr_values[:, 1], label="learning rate")
  
          # Attach to the trainer
          trainer.add_event_handler(Events.ITERATION_STARTED, scheduler)
  
      """
      if not isinstance(lr_scheduler, (ParamScheduler, _LRScheduler)):
          raise TypeError("Argument lr_scheduler should be a subclass of torch.optim.lr_scheduler._LRScheduler or "
                          "ParamScheduler, but given {}".format(type(lr_scheduler)))
  
      if isinstance(lr_scheduler, _LRScheduler):
          lr_scheduler = LRScheduler(lr_scheduler)
  
      dummy_optimizer = {}
      warmup_scheduler = LinearCyclicalScheduler(dummy_optimizer, param_name="lr",
                                                 start_value=warmup_start_value,
                                                 end_value=warmup_end_value,
                                                 cycle_size=warmup_duration * 2)
  
      warmup_scheduler.optimizer_param_groups = lr_scheduler.optimizer_param_groups
  
      schedulers = [warmup_scheduler, lr_scheduler]
      durations = [warmup_duration, ]
      combined_scheduler = ConcatScheduler(schedulers, durations=durations,
                                           save_history=save_history)
      if output_simulated_values is not None:
          if not isinstance(output_simulated_values, list):
              raise TypeError("Argument output_simulated_values should be a list of None, e.g. `[None] * 100`, "
                              "but given {}.".format(type(output_simulated_values)))
          num_events = len(output_simulated_values)
          result = ConcatScheduler.simulate_values(num_events=num_events, schedulers=schedulers, durations=durations)
          for i in range(num_events):
              output_simulated_values[i] = result[i]
      return combined_scheduler