code: def lazy_load_decompositions():
      global DECOMPOSITIONS_LOADED
      if DECOMPOSITIONS_LOADED:
          return
  
      with DECOMPOSITIONS_LOCK:
          if DECOMPOSITIONS_LOADED:
              return
  
          if not (
              os.environ.get("PYTORCH_JIT", "1") == "1" and __debug__
          ):
              DECOMPOSITIONS_LOADED = True
              return
  
          # use an alternate way to register an operator into the decomposition table
          # _register_jit_decomposition doesn't work for some operators, e.g. addr,
          #  because the Tensor types generated cannot be unioned by torchscript
          # decomp should be type OpOverload
          global VMAP_DECOMPOSITIONS_LIB
          VMAP_DECOMPOSITIONS_LIB = torch.library.Library(
              "aten", "IMPL", "FuncTorchBatched"
          )
  
          from torch._decomp import decomposition_table
  
          def _register_python_decomposition_vmap(decomp):
              if decomp in decomposition_table:
                  VMAP_DECOMPOSITIONS_LIB.impl(
                      decomp, decomposition_table[decomp]
                  )
              else:
                  raise RuntimeError(
                      f"could not find decomposition for {decomp}"
                  )
  
          _register_python_decomposition_vmap(
              torch.ops.aten.mse_loss_backward.default
          )
          _register_python_decomposition_vmap(
              torch.ops.aten.smooth_l1_loss_backward.default
          )
          _register_python_decomposition_vmap(
              torch.ops.aten.huber_loss_backward.default
          )
          _register_python_decomposition_vmap(
              torch.ops.aten.nll_loss_forward.default
          )
          _register_python_decomposition_vmap(
              torch.ops.aten.nll_loss2d_forward.default
          )
          _register_python_decomposition_vmap(
              torch.ops.aten.nll_loss_backward.default
          )
          _register_python_decomposition_vmap(
              torch.ops.aten.nll_loss2d_backward.default
          )
          _register_python_decomposition_vmap(
              torch.ops.aten.addr.default
          )
  
          DECOMPOSITIONS_LOADED = True
  
imports: import torch
  import functools
  import threading
  from torch import Tensor
  from typing import Any, Callable, Optional, Tuple, Union, List
  from torch.utils._pytree import tree_flatten, tree_unflatten, tree_map_, _broadcast_to_and_flatten, TreeSpec
  from functools import partial
  import os
  import itertools
  from torch._C._functorch import _add_batch_dim, _remove_batch_dim, _vmap_decrement_nesting, _vmap_increment_nesting, is_batchedtensor
label_desc: Use image node_id 12 for calling a global function with example usage: lazy_load_decompositions() without return types