Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/torch/_export/__init__.py

@@ -0,0 +1,1155 @@
+import copy
+import dataclasses
+import functools
+import io
+import json
+import pathlib
+import re
+import sys
+
+import types
+import warnings
+import weakref
+import zipfile
+from collections import OrderedDict
+from contextlib import contextmanager
+
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from unittest.mock import patch
+
+import sympy
+
+import torch
+import torch._dynamo
+import torch.fx
+import torch.fx._pytree as fx_pytree
+
+import torch.utils._pytree as pytree
+from torch._decomp import core_aten_decompositions, get_decompositions
+from torch._dispatch.python import enable_python_dispatcher
+from torch._dynamo.exc import UserError, UserErrorType
+from torch._dynamo.source import ConstantSource
+from torch._export.passes.collect_tracepoints_pass import CollectTracepointsPass
+from torch._functorch.aot_autograd import aot_export_module, GraphSignature
+from torch._functorch.eager_transforms import functionalize
+from torch._guards import detect_fake_mode
+from torch._ops import OpOverload
+from torch._subclasses.fake_tensor import FakeTensor, FakeTensorMode
+from torch.export import _create_constraint, _Dim, Constraint
+from torch.export.exported_program import (
+    ExportedProgram,
+    ModuleCallEntry,
+    ModuleCallSignature,
+    _disable_prexisiting_fake_mode,
+)
+from torch.export.graph_signature import (
+    _sig_to_specs,
+    ArgumentSpec,
+    ConstantArgument,
+    ExportGraphSignature,
+    InputKind,
+    InputSpec,
+    OutputKind,
+    OutputSpec,
+    SymIntArgument,
+    TensorArgument,
+)
+from torch.fx import traceback as fx_traceback
+from torch.fx._compatibility import compatibility
+from torch.fx.experimental.proxy_tensor import make_fx, maybe_disable_fake_tensor_mode
+from torch.fx.experimental.symbolic_shapes import (
+    ConstraintViolationError,
+    GuardOnDataDependentSymNode,
+    ShapeEnv,
+    StrictMinMaxConstraint,
+)
+from torch.fx.graph import _PyTreeCodeGen, _PyTreeInfo
+from torch.utils._sympy.value_ranges import ValueRangeError, ValueRanges
+
+from .exported_program import (
+    _create_stateful_graph_module,
+    _process_constraints,
+    CallSpec,
+)
+from .passes.add_runtime_assertions_for_constraints_pass import (
+    _AddRuntimeAssertionsForInlineConstraintsPass,
+)
+from .passes.lift_constant_tensor_pass import lift_constant_tensor_pass
+from .passes.remove_runtime_assertions import _RemoveRuntimeAssertionsPass
+from .passes.replace_sym_size_ops_pass import _replace_sym_size_ops_pass
+from .passes.replace_view_ops_with_view_copy_ops_pass import (
+    ReplaceViewOpsWithViewCopyOpsPass,
+)
+from .wrappers import _wrap_submodules
+
+
+def _process_dynamic_shapes(
+    f: Callable,
+    args: Tuple[Any, ...],
+    kwargs: Optional[Dict[str, Any]] = None,
+    dynamic_shapes: Optional[Union[Dict[str, Any], Tuple[Any]]] = None,
+) -> Optional[List[Constraint]]:
+    if dynamic_shapes is None or len(dynamic_shapes) == 0:
+        return None
+
+    kwargs = kwargs if kwargs is not None else {}
+
+    from collections.abc import Mapping, Sequence
+
+    def tree_zip(combined_args, dynamic_shapes):
+        if isinstance(combined_args, (tuple, list)):
+            if not isinstance(dynamic_shapes, Sequence):
+                raise UserError(
+                    UserErrorType.INVALID_INPUT,
+                    f"Expected dynamic_shapes of a {type(combined_args)} to be a Sequence, "
+                    f"got {dynamic_shapes} instead",
+                )
+            if len(combined_args) != len(dynamic_shapes):
+                raise UserError(
+                    UserErrorType.INVALID_INPUT,
+                    f"Expected {dynamic_shapes} to have {len(combined_args)} items",
+                )
+            for i, shape in enumerate(dynamic_shapes):
+                yield from tree_zip(combined_args[i], shape)
+        elif isinstance(combined_args, dict):
+            if not isinstance(dynamic_shapes, Mapping):
+                raise UserError(
+                    UserErrorType.INVALID_INPUT,
+                    f"Expected dynamic_shapes of a {type(combined_args)} to be a Mapping, "
+                    f"got {dynamic_shapes} instead",
+                )
+            if len(combined_args) != len(dynamic_shapes):
+                raise UserError(
+                    UserErrorType.INVALID_INPUT,
+                    f"Expected {dynamic_shapes} to have {len(combined_args)} items",
+                )
+            for k, shape in dynamic_shapes.items():
+                yield from tree_zip(combined_args[k], shape)
+        elif dataclasses.is_dataclass(combined_args):
+            if not type(dynamic_shapes) == type(combined_args):
+                raise UserError(
+                    UserErrorType.INVALID_INPUT,
+                    f"Expected dynamic_shapes of a {type(combined_args)} to be a {type(combined_args)}, "
+                    f"got {dynamic_shapes} instead",
+                )
+            for f in dataclasses.fields(combined_args):
+                yield from tree_zip(getattr(combined_args, f.name), getattr(dynamic_shapes, f.name))
+        elif isinstance(combined_args, torch.Tensor):
+            yield (combined_args, dynamic_shapes)
+        else:
+            if dynamic_shapes is not None:
+                raise UserError(
+                    UserErrorType.INVALID_INPUT,
+                    f"Expected dynamic_shapes of a {type(combined_args)} to be None, "
+                    f"got {dynamic_shapes} instead",
+                )
+
+    def to_constraint(dim, tensor, i):
+        constraint = dynamic_dim(tensor, i, debug_name=dim.__name__)
+        if dim.min != 2:
+            constraint = constraint >= dim.min
+        if dim.max != sys.maxsize - 1:
+            constraint = constraint <= dim.max
+        return constraint
+
+    from collections import defaultdict
+    symbols = defaultdict(list)
+    bounds: Dict[str, Tuple[int, int]] = {}
+
+    def check_same_bounds(dim):
+        if dim.__name__ in symbols:
+            min_, max_ = bounds[dim.__name__]
+            if dim.min != min_ or dim.max != max_:
+                this_ = _Dim.readable(dim.__name__, min_, max_)
+                that_ = _Dim.readable(dim.__name__, dim.min, dim.max)
+                raise UserError(
+                    UserErrorType.INVALID_INPUT,
+                    f"Found different definitions {this_} and {that_} "
+                    f"for the same symbolic dimension {dim}!"
+                )
+
+        else:
+            bounds[dim.__name__] = (dim.min, dim.max)
+
+    def update_symbols(tensor, shape):
+        if isinstance(shape, dict):
+            for i, dim in shape.items():
+                if isinstance(dim, _Dim):
+                    check_same_bounds(dim)
+                    symbols[dim.__name__].append(to_constraint(dim, tensor, i))
+                else:
+                    if dim is not None:
+                        raise UserError(
+                            UserErrorType.INVALID_INPUT,
+                            f"Unexpected item #{i} ({dim}) in dynamic_shape {shape} of Tensor, "
+                            "try None instead",
+                        )
+        elif isinstance(shape, (tuple, list)):
+            for i, dim in enumerate(shape):
+                if isinstance(dim, _Dim):
+                    check_same_bounds(dim)
+                    symbols[dim.__name__].append(to_constraint(dim, tensor, i))
+                else:
+                    if dim is not None:
+                        raise UserError(
+                            UserErrorType.INVALID_INPUT,
+                            f"Unexpected item #{i} ({dim}) in dynamic_shape {shape} of Tensor, "
+                            "try None instead",
+                        )
+        else:
+            if shape is not None:
+                raise UserError(
+                    UserErrorType.INVALID_INPUT,
+                    f"Unexpected dynamic_shape {shape} of Tensor, "
+                    "try None instead",
+                )
+
+    import inspect
+    if isinstance(f, ExportedProgram):
+        f = f.module()
+    signature = inspect.signature(f.forward) if isinstance(f, torch.nn.Module) else inspect.signature(f)
+    combined_args = signature.bind(*args, **kwargs).arguments
+
+    # This means user didn't specify dynamic shapes with argument names.
+    combined_args = combined_args if isinstance(dynamic_shapes, Mapping) else list(combined_args.values())  # type: ignore[assignment]
+    for tensor, shape in tree_zip(combined_args, dynamic_shapes):
+        update_symbols(tensor, shape)
+
+    constraints = []
+    for dynamic_dims in symbols.values():
+        primary, *others = dynamic_dims
+        if others:
+            for other in others:
+                constraints.append(primary == other)
+        else:
+            constraints.append(primary)
+
+    return constraints
+
+
+def export__RC__(
+    f: Callable,
+    args: Tuple[Any, ...],
+    kwargs: Optional[Dict[str, Any]] = None,
+    *,
+    dynamic_shapes: Optional[Union[Dict[str, Any], Tuple[Any]]] = None,
+    strict: bool = True,
+    preserve_module_call_signature: Tuple[str, ...] = (),
+) -> ExportedProgram:
+    """
+    API for exporting with dynamic shape specifications instead of constraints.
+    It should be considered "release candidate" (RC), meant to replace `export`.
+
+    Here, `dynamic_shapes` is expected to be a dict from
+    argument names of `f` to dynamic shape specifications OR a tuple where each element
+    corresponds to the original order of the arguments defined in the function signature
+    ,as follows:
+    - The dynamic shape of a tensor argument can be specified as:
+      - Either a dict from dynamic dimension indices to Dim types. It is not
+        required to include static dimension indices in this dict, but when
+        they are, they should be mapped to None.
+      - Or a tuple of Dim types or None. The Dim types correspond to dynamic
+        dimensions, whereas static dimensions are denoted by None.
+    - Arguments that are dicts or tuples of tensors are recursively specified
+      by using mappings or sequences of contained specifications.
+
+    See `export` for documentation of `f`, `args`, `kwargs` and return.
+    """
+    constraints = _process_dynamic_shapes(f, args, kwargs, dynamic_shapes)
+    return _export(
+        f,
+        args,
+        kwargs,
+        constraints=constraints,
+        strict=strict,
+        preserve_module_call_signature=preserve_module_call_signature
+    )
+
+
+def dynamic_dim(t: torch.Tensor, index: int, debug_name: Optional[str] = None):
+    if not isinstance(t, torch.Tensor):
+        raise UserError(
+            UserErrorType.DYNAMIC_DIM,
+            f"Expected tensor as input to dynamic_dim but got {type(t)}"
+        )
+
+    if t.dim() < 1:
+        raise UserError(
+            UserErrorType.DYNAMIC_DIM,
+            "Cannot mark 0-dimension tensors to be dynamic"
+        )
+
+    if index >= t.dim():
+        raise UserError(
+            UserErrorType.DYNAMIC_DIM,
+            f"Expected the dimension passed to dynamic_dim to be in the range [0:{t.dim()-1}]"
+            f" but got {index}, which is out of bounds for the given tensor."
+        )
+
+    return _create_constraint(
+        weakref.ref(t),
+        id(t),
+        index,
+        StrictMinMaxConstraint(
+            vr=ValueRanges(lower=2, upper=sympy.oo), warn_only=False
+        ),
+        debug_name=debug_name,
+    )
+
+
+@dataclasses.dataclass
+class ExportDynamoConfig:
+    """
+    Manage Export-specific configurations of Dynamo.
+    """
+    allow_rnn: bool = True
+
+DEFAULT_EXPORT_DYNAMO_CONFIG = ExportDynamoConfig()
+
+
+DECOMP_TABLE = core_aten_decompositions()
+
+
+# TODO(zhxchen17) This is not needed if we output pre_dispatch graph upfront from export().
+@contextmanager
+def _disable_decomp_table():
+    global DECOMP_TABLE
+    prev, DECOMP_TABLE = DECOMP_TABLE, {}
+    try:
+        yield
+    finally:
+        DECOMP_TABLE = prev
+
+
+@compatibility(is_backward_compatible=False)
+def capture_pre_autograd_graph(
+    f: Callable,
+    args: Tuple[Any],
+    kwargs: Optional[Dict[str, Any]] = None,
+    constraints: Optional[List[Constraint]] = None,
+) -> torch.nn.Module:
+    """
+    A helper function that is intended to trace a module before any pre-autograd
+    decomposition is run. The produced module will be "non-functional" and
+    composed of aten operators. Later this API will be deleted in favor of more general
+    torch.export API.
+
+    Args:
+      f: A callable to be traced
+
+      args: example positional inputs.
+
+      kwargs: optional example keyword inputs.
+
+      constraints: A optional list of constraints on the dynamic arguments specifying
+            their possible range of their shapes
+
+    Returns:
+        An nn.Module containing the traced method.
+
+    """
+
+    decomp_table = {
+        torch.ops.aten.dropout.default: torch.ops.aten.dropout.default.decompose,
+        torch.ops.aten.batch_norm.default: torch.ops.aten.batch_norm.default.decompose,
+        torch.ops.aten._batch_norm_impl_index.default: torch.ops.aten._batch_norm_impl_index.default.decompose,
+        torch.ops.aten.native_batch_norm.default: torch.ops.aten.native_batch_norm.default.decompose,
+    }
+
+    if kwargs is None:
+        kwargs = {}
+
+    with torch._dynamo.config.patch(dataclasses.asdict(DEFAULT_EXPORT_DYNAMO_CONFIG)):
+        m = torch._dynamo.export(
+            f,
+            constraints=constraints,
+            assume_static_by_default=True,
+            tracing_mode="symbolic",
+            decomposition_table=decomp_table,
+            pre_dispatch=True,
+            aten_graph=True,
+        )(
+            *args,
+            **kwargs,
+        )[0]
+
+        def _train(self, mode: bool = True):
+            raise NotImplementedError("Calling train() is not supported yet.")
+
+        def _eval(self, mode: bool = True):
+            raise NotImplementedError("Calling eval() is not supported yet.")
+
+        _, _, _, fake_mode = _convert_input_to_fake(m, args, kwargs)
+
+        m.meta["inline_constraints"] = {
+            k: v
+            for k, v in fake_mode.shape_env.runtime_var_to_range.items()
+            if re.match(r"^[if]\d+$", str(k))
+        }
+
+        flat_args, _ = pytree.tree_flatten((args, kwargs or {}))
+        range_constraints, equality_constraints = _process_constraints(m, 0, flat_args)
+        unlifted_m = _create_stateful_graph_module(
+            m,
+            range_constraints=range_constraints,
+            equality_constraints=equality_constraints,
+        )
+        unlifted_m.train = types.MethodType(_train, m)  # type: ignore[method-assign]
+        unlifted_m.eval = types.MethodType(_eval, m)  # type: ignore[method-assign]
+        return unlifted_m
+
+
+def _convert_input_to_fake(gm, args, kwargs):
+    if len(args) == 0 and len(kwargs) == 0 and len(dict(gm.named_parameters())) == 0 and len(dict(gm.named_buffers())) == 0:
+        return [], {}, {}, None
+
+    fake_inps: List[torch.Tensor] = []
+    fake_mode = None
+    for node in gm.graph.nodes:
+        if node.op == "placeholder" and "val" in node.meta:
+            fake_val = node.meta["val"]
+            if fake_val is not None and isinstance(fake_val, torch.Tensor):
+                fake_inps.append(fake_val)
+
+    if detected_fake_mode := detect_fake_mode(fake_inps):
+        fake_mode = detected_fake_mode
+
+    assert fake_mode is not None, "Cannot find fake_mode attatched to the graph's placeholders."
+
+    count = 0
+
+    def convert_to_fake(x):
+        nonlocal count
+        val = fake_inps[count]
+        count += 1
+        return val
+
+    fake_args = pytree.tree_map_only(torch.Tensor, convert_to_fake, args)
+    # TODO properly use the cached fake tensor
+    fake_kwargs = pytree.tree_map_only(torch.Tensor, fake_mode.from_tensor, kwargs)
+    fake_params_buffers = pytree.tree_map_only(torch.Tensor,
+                                               functools.partial(fake_mode.from_tensor, static_shapes=True),
+                                               {**dict(gm.named_parameters(remove_duplicate=False)),
+                                                **dict(gm.named_buffers(remove_duplicate=False))})
+    return fake_args, fake_kwargs, fake_params_buffers, fake_mode
+
+
+def _replace_param_buffer_names(param_buffer_table, sig):
+    for spec in sig.input_specs:
+        spec.target = param_buffer_table.get(spec.target, spec.target)
+    for spec in sig.output_specs:
+        spec.target = param_buffer_table.get(spec.target, spec.target)
+
+
+def _normalize_nn_module_stack(gm_torch_level, root_cls):
+    # Append a root module to every nn_module_stack.
+    root = "L['self']"
+    root_key = re.sub(r'[^a-zA-Z0-9]', '_', root)
+    for gm in gm_torch_level.modules():
+        if not isinstance(gm, torch.fx.GraphModule):
+            continue
+        for node in gm.graph.nodes:
+            if node.op in ["placeholder", "output"]:
+                continue
+            add_root = True
+            if nn_module_stack := node.meta.get("nn_module_stack", {}):
+                path, ty = next(iter(nn_module_stack.values()))
+                assert issubclass(ty, torch.nn.Module)
+                # TODO Figure out why sometimes we have root sometimes we don't.
+                if path == root and ty is root_cls:
+                    add_root = False
+            if add_root:
+                def normalize_path(path):
+                    try:
+                        parts = []
+
+                        class Path:
+                            def __getattr__(self, name):
+                                parts.append(name)
+                                return self
+
+                            def __getitem__(self, idx):
+                                parts.append(str(idx))
+                                return self
+
+                        eval(path, {"L": {"self": Path()}})
+                        return ".".join(parts)
+                    except Exception:  # TODO(zhxchen17) Remove this.
+                        return path
+
+                nn_module_stack = {root_key: (root, root_cls), **nn_module_stack}
+                node.meta["nn_module_stack"] = {
+                    key: (normalize_path(path), ty)
+                    for key, (path, ty) in nn_module_stack.items()
+                }
+
+def _export_to_torch_ir(
+    f: Callable,
+    args: Tuple[Any, ...],
+    kwargs: Optional[Dict[str, Any]] = None,
+    constraints: Optional[List[Constraint]] = None,
+    *,
+    preserve_module_call_signature: Tuple[str, ...] = (),
+    disable_constraint_solver: bool = False,
+) -> torch.fx.GraphModule:
+    """
+    Traces either an nn.Module's forward function or just a callable with PyTorch
+    operations inside and produce a torch.fx.GraphModule in torch IR.
+    """
+
+    constraints = constraints or []
+    kwargs = kwargs or {}
+
+    if not isinstance(args, tuple):
+        raise UserError(UserErrorType.INVALID_INPUT,
+                        f"Expecting `args` to be a tuple of example positional inputs, got {type(args)}")
+
+    # We convert to nn.Module because __call__ of ExportedProgram
+    # is untracable right now.
+    if isinstance(f, ExportedProgram):
+        f = f.module()
+
+    with torch._dynamo.config.patch(dataclasses.asdict(DEFAULT_EXPORT_DYNAMO_CONFIG)):
+        try:
+            module_call_specs: Dict[str, Dict[str, pytree.TreeSpec]] = {}
+            with _wrap_submodules(f, preserve_module_call_signature, module_call_specs):
+                gm_torch_level, _ = torch._dynamo.export(
+                    f,
+                    constraints=constraints,
+                    assume_static_by_default=True,
+                    tracing_mode="symbolic",
+                    disable_constraint_solver=disable_constraint_solver,
+                )(
+                    *args,
+                    **kwargs,
+                )
+        except (ConstraintViolationError, ValueRangeError) as e:
+            raise UserError(UserErrorType.CONSTRAINT_VIOLATION, str(e))  # noqa: TRY200
+        except GuardOnDataDependentSymNode as e:
+            raise UserError(  # noqa: TRY200
+                UserErrorType.ANTI_PATTERN,
+                f"Consider annotating your code using torch._constrain_as_*(). {str(e)}",
+                case_name="constrain_as_size_example",
+            )
+
+    gm_torch_level.meta["module_call_specs"] = module_call_specs
+    return gm_torch_level
+
+
+def export(
+    f: Callable,
+    args: Tuple[Any, ...],
+    kwargs: Optional[Dict[str, Any]] = None,
+    constraints: Optional[List[Constraint]] = None,
+    *,
+    strict: bool = True,
+    preserve_module_call_signature: Tuple[str, ...] = (),
+) -> ExportedProgram:
+
+    if constraints is not None:
+        warnings.warn(
+            "Using `constraints` to specify dynamic shapes for export is DEPRECATED "
+            "and will not be supported in the future. "
+            "Please use `dynamic_shapes` instead (see docs on `torch.export.export`).",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+    return _export(
+        f,
+        args,
+        kwargs,
+        constraints,
+        strict=strict,
+        preserve_module_call_signature=preserve_module_call_signature,
+    )
+
+
+def _unlift_user_inputs_to_buffers(
+    gm_torch_level: torch.fx.GraphModule,
+    aot_export_args
+) -> List[str]:
+    flat_args = pytree.tree_leaves(aot_export_args)
+    user_input_names = []
+    with gm_torch_level.graph.inserting_before():
+        for i, (arg, node) in enumerate(zip(flat_args, gm_torch_level.graph.nodes)):
+            assert node.op == "placeholder"
+            user_input_names.append(node.name)
+            if isinstance(arg, torch.Tensor):
+                assert not hasattr(gm_torch_level, node.name)
+                gm_torch_level.register_buffer(node.name, arg)
+                get_attr = gm_torch_level.graph.get_attr(node.name)
+                node.replace_all_uses_with(get_attr)
+                get_attr.meta = copy.copy(node.meta)
+
+    for node in list(gm_torch_level.graph.nodes):
+        if node.op == "placeholder":
+            assert len(node.users) == 0
+            gm_torch_level.graph.erase_node(node)
+    gm_torch_level.recompile()
+    return user_input_names
+
+
+def _lift_buffers_to_user_inputs(
+    gm: torch.fx.GraphModule,
+    graph_signature: GraphSignature,
+    user_input_names: List[str]
+) -> Dict[str, str]:
+    assert len(graph_signature.user_inputs) == 0
+    assert graph_signature.backward_signature is None
+    names = set(user_input_names)
+
+    placeholders = [node for node in gm.graph.nodes if node.op == "placeholder"]
+    # user inputs are always added in the end
+    start = len(graph_signature.parameters)
+    end = start + len(graph_signature.buffers)
+    buffer_nodes = placeholders[start:end]
+    last_placeholder_node = placeholders[-1] if len(placeholders) > 0 else None
+    old_nodes: Dict[str, torch.fx.Node] = {}
+    for node in buffer_nodes:
+        buffer_name = graph_signature.inputs_to_buffers[node.name]
+        if buffer_name not in names:
+            continue
+        old_nodes[buffer_name] = node
+    replaces = {}
+    new_node_names: Dict[str, str] = {}
+    with gm.graph.inserting_after(last_placeholder_node):
+        for name in reversed(user_input_names):
+            new_node = gm.graph.placeholder(name)
+            new_node.target = new_node.name
+            new_node_names[name] = new_node.name
+            if name in old_nodes:
+                old_node = old_nodes[name]
+                new_node.meta = copy.copy(old_node.meta)
+                old_node.replace_all_uses_with(new_node)
+                replaces[old_node.name] = new_node.name
+    new_node_names = dict(reversed(new_node_names.items()))
+    for old_node in old_nodes.values():
+        gm.graph.erase_node(old_node)
+
+    gm.recompile()
+
+    graph_signature.buffers = [b for b in graph_signature.buffers if b not in names]
+    graph_signature.inputs_to_buffers = {
+        i: b for i, b in graph_signature.inputs_to_buffers.items() if b not in names
+    }
+    user_inputs_to_mutate = {
+        o: b for o, b in graph_signature.buffers_to_mutate.items() if b in names
+    }
+    graph_signature.buffers_to_mutate = {
+        o: b for o, b in graph_signature.buffers_to_mutate.items() if b not in names
+    }
+    graph_signature.user_inputs.extend(new_node_names.values())  # type: ignore[arg-type]
+    graph_signature.user_outputs = [
+        replaces[o] if o in replaces else o for o in graph_signature.user_outputs
+    ]
+    return user_inputs_to_mutate  # type: ignore[return-value]
+
+
+def _export_non_strict(
+    mod,
+    fake_args,
+    fake_kwargs,
+    fake_params_buffers,
+    *,
+    transform=lambda x: x  # TODO(zhxchen17) Revisit if this is needed later.
+):
+    # This _reparametrize_module makes sure inputs and module.params/buffers have the same fake_mode,
+    # otherwise aot_export_module will error out because it sees a mix of fake_modes.
+    # And we want aot_export_module to use the fake_tensor mode in dynamo to keep the pipeline easy to reason about.
+    with torch.nn.utils.stateless._reparametrize_module(mod, fake_params_buffers):
+        gm, graph_signature = transform(aot_export_module)(
+            mod,
+            (*fake_args, *fake_kwargs.values()),
+            trace_joint=False
+        )
+
+    # NOTE: aot_export adds symint metadata for placeholders with int values;
+    # since these become specialized, we replace such metadata with the original values
+    flat_args = pytree.tree_leaves((fake_args, fake_kwargs))
+    index = 0
+    total_param_buffers = len(graph_signature.parameters) + len(graph_signature.buffers)
+    for node in gm.graph.nodes:
+        if node.op == "placeholder":
+            if index >= total_param_buffers:
+                user_arg = flat_args[index - total_param_buffers]
+                if not isinstance(user_arg, torch.Tensor):
+                    node.meta["val"] = user_arg
+            index += 1
+
+    is_joint = graph_signature.backward_signature is not None
+
+    def make_argument_spec(node) -> ArgumentSpec:
+        assert "val" in node.meta, f"{node} has no 'val' metadata field"
+        val = node.meta["val"]
+        if isinstance(val, FakeTensor):
+            return TensorArgument(name=node.name)
+        elif isinstance(val, torch.SymInt):
+            return SymIntArgument(name=node.name)
+        else:
+            return ConstantArgument(value=val)
+
+    input_specs, output_specs = _sig_to_specs(
+        user_inputs=set(graph_signature.user_inputs),
+        inputs_to_parameters=graph_signature.inputs_to_parameters,  # type: ignore[arg-type]
+        inputs_to_buffers=graph_signature.inputs_to_buffers,  # type: ignore[arg-type]
+        user_outputs=set(graph_signature.user_outputs),  # type: ignore[arg-type]
+        buffer_mutations=graph_signature.buffers_to_mutate,  # type: ignore[arg-type]
+        user_input_mutations=gm.meta.get("user_inputs_to_mutate", {}),  # type: ignore[arg-type]
+        grad_params=graph_signature.backward_signature.gradients_to_parameters if is_joint else {},  # type: ignore[arg-type, union-attr]
+        grad_user_inputs=graph_signature.backward_signature.gradients_to_user_inputs if is_joint else {},  # type: ignore[arg-type, union-attr]
+        loss_output=graph_signature.backward_signature.loss_output if is_joint else None,  # type: ignore[arg-type, union-attr]
+        inputs=[make_argument_spec(node) for node in gm.graph.nodes if node.op == "placeholder"],
+        outputs=[make_argument_spec(node) for node in pytree.tree_leaves(next(iter(reversed(gm.graph.nodes))).args)],
+    )
+    export_graph_signature = ExportGraphSignature(input_specs=input_specs, output_specs=output_specs)
+
+    tensor_constants = lift_constant_tensor_pass(gm, export_graph_signature)
+
+    @dataclasses.dataclass
+    class _ExportedProgramNonStrict:
+        gm: torch.fx.GraphModule
+        sig: ExportGraphSignature
+        tensor_constants: Dict[str, torch.Tensor]
+
+    return _ExportedProgramNonStrict(
+        gm,
+        export_graph_signature,
+        tensor_constants,
+    )
+
+
+def _get_params_buffers(mod: torch.nn.Module) -> Dict[str, torch.Tensor]:
+    params_buffers: Dict[str, torch.Tensor] = {}
+    for name, param in mod.named_parameters(remove_duplicate=False):
+        params_buffers[name] = param
+
+    for name, buffer in mod.named_buffers(remove_duplicate=False):
+        params_buffers[name] = buffer
+    return params_buffers
+
+
+@_disable_prexisiting_fake_mode
+def _export(
+    f: Callable,
+    args: Tuple[Any, ...],
+    kwargs: Optional[Dict[str, Any]] = None,
+    constraints: Optional[List[Constraint]] = None,
+    *,
+    strict: bool = True,
+    preserve_module_call_signature: Tuple[str, ...] = (),
+) -> ExportedProgram:
+    """
+    Traces either an nn.Module's forward function or just a callable with PyTorch
+    operations inside and produce a ExportedProgram.
+
+    Args:
+        m: the `nn.Module` or callable to trace.
+
+        args: example positional inputs.
+
+        kwargs: optional example keyword inputs.
+
+        constraints: A optional list of constraints on the dynamic arguments specifying
+            their possible range of their shapes
+
+        preserve_module_call_signature: A list of submodule paths for which the original
+            calling conventions are preserved as metadata.
+
+    Returns:
+        An ExportedProgram containing the traced method.
+    """
+    constraints = constraints or []
+    kwargs = kwargs or {}
+
+    if not strict:
+        assert isinstance(f, torch.nn.Module)
+        assert len(preserve_module_call_signature) == 0
+        assert len(constraints) == 0, "dynamic shape NYI"
+        assert len(kwargs) == 0, "keyword arguments NYI"
+        out_spec = None
+
+        def _tuplify_outputs(aot_export):
+            def _aot_export_non_strict(mod, args, **kwargs):
+                class Wrapper(torch.nn.Module):
+                    def __init__(self, mod):
+                        super().__init__()
+                        self._export_root = mod
+
+                    def forward(self, *args, **kwargs):
+                        nonlocal out_spec
+                        flat_outs, out_spec = pytree.tree_flatten(self._export_root(*args, **kwargs))
+                        return tuple(flat_outs)
+
+                gm, sig = aot_export(Wrapper(mod), args, **kwargs)
+
+                def strip_root(x):
+                    return x[len('_export_root.'):] if x.startswith('_export_root.') else x
+
+                sig.parameters = pytree.tree_map(strip_root, sig.parameters)
+                sig.buffers = pytree.tree_map(strip_root, sig.buffers)
+                sig.inputs_to_buffers = pytree.tree_map(strip_root, sig.inputs_to_buffers)
+                sig.inputs_to_parameters = pytree.tree_map(strip_root, sig.inputs_to_parameters)
+                sig.buffers_to_mutate = pytree.tree_map(strip_root, sig.buffers_to_mutate)
+                return gm, sig
+            return _aot_export_non_strict
+        ep_non_strict = _export_non_strict(f, args, {}, f.state_dict(), transform=_tuplify_outputs)
+        assert out_spec is not None
+        return ExportedProgram(
+            ep_non_strict.gm,
+            ep_non_strict.gm.graph,
+            ep_non_strict.sig,
+            _get_params_buffers(f),
+            {},
+            [],
+            [ModuleCallEntry("", ModuleCallSignature([], [], pytree.tree_flatten((args, {}))[1], out_spec))],
+            (args, kwargs),
+            tensor_constants=ep_non_strict.tensor_constants,
+        )
+
+
+    gm_torch_level = _export_to_torch_ir(
+        f,
+        args,
+        kwargs,
+        constraints,
+        preserve_module_call_signature=preserve_module_call_signature,
+    )
+
+    params_buffers = _get_params_buffers(gm_torch_level)
+
+    # We detect the fake_mode by looking at gm_torch_level's placeholders, this is the fake_mode created in dynamo.
+    fake_args, fake_kwargs, fake_params_buffers, dynamo_fake_mode = _convert_input_to_fake(gm_torch_level, args, kwargs)
+
+    # First, we want to pass through the graph to try populating
+    # val field for getattr if there is anything missing.
+    # THis can happen when quantization adds extra params and forgets
+    # to update "val"
+    for node in gm_torch_level.graph.nodes:
+        if node.op == "get_attr" and "val" not in node.meta:
+            attr = getattr(gm_torch_level, node.target)
+            # Checks if it is not a HigherOrderOp branch or a module
+            if not isinstance(attr, torch.nn.Module):
+                assert dynamo_fake_mode is not None, (
+                    "Cannot find dynamo_fake_mode. This could be due to the exported graph module have no placeholders."
+                )
+                node.meta["val"] = dynamo_fake_mode.from_tensor(attr, static_shapes=True)
+
+    # When aot_export lifts the params, we lose the nn_module_stack
+    # and source_fn from the param nodes as they are treated as fresh inputs
+    # Therefore, we manually extract them before calling into aot_export
+    params_buffers_to_node_meta = {}
+    for node in gm_torch_level.graph.nodes:
+        target = node.target
+        meta = node.meta
+        if node.op == "call_module":
+            submodule = getattr(gm_torch_level, target)
+            if isinstance(submodule, torch.nn.Module):
+                for name, _ in submodule.named_parameters(recurse=True, remove_duplicate=False):
+                    params_buffers_to_node_meta[target + "." + name] = meta
+
+                for name, _ in submodule.named_buffers(recurse=True, remove_duplicate=False):
+                    params_buffers_to_node_meta[target + "." + name] = meta
+
+        if node.op == "get_attr":
+            submodule = getattr(gm_torch_level, target)
+            if not isinstance(submodule, torch.fx.GraphModule):
+                params_buffers_to_node_meta[target] = meta
+
+        # If the call_function uses param as input, we also need to update params' meta
+        # with this call_function node's meta.
+        # This is basically the same flow as torch.fx.traceback.preserve_meta()
+        if node.op == "call_function" and not isinstance(node.target, torch._ops.HigherOrderOperator):
+            for arg in node._input_nodes:
+                if arg.op == "get_attr":
+                    for entry in torch.fx.proxy._COPY_META_FIELDS:
+                        if entry in meta:
+                            params_buffers_to_node_meta[arg.target][entry] = meta[entry]
+
+    # Fix the graph output signature to be tuple if scalar
+    out_spec = orig_out_spec = gm_torch_level._out_spec
+    assert out_spec is not None
+    # aot_export expect the return type to always be a tuple.
+    if out_spec.type not in (list, tuple):
+        out_spec = pytree.TreeSpec(tuple, None, [out_spec])
+
+    orig_args = gm_torch_level.graph._codegen.pytree_info.orig_args  # type: ignore[attr-defined]
+
+    gm_torch_level.graph._codegen = _PyTreeCodeGen(
+        _PyTreeInfo(
+            orig_args,
+            gm_torch_level._in_spec,
+            out_spec,
+        )
+    )
+    gm_torch_level.recompile()
+
+    param_buffer_table: Dict[str, str] = {}
+    if isinstance(f, torch.nn.Module):
+        param_lookup: Dict[int, List[str]] = {}
+        buffer_lookup: Dict[int, List[str]] = {}
+        for name, param in f.named_parameters(remove_duplicate=False):
+            param_lookup.setdefault(id(param), []).append(name)
+        for name, buffer in f.named_buffers(remove_duplicate=False):
+            buffer_lookup.setdefault(id(buffer), []).append(name)
+        for dynamo_name, dynamo_param in gm_torch_level.named_parameters(remove_duplicate=False):
+            assert dynamo_name not in param_buffer_table
+            if id(dynamo_param) in param_lookup:
+                param_buffer_table[dynamo_name] = param_lookup[id(dynamo_param)].pop()
+
+        for dynamo_name, dynamo_buffer in gm_torch_level.named_buffers(remove_duplicate=False):
+            assert dynamo_name not in param_buffer_table
+            if id(dynamo_buffer) in buffer_lookup:
+                param_buffer_table[dynamo_name] = buffer_lookup[id(dynamo_buffer)].pop()
+
+    if isinstance(f, torch.nn.Module):
+        _normalize_nn_module_stack(gm_torch_level, type(f))
+
+    def _process_user_inputs(aot_export):
+        def _aot_export_strict(gm_torch_level: torch.fx.GraphModule, args, **kwargs):
+            user_input_names = _unlift_user_inputs_to_buffers(gm_torch_level, args)
+            gm, graph_signature = aot_export(gm_torch_level, (), **kwargs)
+            user_inputs_to_mutate = _lift_buffers_to_user_inputs(gm, graph_signature, user_input_names)
+            # TODO unfortunately preserving graph-level metadata is not
+            # working well with aot_export. So we manually copy it.
+            # (The node-level meta is addressed above.)
+            gm.meta.update(gm_torch_level.meta)
+            assert "user_inputs_to_mutate" not in gm.meta
+            gm.meta["user_inputs_to_mutate"] = user_inputs_to_mutate
+            return gm, graph_signature
+
+        return _aot_export_strict
+
+    # Note: aot_export_module doesn't accept kwargs, we'd like to reorder the kwargs as an OrderedDict
+    # to follow the order in orig_args and correctly call module
+    ep_non_strict = _export_non_strict(
+        gm_torch_level,
+        fake_args,
+        _reorder_kwargs_by_names(orig_args, fake_args, fake_kwargs),
+        fake_params_buffers,
+        transform=_process_user_inputs
+    )
+
+    gm = ep_non_strict.gm
+    export_graph_signature = ep_non_strict.sig
+    tensor_constants = ep_non_strict.tensor_constants
+
+    # After aot_export, set the param/buffer metadata back into placeholders
+    # Technically, users can still construct this data from param names
+    # without relying on this metadata
+    for node in gm.graph.nodes:
+        if node.op == "placeholder":
+            if node.target in export_graph_signature.inputs_to_parameters:
+                param_name = export_graph_signature.inputs_to_parameters[node.target]
+                if param_name in params_buffers_to_node_meta:
+                    for k, v in params_buffers_to_node_meta[param_name].items():
+                        node.meta[k] = v
+            if node.target in export_graph_signature.inputs_to_buffers:
+                buffer_name = export_graph_signature.inputs_to_buffers[node.target]
+                if buffer_name in params_buffers_to_node_meta:
+                    for k, v in params_buffers_to_node_meta[buffer_name].items():
+                        node.meta[k] = v
+
+    # The unbacked symint symbols are updated in aot_export
+    # so we serialize them here instead of inside dynamo
+
+    # dynamo_fake_mode can be None if there's no placeholder in gm_torch_level
+    if dynamo_fake_mode:
+        gm.meta["inline_constraints"] = {
+            k: v
+            for k, v in dynamo_fake_mode.shape_env.runtime_var_to_range.items()
+            if re.match(r"^[if]\d+$", str(k))
+        }
+
+    num_lifted = next(
+        (i for i, s in enumerate(export_graph_signature.input_specs) if s.kind == InputKind.USER_INPUT), 0
+    )
+    flat_args, orig_in_spec = pytree.tree_flatten((args, kwargs))
+    range_constraints, equality_constraints = _process_constraints(
+        gm,
+        num_lifted,
+        flat_args,
+    )
+
+    if isinstance(f, torch.nn.Module):
+        _replace_param_buffer_names(param_buffer_table, export_graph_signature)
+        params_buffers = {param_buffer_table.get(name, name): tensor for name, tensor in params_buffers.items()}
+
+    module_call_signatures = {
+        fqn: ModuleCallSignature(inputs=[], outputs=[], **specs)
+        for fqn, specs in gm_torch_level.meta["module_call_specs"].items()
+    }
+
+    if len(preserve_module_call_signature) > 0:
+        res = CollectTracepointsPass(module_call_signatures, export_graph_signature)(gm)
+        assert res is not None
+        gm = res.graph_module
+
+    assert orig_out_spec is not None
+    exported_program = ExportedProgram(
+        gm,
+        gm.graph,
+        export_graph_signature,
+        # TODO(zhxchen17) Return empty state_dict for functions.
+        params_buffers,
+        range_constraints,
+        equality_constraints,
+        [ModuleCallEntry("", ModuleCallSignature(inputs=[], outputs=[], in_spec=orig_in_spec, out_spec=orig_out_spec))] +
+        [ModuleCallEntry(fqn, sig) for fqn, sig in module_call_signatures.items()],
+        (args, kwargs),
+        tensor_constants=tensor_constants,
+    )
+
+    if len(range_constraints) > 0 or len(equality_constraints) > 0:
+        exported_program = exported_program._transform(
+            _AddRuntimeAssertionsForInlineConstraintsPass(range_constraints, equality_constraints)
+        )
+
+    return exported_program
+
+
+def _reorder_kwargs_by_names(arg_names: List[str], args: Tuple[Any], kwargs: Dict[str, Any]):
+    assert len(arg_names) == len(args) + len(kwargs), (
+        f"Total number of arg names is expected to be {len(arg_names)} "
+        f"but got {len(args)} positional args, {len(kwargs)} kwargs."
+    )
+    return {kw_name: kwargs[kw_name] for kw_name in arg_names[len(args):]}
+
+
+def save(
+    ep: ExportedProgram,
+    f: Union[str, pathlib.Path, io.BytesIO],
+    *,
+    extra_files: Optional[Dict[str, Any]] = None,
+    opset_version: Optional[Dict[str, int]] = None,
+) -> None:
+    from .serde.serialize import serialize, SerializedArtifact
+    from .serde.schema import SCHEMA_VERSION
+    artifact: SerializedArtifact = serialize(ep, opset_version)
+
+    if isinstance(f, (str, pathlib.Path)):
+        f = str(f)
+
+    with zipfile.ZipFile(f, 'w') as zipf:
+        # Save every field the SerializedArtifact to a file
+        for field in dataclasses.fields(artifact):
+            field_name = field.name
+            serialized_field = getattr(artifact, field_name)
+            zipf.writestr(f"serialized_{field_name}.json", serialized_field)
+
+        zipf.writestr('version', str(SCHEMA_VERSION))
+
+        # Add extra files if provided
+        if extra_files:
+            for extra_file_name, content in extra_files.items():
+                encoded_content = content.encode('utf-8')
+                zipf.writestr(f"extra_files/{extra_file_name}", encoded_content)
+
+
+def load(
+    f: Union[str, pathlib.Path, io.BytesIO],
+    *,
+    extra_files: Optional[Dict[str, Any]] = None,
+    expected_opset_version: Optional[Dict[str, int]] = None,
+) -> ExportedProgram:
+    if isinstance(f, (str, pathlib.Path)):
+        f = str(f)
+
+    with zipfile.ZipFile(f, 'r') as zipf:
+        # Check the version
+        version = int(zipf.read('version'))
+        from .serde.schema import SCHEMA_VERSION
+
+        if version != SCHEMA_VERSION:
+            raise RuntimeError(
+                f"Serialized version {version} does not match our current "
+                f"schema version {SCHEMA_VERSION}."
+            )
+
+        from .serde.serialize import deserialize, SerializedArtifact
+
+        # Load serialized_ep and serialized_state_dict from the zip file
+        artifact: SerializedArtifact = SerializedArtifact(
+            **{
+                field.name: zipf.read(f"serialized_{field.name}.json")
+                for field in dataclasses.fields(SerializedArtifact)
+            }
+        )
+
+        # Deserialize ExportedProgram
+        ep = deserialize(artifact)
+
+        # Populate extra_files map
+        if extra_files is not None:
+            for filename in extra_files.keys():
+                extra_files[filename] = zipf.read(f"extra_files/{filename}").decode('utf-8')
+
+        return ep
+
+
+def aot_compile(
+    f: Callable,
+    args: Tuple[Any],
+    kwargs: Optional[Dict[str, Any]] = None,
+    *,
+    constraints: Optional[List[Constraint]] = None,
+    dynamic_shapes: Optional[Dict[str, Any]] = None,
+    options: Optional[Dict[str, Any]] = None,
+    remove_runtime_assertions: bool = False,
+    disable_constraint_solver: bool = False,
+) -> str:
+    """
+    Note: this function is not stable yet
+
+    Traces either an nn.Module's forward function or just a callable with PyTorch
+    operations inside, generates executable cpp code from the program, and returns
+    the path to the generated shared library
+
+    Args:
+        f: the `nn.Module` or callable to trace.
+
+        args: example positional inputs.
+
+        kwargs: optional example keyword inputs.
+
+        constraints: A optional list of constraints on the dynamic arguments specifying
+            their possible range of their shapes
+
+        dynamic_shapes: An experimental new feature designed to subsume ``constraints``.
+            A dict mapping argument names of ``f`` to their dynamic shape
+            specifications, as follows. Dynamic shape specifications can be a
+            dict from dynamic dimensions to ``Dim`` types, or a tuple/list of
+            ``Optional[Dim]`` corresponding to each input dimension.
+
+        options: A dictionary of options to control inductor
+
+        disable_constraint_solver: Whether the dim constraint solver must be disabled.
+
+    Returns:
+        Path to the generated shared library
+    """
+    if constraints is not None:
+        warnings.warn(
+            "The constraints field is deprecated. "
+            "Please use dynamic_shapes instead."
+        )
+
+    from torch._inductor.decomposition import select_decomp_table
+
+    if constraints is None:
+        constraints = _process_dynamic_shapes(f, args, kwargs, dynamic_shapes)
+
+    # We want to export to Torch IR here to utilize the pre_grad passes in
+    # inductor, which run on Torch IR.
+    gm = _export_to_torch_ir(
+        f,
+        args,
+        kwargs,
+        constraints,
+        disable_constraint_solver=disable_constraint_solver
+    )
+    flat_example_inputs = pytree.arg_tree_leaves(*args, **(kwargs or {}))
+
+    with torch.no_grad():
+        so_path = torch._inductor.aot_compile(gm, flat_example_inputs, options)  # type: ignore[arg-type]
+
+    return so_path

env-llmeval/lib/python3.10/site-packages/torch/_export/db/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.

env-llmeval/lib/python3.10/site-packages/torch/_export/db/case.py

@@ -0,0 +1,188 @@
+import inspect
+import re
+import string
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional, Set, Tuple, Union
+
+import torch
+
+_TAGS: Dict[str, Dict[str, Any]] = {
+    "torch": {
+        "cond": {},
+        "dynamic-shape": {},
+        "escape-hatch": {},
+        "map": {},
+        "dynamic-value": {},
+        "operator": {},
+        "mutation": {},
+    },
+    "python": {
+        "assert": {},
+        "builtin": {},
+        "closure": {},
+        "context-manager": {},
+        "control-flow": {},
+        "data-structure": {},
+        "standard-library": {},
+        "object-model": {},
+    },
+}
+
+
+class SupportLevel(Enum):
+    """
+    Indicates at what stage the feature
+    used in the example is handled in export.
+    """
+
+    SUPPORTED = 1
+    NOT_SUPPORTED_YET = 0
+
+
+class ExportArgs:
+    __slots__ = ("args", "kwargs")
+
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+
+
+InputsType = Union[Tuple[Any, ...], ExportArgs]
+
+
+def check_inputs_type(x):
+    if not isinstance(x, (ExportArgs, tuple)):
+        raise ValueError(
+            f"Expecting inputs type to be either a tuple, or ExportArgs, got: {type(x)}"
+        )
+
+
+def _validate_tag(tag: str):
+    parts = tag.split(".")
+    t = _TAGS
+    for part in parts:
+        assert set(part) <= set(
+            string.ascii_lowercase + "-"
+        ), f"Tag contains invalid characters: {part}"
+        if part in t:
+            t = t[part]
+        else:
+            raise ValueError(f"Tag {tag} is not found in registered tags.")
+
+
+@dataclass(frozen=True)
+class ExportCase:
+    example_inputs: InputsType
+    description: str  # A description of the use case.
+    model: torch.nn.Module
+    name: str
+    extra_inputs: Optional[InputsType] = None  # For testing graph generalization.
+    # Tags associated with the use case. (e.g dynamic-shape, escape-hatch)
+    tags: Set[str] = field(default_factory=set)
+    support_level: SupportLevel = SupportLevel.SUPPORTED
+    dynamic_shapes: Optional[Dict[str, Any]] = None
+
+    def __post_init__(self):
+        check_inputs_type(self.example_inputs)
+        if self.extra_inputs is not None:
+            check_inputs_type(self.extra_inputs)
+
+        for tag in self.tags:
+            _validate_tag(tag)
+
+        if not isinstance(self.description, str) or len(self.description) == 0:
+            raise ValueError(f'Invalid description: "{self.description}"')
+
+
+_EXAMPLE_CASES: Dict[str, ExportCase] = {}
+_MODULES = set()
+_EXAMPLE_CONFLICT_CASES = {}
+_EXAMPLE_REWRITE_CASES: Dict[str, List[ExportCase]] = {}
+
+
+def register_db_case(case: ExportCase) -> None:
+    """
+    Registers a user provided ExportCase into example bank.
+    """
+    if case.name in _EXAMPLE_CASES:
+        if case.name not in _EXAMPLE_CONFLICT_CASES:
+            _EXAMPLE_CONFLICT_CASES[case.name] = [_EXAMPLE_CASES[case.name]]
+        _EXAMPLE_CONFLICT_CASES[case.name].append(case)
+        return
+
+    _EXAMPLE_CASES[case.name] = case
+
+
+def to_snake_case(name):
+    name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
+    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", name).lower()
+
+
+def _make_export_case(m, name, configs):
+    if inspect.isclass(m):
+        if not issubclass(m, torch.nn.Module):
+            raise TypeError("Export case class should be a torch.nn.Module.")
+        m = m()
+
+    if "description" not in configs:
+        # Fallback to docstring if description is missing.
+        assert (
+            m.__doc__ is not None
+        ), f"Could not find description or docstring for export case: {m}"
+        configs = {**configs, "description": m.__doc__}
+    return ExportCase(**{**configs, "model": m, "name": name})
+
+
+def export_case(**kwargs):
+    """
+    Decorator for registering a user provided case into example bank.
+    """
+
+    def wrapper(m):
+        configs = kwargs
+        module = inspect.getmodule(m)
+        if module in _MODULES:
+            raise RuntimeError("export_case should only be used once per example file.")
+
+        _MODULES.add(module)
+        normalized_name = to_snake_case(m.__name__)
+        assert module is not None
+        module_name = module.__name__.split(".")[-1]
+        if module_name != normalized_name:
+            raise RuntimeError(
+                f'Module name "{module.__name__}" is inconsistent with exported program '
+                + f'name "{m.__name__}". Please rename the module to "{normalized_name}".'
+            )
+
+        case = _make_export_case(m, module_name, configs)
+        register_db_case(case)
+        return case
+
+    return wrapper
+
+
+def export_rewrite_case(**kwargs):
+    def wrapper(m):
+        configs = kwargs
+
+        parent = configs.pop("parent")
+        assert isinstance(parent, ExportCase)
+        key = parent.name
+        if key not in _EXAMPLE_REWRITE_CASES:
+            _EXAMPLE_REWRITE_CASES[key] = []
+
+        configs["example_inputs"] = parent.example_inputs
+        case = _make_export_case(m, to_snake_case(m.__name__), configs)
+        _EXAMPLE_REWRITE_CASES[key].append(case)
+        return case
+
+    return wrapper
+
+
+def normalize_inputs(x: InputsType) -> ExportArgs:
+    if isinstance(x, tuple):
+        return ExportArgs(*x)
+
+    assert isinstance(x, ExportArgs)
+    return x

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/__init__.py

@@ -0,0 +1,52 @@
+import glob
+import importlib
+from os.path import basename, dirname, isfile, join
+
+import torch
+from torch._export.db.case import (
+    _EXAMPLE_CASES,
+    _EXAMPLE_CONFLICT_CASES,
+    _EXAMPLE_REWRITE_CASES,
+    SupportLevel,
+)
+
+
+modules = glob.glob(join(dirname(__file__), "*.py"))
+__all__ = [
+    basename(f)[:-3] for f in modules if isfile(f) and not f.endswith("__init__.py")
+]
+
+# Import all module in the current directory.
+from . import *  # noqa: F403
+
+
+def all_examples():
+    return _EXAMPLE_CASES
+
+
+if len(_EXAMPLE_CONFLICT_CASES) > 0:
+
+    def get_name(case):
+        model = case.model
+        if isinstance(model, torch.nn.Module):
+            model = type(model)
+        return model.__name__
+
+    msg = "Error on conflict export case name.\n"
+    for case_name, cases in _EXAMPLE_CONFLICT_CASES.items():
+        msg += f"Case name {case_name} is associated with multiple cases:\n  "
+        msg += f"[{','.join(map(get_name, cases))}]\n"
+
+    raise RuntimeError(msg)
+
+
+def filter_examples_by_support_level(support_level: SupportLevel):
+    return {
+        key: val
+        for key, val in all_examples().items()
+        if val.support_level == support_level
+    }
+
+
+def get_rewrite_cases(case):
+    return _EXAMPLE_REWRITE_CASES.get(case.name, [])

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/assume_constant_result.py

@@ -0,0 +1,24 @@
+import torch
+import torch._dynamo as torchdynamo
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2), torch.tensor(4)),
+    tags={"torch.escape-hatch"},
+)
+class AssumeConstantResult(torch.nn.Module):
+    """
+    Applying `assume_constant_result` decorator to burn make non-tracable code as constant.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    @torchdynamo.assume_constant_result
+    def get_item(self, y):
+        return y.int().item()
+
+    def forward(self, x, y):
+        return x[: self.get_item(y)]

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/autograd_function.py

@@ -0,0 +1,26 @@
+import torch
+
+from torch._export.db.case import export_case
+
+
+class MyAutogradFunction(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, x):
+        return x.clone()
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        return grad_output + 1
+
+
+@export_case(
+    example_inputs=(torch.randn(3, 2),),
+)
+class AutogradFunction(torch.nn.Module):
+    """
+    TorchDynamo does not keep track of backward() on autograd functions. We recommend to
+    use `allow_in_graph` to mitigate this problem.
+    """
+
+    def forward(self, x):
+        return MyAutogradFunction.apply(x)

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/class_method.py

@@ -0,0 +1,24 @@
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 4),),
+)
+class ClassMethod(torch.nn.Module):
+    """
+    Class methods are inlined during tracing.
+    """
+
+    @classmethod
+    def method(cls, x):
+        return x + 1
+
+    def __init__(self):
+        super().__init__()
+        self.linear = torch.nn.Linear(4, 2)
+
+    def forward(self, x):
+        x = self.linear(x)
+        return self.method(x) * self.__class__.method(x) * type(self).method(x)

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/cond_branch_class_method.py

@@ -0,0 +1,46 @@
+import torch
+
+from torch._export.db.case import export_case
+from functorch.experimental.control_flow import cond
+
+
+class MySubModule(torch.nn.Module):
+    def foo(self, x):
+        return x.cos()
+
+    def forward(self, x):
+        return self.foo(x)
+
+
+@export_case(
+    example_inputs=(torch.ones(3),),
+    tags={
+        "torch.cond",
+        "torch.dynamic-shape",
+    },
+)
+class CondBranchClassMethod(torch.nn.Module):
+    """
+    The branch functions (`true_fn` and `false_fn`) passed to cond() must follow these rules:
+      - both branches must take the same args, which must also match the branch args passed to cond.
+      - both branches must return a single tensor
+      - returned tensor must have the same tensor metadata, e.g. shape and dtype
+      - branch function can be free function, nested function, lambda, class methods
+      - branch function can not have closure variables
+      - no inplace mutations on inputs or global variables
+
+
+    This example demonstrates using class method in cond().
+
+    NOTE: If the `pred` is test on a dim with batch size < 2, it will be specialized.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.subm = MySubModule()
+
+    def bar(self, x):
+        return x.sin()
+
+    def forward(self, x):
+        return cond(x.shape[0] <= 2, self.subm.forward, self.bar, [x])

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/cond_branch_nested_function.py

