class_docstr: Standard supervised training method with image and label, inherits from ``Trainer`` and ``Workflow``.
  
  Args:
      device: an object representing the device on which to run.
      max_epochs: the total epoch number for trainer to run.
      train_data_loader: Ignite engine use data_loader to run, must be Iterable or torch.DataLoader.
      network: network to train in the trainer, should be regular PyTorch `torch.nn.Module`.
      optimizer: the optimizer associated to the network, should be regular PyTorch optimizer from `torch.optim`
          or its subclass.
      loss_function: the loss function associated to the optimizer, should be regular PyTorch loss,
          which inherit from `torch.nn.modules.loss`.
      epoch_length: number of iterations for one epoch, default to `len(train_data_loader)`.
      non_blocking: if True and this copy is between CPU and GPU, the copy may occur asynchronously
          with respect to the host. For other cases, this argument has no effect.
      prepare_batch: function to parse expected data (usually `image`, `label` and other network args)
          from `engine.state.batch` for every iteration, for more details please refer to:
          https://pytorch.org/ignite/generated/ignite.engine.create_supervised_trainer.html.
      iteration_update: the callable function for every iteration, expect to accept `engine`
          and `engine.state.batch` as inputs, return data will be stored in `engine.state.output`.
          if not provided, use `self._iteration()` instead. for more details please refer to:
          https://pytorch.org/ignite/generated/ignite.engine.engine.Engine.html.
      inferer: inference method that execute model forward on input data, like: SlidingWindow, etc.
      postprocessing: execute additional transformation for the model output data.
          Typically, several Tensor based transforms composed by `Compose`.
      key_train_metric: compute metric when every iteration completed, and save average value to
          engine.state.metrics when epoch completed. key_train_metric is the main metric to compare and save the
          checkpoint into files.
      additional_metrics: more Ignite metrics that also attach to Ignite Engine.
      metric_cmp_fn: function to compare current key metric with previous best key metric value,
          it must accept 2 args (current_metric, previous_best) and return a bool result: if `True`, will update
          `best_metric` and `best_metric_epoch` with current metric and epoch, default to `greater than`.
      train_handlers: every handler is a set of Ignite Event-Handlers, must have `attach` function, like:
          CheckpointHandler, StatsHandler, etc.
      amp: whether to enable auto-mixed-precision training, default is False.
      event_names: additional custom ignite events that will register to the engine.
          new events can be a list of str or `ignite.engine.events.EventEnum`.
      event_to_attr: a dictionary to map an event to a state attribute, then add to `engine.state`.
          for more details, check: https://pytorch.org/ignite/generated/ignite.engine.engine.Engine.html
          #ignite.engine.engine.Engine.register_events.
      decollate: whether to decollate the batch-first data to a list of data after model computation,
          recommend `decollate=True` when `postprocessing` uses components from `monai.transforms`.
          default to `True`.
      optim_set_to_none: when calling `optimizer.zero_grad()`, instead of setting to zero, set the grads to None.
          more details: https://pytorch.org/docs/stable/generated/torch.optim.Optimizer.zero_grad.html.
      to_kwargs: dict of other args for `prepare_batch` API when converting the input data, except for
          `device`, `non_blocking`.
      amp_kwargs: dict of the args for `torch.cuda.amp.autocast()` API, for more details:
          https://pytorch.org/docs/stable/amp.html#torch.cuda.amp.autocast.
code: def __init__(
      self,
      device: str | torch.device,
      max_epochs: int,
      train_data_loader: Iterable | DataLoader,
      network: torch.nn.Module,
      optimizer: Optimizer,
      loss_function: Callable,
      epoch_length: int | None = None,
      non_blocking: bool = False,
      prepare_batch: Callable = default_prepare_batch,
      iteration_update: Callable[[Engine, Any], Any] | None = None,
      inferer: Inferer | None = None,
      postprocessing: Transform | None = None,
      key_train_metric: dict[str, Metric] | None = None,
      additional_metrics: dict[str, Metric] | None = None,
      metric_cmp_fn: Callable = default_metric_cmp_fn,
      train_handlers: Sequence | None = None,
      amp: bool = False,
      event_names: list[str | EventEnum | type[EventEnum]]
      | None = None,
      event_to_attr: dict | None = None,
      decollate: bool = True,
      optim_set_to_none: bool = False,
      to_kwargs: dict | None = None,
      amp_kwargs: dict | None = None,
  ) -> None:
      super().__init__(
          device=device,
          max_epochs=max_epochs,
          data_loader=train_data_loader,
          epoch_length=epoch_length,
          non_blocking=non_blocking,
          prepare_batch=prepare_batch,
          iteration_update=iteration_update,
          postprocessing=postprocessing,
          key_metric=key_train_metric,
          additional_metrics=additional_metrics,
          metric_cmp_fn=metric_cmp_fn,
          handlers=train_handlers,
          amp=amp,
          event_names=event_names,
          event_to_attr=event_to_attr,
          decollate=decollate,
          to_kwargs=to_kwargs,
          amp_kwargs=amp_kwargs,
      )
  
      self.network = network
      self.optimizer = optimizer
      self.loss_function = loss_function
      self.inferer = SimpleInferer() if inferer is None else inferer
      self.optim_set_to_none = optim_set_to_none
  
imports: from __future__ import annotations
  from typing import TYPE_CHECKING, Any, Callable, Iterable, Sequence
  import torch
  from torch.optim.optimizer import Optimizer
  from torch.utils.data import DataLoader
  from monai.config import IgniteInfo
  from monai.engines.utils import IterationEvents, default_make_latent, default_metric_cmp_fn, default_prepare_batch
  from monai.engines.workflow import Workflow
  from monai.inferers import Inferer, SimpleInferer
  from monai.transforms import Transform
  from monai.utils import GanKeys, min_version, optional_import
  from monai.utils.enums import CommonKeys
  from monai.utils.enums import EngineStatsKeys
label_desc: Use image node_id 1 to create a new SupervisedTrainer object from inherited base classes: Trainer with example: obj = SupervisedTrainer(device, max_epochs, train_data_loader, network, optimizer, loss_function, epoch_length, non_blocking, prepare_batch, iteration_update, inferer, postprocessing, key_train_metric, additional_metrics, metric_cmp_fn, train_handlers, amp, event_names, event_to_attr, decollate, optim_set_to_none, to_kwargs, amp_kwargs)