class_docstr: Package of a program from :func:`export`. It contains
  an :class:`torch.fx.Graph` that represents Tensor computation, a state_dict containing
  tensor values of all lifted parameters and buffers, and various metadata.
  
  You can call an ExportedProgram like the original callable traced by
  :func:`export` with the same calling convention.
  
  To perform transformations on the graph, use ``.module`` property to access
  an :class:`torch.fx.GraphModule`. You can then use
  `FX transformation <https://pytorch.org/docs/stable/fx.html#writing-transformations>`_
  to rewrite the graph. Afterwards, you can simply use :func:`export`
  again to construct a correct ExportedProgram.
code: def __init__(
      self,
      root: Union[torch.nn.Module, Dict[str, Any]],
      graph: torch.fx.Graph,
      graph_signature: ExportGraphSignature,
      state_dict: Dict[str, Union[torch.Tensor, torch.nn.Parameter]],
      range_constraints: "Dict[sympy.Symbol, Any]",
      module_call_graph: List[ModuleCallEntry],
      example_inputs: Optional[
          Tuple[Tuple[Any, ...], Dict[str, Any]]
      ] = None,
      verifier: Optional[
          Type[Any]
      ] = None,  # TODO Change typing hint to Verifier.
      tensor_constants: Optional[Dict[str, torch.Tensor]] = None,
  ):
      from torch._export.exported_program import (
          _create_graph_module_for_export,
      )
  
      # Remove codegen related things from the graph. It should just be a flat graph.
      graph._codegen = torch.fx.graph.CodeGen()
      self._graph_module = _create_graph_module_for_export(root, graph)
      if isinstance(root, torch.fx.GraphModule):
          self._graph_module.meta.update(root.meta)
  
      self._graph_signature: ExportGraphSignature = graph_signature
      self._state_dict: Dict[str, Any] = state_dict
      self._range_constraints: "Dict[sympy.Symbol, ValueRanges]" = (
          range_constraints
      )
      assert module_call_graph is not None
      self._module_call_graph: List[ModuleCallEntry] = module_call_graph
      self._example_inputs = example_inputs
  
      self._tensor_constants = tensor_constants or {}
  
      from torch._export.verifier import Verifier
  
      if verifier is None:
          verifier = Verifier
      assert issubclass(verifier, Verifier)
      self._verifier = verifier
      # Validate should be always the last step of the constructor.
      self.verifier().check(self)
  
imports: import copy
  import dataclasses
  import functools
  import types
  from typing import Any, Callable, Dict, Iterator, List, Optional, Tuple, Type, TYPE_CHECKING, Union
  import torch
  import torch.fx._pytree
  import torch.utils._pytree
  from torch.fx._compatibility import compatibility
  from torch.fx.experimental.proxy_tensor import maybe_disable_fake_tensor_mode
  from torch.fx.passes.infra.pass_base import PassResult
  from torch.fx.passes.infra.pass_manager import PassManager
  from .graph_signature import _sig_to_specs, ArgumentSpec, ConstantArgument, ExportGraphSignature, InputKind, InputSpec, OutputKind, OutputSpec, SymIntArgument, TensorArgument
label_desc: Use image node_id 1 to create a new ExportedProgram object  with example: obj = ExportedProgram(root, graph, graph_signature, state_dict, range_constraints, module_call_graph, example_inputs, verifier, tensor_constants)