@@ -0,0 +1,41 @@
+import torch
+
+from torch._export.db.case import export_case
+from functorch.experimental.control_flow import cond
+
+
+@export_case(
+    example_inputs=(torch.ones(3),),
+    tags={
+        "torch.cond",
+        "torch.dynamic-shape",
+    },
+)
+def cond_branch_nested_function(x):
+    """
+    The branch functions (`true_fn` and `false_fn`) passed to cond() must follow these rules:
+      - both branches must take the same args, which must also match the branch args passed to cond.
+      - both branches must return a single tensor
+      - returned tensor must have the same tensor metadata, e.g. shape and dtype
+      - branch function can be free function, nested function, lambda, class methods
+      - branch function can not have closure variables
+      - no inplace mutations on inputs or global variables
+
+    This example demonstrates using nested function in cond().
+
+    NOTE: If the `pred` is test on a dim with batch size < 2, it will be specialized.
+    """
+
+    def true_fn(x):
+        def inner_true_fn(y):
+            return x + y
+
+        return inner_true_fn(x)
+
+    def false_fn(x):
+        def inner_false_fn(y):
+            return x - y
+
+        return inner_false_fn(x)
+
+    return cond(x.shape[0] < 10, true_fn, false_fn, [x])

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/cond_branch_nonlocal_variables.py

