code: def test_trainer_compiled_model(
      _, tmp_path, monkeypatch, mps_count_0
  ):
      trainer_kwargs = {
          "default_root_dir": tmp_path,
          "fast_dev_run": True,
          "logger": False,
          "enable_checkpointing": False,
          "enable_model_summary": False,
          "enable_progress_bar": False,
      }
  
      model = BoringModel()
      compiled_model = torch.compile(model)
      assert (
          model._compiler_ctx is compiled_model._compiler_ctx
      )  # shared reference
  
      # can train with compiled model
      trainer = Trainer(**trainer_kwargs)
      trainer.fit(compiled_model)
      assert trainer.model._compiler_ctx["compiler"] == "dynamo"
  
      # the compiled model can be uncompiled
      to_uncompiled_model = to_uncompiled(compiled_model)
      assert model._compiler_ctx is None
      assert compiled_model._compiler_ctx is None
      assert to_uncompiled_model._compiler_ctx is None
  
      # the compiled model needs to be passed
      with pytest.raises(
          ValueError, match="required to be a compiled LightningModule"
      ):
          to_uncompiled(to_uncompiled_model)
  
      # the uncompiled model can be fitted
      trainer = Trainer(**trainer_kwargs)
      trainer.fit(model)
      assert trainer.model._compiler_ctx is None
  
      # some strategies do not support it
      if module_available("deepspeed"):
          compiled_model = torch.compile(model)
          mock_cuda_count(monkeypatch, 2)
          trainer = Trainer(
              strategy="deepspeed", accelerator="cuda", **trainer_kwargs
          )
          with pytest.raises(
              RuntimeError,
              match="Using a compiled model is incompatible with the current strategy.*",
          ):
              trainer.fit(compiled_model)
  
      # ddp does
      trainer = Trainer(strategy="ddp", **trainer_kwargs)
      trainer.fit(compiled_model)
  
      # an exception is raised
      trainer = Trainer(**trainer_kwargs)
      with pytest.raises(TypeError, match="must be a `Light"):
          trainer.fit(object())
  
file_path: pytorch-lightning/tests/tests_pytorch/utilities/test_compile.py
imports: import sys
  from unittest import mock
  import pytest
  import torch
  from lightning.fabric.utilities.imports import _TORCH_GREATER_EQUAL_2_1
  from lightning.pytorch import LightningModule, Trainer
  from lightning.pytorch.demos.boring_classes import BoringModel
  from lightning.pytorch.utilities.compile import from_compiled, to_uncompiled
  from lightning_utilities.core import module_available
  from tests_pytorch.conftest import mock_cuda_count
  from tests_pytorch.helpers.runif import RunIf
label_desc: Use image node_id 1 for calling a global function with example usage: test_trainer_compiled_model(_, tmp_path, monkeypatch, mps_count_0) without return types