code: def test_concat_scheduler_two_schedulers(duration_vals_as_np_int):
      tensor = torch.zeros([1], requires_grad=True)
      optimizer = torch.optim.SGD([tensor], lr=0)
  
      scheduler_1 = LinearCyclicalScheduler(
          optimizer, "lr", start_value=1.0, end_value=0.0, cycle_size=10
      )
      scheduler_2 = CosineAnnealingScheduler(
          optimizer, "lr", start_value=0.0, end_value=1.0, cycle_size=10
      )
  
      durations = [10]
      if duration_vals_as_np_int:
          durations = [np.int64(t) for t in durations]
  
      concat_scheduler = ConcatScheduler(
          schedulers=[scheduler_1, scheduler_2],
          durations=durations,
          save_history=True,
      )
      state_dict = concat_scheduler.state_dict()
  
      data = [0] * 10
      max_epochs = 2
      simulated_values = ConcatScheduler.simulate_values(
          num_events=len(data) * max_epochs,
          schedulers=[scheduler_1, scheduler_2],
          durations=durations,
      )
  
      def save_lr(engine):
          lrs.append(optimizer.param_groups[0]["lr"])
  
      trainer = Engine(lambda engine, batch: None)
      trainer.add_event_handler(
          Events.ITERATION_STARTED, concat_scheduler
      )
      trainer.add_event_handler(Events.ITERATION_COMPLETED, save_lr)
  
      for _ in range(2):
          lrs = []
          trainer.run(data, max_epochs=max_epochs)
  
          assert lrs == list(
              map(
                  pytest.approx,
                  [
                      # Cycle 1 of the LinearCyclicalScheduler
                      1.0,
                      0.8,
                      0.6,
                      0.4,
                      0.2,
                      0.0,
                      0.2,
                      0.4,
                      0.6,
                      0.8,
                      # Cycle 1 of the CosineAnnealingScheduler
                      0.0,
                      0.02447174185242318,
                      0.09549150281252627,
                      0.20610737385376332,
                      0.3454915028125263,
                      0.5,
                      0.6545084971874737,
                      0.7938926261462365,
                      0.9045084971874737,
                      0.9755282581475768,
                  ],
              )
          )
  
          state_lrs = trainer.state.param_history["lr"]
          assert len(state_lrs) == len(lrs)
          # Unpack singleton lists
          assert [group[0] for group in state_lrs] == lrs
          assert lrs == pytest.approx([v for i, v in simulated_values])
          concat_scheduler.load_state_dict(state_dict)
  
          trainer.state.param_history = None
  
imports: from unittest.mock import MagicMock, patch
  import numpy
  import pytest
  import torch
  from torch.optim.lr_scheduler import CosineAnnealingWarmRestarts, ExponentialLR, StepLR
  from ignite.engine import Engine, Events
  from ignite.handlers.param_scheduler import ConcatScheduler, CosineAnnealingScheduler, create_lr_scheduler_with_warmup, LinearCyclicalScheduler, LRScheduler, ParamGroupScheduler, ParamScheduler, PiecewiseLinear, ReduceLROnPlateauScheduler
  from tests.ignite.contrib.handlers import MockFP16DeepSpeedZeroOptimizer
label_desc: Use image node_id 8 for calling a global function with example usage: test_concat_scheduler_two_schedulers(duration_vals_as_np_int) without return types