@@ -0,0 +1,59 @@
+import torch
+
+from torch._export.db.case import export_case
+from functorch.experimental.control_flow import cond
+
+
+@export_case(
+    example_inputs=(torch.ones(6),),
+    tags={
+        "torch.cond",
+        "torch.dynamic-shape",
+    },
+)
+def cond_branch_nonlocal_variables(x):
+    """
+    The branch functions (`true_fn` and `false_fn`) passed to cond() must follow these rules:
+      - both branches must take the same args, which must also match the branch args passed to cond.
+      - both branches must return a single tensor
+      - returned tensor must have the same tensor metadata, e.g. shape and dtype
+      - branch function can be free function, nested function, lambda, class methods
+      - branch function can not have closure variables
+      - no inplace mutations on inputs or global variables
+
+    This example demonstrates how to rewrite code to avoid capturing closure variables in branch functions.
+
+    The code below will not work because capturing closure variables is not supported.
+    ```
+    my_tensor_var = x + 100
+    my_primitive_var = 3.14
+
+    def true_fn(y):
+        nonlocal my_tensor_var, my_primitive_var
+        return y + my_tensor_var + my_primitive_var
+
+    def false_fn(y):
+        nonlocal my_tensor_var, my_primitive_var
+        return y - my_tensor_var - my_primitive_var
+
+    return cond(x.shape[0] > 5, true_fn, false_fn, [x])
+    ```
+
+    NOTE: If the `pred` is test on a dim with batch size < 2, it will be specialized.
+    """
+
+    my_tensor_var = x + 100
+    my_primitive_var = 3.14
+
+    def true_fn(x, y, z):
+        return x + y + z
+
+    def false_fn(x, y, z):
+        return x - y - z
+
+    return cond(
+        x.shape[0] > 5,
+        true_fn,
+        false_fn,
+        [x, my_tensor_var, torch.tensor(my_primitive_var)],
+    )

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/cond_operands.py

