class_docstr: Strategy for multi-process single-device training on one or multiple nodes.
class_docstr_tok: ["Strategy","for","multi-process","single-device","training","on","one","or","multiple","nodes","."]
code: def setup(self, trainer: "pl.Trainer") -> None:
      assert self.accelerator is not None
      self.accelerator.setup(trainer)
  
      # move the model to the correct device
      self.model_to_device()
  
      # skip wrapping the model if we are not fitting as no gradients need to be exchanged
      trainer_fn = trainer.state.fn
  
      if trainer_fn == TrainerFn.FITTING and self._layer_sync:
          assert self.model is not None
          self.model = self._layer_sync.apply(self.model)
  
      self.setup_precision_plugin()
  
      if trainer_fn == TrainerFn.FITTING:
          # do not wrap with DDP if not fitting as there's no gradients to reduce
          self.configure_ddp()
  
          # set up optimizers after the wrapped module has been moved to the device
          self.setup_optimizers(trainer)
          _optimizers_to_device(self.optimizers, self.root_device)
  
          import torch.distributed.algorithms.ddp_comm_hooks.post_localSGD_hook as post_localSGD
  
          if isinstance(
              self._ddp_comm_state, post_localSGD.PostLocalSGDState
          ):
              self._enable_model_averaging()
      else:
          # we need to manually synchronize the module's states since we aren't using the DDP wrapper
          assert self.model is not None
          _sync_module_states(self.model)
  
imports: import logging
  from contextlib import nullcontext
  from datetime import timedelta
  from typing import TYPE_CHECKING, Any, Callable, Dict, List, Literal, Optional, Union
  import torch
  import torch.distributed
  from lightning_utilities.core.rank_zero import rank_zero_only
  from torch import Tensor
  from torch.nn import Module
  from torch.nn.parallel.distributed import DistributedDataParallel
  from torch.optim.optimizer import Optimizer
  from typing_extensions import override
  import lightning.pytorch
  from lightning.fabric.plugins import CheckpointIO, ClusterEnvironment
  from lightning.fabric.plugins.collectives.torch_collective import default_pg_timeout
  from lightning.fabric.strategies import _StrategyRegistry
  from lightning.fabric.utilities.distributed import _distributed_is_initialized, _get_default_process_group_backend_for_device, _init_dist_connection, _sync_ddp_if_available
  from lightning.fabric.utilities.distributed import group
  from lightning.fabric.utilities.imports import _IS_WINDOWS
  from lightning.fabric.utilities.optimizer import _optimizers_to_device
  from lightning.fabric.utilities.seed import reset_seed
  from lightning.fabric.utilities.types import ReduceOp
  from lightning.pytorch.core.optimizer import LightningOptimizer
  from lightning.pytorch.overrides.distributed import _register_ddp_comm_hook, _sync_module_states, prepare_for_backward
  from lightning.pytorch.plugins.precision import Precision
  from lightning.pytorch.strategies.launchers import _MultiProcessingLauncher, _SubprocessScriptLauncher
  from lightning.pytorch.strategies.parallel import ParallelStrategy
  from lightning.pytorch.strategies.strategy import TBroadcast, _ForwardRedirection
  from lightning.pytorch.trainer.states import TrainerFn
  from lightning.pytorch.utilities.exceptions import _augment_message
  from lightning.pytorch.utilities.rank_zero import rank_zero_deprecation, rank_zero_info, rank_zero_only
label_desc: Use image node_id 11 for calling the DDPStrategy obj's underlying member method code with example usage: obj.setup(trainer) without return types