@@ -0,0 +1,35 @@
+import torch
+
+from torch._export.db.case import export_case
+from torch.export import Dim
+from functorch.experimental.control_flow import cond
+
+x = torch.randn(3, 2)
+y = torch.ones(2)
+dim0_x = Dim("dim0_x")
+
+@export_case(
+    example_inputs=(x, y),
+    tags={
+        "torch.cond",
+        "torch.dynamic-shape",
+    },
+    extra_inputs=(torch.randn(2, 2), torch.ones(2)),
+    dynamic_shapes={"x": {0: dim0_x}, "y": None},
+)
+def cond_operands(x, y):
+    """
+    The operands passed to cond() must be:
+      - a list of tensors
+      - match arguments of `true_fn` and `false_fn`
+
+    NOTE: If the `pred` is test on a dim with batch size < 2, it will be specialized.
+    """
+
+    def true_fn(x, y):
+        return x + y
+
+    def false_fn(x, y):
+        return x - y
+
+    return cond(x.shape[0] > 2, true_fn, false_fn, [x, y])

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/cond_predicate.py

@@ -0,0 +1,25 @@
+import torch
+
+from torch._export.db.case import export_case
+from functorch.experimental.control_flow import cond
+
+
+@export_case(
+    example_inputs=(torch.ones(6, 4, 3),),
+    tags={
+        "torch.cond",
+        "torch.dynamic-shape",
+    },
+)
+def cond_predicate(x):
+    """
+    The conditional statement (aka predicate) passed to cond() must be one of the following:
+      - torch.Tensor with a single element
+      - boolean expression
+
+    NOTE: If the `pred` is test on a dim with batch size < 2, it will be specialized.
+    """
+
+    pred = x.dim() > 2 and x.shape[2] > 10
+
+    return cond(pred, lambda x: x.cos(), lambda y: y.sin(), [x])

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/constrain_as_size_example.py

@@ -0,0 +1,22 @@
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.tensor(4),),
+    tags={
+        "torch.dynamic-value",
+        "torch.escape-hatch",
+    },
+)
+def constrain_as_size_example(x):
+    """
+    If the value is not known at tracing time, you can provide hint so that we
+    can trace further. Please look at constrain_as_value and constrain_as_size APIs
+    constrain_as_size is used for values that NEED to be used for constructing
+    tensor.
+    """
+    a = x.item()
+    torch._constrain_as_size(a, min=0, max=5)
+    return torch.ones((a, 5))

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/decorator.py

@@ -0,0 +1,26 @@
+import functools
+
+import torch
+
+from torch._export.db.case import export_case
+
+
+def test_decorator(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs) + 1
+
+    return wrapper
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2), torch.ones(3, 2)),
+)
+class Decorator(torch.nn.Module):
+    """
+    Decorators calls are inlined into the exported function during tracing.
+    """
+
+    @test_decorator
+    def forward(self, x, y):
+        return x + y

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/dictionary.py

@@ -0,0 +1,17 @@
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2), torch.tensor(4)),
+    tags={"python.data-structure"},
+)
+def dictionary(x, y):
+    """
+    Dictionary structures are inlined and flattened along tracing.
+    """
+    elements = {}
+    elements["x2"] = x * x
+    y = y * elements["x2"]
+    return {"y": y}

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/dynamic_shape_assert.py

@@ -0,0 +1,18 @@
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2),),
+    tags={"python.assert"},
+)
+def dynamic_shape_assert(x):
+    """
+    A basic usage of python assertion.
+    """
+    # assertion with error message
+    assert x.shape[0] > 2, f"{x.shape[0]} is greater than 2"
+    # assertion without error message
+    assert x.shape[0] > 1
+    return x

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/dynamic_shape_constructor.py

@@ -0,0 +1,15 @@
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2),),
+    tags={"torch.dynamic-shape"},
+)
+def dynamic_shape_constructor(x):
+    """
+    Tensor constructors should be captured with dynamic shape inputs rather
+    than being baked in with static shape.
+    """
+    return torch.ones(x.shape[0] * 2)

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/dynamic_shape_if_guard.py

@@ -0,0 +1,21 @@
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2, 2),),
+    tags={"torch.dynamic-shape", "python.control-flow"},
+)
+class DynamicShapeIfGuard(torch.nn.Module):
+    """
+    `if` statement with backed dynamic shape predicate will be specialized into
+    one particular branch and generate a guard. However, export will fail if the
+    the dimension is marked as dynamic shape from higher level API.
+    """
+
+    def forward(self, x):
+        if x.shape[0] == 3:
+            return x.cos()
+
+        return x.sin()

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/dynamic_shape_round.py

@@ -0,0 +1,19 @@
+import torch
+
+from torch._export.db.case import export_case, SupportLevel
+from torch.export import Dim
+
+x = torch.ones(3, 2)
+dim0_x = Dim("dim0_x")
+
+@export_case(
+    example_inputs=(x,),
+    tags={"torch.dynamic-shape", "python.builtin"},
+    support_level=SupportLevel.NOT_SUPPORTED_YET,
+    dynamic_shapes={"x": {0: dim0_x}},
+)
+def dynamic_shape_round(x):
+    """
+    Calling round on dynamic shapes is not supported.
+    """
+    return x[: round(x.shape[0] / 2)]

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/dynamic_shape_slicing.py

@@ -0,0 +1,15 @@
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2),),
+    tags={"torch.dynamic-shape"},
+)
+def dynamic_shape_slicing(x):
+    """
+    Slices with dynamic shape arguments should be captured into the graph
+    rather than being baked in.
+    """
+    return x[: x.shape[0] - 2, x.shape[1] - 1 :: 2]

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/dynamic_shape_view.py

@@ -0,0 +1,17 @@
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.ones(10, 10),),
+    tags={"torch.dynamic-shape"},
+)
+def dynamic_shape_view(x):
+    """
+    Dynamic shapes should be propagated to view arguments instead of being
+    baked into the exported graph.
+    """
+    new_x_shape = x.size()[:-1] + (2, 5)
+    x = x.view(*new_x_shape)
+    return x.permute(0, 2, 1)

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/fn_with_kwargs.py

@@ -0,0 +1,28 @@
+import torch
+
+from torch._export.db.case import export_case, ExportArgs, SupportLevel
+
+
+@export_case(
+    example_inputs=ExportArgs(
+        torch.randn(4),
+        (torch.randn(4), torch.randn(4)),
+        *[torch.randn(4), torch.randn(4)],
+        mykw0=torch.randn(4),
+        input0=torch.randn(4), input1=torch.randn(4)
+    ),
+    tags={"python.data-structure"},
+    support_level=SupportLevel.SUPPORTED,
+)
+def fn_with_kwargs(pos0, tuple0, *myargs, mykw0, **mykwargs):
+    """
+    Keyword arguments are not supported at the moment.
+    """
+    out = pos0
+    for arg in tuple0:
+        out = out * arg
+    for arg in myargs:
+        out = out * arg
+    out = out * mykw0
+    out = out * mykwargs["input0"] * mykwargs["input1"]
+    return out

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/list_contains.py

@@ -0,0 +1,17 @@
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2),),
+    tags={"torch.dynamic-shape", "python.data-structure", "python.assert"},
+)
+def list_contains(x):
+    """
+    List containment relation can be checked on a dynamic shape or constants.
+    """
+    assert x.size(-1) in [6, 2]
+    assert x.size(0) not in [4, 5, 6]
+    assert "monkey" not in ["cow", "pig"]
+    return x + x

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/list_unpack.py

@@ -0,0 +1,18 @@
+from typing import List
+
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=([torch.ones(3, 2), torch.tensor(4), torch.tensor(5)],),
+    tags={"python.control-flow", "python.data-structure"},
+)
+def list_unpack(args: List[torch.Tensor]):
+    """
+    Lists are treated as static construct, therefore unpacking should be
+    erased after tracing.
+    """
+    x, *y = args
+    return x + y[0]

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/model_attr_mutation.py

@@ -0,0 +1,25 @@
+import torch
+
+from torch._export.db.case import export_case, SupportLevel
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2),),
+    tags={"python.object-model"},
+    support_level=SupportLevel.NOT_SUPPORTED_YET,
+)
+class ModelAttrMutation(torch.nn.Module):
+    """
+    Attribute mutation is not supported.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.attr_list = [torch.ones(3, 2), torch.ones(3, 2)]
+
+    def recreate_list(self):
+        return [torch.zeros(3, 2), torch.zeros(3, 2)]
+
+    def forward(self, x):
+        self.attr_list = self.recreate_list()
+        return x.sum() + self.attr_list[0].sum()

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/optional_input.py

@@ -0,0 +1,19 @@
+import torch
+
+from torch._export.db.case import export_case, SupportLevel
+
+
+@export_case(
+    example_inputs=(torch.randn(2, 3),),
+    tags={"python.object-model"},
+    support_level=SupportLevel.NOT_SUPPORTED_YET,
+)
+class OptionalInput(torch.nn.Module):
+    """
+    Tracing through optional input is not supported yet
+    """
+
+    def forward(self, x, y=torch.ones(2, 3)):
+        if y is not None:
+            return x + y
+        return x

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/pytree_flatten.py

@@ -0,0 +1,16 @@
+import torch
+
+from torch._export.db.case import export_case, SupportLevel
+from torch.utils import _pytree as pytree
+
+
+@export_case(
+    example_inputs=({1: torch.randn(3, 2), 2: torch.randn(3, 2)},),
+    support_level=SupportLevel.SUPPORTED,
+)
+def pytree_flatten(x):
+    """
+    Pytree from PyTorch cannot be captured by TorchDynamo.
+    """
+    y, spec = pytree.tree_flatten(x)
+    return y[0] + 1

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/scalar_output.py

@@ -0,0 +1,19 @@
+import torch
+
+from torch._export.db.case import export_case
+from torch.export import Dim
+
+x = torch.ones(3, 2)
+dim1_x = Dim("dim1_x")
+
+@export_case(
+    example_inputs=(x,),
+    tags={"torch.dynamic-shape"},
+    dynamic_shapes={"x": {1: dim1_x}},
+)
+def scalar_output(x):
+    """
+    Returning scalar values from the graph is supported, in addition to Tensor
+    outputs. Symbolic shapes are captured and rank is specialized.
+    """
+    return x.shape[1] + 1

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/specialized_attribute.py

@@ -0,0 +1,29 @@
+from enum import Enum
+
+import torch
+
+from torch._export.db.case import export_case
+
+
+class Animal(Enum):
+    COW = "moo"
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2),),
+)
+class SpecializedAttribute(torch.nn.Module):
+    """
+    Model attributes are specialized.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.a = "moo"
+        self.b = 4
+
+    def forward(self, x):
+        if self.a == Animal.COW.value:
+            return x * x + self.b
+        else:
+            raise ValueError("bad")

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/static_if.py

@@ -0,0 +1,23 @@
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2, 2),),
+    tags={"python.control-flow"},
+)
+class StaticIf(torch.nn.Module):
+    """
+    `if` statement with static predicate value should be traced through with the
+    taken branch.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        if len(x.shape) == 3:
+            return x + torch.ones(1, 1, 1)
+
+        return x

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/tensor_setattr.py

@@ -0,0 +1,16 @@
+import torch
+
+from torch._export.db.case import export_case, SupportLevel
+
+
+@export_case(
+    example_inputs=(torch.randn(3, 2), "attr"),
+    tags={"python.builtin"},
+    support_level=SupportLevel.SUPPORTED,
+)
+def tensor_setattr(x, attr):
+    """
+    setattr() call onto tensors is not supported.
+    """
+    setattr(x, attr, torch.randn(3, 2))
+    return x + 4

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/torch_sym_min.py

@@ -0,0 +1,17 @@
+import torch
+
+from torch._export.db.case import export_case, SupportLevel
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2),),
+    tags={"torch.operator"},
+    support_level=SupportLevel.NOT_SUPPORTED_YET,
+)
+class TorchSymMin(torch.nn.Module):
+    """
+    torch.sym_min operator is not supported in export.
+    """
+
+    def forward(self, x):
+        return x.sum() + torch.sym_min(x.size(0), 100)

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/type_reflection_method.py

@@ -0,0 +1,31 @@
+import torch
+
+from torch._export.db.case import export_case, SupportLevel, export_rewrite_case
+
+
+class A:
+    @classmethod
+    def func(cls, x):
+        return 1 + x
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 4),),
+    tags={"python.builtin"},
+    support_level=SupportLevel.SUPPORTED,
+)
+def type_reflection_method(x):
+    """
+    type() calls on custom objects followed by method calls are not allowed
+    due to its overly dynamic nature.
+    """
+    a = A()
+    return type(a).func(x)
+
+
+@export_rewrite_case(parent=type_reflection_method)
+def type_reflection_method_rewrite(x):
+    """
+    Custom object class methods will be inlined.
+    """
+    return A.func(x)

env-llmeval/lib/python3.10/site-packages/torch/_export/db/examples/user_input_mutation.py

@@ -0,0 +1,18 @@
+import torch
+
+from torch._export.db.case import export_case, SupportLevel
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2),),
+    tags={"torch.mutation"},
+    support_level=SupportLevel.SUPPORTED,
+)
+class UserInputMutation(torch.nn.Module):
+    """
+    Directly mutate user input in forward
+    """
+
+    def forward(self, x):
+        x.mul_(2)
+        return x.cos()

env-llmeval/lib/python3.10/site-packages/torch/_export/db/gen_example.py

@@ -0,0 +1,28 @@
+import os
+import sys
+
+import torch._export.db.examples as examples
+
+TEMPLATE = '''import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.randn(3, 2),),
+    tags={{}},
+)
+def {case_name}(x):
+    """
+    """
+
+    return
+'''
+
+if __name__ == "__main__":
+    assert len(sys.argv) == 2
+    root_dir = examples.__name__.replace(".", "/")
+    assert os.path.exists(root_dir)
+    with open(os.path.join(root_dir, sys.argv[1] + ".py"), "w") as f:
+        print("Writing to", f.name, "...")
+        f.write(TEMPLATE.format(case_name=sys.argv[1]))

env-llmeval/lib/python3.10/site-packages/torch/_export/db/logging.py

@@ -0,0 +1,2 @@
+def exportdb_error_message(case_name: str):
+    return ""

env-llmeval/lib/python3.10/site-packages/torch/_export/exported_program.py

@@ -0,0 +1,430 @@
+import copy
+from collections import defaultdict
+import dataclasses
+from typing import Dict, List, Optional, Tuple
+import warnings
+
+import sympy
+
+import torch
+import torch.fx
+
+import torch.utils._pytree as pytree
+from torch._subclasses.fake_tensor import FakeTensor
+from torch.fx.experimental.symbolic_shapes import SymInt
+from torch.fx.graph import _PyTreeCodeGen, _PyTreeInfo
+from torch.utils._sympy.value_ranges import ValueRanges
+
+from torch._export.passes.add_runtime_assertions_for_constraints_pass import (
+    InputDim,
+)
+
+
+# TODO(ycao): This is added to avoid breaking existing code temporarily.
+# Remove when migration is done.
+from torch.export.graph_signature import (
+    ExportBackwardSignature,
+    ExportGraphSignature,
+)
+
+from torch.export.exported_program import (
+    ExportedProgram,
+    ModuleCallEntry,
+    ModuleCallSignature,
+)
+
+from .utils import _check_input_constraints_pre_hook
+
+
+__all__ = [
+    "ExportBackwardSignature",
+    "ExportGraphSignature",
+    "ExportedProgram",
+    "ModuleCallEntry",
+    "ModuleCallSignature",
+]
+
+
+# Information to maintain user calling/returning specs
+@dataclasses.dataclass
+class CallSpec:
+    in_spec: Optional[pytree.TreeSpec]
+    out_spec: Optional[pytree.TreeSpec]
+
+
+def _unlift(gm, inp_pos_to_param_buffer_name, in_spec, out_spec, state_dict, tensor_constants, buffers_to_mutate):
+    count = 0
+    buffer_name_to_node = {}
+    # Step 1: make lifted params as get_attr
+    for node in gm.graph.nodes:
+        if node.op == "placeholder":
+            if count in inp_pos_to_param_buffer_name:
+                with gm.graph.inserting_after(node):
+                    getattr_node = gm.graph.get_attr(
+                        inp_pos_to_param_buffer_name[count]
+                    )
+                    node.replace_all_uses_with(getattr_node)
+                    metadata = node.meta
+                    gm.graph.erase_node(node)
+                    getattr_node.meta = metadata
+                    buffer_name_to_node[inp_pos_to_param_buffer_name[count]] = getattr_node
+
+            count += 1
+        # Step 2: Find the all the buffers that were mutated and update them
+        if node.op == "output":
+            user_output_nodes = []
+            # In the case that the same node is returned multiple times,
+            # node.all_input_nodes will only iterate that node once
+            for return_node in pytree.tree_flatten(node.args)[0]:
+                return_node_name = return_node.name
+                # we found a param/buffer mutation
+                if return_node_name in buffers_to_mutate:
+                    # TODO Fix situation here to replace dot with underscore...
+                    buffer_node_name = buffers_to_mutate[return_node_name].replace('.', '_')
+                    assert buffer_node_name in buffer_name_to_node
+                    buffer_node = buffer_name_to_node[buffer_node_name]
+                    with gm.graph.inserting_before(node):
+                        gm.graph.call_function(
+                            torch.ops.aten.copy_.default, (buffer_node, return_node)
+                        )
+                else:
+                    user_output_nodes.append(return_node)
+            with gm.graph.inserting_before(node):
+                # Only return user outputs
+                new_output = gm.graph.output(tuple(user_output_nodes))
+                node.replace_all_uses_with(new_output)
+                gm.graph.erase_node(node)
+
+    # Step 3: Fix the input/output of the graph now that we deleted
+    # some args.
+    gm.graph.lint()
+
+    if (
+        in_spec.type == tuple and
+        len(in_spec.children_specs) == 2 and
+        in_spec.children_specs[0].type == tuple and
+        in_spec.children_specs[1].type == dict
+    ):
+        # if in_spec contains the args (tuple) and kwargs (dict)
+
+        num_args = (
+            len(in_spec.children_specs[0].children_specs) +
+            len(in_spec.children_specs[1].children_specs)
+        )
+    else:
+        num_args = len(in_spec.children_specs)
+
+    names = [f"arg_{i}" for i in range(num_args)]
+
+    gm.graph._codegen = _PyTreeCodeGen(
+        _PyTreeInfo(
+            names,
+            in_spec,
+            out_spec,
+        )
+    )
+    gm.recompile()
+
+    # Step 4: Find state references in HigherOrderOps and recursively
+    # fix them.
+    for node in gm.graph.nodes:
+        if node.op == "call_function" and node.target == torch.ops.cond:
+            pred, true_graph, false_graph, operands = node.args
+            true_gm = getattr(gm, true_graph.name)
+            false_gm = getattr(gm, false_graph.name)
+            inp_pos_to_param_buffer_name_for_submod = {}
+            real_operands = []
+            for ix, operand in enumerate(operands):
+                if operand.target in inp_pos_to_param_buffer_name.values():
+                    inp_pos_to_param_buffer_name_for_submod[ix] = operand.target
+                    if operand.target in state_dict:
+                        value = state_dict[operand.target]
+                    elif operand.target in tensor_constants:
+                        value = tensor_constants[operand.target]
+                    else:
+                        raise RuntimeError("Unable to find value for ", operand.target)
+                    true_gm.register_buffer(operand.target, value)
+                    false_gm.register_buffer(operand.target, value)
+                else:
+                    real_operands.append(operand)
+            node.args = (pred, true_graph, false_graph, real_operands)
+
+            _, in_spec = pytree.tree_flatten(real_operands)
+
+            _unlift(
+                true_gm,
+                inp_pos_to_param_buffer_name_for_submod,
+                in_spec,
+                None,
+                state_dict,
+                tensor_constants,
+                buffers_to_mutate,
+            )
+            _unlift(
+                false_gm,
+                inp_pos_to_param_buffer_name_for_submod,
+                in_spec,
+                None,
+                state_dict,
+                tensor_constants,
+                buffers_to_mutate,
+            )
+        if node.op == "call_function" and node.target.__name__ == "map_impl":
+            body_graph, num_mapped, *operands = node.args
+            body_gm = getattr(gm, body_graph.name)
+            inp_pos_to_buffer_name_for_submod = {}
+            real_operands = []
+            # TODO Fix situation here to replace dot with underscore...
+            state_dict_for_lookup = {
+                key.replace(".", "_"): value
+                for key, value in state_dict.items()
+            }
+            for ix, operand in enumerate(operands):
+                if operand.target in inp_pos_to_param_buffer_name.values():
+                    inp_pos_to_buffer_name_for_submod[ix] = operand.target
+                    if operand.target in state_dict_for_lookup:
+                        value = state_dict_for_lookup[operand.target]
+                    elif operand.target in tensor_constants:
+                        value = tensor_constants[operand.target]
+                    else:
+                        raise RuntimeError(f"Unable to find value for {operand.target}")
+                    body_gm.register_buffer(operand.target, value)
+                else:
+                    real_operands.append(operand)
+            node.args = (body_graph, num_mapped, *real_operands)
+
+            _, in_spec = pytree.tree_flatten(real_operands)
+
+            _unlift(
+                body_gm,
+                inp_pos_to_buffer_name_for_submod,
+                in_spec,
+                None,
+                state_dict,
+                tensor_constants,
+                buffers_to_mutate,
+            )
+    gm.graph.lint()
+    gm.graph.eliminate_dead_code()
+    gm.recompile()
+    return gm
+
+def _construct_inp_pos_to_param_buffer_name(new_gm, graph_signature, state_dict, tensor_constants=None):
+    # TODO Fix the period in params/buffers names later
+    # maybe a pass to replace graph signature with fixed names
+    param_buffer_name_to_corrected_name = {}
+
+    for name, value in state_dict.items():
+        if name in graph_signature.buffers:
+            if "." in name:
+                new_gm.register_buffer(name.replace(".", "_"), value)
+                param_buffer_name_to_corrected_name[name] = name.replace(".", "_")
+            else:
+                new_gm.register_buffer(name, value)
+        if name in graph_signature.parameters:
+            if "." in name:
+                new_gm.register_parameter(name.replace(".", "_"), value)
+                param_buffer_name_to_corrected_name[name] = name.replace(".", "_")
+            else:
+                new_gm.register_parameter(name, value)
+
+    if tensor_constants is not None and len(tensor_constants) > 0:
+        assert hasattr(graph_signature, "lifted_tensor_constants")
+        for name, value in tensor_constants.items():
+            if name in graph_signature.lifted_tensor_constants:
+                new_gm.register_buffer(name, value)
+                param_buffer_name_to_corrected_name[name] = name
+
+    count = 0
+    inp_pos_to_param_buffer_name = {}
+    for node in new_gm.graph.nodes:
+        if node.op == "placeholder":
+            if node.name in graph_signature.inputs_to_buffers:
+                buffer_name = graph_signature.inputs_to_buffers[node.name]
+                if buffer_name in param_buffer_name_to_corrected_name:
+                    inp_pos_to_param_buffer_name[
+                        count
+                    ] = param_buffer_name_to_corrected_name[buffer_name]
+                else:
+                    inp_pos_to_param_buffer_name[count] = buffer_name
+            if node.name in graph_signature.inputs_to_parameters:
+                param_name = graph_signature.inputs_to_parameters[node.name]
+                if param_name in param_buffer_name_to_corrected_name:
+                    inp_pos_to_param_buffer_name[
+                        count
+                    ] = param_buffer_name_to_corrected_name[param_name]
+                else:
+                    inp_pos_to_param_buffer_name[count] = param_name
+            if hasattr(graph_signature, "inputs_to_lifted_tensor_constants"):
+                if node.name in graph_signature.inputs_to_lifted_tensor_constants:
+                    inp_pos_to_param_buffer_name[
+                        count
+                    ] = graph_signature.inputs_to_lifted_tensor_constants[node.name]
+            count += 1
+
+    return inp_pos_to_param_buffer_name
+
+
+class _StatefulGraphModuleFactory(type):
+    """
+    Metaclass that ensures a private constructor for _StatefulGraphModule
+    """
+
+    def __call__(cls, *args, **kwargs):
+        raise TypeError(
+            f"{cls.__module__}.{cls.__qualname__} has no public constructor. "
+        )
+
+    def _create(cls, root, graph, range_constraints=None, equality_constraints=None):
+        return super().__call__(
+            root,
+            graph,
+            range_constraints=range_constraints,
+            equality_constraints=equality_constraints
+        )
+
+
+class _StatefulGraphModule(torch.fx.GraphModule, metaclass=_StatefulGraphModuleFactory):
+    def __init__(self, root, graph, range_constraints=None, equality_constraints=None):
+        super().__init__(root, graph)
+        self.range_constraints = range_constraints or []
+        self.equality_constraints = equality_constraints or []
+
+
+def _create_stateful_graph_module(plain_graph_module: torch.fx.GraphModule, range_constraints, equality_constraints):
+    stateful_gm = _StatefulGraphModule._create(
+        plain_graph_module,
+        plain_graph_module.graph,
+        range_constraints=range_constraints,
+        equality_constraints=equality_constraints
+    )
+    stateful_gm.register_forward_pre_hook(_check_input_constraints_pre_hook, with_kwargs=True)
+    return stateful_gm
+
+
+def unlift_exported_program_lifted_states(ep: torch.export.ExportedProgram) -> torch.nn.Module:
+    new_gm = copy.deepcopy(ep.graph_module)
+    inp_pos_to_param_buffer_name = _construct_inp_pos_to_param_buffer_name(
+        new_gm, ep.graph_signature, ep.state_dict, ep.tensor_constants
+    )
+    new_gm = _unlift(
+        new_gm,
+        inp_pos_to_param_buffer_name,
+        ep.call_spec.in_spec,
+        ep.call_spec.out_spec,
+        ep.state_dict,
+        ep.tensor_constants,
+        ep.graph_signature.buffers_to_mutate,
+    )
+    unlift_gm = _create_stateful_graph_module(new_gm, ep.range_constraints, ep.equality_constraints)
+    unlift_gm.meta.update(ep.graph_module.meta)
+    return unlift_gm
+
+
+def _create_graph_module_for_export(root, graph):
+    try:
+        gm = torch.fx.GraphModule(root, graph)
+    except SyntaxError:
+        # If custom objects stored in memory are being used in the graph,
+        # the generated python code will result in a syntax error on the custom
+        # object, since it is unable to parse the in-memory object. However
+        # we can still run the graph eagerly through torch.fx.Interpreter,
+        # so we will bypass this error.
+        warnings.warn(
+            "Unable to execute the generated python source code from "
+            "the graph. The graph module will no longer be directly callable, "
+            "but you can still run the ExportedProgram, and if needed, you can "
+            "run the graph module eagerly using torch.fx.Interpreter."
+        )
+        gm = torch.fx.GraphModule(root, torch.fx.Graph())
+        gm._graph = graph
+
+    return gm
+
+
+def _process_constraints(
+    graph_module: torch.fx.GraphModule,
+    num_lifted_params_buffers: int,
+    example_inputs: List[torch.Tensor],
+) -> Tuple[Dict[sympy.Symbol, ValueRanges], List[Tuple[InputDim, InputDim]]]:
+    """
+    Process the constraints stored in the graph module to return something more readable.
+
+    Args:
+        graph_module (torch.fx.GraphModule): GraphModule returned from
+            dynamo.export, which contains the "input_shape_constraints" and
+            "inline_constraints" metadata
+
+        example_inputs: Flattened list of example inputs used to export the graph module
+
+    Returns:
+        range_constraints (Dict[sympy.Symbol, ValueRanges]): Mapping of
+            symbols (from SymInts) appearing in the fake tensors in
+            node.meta["val"] to their range constraints, which are a tuple
+            containing (lower, upper) constraints.
+
+        equality_constraints (List[Tuple[InputDim, InputDim]]): List of tuples
+            of (node, dim) to mark that these dimensions are equal.
+    """
+    input_shape_constraints = graph_module.meta.get("input_shape_constraints", [])
+    inline_constraints = graph_module.meta.get("inline_constraints", [])
+
+    # Create dict mapping tensor_id to node names
+    tensor_id_to_nodes: Dict[int, List[str]] = defaultdict(list)
+    # Create dict mapping placeholder node names to their nodes
+    placeholder_nodes: Dict[str, torch.fx.Node] = {}
+    for i, node in enumerate(graph_module.graph.nodes):
+        if node.op != "placeholder":
+            # All placeholder nodes should be together in the beginning of the
+            # graph
+            break
+        if i >= num_lifted_params_buffers:
+            example_input = example_inputs[i - num_lifted_params_buffers]
+            tensor_id_to_nodes[id(example_input)].append(node.name)
+            placeholder_nodes[node.name] = node
+
+    # Create list of (node name, dim) tuples to mark that they are equal
+    equality_constraints: List[Tuple[InputDim, InputDim]] = []
+    # Create dict mapping (node name, dim) a list of range (lower, upper)
+    # constraints
+    multi_range_constraints: Dict[InputDim, List[ValueRanges]] = defaultdict(list)
+    for constraint in input_shape_constraints:
+        for node in tensor_id_to_nodes[constraint["t_id"]]:
+            node_dim = InputDim(node, constraint["dim"])
+
+            # Accumulate range constraints
+            multi_range_constraints[node_dim].append(
+                ValueRanges(constraint["min"], constraint["max"])
+            )
+
+            # Accumulate equality constraints
+            if shared := constraint.get("shared", None):
+                for other_node in tensor_id_to_nodes[shared["t_id"]]:
+                    other_node_dim = InputDim(other_node, shared["dim"])
+                    equality_constraints.append((node_dim, other_node_dim))
+
+    # Create dict mapping symbol to a singular range (lower, upper)
+    range_constraints: Dict[sympy.Symbol, ValueRanges] = {}
+
+    # Add inline constraints to range_constraints
+    range_constraints = {symbol: inline_constraints[symbol] for symbol in inline_constraints}
+
+    # Add input range constraints to range_constraints
+    for input_dim, multi_range_constraint in multi_range_constraints.items():  # type: ignore[assignment]
+        # Simplify the range constraints into a single range constraint
+        # Ex. ranges [2, 10] and [3, 11] would get merged to [3, 10]
+        min_vals = [rc.lower for rc in multi_range_constraint]
+        max_vals = [rc.upper for rc in multi_range_constraint]
+        min_val = max(min_vals)  # type: ignore[type-var]
+        max_val = min(max_vals)  # type: ignore[type-var]
+        assert min_val <= max_val  # type: ignore[operator]
+
+        # Add input node range constraints
+        val = placeholder_nodes[input_dim.input_name].meta["val"]
+        assert isinstance(val, FakeTensor)
+        symint = val.shape[input_dim.dim]
+        assert isinstance(symint, SymInt), f"Expected SymInt but got {symint}: {type(symint)}"
+        symbol = symint.node._expr
+        range_constraints[symbol] = ValueRanges(min_val, max_val)
+
+    return range_constraints, equality_constraints

env-llmeval/lib/python3.10/site-packages/torch/_export/passes/__init__.py

@@ -0,0 +1 @@
+from .replace_view_ops_with_view_copy_ops_pass import ReplaceViewOpsWithViewCopyOpsPass