Upload folder using huggingface_hub (part 21)

.gitattributes

@@ -526,3 +526,26 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/torch/_export/serde/__pycache__/serialize.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/torch/_functorch/__pycache__/partitioners.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.12/site-packages/torch/_functorch/_aot_autograd/__pycache__/runtime_wrappers.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_higher_order_ops/__pycache__/triton_kernel_wrap.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/__pycache__/codecache.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/__pycache__/compile_fx.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/__pycache__/cpp_builder.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/__pycache__/cudagraph_trees.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/__pycache__/graph.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/__pycache__/ir.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/__pycache__/lowering.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/__pycache__/pattern_matcher.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/__pycache__/scheduler.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/__pycache__/select_algorithm.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/__pycache__/utils.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/codegen/__pycache__/common.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/codegen/__pycache__/cpp.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/codegen/__pycache__/cpp_wrapper_cpu.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/codegen/__pycache__/pallas.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/codegen/__pycache__/simd.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/codegen/__pycache__/triton.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/codegen/__pycache__/wrapper.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/fx_passes/__pycache__/post_grad.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/fx_passes/__pycache__/split_cat.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/heuristics/template/__pycache__/triton.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.12/site-packages/torch/_inductor/runtime/__pycache__/triton_heuristics.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.12/site-packages/torch/_functorch/_aot_autograd/streams.py

@@ -0,0 +1,979 @@
+import operator
+from collections.abc import Callable
+from typing import Any, TYPE_CHECKING, TypeAlias
+
+import torch.fx
+import torch.fx.traceback
+import torch.utils._pytree as pytree
+from torch._dynamo.graph_utils import _get_flat_args
+from torch._dynamo.variables.streams import get_current_stream, new_event
+from torch.fx.node import map_arg
+from torch.utils._ordered_set import OrderedSet
+from torch.utils._runtime_estimation import (
+    _FLOAT_TYPES,
+    _IGNORE_OPS,
+    get_compute_time,
+    get_transfer_time,
+)
+
+
+if TYPE_CHECKING:
+    from .schemas import ViewAndMutationMeta
+
+from .indexed_dict import IndexedDict
+
+
+aten = torch.ops.aten
+
+Node: TypeAlias = torch.fx.Node
+Graph: TypeAlias = torch.fx.Graph
+Partition: TypeAlias = bool
+
+FORWARD: Partition = False
+BACKWARD: Partition = True
+_EMPTY_LOCATIONS: frozenset[tuple[Partition, int]] = frozenset()
+
+_SYNC_OPS = (
+    torch.ops.streams.record_event.default,
+    torch.ops.streams.wait_event.default,
+    torch.ops.streams.wait_stream.default,
+    torch.ops.streams.synchronize_event.default,
+    torch.ops.streams.synchronize_device.default,
+    torch.ops.streams.synchronize_stream.default,
+)
+
+
+def get_roofline_estimate(node: Node) -> float:
+    if node.op != "call_function":
+        raise AssertionError(f"non-func node in roofline estimate: {node.op}")
+
+    def map_value(x: Any) -> Any:
+        return x.meta.get("value", x) if isinstance(x, Node) else x
+
+    func = node.target
+    if func in _IGNORE_OPS:
+        return 0.0
+
+    mapped_args = torch.fx.map_arg(node.args, map_value)
+    mapped_kwargs = torch.fx.map_arg(node.kwargs, map_value)
+    flat_args_kwargs = [map_value(x) for x in _get_flat_args(node, {})]
+    flat_outs, _ = pytree.tree_flatten(node.meta.get("value", node))
+    out = node.meta.get("value", node)
+    out_dtypes = {
+        t.dtype
+        for t in flat_outs
+        if isinstance(t, torch.Tensor) and t.dtype in _FLOAT_TYPES
+    }
+
+    return (
+        max(
+            get_transfer_time(flat_args_kwargs, flat_outs),
+            get_compute_time(func, mapped_args, mapped_kwargs, out, out_dtypes),
+        )
+        / 1e6
+    )
+
+
+def is_gradient_acc(node: Node) -> bool:
+    return node.meta.get("is_gradient_acc", False)
+
+
+def is_bwd_node(node: Node) -> Partition:
+    tag = node.meta.get("partitioner_tag")
+    return tag == "is_backward" or tag == "must_be_in_backward"
+
+
+def get_device(node: Node) -> torch.device:
+    return node.meta["val"].device
+
+
+def get_stream(node: Node) -> int | None:
+    maybe_annotation = node.meta.get("custom", None)
+    if maybe_annotation is not None:
+        return node.meta["custom"].get("stream", None)
+    else:
+        return None
+
+
+def get_stream_or_current_stream(node: Node) -> int:
+    ind = get_stream(node)
+    if ind is None:
+        ind = get_current_stream(get_device(node))
+    return ind
+
+
+def set_stream(node: Node, ind: int) -> None:
+    if "custom" in node.meta:
+        node.meta["custom"].update({"stream": ind})
+    else:
+        node.meta["custom"] = {"stream": ind}
+
+
+def insert_record_event_after_node(graph: Graph, node: Node, event_ind: int) -> Node:
+    with graph.inserting_after(node):
+        node = graph.call_function(
+            torch.ops.streams.record_event.default,
+            (
+                event_ind,
+                get_stream_or_current_stream(node),
+            ),
+        )
+        node.meta["partitioner_tag"] = "must_be_in_backward"
+
+    return node
+
+
+def insert_wait_event_before_node(graph: Graph, node: Node, event_ind: int) -> Node:
+    with graph.inserting_before(node):
+        node = graph.call_function(
+            torch.ops.streams.wait_event.default,
+            (
+                event_ind,
+                get_stream_or_current_stream(node),
+            ),
+        )
+        node.meta["partitioner_tag"] = "must_be_in_backward"
+
+    return node
+
+
+def populate_stream_timeline(
+    stream_to_timeline: dict[int | None, IndexedDict[Node, float]],
+    graph: Graph,
+    stream_index: int | None,
+) -> IndexedDict[Node, float]:
+    if stream_index not in stream_to_timeline:
+        stream_to_timeline[stream_index] = IndexedDict()
+        total_time = 0.0
+        for node in graph.nodes:
+            # mlazos: not sure if we should include forward here too but don't think it matters
+            if (
+                node.op == "call_function"
+                and is_bwd_node(node)
+                and get_stream(node) == stream_index
+            ):
+                total_time += get_roofline_estimate(node)
+                stream_to_timeline[stream_index][node] = (
+                    total_time  # NB: total time includes the node's runtime
+                )
+
+    return stream_to_timeline[stream_index]
+
+
+# NB: we start all estimates at 0, estimating the total runtime of each stream with timestamps at each node
+# we then try and use these timestamps to estimate when to deallocate tensors used in side streams
+# See https://docs.pytorch.org/docs/stable/generated/torch.Tensor.record_stream.html#torch.Tensor.record_stream
+# for details on the problem being addressed. Rather than using the automatic memory management approach of record_stream
+# we attempt to find the point which to deallocate based on the estimated timestamps.
+def handle_synced_deallocation(
+    graph: Graph,
+    stream_to_exec_trace: dict[int | None, IndexedDict[Node, float]],
+    node: Node,
+    last_usage: Node,
+) -> None:
+    if not is_bwd_node(node):
+        raise AssertionError(
+            "synced allocations should only be handled on backward nodes"
+        )
+    if not is_bwd_node(last_usage):
+        raise AssertionError(
+            "synced allocations should only be handled on backward nodes"
+        )
+    allocating_stream = get_stream(node)
+    side_stream = get_stream(last_usage)
+    if allocating_stream == side_stream:
+        raise AssertionError(
+            "allocating and side stream should be different for synced deallocations"
+        )
+    if not torch.accelerator.is_available():
+        # fallback to record_stream in this case
+        with graph.inserting_after(node):
+            rs = graph.call_function(
+                torch.ops.streams.record_stream.default,
+                (
+                    node,
+                    get_stream_or_current_stream(last_usage),
+                ),
+                {},
+            )
+        rs.meta["partitioner_tag"] = "must_be_in_backward"
+
+    allocating_stream_trace = populate_stream_timeline(
+        stream_to_exec_trace, graph, allocating_stream
+    )
+    side_stream_trace = populate_stream_timeline(
+        stream_to_exec_trace, graph, side_stream
+    )
+
+    alloc_ptr = node
+    target_side_stream_time = side_stream_trace[last_usage]
+    # linear search from first usage of tensor to a point in time after the side stream has finished
+    while alloc_ptr is not None:
+        alloc_time = allocating_stream_trace[alloc_ptr]
+
+        if alloc_time >= target_side_stream_time:
+            break
+        elif alloc_time < target_side_stream_time:
+            next_ptr = allocating_stream_trace.next_key(alloc_ptr)
+            if next_ptr is not None:
+                alloc_ptr = next_ptr
+            else:
+                break
+
+    wait_event = new_event()
+    record_node = insert_record_event_after_node(graph, last_usage, wait_event)
+    with graph.inserting_after(max(alloc_ptr, record_node)):
+        sd = graph.call_function(
+            torch.ops.streams.sync_dealloc.default,
+            (wait_event, get_stream_or_current_stream(alloc_ptr), node),
+            {},
+        )
+        sd.meta["partitioner_tag"] = "must_be_in_backward"
+
+
+def insert_sync(
+    graph: Graph,
+    consumer: Node,
+    producer: Node,
+    node_to_wait_event_ind: dict[Node, int],
+) -> None:
+    if producer not in node_to_wait_event_ind:
+        node_to_wait_event_ind[producer] = new_event()
+
+        insert_record_event_after_node(
+            graph, producer, node_to_wait_event_ind[producer]
+        )
+        insert_wait_event_before_node(graph, consumer, node_to_wait_event_ind[producer])
+
+
+def assign_backward_streams(gm: torch.fx.GraphModule) -> None:
+    """Assigns backward streams to gradient accumulation nodes"""
+
+    # NB: iterate in reverse order to more closely match eager
+    # the user node stream will be populated first
+    for node in reversed(list(gm.graph.nodes)):
+        if is_gradient_acc(node):
+            # Accumulation stream selection. Follow the rules from top to bottom to determine the accumulation stream:
+            # 1. Match first stream assignment of the first user with a stream
+            # 2. Match first stream assignment encountered in the args from left to right
+            # This differs from eager in some cases:
+            # Specifically the eager code uses the autograd node to determine the stream,
+            # crucially this does not necessarily correspond to the FX graph node. For example,
+            # in the backward for an add node with a constant we will passthrough and during backward tracing,
+            # no op will be added to the FX graph, so our stream assignment will differ in this case.
+            gradients = _get_flat_args(node, {})
+            users = list(node.users.keys())
+
+            # All gradients will be on same device, they will be coerced if they were not with a .to() node
+            for neighbor in users + gradients:
+                ind = get_stream(neighbor)
+                if ind is not None:
+                    set_stream(node, ind)
+                    break
+
+
+def insert_backward_syncs(gm: torch.fx.GraphModule) -> None:
+    """Inserts stream syncs for backward nodes if consumer and producer are on different streams"""
+    node_to_wait_event_ind: dict[Node, int] = {}
+    for node in gm.graph.nodes:
+        if node.op == "call_function" and is_bwd_node(node):
+            flat_args = _get_flat_args(node, {})
+            cur_node_stream = get_stream(node)
+
+            for arg in flat_args:
+                if arg.op == "call_function" and is_bwd_node(arg):
+                    arg_stream = get_stream(arg)
+                    if arg_stream != cur_node_stream and get_device(arg).type != "cpu":
+                        insert_sync(gm.graph, node, arg, node_to_wait_event_ind)
+
+
+def sync_deallocations(gm: torch.fx.GraphModule) -> None:
+    """Handles https://docs.pytorch.org/docs/stable/generated/torch.Tensor.record_stream.html#torch.Tensor.record_stream"""
+    # Note: this is only needed if the last usage of a tensor is on a stream other than
+    # the stream the tensor was allocated on
+
+    # an estimated timestamp from the beginning of graph execution (assuming 0 CPU overhead)
+    # I think this is fine because you should have large tensors if you're using streams
+    # although perhaps I could add a constant 10us per op ahead of the first stream op?
+    # a trace of all the nodes running in a given stream
+    stream_to_exec_trace: dict[int | None, IndexedDict[Node, float]] = {}
+    for node in gm.graph.nodes:
+        if node.op == "call_function" and is_bwd_node(node):
+            allocating_stream = get_stream(node)
+            users = list(node.users.keys())
+            if not users:
+                continue
+            last_user = max(user for user in users)
+            if last_user.op == "output":
+                continue
+            side_stream = get_stream(last_user)
+            if allocating_stream != side_stream:
+                handle_synced_deallocation(
+                    gm.graph, stream_to_exec_trace, node, last_user
+                )
+
+
+def assign_epilogue_copy_streams(gm: torch.fx.GraphModule) -> None:
+    for epi_copy in gm.graph.find_nodes(op="call_function", target=aten.copy_.default):
+        arg_stream = get_stream(epi_copy.args[1])
+        copy_stream = get_stream(epi_copy)
+        if arg_stream != copy_stream:
+            set_stream(epi_copy, get_stream_or_current_stream(epi_copy.args[1]))
+
+
+def populate_fw_metadata_with_stream_indices(
+    gm: torch.fx.GraphModule, fw_metadata: "ViewAndMutationMeta"
+) -> None:
+    """
+    Populates fw_metadata.mutated_inp_stream_indices with stream indices from the compiled graph.
+
+    The forward graph outputs are structured as:
+    (*mutated_inputs, *user_outputs, *intermediate_bases, *saved_tensors, *saved_symints)
+
+    We extract the stream index for each mutated input from the graph's output node.
+    """
+
+    num_mutated_inps = fw_metadata.num_mutated_inp_runtime_indices
+    if num_mutated_inps == 0:
+        fw_metadata.mutated_inp_stream_indices = []
+        return
+
+    # Find the output node in the graph
+    output_node = None
+    for node in gm.graph.find_nodes(op="output"):
+        output_node = node
+        break
+
+    if output_node is None:
+        raise AssertionError(
+            "No output node found in the graph when extracting stream indices"
+        )
+
+    # The output node's args[0] is a tuple/list of all outputs
+    output_args = output_node.args[0]
+
+    # Extract stream indices for the first num_mutated_inps outputs
+    stream_indices = []
+    for i in range(num_mutated_inps):
+        if i < len(output_args):
+            output_arg = output_args[i]
+            # Get the stream index from the node metadata
+            stream_idx = (
+                get_stream(output_arg)
+                if isinstance(output_arg, torch.fx.Node)
+                else None
+            )
+            stream_indices.append(stream_idx)
+        else:
+            stream_indices.append(None)
+
+    fw_metadata.mutated_inp_stream_indices = stream_indices
+
+
+def _expand_dict_returning_deps(
+    deps: list[Node],
+    visited: set[Node],
+    graph: torch.fx.Graph,
+    sync_node: Node,
+) -> list[Node]:
+    """Expand triton_kernel_wrapper_functional dict deps into per-key getitems.
+
+    ``triton_kernel_wrapper_functional`` returns a flat ``dict[str, Tensor]``.
+    If such a node is threaded through ``control_deps`` as a pass-through
+    value, ``decompose_triton_kernel_wrapper_functional`` later replaces it
+    with a raw Python dict, corrupting every user that expected an FX Node.
+
+    To avoid this, we insert ``operator.getitem`` nodes *before* the sync for
+    each after-sync getitem user, so that only tensor-valued nodes are passed
+    through ``control_deps``.  The dict node may still appear in
+    ``additional_deps`` (ordering-only) which is safe since that tuple is
+    never decomposed.
+    """
+    expanded: list[Node] = []
+    for dep in deps:
+        if not (
+            dep.op == "call_function"
+            and dep.target is torch.ops.higher_order.triton_kernel_wrapper_functional
+        ):
+            expanded.append(dep)
+            continue
+
+        after_sync_getitems = [
+            user
+            for user in dep.users
+            if user not in visited
+            and user.op == "call_function"
+            and user.target is operator.getitem
+        ]
+        if not after_sync_getitems:
+            expanded.append(dep)
+            continue
+
+        with graph.inserting_before(sync_node):
+            for old_gi in after_sync_getitems:
+                key = old_gi.args[1]
+                new_gi = graph.call_function(operator.getitem, args=(dep, key))
+                new_gi.meta.update(old_gi.meta)
+                if isinstance(new_gi.meta.get("val"), dict):
+                    raise AssertionError(
+                        f"nested dict in triton kernel output for key {key}"
+                    )
+                visited.add(new_gi)
+                expanded.append(new_gi)
+                old_gi.replace_all_uses_with(new_gi)
+                graph.erase_node(old_gi)
+
+    return expanded
+
+
+def _wrap_sync_node(
+    gm: torch.fx.GraphModule,
+    sync_node: Node,
+    deps_before_sync: list[Node],
+    visited: set[Node],
+    partition_scoped_deps: set[Node] | None = None,
+) -> tuple[Node, list[Node]]:
+    """
+    Core logic: wrap a single sync node in control_deps.
+
+    Returns (control_deps_node, passthrough_getitems) where passthrough_getitems
+    are the getitem nodes that thread dependencies through the control_deps node.
+    ``visited`` is the set of nodes at or before the sync node in graph order,
+    used to distinguish pre-sync vs post-sync users.
+    """
+    from torch._inductor.fx_passes.control_dependencies import (
+        _create_subgraph_for_node,
+        control_deps,
+        get_subgraph_name,
+    )
+
+    graph = gm.graph
+    if partition_scoped_deps is None:
+        partition_scoped_deps = set()
+
+    sync_is_bwd = is_bwd_node(sync_node)
+
+    def _user_rewrite_pred(dep: Node) -> Callable[[Node], bool]:
+        if dep in partition_scoped_deps:
+
+            def pred(user: Node) -> bool:
+                if user in visited:
+                    return False
+                if user.op == "output":
+                    return sync_is_bwd
+                return is_bwd_node(user) == sync_is_bwd
+
+            return pred
+
+        dep_is_bwd = is_bwd_node(dep)
+
+        def pred(user: Node) -> bool:
+            return user not in visited and (user.op != "output" or dep_is_bwd)
+
+        return pred
+
+    # Use dep.users to find deps with uses after the sync — avoids a forward walk.
+    deps_with_uses_after_sync = []
+    for dep in deps_before_sync:
+        pred = _user_rewrite_pred(dep)
+        if any(pred(user) for user in dep.users):
+            deps_with_uses_after_sync.append(dep)
+
+    # Expand dict-returning nodes (triton_kernel_wrapper_functional) into
+    # individual getitem outputs.  Passing a dict-valued node through
+    # control_deps breaks post-grad passes: reinplace + decomposition replace
+    # the dict node with a Python dict, corrupting any user that expected an
+    # FX Node.  Unwrapping here ensures only tensor-valued nodes flow through.
+    deps_with_uses_after_sync = _expand_dict_returning_deps(
+        deps_with_uses_after_sync, visited, graph, sync_node
+    )
+
+    # Create subgraph that executes sync and passes through only used dependencies
+    subgraph_module = _create_subgraph_for_node(
+        graph, sync_node, deps_with_uses_after_sync
+    )
+    subgraph_attr_name = get_subgraph_name(gm, sync_node.name)
+    setattr(gm, subgraph_attr_name, subgraph_module)
+
+    # Create control_deps call
+    # Note: sync nodes (record_event/wait_event) only take int args, no Node args.
+    with graph.inserting_before(sync_node):
+        get_subgraph = graph.get_attr(subgraph_attr_name)
+        control_deps_node = graph.call_function(
+            control_deps,
+            args=(
+                tuple(deps_before_sync),  # additional_deps (all deps for ordering)
+                get_subgraph,  # subgraph
+                *deps_with_uses_after_sync,  # only pass through deps that are used
+            ),
+            kwargs={},
+        )
+
+    # Propagate partitioner_tag so the partitioner can distinguish
+    # forward vs backward sync control_deps during graph extraction.
+    if "partitioner_tag" in sync_node.meta:
+        control_deps_node.meta["partitioner_tag"] = sync_node.meta["partitioner_tag"]
+
+    # Mark newly created nodes as visited so subsequent syncs don't
+    # misclassify them as "after the sync" during replacement.
+    visited.add(get_subgraph)
+    visited.add(control_deps_node)
+
+    # The output is (sync_result, *deps_with_uses_after_sync)
+    # Reuse the val the subgraph output already carries: the min-cut
+    # partitioner's _size_of() raises on any node without `val`, and its escape
+    # hatch covers only get_attr and zero-return OpOverloads, not a schema-less
+    # HOP.  The subgraph output is unwrapped when it has no pass-through deps.
+    sg_val = subgraph_module.graph.output_node().meta.get("val")
+    control_deps_node.meta["val"] = sg_val if isinstance(sg_val, tuple) else (sg_val,)
+
+    # Create getitem nodes only for dependencies that have uses after sync
+    replacements: dict[Node, Node] = {}
+    with graph.inserting_after(control_deps_node):
+        for i, dep in enumerate(deps_with_uses_after_sync):
+            getitem_node = graph.call_function(
+                operator.getitem,
+                args=(control_deps_node, i + 1),  # +1 because index 0 is sync result
+            )
+            getitem_node.meta.update(dep.meta)
+            # The getitem is a passthrough projection of an existing value, not
+            # a node that *produces* an unbacked symbol - the original ``dep``
+            # (still inside the subgraph) is the binding site. Leaving the
+            # binding on the getitem trips Inductor's run_node assertion that
+            # ``new_unbacked_defs >= renamed_unbacked_bindings``.
+            getitem_node.meta.pop("unbacked_bindings", None)
+            replacements[dep] = getitem_node
+            visited.add(getitem_node)
+
+    # Replace uses of dependencies that come after sync_node.
+    # Use map_arg to handle nested structures (e.g. output node's list args).
+    for dep, getitem_node in replacements.items():
+        pred = _user_rewrite_pred(dep)
+        for user in list(dep.users.keys()):
+            if user is control_deps_node:
+                continue
+            if not pred(user):
+                continue
+
+            def _replace(n: Node) -> Node:
+                return getitem_node if n is dep else n
+
+            if (
+                user.op == "call_function"
+                and user.target is torch.ops.aten.copy_.default
+                and user.args[0] is dep
+                and dep in partition_scoped_deps
+            ):
+                # AOT functionalization leaves keep_input_mutations epilogue
+                # copy_ as the only writer of a partition-scoped placeholder.
+                # Preserve the destination identity used by mutation bookkeeping.
+                user.args = (dep, *map_arg(user.args[1:], _replace))
+            else:
+                user.args = map_arg(user.args, _replace)
+            user.kwargs = map_arg(user.kwargs, _replace)
+
+    # Remove original sync node
+    sync_node.replace_all_uses_with(control_deps_node)
+    graph.erase_node(sync_node)
+    return control_deps_node, list(replacements.values())
+
+
+def _collect_sync_forward_deps(
+    graph: torch.fx.Graph,
+) -> tuple[dict[Node, OrderedSet[Node]], dict[Node, OrderedSet[Node]]]:
+    """Collect values that must cross sync boundaries.
+
+    ``live_inputs[partition][stream]`` tracks values whose passthrough can anchor
+    later work in that partition on that stream. Demand labels propagate through
+    producers while each producer also seeds its own execution stream. This is a
+    single reverse liveness traversal; the forward pass still handles sync/event
+    state introduced while rewriting the graph.
+    """
+    stream_sync_deps: dict[Node, OrderedSet[Node]] = {}
+    full_barrier_deps: dict[Node, OrderedSet[Node]] = {}
+    live_inputs: dict[Partition, dict[int, OrderedSet[Node]]] = {
+        FORWARD: {},
+        BACKWARD: {},
+    }
+    locations: dict[Node, OrderedSet[tuple[Partition, int]]] = {}
+    full_barriers = (
+        torch.ops.streams.synchronize_device.default,
+        torch.ops.streams.synchronize_event.default,
+        torch.ops.streams.synchronize_stream.default,
+    )
+
+    def _add_live(node: Node, partition: Partition, stream: int) -> None:
+        stream_inputs = live_inputs[partition].get(stream)
+        if stream_inputs is None:
+            stream_inputs = live_inputs[partition][stream] = OrderedSet()
+        stream_inputs.add(node)
+        node_locations = locations.get(node)
+        if node_locations is None:
+            node_locations = locations[node] = OrderedSet()
+        node_locations.add((partition, stream))
+
+    for node in reversed(graph.nodes):
+        if node.op == "call_function" and node.target in full_barriers:
+            deps = OrderedSet(
+                dep
+                for stream_inputs in live_inputs[is_bwd_node(node)].values()
+                for dep in stream_inputs
+            )
+            if deps:
+                full_barrier_deps[node] = deps
+            continue
+        if (
+            node.op == "call_function"
+            and node.target is torch.ops.streams.wait_stream.default
+        ):
+            waiting_stream: int = node.args[0]  # type: ignore[assignment]
+            deps = live_inputs[is_bwd_node(node)].get(waiting_stream)
+            if deps:
+                stream_sync_deps[node] = deps.copy()
+            continue
+        if (
+            node.op == "call_function"
+            and node.target is torch.ops.streams.wait_event.default
+        ):
+            waiting_stream: int = node.args[1]  # type: ignore[assignment]
+            deps = live_inputs[is_bwd_node(node)].get(waiting_stream, ())
+            graph_inputs = OrderedSet(dep for dep in deps if dep.op == "placeholder")
+            if graph_inputs:
+                stream_sync_deps[node] = graph_inputs
+            continue
+        if node.op != "call_function" or node.target in _SYNC_OPS:
+            continue
+
+        inherited_locations = locations.pop(node, _EMPTY_LOCATIONS)
+        for partition, stream in inherited_locations:
+            live_inputs[partition][stream].discard(node)
+        execution_stream = get_stream(node)
+        if execution_stream is None:
+            execution_stream = 0
+        target_locations = OrderedSet(
+            (*inherited_locations, (is_bwd_node(node), execution_stream))
+        )
+
+        def _collect(n: Node) -> Node:
+            if "val" in n.meta:
+                for partition, stream in target_locations:
+                    _add_live(n, partition, stream)
+            return n
+
+        map_arg(node.args, _collect)
+        map_arg(node.kwargs, _collect)
+    return stream_sync_deps, full_barrier_deps
+
+
+def _collect_full_barrier_deps(
+    stream_to_nodes: dict[int | None, list[Node]],
+    stream_sync_deps: dict[int | None, list[Node]],
+    bwd: bool = False,
+) -> list[Node]:
+    """Collect all still-live cross-stream deps for a full CPU barrier
+    (synchronize_stream/device/event).
+
+    These ops block the CPU, so a consumer is only ordered after them by an
+    explicit control_deps edge (nothing on the consumer's stream waits for a CPU
+    barrier). Includes live compute nodes (stream_to_nodes) plus the ctrl/
+    passthrough nodes accumulated by prior sync ops that already cleared
+    stream_to_nodes (stream_sync_deps), deduped by identity preserving order.
+
+    ``bwd`` marks a backward barrier: its accumulated sync deps are filtered to
+    backward nodes only, so it never depends on a forward control_deps node.
+    That edge would cross the fwd/bwd boundary onto a node that is neither
+    saveable nor recomputable, making the min-cut partitioner infeasible.
+    Forward compute deps (stream_to_nodes) are kept -- backward legitimately
+    depends on forward activations.
+    """
+    all_deps = [n for nodes in stream_to_nodes.values() for n in nodes]
+    seen = set(all_deps)
+    for deps in stream_sync_deps.values():
+        for dep in deps:
+            if dep in seen or (bwd and not is_bwd_node(dep)):
+                continue
+            all_deps.append(dep)
+            seen.add(dep)
+    return all_deps
+
+
+def wrap_all_sync_nodes_with_control_deps(gm: torch.fx.GraphModule) -> None:
+    """
+    Single-pass wrap of all sync nodes in control_deps.
+
+    Iterates through the graph once, accumulating per-stream node lists.
+    When a sync node is encountered, it is wrapped using the accumulated deps
+    for that stream, then the deps are reset to the control_deps node
+    (maintaining the ordering chain for subsequent syncs on the same stream).
+    """
+    graph = gm.graph
+    if len(graph.nodes) == 0:
+        raise RuntimeError("Expected a non-empty graph")
+
+    stream_sync_forward_deps, full_barrier_forward_deps = _collect_sync_forward_deps(
+        graph
+    )
+
+    stream_to_nodes: dict[int | None, list[Node]] = {}
+    # Maps event_index to its latest ordering anchor: either the control_deps that
+    # wrapped record_event or a raw record_event with no dependencies.
+    event_to_anchor: dict[int, Node] = {}
+    # Maps event_index -> getitem nodes threaded through record_event's control_deps,
+    # so synchronize_event can thread them through to subsequent ops.
+    event_to_passthrough: dict[int, list[Node]] = {}
+    # Maps event_index -> stream that the event was recorded on,
+    # so synchronize_event can infer its stream.
+    event_to_stream: dict[int, int | None] = {}
+    # Tracks the most recent control_deps node and its passthrough
+    # getitems per stream. synchronize_stream/device consults this to
+    # depend on prior sync ops (ctrl_node for ordering) and thread
+    # cross-stream data through (passthrough for data edges), even
+    # after stream_to_nodes has been cleared by those sync ops.
+    stream_sync_deps: dict[int | None, list[Node]] = {}
+    visited: set[Node] = set()
+    found_sync = False
+
+    # Walk the node linked-list manually so we can mutate the graph
+    # (wrapping sync nodes inserts/erases nodes) without losing our place.
+    node = next(iter(graph.nodes))
+    while node.op != "root":
+        next_node = node.next
+        visited.add(node)
+
+        if node.op == "call_function":
+            if node.target in _SYNC_OPS:
+                # synchronize_device and synchronize_stream block the CPU,
+                # so all subsequent kernel launches are host-ordered after
+                # them. Treat both as full barriers across all streams.
+                if node.target in (
+                    torch.ops.streams.synchronize_device.default,
+                    torch.ops.streams.synchronize_stream.default,
+                ):
+                    all_stream_deps = _collect_full_barrier_deps(
+                        stream_to_nodes, stream_sync_deps, bwd=is_bwd_node(node)
+                    )
+                    existing_deps = set(all_stream_deps)
+                    for dep in full_barrier_forward_deps.get(node, ()):
+                        if dep not in existing_deps:
+                            all_stream_deps.append(dep)
+                            existing_deps.add(dep)
+                    if all_stream_deps:
+                        found_sync = True
+                        ctrl_node_sync, passthrough_sync = _wrap_sync_node(
+                            gm, node, all_stream_deps, visited
+                        )
+                    else:
+                        ctrl_node_sync = None
+                        passthrough_sync: list[Node] = []
+                    stream_to_nodes.clear()
+                    stream_sync_deps.clear()
+                    sync_anchor = ctrl_node_sync if ctrl_node_sync is not None else node
+                    stream_sync_deps[None] = [sync_anchor, *passthrough_sync]
+                    while (
+                        getattr(next_node, "_erased", False) and next_node.op != "root"
+                    ):
+                        next_node = next_node.next
+                    node = next_node
+                    continue
+
+                # wait_stream(waiting, waited_on) creates a dependency on
+                # the waited_on stream: all prior work there must complete
+                # before the waiting stream proceeds.
+                if node.target is torch.ops.streams.wait_stream.default:
+                    waiting_stream: int = node.args[0]  # type: ignore[assignment]
+                    waited_on_stream: int = node.args[1]  # type: ignore[assignment]
+                    deps_before_sync = list(stream_to_nodes.get(waited_on_stream, ()))
+                    if waiting_stream != waited_on_stream:
+                        deps_before_sync.extend(stream_to_nodes.get(waiting_stream, ()))
+                    if None in stream_to_nodes and waited_on_stream is not None:
+                        deps_before_sync.extend(stream_to_nodes[None])
+                    participating_streams = dict.fromkeys(
+                        (waited_on_stream, waiting_stream, None)
+                    )
+                    prior_syncs = list(
+                        dict.fromkeys(
+                            dep
+                            for stream in participating_streams
+                            for dep in stream_sync_deps.get(stream, ())
+                        )
+                    )
+                    if is_bwd_node(node):
+                        prior_syncs = [n for n in prior_syncs if is_bwd_node(n)]
+                    deps_before_sync.extend(prior_syncs)
+                    # Also include inputs of subsequent waiting-stream nodes
+                    # so they get threaded through control_deps, creating a
+                    # forward ordering constraint (waiting-stream work must
+                    # come after wait_stream).
+                    existing_deps = set(deps_before_sync)
+                    for dep in stream_sync_forward_deps.get(node, ()):
+                        if dep not in existing_deps:
+                            deps_before_sync.append(dep)
+                            existing_deps.add(dep)
+                    if deps_before_sync:
+                        found_sync = True
+                        ctrl_node_ws, passthrough_ws = _wrap_sync_node(
+                            gm, node, deps_before_sync, visited
+                        )
+                    else:
+                        ctrl_node_ws = None
+                        passthrough_ws: list[Node] = []
+                    wait_anchor = ctrl_node_ws if ctrl_node_ws is not None else node
+                    # Key under both streams: the wait executes on waiting_stream
+                    # and subsumes the waited-on work used to anchor it.
+                    stream_sync_deps[waiting_stream] = [
+                        wait_anchor,
+                        *passthrough_ws,
+                    ]
+                    stream_sync_deps[waited_on_stream] = [
+                        wait_anchor,
+                        *passthrough_ws,
+                    ]
+                    stream_to_nodes[waited_on_stream] = []
+                    if None in stream_to_nodes:
+                        stream_to_nodes[None] = []
+                    while (
+                        getattr(next_node, "_erased", False) and next_node.op != "root"
+                    ):
+                        next_node = next_node.next
+                    node = next_node
+                    continue
+
+                event_index: int = node.args[0]  # type: ignore[assignment]
+
+                # synchronize_event blocks the CPU thread, so it acts
+                # as a barrier across all streams. Collect deps from every
+                # stream and reset them all afterward. If the event was
+                # recorded externally, thread the graph inputs through so
+                # that any post-sync uses depend on the synchronize.
+                partition_scoped_deps: list[Node] = []
+                if node.target is torch.ops.streams.synchronize_event.default:
+                    sync_stream: int | None = event_to_stream.get(event_index)
+                    # Like synchronize_stream/device, this is a CPU-side barrier,
+                    # so fold in still-live cross-stream data accumulated by prior
+                    # sync ops (which cleared stream_to_nodes).
+                    all_stream_deps = _collect_full_barrier_deps(
+                        stream_to_nodes, stream_sync_deps, bwd=is_bwd_node(node)
+                    )
+                    deps_before_sync = [
+                        *all_stream_deps,
+                        *full_barrier_forward_deps.get(node, ()),
+                    ]
+                else:
+                    sync_stream = node.args[1]  # type: ignore[assignment]
+                    deps_before_sync = list(stream_to_nodes.get(sync_stream, ()))
+                    partition_scoped_deps = (
+                        list(stream_sync_forward_deps.get(node, ()))
+                        if node.target is torch.ops.streams.wait_event.default
+                        and event_index not in event_to_anchor
+                        else []
+                    )
+                    deps_before_sync.extend(partition_scoped_deps)
+                    # Nodes without explicit stream annotation (custom.stream=None)
+                    # run on the current/default stream. Include them when the sync
+                    # op references a stream, since the unannotated nodes are
+                    # implicitly on that stream.
+                    if None in stream_to_nodes and sync_stream is not None:
+                        deps_before_sync.extend(stream_to_nodes[None])
+                    # Order this sync op after the prior sync on its own stream
+                    # (and after any full barrier, keyed under None). Without this,
+                    # a record/wait whose stream_to_nodes was reset by an earlier
+                    # sync would have no deps, stay unwrapped, and float as a bare
+                    # side-effectful node -- capturing nothing, the same failure as
+                    # an unanchored synchronize_stream.
+                    prior_syncs = [
+                        *stream_sync_deps.get(sync_stream, ()),
+                        *stream_sync_deps.get(None, ()),
+                    ]
+                    # A backward sync must anchor only on backward sync nodes:
+                    # depending on a forward control_deps node crosses the fwd/bwd
+                    # boundary onto a node that is neither saveable nor
+                    # recomputable, which makes the min-cut partitioner infeasible.
+                    if is_bwd_node(node):
+                        prior_syncs = [n for n in prior_syncs if is_bwd_node(n)]
+                    deps_before_sync.extend(prior_syncs)
+
+                # For wait_event and synchronize_event, depend on the matching
+                # record_event's control_deps node (ordering) and thread its
+                # passthrough getitems through (data edge), so consumers of
+                # recorded values are rewired through the wait/synchronize
+                # and the scheduler sees the dependency.
+                if node.target in (
+                    torch.ops.streams.wait_event.default,
+                    torch.ops.streams.synchronize_event.default,
+                ):
+                    if event_index in event_to_anchor:
+                        deps_before_sync = [
+                            event_to_anchor[event_index],
+                            *deps_before_sync,
+                        ]
+                    if event_index in event_to_passthrough:
+                        deps_before_sync = [
+                            *deps_before_sync,
+                            *event_to_passthrough[event_index],
+                        ]
+                elif (
+                    node.target is torch.ops.streams.record_event.default
+                    and event_index in event_to_anchor
+                ):
+                    # Re-recording replaces an event's state, but the host-side
+                    # record operations must retain program order even when the
+                    # new record is on an otherwise-empty stream.
+                    deps_before_sync.insert(0, event_to_anchor[event_index])
+
+                # Deduplicate (preserving order): the folded stream_sync_deps and
+                # the event's own anchor/passthrough can overlap.
+                deps_before_sync = list(OrderedSet(deps_before_sync))
+
+                if deps_before_sync:
+                    found_sync = True
+                    ctrl_node, passthrough = _wrap_sync_node(
+                        gm,
+                        node,
+                        deps_before_sync,
+                        visited,
+                        set(partition_scoped_deps)
+                        if node.target is torch.ops.streams.wait_event.default
+                        else None,
+                    )
+                else:
+                    ctrl_node = None
+                    passthrough: list[torch.fx.Node] = []
+
+                if node.target is torch.ops.streams.record_event.default:
+                    event_to_stream[event_index] = sync_stream
+                    event_to_anchor[event_index] = (
+                        ctrl_node if ctrl_node is not None else node
+                    )
+                    event_to_passthrough[event_index] = passthrough
+
+                sync_anchor = ctrl_node if ctrl_node is not None else node
+                stream_sync_deps[sync_stream] = [sync_anchor, *passthrough]
+
+                # Reset: ops between this sync and the next will accumulate
+                # fresh. Ordering with prior ops is already enforced because
+                # their uses were rewired through getitems from control_deps.
+                # synchronize_event is a full barrier, so its own passthrough
+                # subsumes all prior per-stream data: clear then re-seed. Key the
+                # reseed under None (like synchronize_stream/device) so a later
+                # record/wait on any stream chains after it.
+                if node.target is torch.ops.streams.synchronize_event.default:
+                    stream_to_nodes.clear()
+                    stream_sync_deps.clear()
+                    stream_sync_deps[None] = [sync_anchor, *passthrough]
+                else:
+                    stream_to_nodes[sync_stream] = []
+                    if None in stream_to_nodes:
+                        stream_to_nodes[None] = []
+            elif "val" in node.meta:
+                stream = get_stream(node)
+                stream_to_nodes.setdefault(stream, []).append(node)
+
+        # _wrap_sync_node may erase nodes after the sync (e.g.
+        # _expand_dict_returning_deps erases getitems).  Skip erased nodes
+        # so we don't re-process a dead node into stream_to_nodes.
+        while getattr(next_node, "_erased", False) and next_node.op != "root":
+            next_node = next_node.next
+        node = next_node
+
+    if found_sync:
+        gm.recompile()

.venv/lib/python3.12/site-packages/torch/_functorch/_aot_autograd/subclass_codegen.py

@@ -0,0 +1,623 @@
+"""
+Codegen for AOTDispatchSubclassWrapper.
+
+Generates a Python function that replaces the data-driven
+runtime_unwrap_tensor_subclasses / wrap_tensor_subclasses loop with
+a straight-line function where all metadata (indices, attr names,
+subclass types, symint positions) is baked in at compile time.
+"""
+
+import functools
+import keyword
+from collections.abc import Callable, Iterable
+from typing import cast, TYPE_CHECKING
+
+from torch import SymInt
+
+from .codegen import _compile_and_exec_source, PySourceBuilder
+from .schemas import ActInputPaths, OpaqueMeta, PlainTensorMeta, SubclassCreationMeta
+from .utils import import_async_collective_tensor_type
+
+
+if TYPE_CHECKING:
+    from torch.distributed._functional_collectives import AsyncCollectiveTensor
+
+
+def _is_symint_placeholder(x: None | int | SymInt) -> bool:
+    """Check whether a size/stride entry is symbolic and needs a runtime value.
+
+    Works both before make_runtime_safe() (entries are SymInt) and after
+    (symbolic entries replaced with None, nested ints with -1).
+    """
+    if x is None:
+        return True
+    if isinstance(x, SymInt) and not x.node.is_nested_int():
+        return True
+    return False
+
+
+def _compute_placeholders(outer: Iterable[None | int | SymInt]) -> list[bool]:
+    return [_is_symint_placeholder(s) for s in outer]
+
+
+def _safe_attr_access(var: str, attr: str) -> str:
+    if attr.isidentifier() and not keyword.iskeyword(attr):
+        return f"{var}.{attr}"
+    return f"getattr({var}, {attr!r})"
+
+
+class _OutputWrapState:
+    def __init__(
+        self,
+        *,
+        remaining_min_count: int,
+        remaining_max_count: int,
+        optional_symint_check: str,
+    ) -> None:
+        self.remaining_min_count = remaining_min_count
+        self.remaining_max_count = remaining_max_count
+        self.optional_symint_check = optional_symint_check
+
+    def mark_required(self) -> None:
+        self.remaining_min_count -= 1
+        self.remaining_max_count -= 1
+
+    def mark_optional(self) -> None:
+        self.remaining_max_count -= 1
+
+
+def _maybe_wait_async_collective_tensor(
+    x: object,
+    AsyncCollectiveTensor: type["AsyncCollectiveTensor"],
+) -> object:
+    """Wait on ACT values and leave all other runtime inputs unchanged."""
+    if isinstance(x, AsyncCollectiveTensor):
+        return cast("AsyncCollectiveTensor", x).trigger_wait()
+    return x
+
+
+def _codegen_unwrap_subclass(
+    state: PySourceBuilder,
+    meta: SubclassCreationMeta,
+    var: str,
+    indent: int = 1,
+    include_symints: bool = True,
+    act_input_paths: set[tuple[str, ...]] | None = None,
+    act_wait_fn: str | None = None,
+) -> None:
+    """Emit code to recursively unwrap a single subclass input."""
+    act_input_paths = act_input_paths or set()
+
+    def emit_plain_tensor_symints(var: str, meta: PlainTensorMeta) -> None:
+        if not include_symints:
+            return
+
+        if any(meta.size_symbol_placeholders):
+            size_var = state.fresh_name("_size")
+            state.emit(f"{size_var} = {var}.size()", indent=indent)
+            for i, is_sym in enumerate(meta.size_symbol_placeholders):
+                if is_sym:
+                    state.emit(f"unwrapped_args.append({size_var}[{i}])", indent=indent)
+
+        if any(meta.stride_symbol_placeholders):
+            stride_var = state.fresh_name("_stride")
+            state.emit(f"{stride_var} = {var}.stride()", indent=indent)
+            for i, is_sym in enumerate(meta.stride_symbol_placeholders):
+                if is_sym:
+                    state.emit(
+                        f"unwrapped_args.append({stride_var}[{i}])", indent=indent
+                    )
+
+    for attr, attr_meta in meta.attrs.items():
+        attr_expr = _safe_attr_access(var, attr)
+        attr_act_input_paths = {
+            path[1:] for path in act_input_paths if path and path[0] == attr
+        }
+        match attr_meta:
+            case PlainTensorMeta():
+                if attr_act_input_paths:
+                    if attr_act_input_paths != {()}:
+                        raise AssertionError(
+                            f"ACT path for {attr} continues past a leaf meta"
+                        )
+                    if act_wait_fn is None:
+                        raise AssertionError("missing ACT wait function")
+                    resolved_var = state.fresh_name("_resolved")
+                    state.emit(
+                        f"{resolved_var} = {act_wait_fn}({attr_expr})",
+                        indent=indent,
+                    )
+                    attr_expr = resolved_var
+                state.emit(f"unwrapped_args.append({attr_expr})", indent=indent)
+                emit_plain_tensor_symints(attr_expr, attr_meta)
+            case OpaqueMeta():
+                if attr_act_input_paths:
+                    if attr_act_input_paths != {()}:
+                        raise AssertionError(
+                            f"ACT path for {attr} continues past a leaf meta"
+                        )
+                    if act_wait_fn is None:
+                        raise AssertionError("missing ACT wait function")
+                    resolved_var = state.fresh_name("_resolved")
+                    state.emit(
+                        f"{resolved_var} = {act_wait_fn}({attr_expr})",
+                        indent=indent,
+                    )
+                    state.emit(f"unwrapped_args.append({resolved_var})", indent=indent)
+                else:
+                    state.emit(
+                        f"unwrapped_args.append({attr_expr})",
+                        indent=indent,
+                    )
+            case SubclassCreationMeta():
+                if () in attr_act_input_paths:
+                    raise AssertionError(f"ACT path for {attr} stops at subclass meta")
+                inner_var = state.fresh_name("_inner")
+                state.emit(f"{inner_var} = {attr_expr}", indent=indent)
+                _codegen_unwrap_subclass(
+                    state,
+                    attr_meta,
+                    inner_var,
+                    indent=indent,
+                    include_symints=include_symints,
+                    act_input_paths=attr_act_input_paths,
+                    act_wait_fn=act_wait_fn,
+                )
+
+    if include_symints:
+        size_placeholders = _compute_placeholders(meta.outer_size)
+        stride_placeholders = _compute_placeholders(meta.outer_stride)
+        if any(size_placeholders) or any(stride_placeholders):
+            size_var = state.fresh_name("_size")
+            state.emit(f"{size_var} = {var}.size()", indent=indent)
+            for i, is_sym in enumerate(size_placeholders):
+                if is_sym:
+                    state.emit(f"unwrapped_args.append({size_var}[{i}])", indent=indent)
+
+            stride_var = state.fresh_name("_stride")
+            state.emit(f"{stride_var} = {var}.stride()", indent=indent)
+            for i, is_sym in enumerate(stride_placeholders):
+                if is_sym:
+                    state.emit(
+                        f"unwrapped_args.append({stride_var}[{i}])", indent=indent
+                    )
+
+
+def _concrete_value(val: None | int | SymInt) -> int:
+    """Get the concrete int value for a non-symbolic size/stride entry.
+
+    Used for entries that are NOT symbolic placeholders, meaning they are
+    concrete ints or nested ints (represented as -1 after make_runtime_safe).
+    """
+    if isinstance(val, int):
+        return val
+    # Before make_runtime_safe: nested ints are SymInts; use -1 as dummy.
+    # After make_runtime_safe: they're already -1.
+    if isinstance(val, SymInt) and val.node.is_nested_int():
+        return -1
+    raise AssertionError(f"Expected concrete int, got {type(val)}: {val}")
+
+
+def _is_optional_symint_output(val: object) -> bool:
+    return isinstance(val, (int, SymInt))
+
+
+def _codegen_wrap_subclass(
+    state: PySourceBuilder,
+    meta: SubclassCreationMeta,
+    output_state: _OutputWrapState,
+) -> str:
+    """Emit code to reconstruct one subclass output. Returns the variable name."""
+    inner_dict_var = state.fresh_name("_out_inner")
+    entries: list[str] = []
+    attr_exprs: dict[str, str] = {}
+
+    for attr, attr_meta in meta.attrs.items():
+        match attr_meta:
+            case PlainTensorMeta():
+                attr_expr = state.fresh_name("_out_attr")
+                state.emit(f"{attr_expr} = unwrapped_outs[_out_idx]")
+                state.emit("_out_idx += 1")
+                output_state.mark_required()
+                _emit_optional_plain_tensor_symint_skips(state, output_state, attr_meta)
+            case OpaqueMeta():
+                attr_expr = state.fresh_name("_out_attr")
+                state.emit(f"{attr_expr} = unwrapped_outs[_out_idx]")
+                state.emit("_out_idx += 1")
+                output_state.mark_required()
+            case SubclassCreationMeta():
+                attr_expr = _codegen_wrap_subclass(state, attr_meta, output_state)
+        attr_exprs[attr] = attr_expr
+        entries.append(f"{attr!r}: {attr_expr}")
+
+    state.emit(f"{inner_dict_var} = {{{', '.join(entries)}}}")
+
+    # Reconstruct outer_size and outer_stride
+    size_placeholders = _compute_placeholders(meta.outer_size)
+    stride_placeholders = _compute_placeholders(meta.outer_stride)
+
+    def _build_tuple(
+        outer: Iterable[None | int | SymInt], placeholders: list[bool]
+    ) -> str:
+        parts: list[str] = []
+        for val, is_sym in zip(outer, placeholders):
+            if is_sym:
+                sym_expr = state.fresh_name("_out_sym")
+                state.emit(f"{sym_expr} = unwrapped_outs[_out_idx]")
+                state.emit("_out_idx += 1")
+                output_state.mark_required()
+                parts.append(sym_expr)
+            else:
+                parts.append(repr(_concrete_value(val)))
+        if len(parts) == 1:
+            return f"({parts[0]},)"
+        return f"({', '.join(parts)})"
+
+    def _consume_optional_placeholders(placeholders: list[bool]) -> None:
+        for is_sym in placeholders:
+            if is_sym:
+                _emit_optional_symint_skip(state, output_state)
+
+    outer_size_from_attr = meta.outer_size_from_attr
+    outer_stride_from_attr = meta.outer_stride_from_attr
+    if outer_size_from_attr is not None:
+        size_expr = f"{attr_exprs[outer_size_from_attr]}.size()"
+        _consume_optional_placeholders(size_placeholders)
+    else:
+        size_expr = _build_tuple(meta.outer_size, size_placeholders)
+
+    if outer_stride_from_attr is not None:
+        stride_expr = f"{attr_exprs[outer_stride_from_attr]}.stride()"
+        _consume_optional_placeholders(stride_placeholders)
+    else:
+        stride_expr = _build_tuple(meta.outer_stride, stride_placeholders)
+
+    type_name = state.add_global(
+        state.fresh_name("_subclass_type"),
+        meta.original_subclass_type or type(meta.original_subclass),
+    )
+    meta_name = state.add_global(state.fresh_name("_meta"), meta.meta)
+
+    result_var = state.fresh_name("_out")
+    state.emit(
+        f"{result_var} = {type_name}.__tensor_unflatten__("
+        f"{inner_dict_var}, {meta_name}, {size_expr}, {stride_expr})"
+    )
+    return result_var
+
+
+def _count_output_args(
+    meta: PlainTensorMeta | SubclassCreationMeta,
+    *,
+    include_subclass_symints: bool,
+) -> int:
+    if isinstance(meta, PlainTensorMeta):
+        return meta.arg_count if include_subclass_symints else 1
+
+    total = 0
+    for attr_meta in meta.attrs.values():
+        if isinstance(attr_meta, OpaqueMeta):
+            total += 1
+        else:
+            total += _count_output_args(
+                attr_meta, include_subclass_symints=include_subclass_symints
+            )
+
+    if include_subclass_symints:
+        total += sum(_compute_placeholders(meta.outer_size))
+        total += sum(_compute_placeholders(meta.outer_stride))
+    else:
+        if meta.outer_size_from_attr is None:
+            total += sum(_compute_placeholders(meta.outer_size))
+        if meta.outer_stride_from_attr is None:
+            total += sum(_compute_placeholders(meta.outer_stride))
+    return total
+
+
+def _emit_optional_symint_skip(
+    state: PySourceBuilder,
+    output_state: _OutputWrapState,
+) -> None:
+    remaining_var = state.fresh_name("_remaining_outs")
+    include_var = state.fresh_name("_include_symints")
+    later_min_count = output_state.remaining_min_count
+    later_max_count = output_state.remaining_max_count - 1
+    max_fits = (
+        f"{remaining_var} - 1 >= {later_min_count} and "
+        f"{remaining_var} - 1 <= {later_max_count}"
+    )
+    min_fits = (
+        f"{remaining_var} >= {later_min_count} and {remaining_var} <= {later_max_count}"
+    )
+
+    state.emit(f"{remaining_var} = _num_wrapped_outs - _out_idx")
+    state.emit(
+        f"{include_var} = ({max_fits}) and "
+        f"{output_state.optional_symint_check}(unwrapped_outs[_out_idx])"
+    )
+    state.emit(
+        f"assert {include_var} or ({min_fits}), "
+        "'could not match output layout with optional SymInt outputs'"
+    )
+    state.emit(f"if {include_var}:")
+    state.emit("_out_idx += 1", indent=2)
+    output_state.mark_optional()
+
+
+def _emit_optional_plain_tensor_symint_skips(
+    state: PySourceBuilder,
+    output_state: _OutputWrapState,
+    meta: PlainTensorMeta,
+) -> None:
+    for is_sym in meta.size_symbol_placeholders:
+        if is_sym:
+            _emit_optional_symint_skip(state, output_state)
+    for is_sym in meta.stride_symbol_placeholders:
+        if is_sym:
+            _emit_optional_symint_skip(state, output_state)
+
+
+def _emit_output_wrapping(
+    state: PySourceBuilder,
+    out_metas: list[PlainTensorMeta | SubclassCreationMeta],
+    num_fw_outs_saved_for_bw: int | None,
+) -> tuple[list[str], int]:
+    """Emit wrapping code for output metas.
+
+    Returns (result_exprs, num_args_tallied) where result_exprs are Python
+    expression strings referencing each wrapped output.
+    """
+    result_exprs: list[str] = []
+    num_args_tallied = 0
+    saved_for_bw = num_fw_outs_saved_for_bw or 0
+    min_counts = [
+        _count_output_args(meta, include_subclass_symints=False) for meta in out_metas
+    ]
+    max_counts = [
+        _count_output_args(meta, include_subclass_symints=True) for meta in out_metas
+    ]
+    min_wrapped_outputs = sum(min_counts)
+    max_wrapped_outputs = sum(max_counts)
+
+    optional_symint_check = (
+        state.add_global(
+            state.fresh_name("_is_optional_symint_output"),
+            _is_optional_symint_output,
+        )
+        if min_wrapped_outputs != max_wrapped_outputs
+        else ""
+    )
+    state.emit("_out_idx = 0")
+    if saved_for_bw:
+        state.emit(f"_num_wrapped_outs = len(unwrapped_outs) - {saved_for_bw}")
+    else:
+        state.emit("_num_wrapped_outs = len(unwrapped_outs)")
+    if min_wrapped_outputs != max_wrapped_outputs:
+        state.emit(
+            "assert "
+            f"{min_wrapped_outputs} <= _num_wrapped_outs <= {max_wrapped_outputs}, "
+            f"f'expected between {min_wrapped_outputs} and {max_wrapped_outputs} "
+            "wrapped outputs, got {_num_wrapped_outs}'"
+        )
+    else:
+        state.emit(
+            f"assert _num_wrapped_outs == {max_wrapped_outputs}, "
+            f"f'expected {max_wrapped_outputs} wrapped outputs, "
+            "got {_num_wrapped_outs}'"
+        )
+
+    output_state = _OutputWrapState(
+        remaining_min_count=min_wrapped_outputs,
+        remaining_max_count=max_wrapped_outputs,
+        optional_symint_check=optional_symint_check,
+    )
+    for meta in out_metas:
+        if isinstance(meta, PlainTensorMeta):
+            out_expr = state.fresh_name("_out_plain")
+            state.emit(f"{out_expr} = unwrapped_outs[_out_idx]")
+            state.emit("_out_idx += 1")
+            output_state.mark_required()
+            _emit_optional_plain_tensor_symint_skips(state, output_state, meta)
+            result_exprs.append(out_expr)
+            num_args_tallied += meta.arg_count
+        else:
+            result_var = _codegen_wrap_subclass(state, meta, output_state)
+            result_exprs.append(result_var)
+            num_args_tallied += meta.arg_count
+
+    if output_state.remaining_min_count != 0 or output_state.remaining_max_count != 0:
+        raise AssertionError(
+            "output wrapping counts did not balance: "
+            f"{output_state.remaining_min_count}, "
+            f"{output_state.remaining_max_count}"
+        )
+    state.emit(
+        "assert _out_idx == _num_wrapped_outs, "
+        "f'wrapped {_out_idx} outputs, expected {_num_wrapped_outs}'"
+    )
+    return result_exprs, num_args_tallied
+
+
+def _emit_input_unwrapping(
+    state: PySourceBuilder,
+    inp_metas: list[PlainTensorMeta | SubclassCreationMeta],
+    frozen_inp_indices: frozenset[int] = frozenset(),
+    include_symints: bool = True,
+    act_input_paths_by_input: dict[int, set[tuple[str, ...]]] | None = None,
+    act_wait_fn: str | None = None,
+) -> None:
+    """Emit unwrapping code for input metas into unwrapped_args.
+
+    Caller must have already emitted ``unwrapped_args = []``.
+    """
+    act_input_paths_by_input = act_input_paths_by_input or {}
+    for i, meta in enumerate(inp_metas):
+        input_act_paths = act_input_paths_by_input.get(i, set())
+        if isinstance(meta, PlainTensorMeta):
+            if input_act_paths:
+                if input_act_paths != {()}:
+                    raise AssertionError(
+                        f"ACT path for input {i} continues past a plain meta"
+                    )
+                if act_wait_fn is None:
+                    raise AssertionError("missing ACT wait function")
+                state.emit(f"unwrapped_args.append({act_wait_fn}(args[{i}]))")
+            else:
+                state.emit(f"unwrapped_args.append(args[{i}])")
+        elif i in frozen_inp_indices:
+            # Frozen by inductor freezing: constant already baked into graph.
+            state.emit("unwrapped_args.append(None)")
+        else:
+            if () in input_act_paths:
+                raise AssertionError(f"ACT path for input {i} stops at subclass meta")
+            inp_var = state.fresh_name("_inp")
+            type_name = state.add_global(
+                state.fresh_name("_expected_type"),
+                meta.original_subclass_type or type(meta.original_subclass),
+            )
+            state.emit(f"{inp_var} = args[{i}]")
+            state.emit(
+                f"assert type({inp_var}) is {type_name}, "
+                f"f'expected {{{type_name}}}, got {{type({inp_var})}}'",
+            )
+            _codegen_unwrap_subclass(
+                state,
+                meta,
+                inp_var,
+                indent=1,
+                include_symints=include_symints,
+                act_input_paths=input_act_paths,
+                act_wait_fn=act_wait_fn,
+            )
+
+
+def _codegen_subclass_wrapper_source(
+    inp_metas: list[PlainTensorMeta | SubclassCreationMeta],
+    out_metas: list[PlainTensorMeta | SubclassCreationMeta],
+    num_fw_outs_saved_for_bw: int | None,
+    frozen_inp_indices: frozenset[int] = frozenset(),
+    act_input_paths: ActInputPaths | None = None,
+) -> tuple[str, dict[str, object]]:
+    """Generate source and globals for a subclass wrapper.
+
+    Returns (source, globals_dict).  The globals_dict will NOT contain
+    ``compiled_fn`` — the caller is responsible for adding it before exec.
+    """
+    state = PySourceBuilder()
+
+    state.emit("def inner_fn(args):", indent=0)
+
+    act_input_paths_by_input: dict[int, set[tuple[str, ...]]] = {}
+    act_wait_fn = None
+    if act_input_paths:
+        AsyncCollectiveTensor = import_async_collective_tensor_type()
+        act_wait_fn = state.add_global(
+            state.fresh_name("_maybe_wait_act"),
+            functools.partial(
+                _maybe_wait_async_collective_tensor,
+                AsyncCollectiveTensor=AsyncCollectiveTensor,
+            ),
+        )
+        for i, attr_path in act_input_paths:
+            act_input_paths_by_input.setdefault(i, set()).add(attr_path)
+
+    # --- Input unwrapping ---
+    state.emit("unwrapped_args = []")
+    _emit_input_unwrapping(
+        state,
+        inp_metas,
+        frozen_inp_indices=frozen_inp_indices,
+        act_input_paths_by_input=act_input_paths_by_input,
+        act_wait_fn=act_wait_fn,
+    )
+
+    # Pass through any trailing args not covered by inp_metas
+    # (e.g. rng seed/offset added by FunctionalizedRngRuntimeWrapper).
+    num_inp_metas = len(inp_metas)
+    state.emit(f"unwrapped_args.extend(args[{num_inp_metas}:])")
+    state.emit("args.clear()")
+
+    # --- Call compiled function ---
+    state.emit("unwrapped_outs = compiled_fn(unwrapped_args)")
+
+    # --- Output wrapping ---
+    result_exprs, _ = _emit_output_wrapping(state, out_metas, num_fw_outs_saved_for_bw)
+    result_tuple = f"({', '.join(result_exprs)},)" if result_exprs else "()"
+    if num_fw_outs_saved_for_bw is not None:
+        state.emit(
+            f"_activation_start = len(unwrapped_outs) - {num_fw_outs_saved_for_bw}"
+        )
+        state.emit(f"return {result_tuple} + tuple(unwrapped_outs[_activation_start:])")
+    else:
+        state.emit(f"return {result_tuple}")
+
+    source = state.getvalue()
+    return source, state.globals
+
+
+def _codegen_subclass_wrap_source(
+    out_metas: list[PlainTensorMeta | SubclassCreationMeta],
+) -> tuple[str, dict[str, object]]:
+    """Generate source for wrapping flat outputs into subclasses.
+
+    Used for the backward epilogue. Shares output-wrapping logic with
+    _codegen_subclass_wrapper_source via _emit_output_wrapping.
+    """
+    state = PySourceBuilder()
+    state.emit("def wrap_fn(unwrapped_outs):", indent=0)
+    result_exprs, _ = _emit_output_wrapping(
+        state, out_metas, num_fw_outs_saved_for_bw=None
+    )
+    result_tuple = f"({', '.join(result_exprs)},)" if result_exprs else "()"
+    state.emit(f"return {result_tuple}")
+    source = state.getvalue()
+    return source, state.globals
+
+
+def codegen_backward_subclass_fns(
+    grad_input_metas: list[PlainTensorMeta | SubclassCreationMeta] | None = None,
+) -> tuple[Callable[..., object], Callable[..., object] | None]:
+    """Generate codegen'd unwrap and wrap functions for the backward pass.
+
+    Returns (unwrap_fn, wrap_fn). unwrap_fn is used by the backward prologue
+    to unwrap non-tangent subclass inputs (always an identity in AOT dispatch
+    since the compiled forward operates on unwrapped inner tensors). wrap_fn
+    is used by the backward epilogue to wrap flat grad inputs back into
+    subclasses; it is None when grad_input_metas is None.
+    """
+    source = "def unwrap_fn(args):\n    return list(args)"
+    globals_dict: dict[str, object] = {}
+    unwrap_fn = _compile_and_exec_source(
+        source, globals_dict, "unwrap_fn", "backward_subclass_unwrap"
+    )
+
+    wrap_fn = None
+    if grad_input_metas is not None:
+        wrap_source, wrap_globals = _codegen_subclass_wrap_source(grad_input_metas)
+        wrap_fn = _compile_and_exec_source(
+            wrap_source, wrap_globals, "wrap_fn", "backward_subclass_wrapper"
+        )
+
+    return unwrap_fn, wrap_fn
+
+
+def codegen_subclass_wrapper(
+    compiled_fn: Callable[..., object],
+    inp_metas: list[PlainTensorMeta | SubclassCreationMeta],
+    out_metas: list[PlainTensorMeta | SubclassCreationMeta],
+    num_fw_outs_saved_for_bw: int | None,
+    frozen_inp_indices: frozenset[int] = frozenset(),
+    act_input_paths: ActInputPaths | None = None,
+) -> Callable[..., object]:
+    """Generate a specialized wrapper function for subclass unwrap/wrap."""
+    source, globals_dict = _codegen_subclass_wrapper_source(
+        inp_metas,
+        out_metas,
+        num_fw_outs_saved_for_bw,
+        frozen_inp_indices,
+        act_input_paths=act_input_paths,
+    )
+    globals_dict["compiled_fn"] = compiled_fn
+    return _compile_and_exec_source(
+        source, globals_dict, "inner_fn", "subclass_wrapper", wrapped_fn=compiled_fn
+    )

.venv/lib/python3.12/site-packages/torch/_functorch/_aot_autograd/subclass_parametrization.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import dataclasses
+import itertools
+from typing import Any, TYPE_CHECKING
+
+import torch
+from torch._custom_class_base import CustomClassBase
+from torch._library.opaque_object import is_opaque_symbolic_type
+from torch.utils._python_dispatch import is_traceable_wrapper_subclass
+
+from .schemas import OpaqueMeta
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+
+# This is technically very similar to SubclassCreatingMeta
+# in aot_autograd, but we don't need all the stuff in there
+# so just recreated a new dataclass.
+@dataclasses.dataclass
+class SubclassCreationMeta:
+    start_idx: int
+    num_tensors: int
+    class_type: Any
+    # None means the attr is a plain tensor (base case of recursion)
+    attrs: dict[str, SubclassCreationMeta | OpaqueMeta | None]
+    metadata: Any
+    outer_size: Iterable[None | int | torch.SymInt]
+    outer_stride: Iterable[None | int | torch.SymInt]
+
+
+class UnwrapTensorSubclass(torch.nn.Module):
+    def forward(self, *tensors) -> torch.Tensor:  # type: ignore[no-untyped-def]
+        todo: list[torch.Tensor | CustomClassBase] = list(tensors)
+
+        def _unwrap_tensor_subclasses(subclass_meta, tensors, offset):  # type: ignore[no-untyped-def]
+            if subclass_meta is None:
+                return tensors[offset], offset + 1
+            inner_tensors = {}
+            for attr, meta in subclass_meta.attrs.items():
+                if isinstance(meta, OpaqueMeta):
+                    inner_tensors[attr] = tensors[offset]
+                    offset += 1
+                else:
+                    built_tensor, offset = _unwrap_tensor_subclasses(
+                        meta, tensors, offset
+                    )
+                    inner_tensors[attr] = built_tensor
+            rebuilt = subclass_meta.class_type.__tensor_unflatten__(
+                inner_tensors,
+                subclass_meta.metadata,
+                subclass_meta.outer_size,
+                subclass_meta.outer_stride,
+            )
+            return rebuilt, offset
+
+        return _unwrap_tensor_subclasses(self.subclass_meta, todo, 0)[0]
+
+    def right_inverse(
+        self, tensor: torch.Tensor
+    ) -> list[torch.Tensor | CustomClassBase]:
+        if type(tensor) is torch.Tensor:
+            raise AssertionError("tensor must be a subclass, not torch.Tensor")
+        plain_tensors: list[torch.Tensor | CustomClassBase] = []
+
+        def _create_subclass_meta(tensor, idx, plain_tensor_container):  # type: ignore[no-untyped-def]
+            if type(tensor) is torch.Tensor:
+                plain_tensor_container.append(tensor)
+                return None, idx + 1
+            inner_tensors_attrnames, metadata = tensor.__tensor_flatten__()  # type: ignore[attr-defined]
+            new_idx = idx
+            attr_to_meta: dict[str, SubclassCreationMeta | OpaqueMeta | None] = {}
+            for attr in inner_tensors_attrnames:
+                val = getattr(tensor, attr)
+                match val:
+                    case CustomClassBase():
+                        if not is_opaque_symbolic_type(type(val)):
+                            raise ValueError(
+                                f"{type(val).__name__!r} found in tensor attrs of "
+                                f"{type(tensor).__name__}.__tensor_flatten__(). "
+                                "Only tensors and reference-type opaques are allowed "
+                                "in tensor attrs."
+                            )
+                        attr_to_meta[attr] = OpaqueMeta()
+                        plain_tensor_container.append(val)
+                        new_idx += 1
+                    case torch.Tensor():
+                        subclass_meta, new_idx = _create_subclass_meta(
+                            val, new_idx, plain_tensor_container
+                        )
+                        attr_to_meta[attr] = subclass_meta
+                    case _:
+                        raise AssertionError(
+                            f"expected Tensor or CustomClassBase, got {type(val)}"
+                        )
+            return (
+                SubclassCreationMeta(
+                    start_idx=idx,
+                    num_tensors=new_idx - idx,
+                    class_type=type(tensor),
+                    attrs=attr_to_meta,
+                    metadata=metadata,
+                    outer_size=tensor.size(),
+                    outer_stride=tensor.stride(),
+                ),
+                new_idx,
+            )
+
+        self.subclass_meta = _create_subclass_meta(tensor, 0, plain_tensors)[0]
+        return plain_tensors
+
+
+def unwrap_tensor_subclass_parameters(module: torch.nn.Module) -> torch.nn.Module:
+    """
+    Model transformation that replaces all the parameters that are subclasses to plain tensors.
+    This reduces runtime overhead of flattening/unflattening the parameters.
+
+    This transformation adds parametrization with `torch.nn.utils.parametrize`.
+    The FQNs of the subclass parameters will be changed and state_dict will become incompatible with the original model.
+    E.g.
+    Original model state_dict: {"p1": torch.testing._internal.TwoTensor}
+    becomes: {"parametrizations.p2.original0": torch.Tensor, "parametrizations.p2.original1": torch.Tensor}
+
+    """
+    for name, tensor in itertools.chain(
+        list(module.named_parameters(recurse=False)),
+        # pyrefly: ignore [bad-argument-type, no-matching-overload]
+        list(module.named_buffers(recurse=False)),
+    ):
+        if is_traceable_wrapper_subclass(tensor):
+            torch.nn.utils.parametrize.register_parametrization(
+                module, name, UnwrapTensorSubclass()
+            )
+
+    for child in module.children():
+        unwrap_tensor_subclass_parameters(child)
+
+    return module

.venv/lib/python3.12/site-packages/torch/_functorch/_aot_autograd/subclass_utils.py

@@ -0,0 +1,784 @@
+"""
+This file contains utilities for tracing through __torch_dispatch__ based tensor subclasses and modes.
+AOTAutograd's responsibility is to trace through all pytorch capabilities that live in the pytorch dispatcher,
+and this includes tensor subclasses that implement __torch_dispatch__.
+"""
+
+import collections
+from collections.abc import Callable, Iterable, Sequence
+from typing import Any, TypeGuard, TypeVar
+
+import torch
+import torch.utils._pytree as pytree
+from torch import SymInt, Tensor
+from torch._custom_class_base import CustomClassBase
+from torch._library.fake_class_registry import maybe_unwrap_fake_script_object
+from torch._library.opaque_object import is_opaque_symbolic_type
+from torch._subclasses.fake_tensor import get_plain_tensors
+from torch.fx.experimental.symbolic_shapes import guard_or_false, sym_eq
+from torch.types import IntLikeType
+from torch.utils._python_dispatch import (
+    is_traceable_wrapper_subclass,
+    TraceableWrapperSubclass,
+)
+
+from .descriptors import (
+    AOTInput,
+    AOTOutput,
+    DummyAOTInput,
+    SubclassGetAttrAOTInput,
+    SubclassGetAttrAOTOutput,
+    SubclassSizeAOTInput,
+    SubclassSizeAOTOutput,
+    SubclassStrideAOTInput,
+    SubclassStrideAOTOutput,
+)
+from .schemas import (
+    FakifiedFlatArgs,
+    FxValue,
+    MutationType,
+    OpaqueMeta,
+    PlainTensorMeta,
+    SubclassCreationMeta,
+    ViewAndMutationMeta,
+)
+from .utils import strict_zip
+
+
+zip = strict_zip
+
+T = TypeVar("T", bound=torch.Tensor)
+
+
+def requires_subclass_dispatch(
+    args: FakifiedFlatArgs, fw_metadata: ViewAndMutationMeta
+) -> bool:
+    args_flattened = pytree.arg_tree_leaves(*args)
+    any_subclass_args = any(
+        is_traceable_wrapper_subclass(x)
+        for x in args_flattened
+        if isinstance(x, Tensor)
+    )
+    from torch._functorch._aot_autograd.schemas import SubclassCreationMeta
+
+    any_subclass_outputs = any(
+        type(x) is SubclassCreationMeta for x in fw_metadata.subclass_fw_graph_out_meta
+    )
+    # This tells us whether or not we need to perform any unwrapping/wrapping of tensor subclasses at runtime.
+    return bool(any_subclass_args or any_subclass_outputs)
+
+
+from .schemas import MemoryFormatMeta
+
+
+def maybe_suggest_memory_format(
+    t: Tensor, with_memory_format: bool
+) -> MemoryFormatMeta | None:
+    if not with_memory_format:
+        return None
+
+    return MemoryFormatMeta.from_tensor(t)
+
+
+def _safe_metadata_eq(
+    outer: Iterable[IntLikeType],
+    inner: Iterable[IntLikeType],
+) -> bool:
+    return guard_or_false(sym_eq(tuple(outer), tuple(inner)))
+
+
+def _find_attr_matching_outer_metadata(
+    a: Tensor,
+    inner_keys: Sequence[str],
+    *,
+    metadata_fn: Callable[[Tensor], Iterable[IntLikeType]],
+) -> str | None:
+    tensor_attrs = [key for key in inner_keys if isinstance(getattr(a, key), Tensor)]
+    if not tensor_attrs:
+        return None
+
+    outer_metadata = tuple(metadata_fn(a))
+    # Only use an attr as the runtime source when every tensor attr agrees
+    # with the wrapper metadata; otherwise there is no single attr to trust.
+    if all(
+        _safe_metadata_eq(outer_metadata, metadata_fn(getattr(a, key)))
+        for key in tensor_attrs
+    ):
+        return tensor_attrs[0]
+    return None
+
+
+def _symint_placeholders(lst: Iterable[IntLikeType]) -> tuple[bool, ...]:
+    return tuple(isinstance(s, SymInt) and not s.node.is_nested_int() for s in lst)
+
+
+def get_subclass_typing_container(
+    tensor_subclass: torch.Tensor,
+) -> dict[type[torch.Tensor], list[type[torch.Tensor]]]:
+    """
+    Given a subclass, returns a recursive dictionary mapping each
+    inner tensors to its subclass types.
+    """
+
+    def _get_types_for_subclass(tensor_subclass: torch.Tensor) -> None:
+        if not is_traceable_wrapper_subclass(tensor_subclass):
+            return
+        tracker[type(tensor_subclass)].append(tensor_subclass)
+        inner_keys, _ = tensor_subclass.__tensor_flatten__()
+        for key in inner_keys:
+            match getattr(tensor_subclass, key):
+                case torch.Tensor() as inner_value:
+                    _get_types_for_subclass(inner_value)
+                case CustomClassBase():
+                    pass
+                case unexpected:
+                    raise AssertionError(
+                        f"expected Tensor or CustomClassBase, got {type(unexpected)}"
+                    )
+
+    tracker: dict[Any, list[Any]] = collections.defaultdict(list)
+    _get_types_for_subclass(tensor_subclass)
+    return tracker
+
+
+def create_subclass_metadata(
+    a: Any,
+    start_idx: int,
+    count_symints: bool,
+    with_memory_format: bool = False,
+) -> tuple[Any, int]:
+    if not is_traceable_wrapper_subclass(a):
+        size_symbol_placeholders = (
+            _symint_placeholders(a.size()) if count_symints else ()
+        )
+        stride_symbol_placeholders = (
+            _symint_placeholders(a.stride()) if count_symints else ()
+        )
+        meta = PlainTensorMeta(
+            start_idx + 1,
+            memory_format=maybe_suggest_memory_format(a, with_memory_format),
+            size_symbol_placeholders=size_symbol_placeholders,
+            stride_symbol_placeholders=stride_symbol_placeholders,
+        )
+        return (
+            meta,
+            start_idx + meta.arg_count,
+        )
+
+    inner_keys, metadata = a.__tensor_flatten__()
+    new_start_idx = start_idx
+    attrs: dict[str, SubclassCreationMeta | PlainTensorMeta | OpaqueMeta] = {}
+
+    for key in inner_keys:
+        inner_value = getattr(a, key)
+        match inner_value:
+            case CustomClassBase():
+                # During tracing, opaques are wrapped in FakeScriptObject;
+                # unwrap to check the real type.
+                real_type = type(maybe_unwrap_fake_script_object(inner_value))
+                if not is_opaque_symbolic_type(real_type):
+                    raise RuntimeError(
+                        f"{real_type.__name__!r} found in tensor attrs of "
+                        f"{type(a).__name__}.__tensor_flatten__(). "
+                        "Only tensors and reference-type opaques are allowed "
+                        "in tensor attrs."
+                    )
+                attrs[key] = OpaqueMeta()
+                new_start_idx += 1
+            case Tensor():
+                new_subclass_meta, new_start_idx = create_subclass_metadata(
+                    inner_value,
+                    new_start_idx,
+                    count_symints=count_symints,
+                    with_memory_format=with_memory_format,
+                )
+                attrs[key] = new_subclass_meta
+            case _:
+                raise AssertionError(
+                    f"expected Tensor or CustomClassBase, got {type(inner_value)}"
+                )
+
+    # It *must* be because is_traceable_wrapper_subclass() - but mypy is not smart.
+    if not isinstance(a, Tensor):
+        raise AssertionError(f"expected Tensor, got {type(a)}")
+
+    new_start_idx = (
+        new_start_idx
+        + count_symints * len(enumerate_filter_symints(a.size()))
+        + count_symints * len(enumerate_filter_symints(a.stride()))
+    )
+
+    return (
+        SubclassCreationMeta(
+            flat_tensor_start_idx=start_idx,
+            arg_count=new_start_idx - start_idx,
+            included_subclass_symints=count_symints,
+            attrs=attrs,
+            meta=metadata,
+            outer_size=a.size(),  # type: ignore[attr-defined, arg-type]
+            outer_stride=a.stride(),  # type: ignore[arg-type]
+            original_subclass=a,
+            memory_format=maybe_suggest_memory_format(a, with_memory_format),
+            outer_size_from_attr=_find_attr_matching_outer_metadata(
+                a, inner_keys, metadata_fn=lambda t: t.size()
+            ),
+            outer_stride_from_attr=_find_attr_matching_outer_metadata(
+                a, inner_keys, metadata_fn=lambda t: t.stride()
+            ),
+        ),
+        new_start_idx,
+    )
+
+
+# Given a flat list of arguments, some of which may be tensor subclasses,
+# computes metadata about "how to reconstruct the current list of subclasses,
+# if we were given their flattened dense tensors instead"
+def create_subclass_meta(
+    curr_args: list[Any] | tuple[Any, ...],
+    *,
+    count_symints: bool = True,
+    with_memory_format: bool = False,
+) -> list[PlainTensorMeta | SubclassCreationMeta]:
+    idx = 0
+    infos: list[PlainTensorMeta | SubclassCreationMeta] = []
+    for a in curr_args:
+        if is_traceable_wrapper_subclass(a):
+            if not isinstance(a, Tensor):
+                raise AssertionError(
+                    f"expected Tensor for traceable wrapper subclass, got {type(a)}"
+                )
+            start_idx = idx
+            subclass_meta, _ = create_subclass_metadata(
+                a,
+                start_idx,
+                count_symints=count_symints,
+                with_memory_format=with_memory_format,
+            )
+            infos.append(subclass_meta)
+            cnt = subclass_meta.arg_count
+        else:
+            infos.append(
+                PlainTensorMeta(
+                    idx,
+                    memory_format=maybe_suggest_memory_format(a, with_memory_format),
+                )
+            )
+            cnt = 1
+        idx += cnt
+    return infos
+
+
+def enumerate_filter_symints(lst: Iterable[IntLikeType]) -> list[tuple[int, SymInt]]:
+    # Capture all SymInts from the iterable.
+    def symint_check(s: IntLikeType) -> TypeGuard[SymInt]:
+        return isinstance(s, SymInt) and not s.node.is_nested_int()
+
+    return [(i, s) for i, s in enumerate(lst) if symint_check(s)]
+
+
+def compute_symint_placeholders(lst: Iterable[None | int | SymInt]) -> list[bool]:
+    # Non-nested symints are replaced with None in `make_runtime_safe()`
+    return [s is None for s in lst]
+
+
+# Intended to make it easier to define function that is
+# either (AOTInput -> AOTInput) or (AOTOutput -> AOTOutput)
+# but not the other combos
+AOTDescriptor = TypeVar("AOTDescriptor", AOTInput, AOTOutput)
+
+
+# This function takes in a pytree of arguments and unwraps any tensor
+# subclasses.
+#
+# NOTE: The reason for "append_symints":
+#
+# * At compile time: we append extra symint args when unwrapping primals
+# (but not tangents, because they should always share symints with primals).
+# We also append extra symints when unwrapping the subclass outputs of the
+# traced function, so we can return them as extra outputs
+#
+# * At runtime: we similarly append subclass sizes when we unwrap subclass
+# primals (but not tangents) on entry to the forward. See the runtime version of
+# this function below.
+def unwrap_tensor_subclasses(
+    wrapped_args: list[FxValue],
+    wrapped_args_descs: Sequence[AOTDescriptor],
+    *,
+    append_symints: bool,
+) -> tuple[list[FxValue], list[AOTDescriptor]]:
+    def _maybe_fakeify_opaque(v: Any) -> Any:
+        # Registered opaque types need to be wrapped as FakeScriptObject for
+        # compile-time FX tracing (proxy slot tracking, hashability, etc.).
+        if isinstance(v, CustomClassBase):
+            from torch._guards import detect_fake_mode
+            from torch._library.fake_class_registry import maybe_to_fake_obj
+            from torch._library.opaque_object import is_custom_class
+
+            fake_mode = detect_fake_mode()
+            if fake_mode is not None and is_custom_class(type(v)):
+                return maybe_to_fake_obj(fake_mode, v)
+        return v
+
+    def flatten_subclass(
+        t: FxValue,
+        desc: AOTDescriptor,
+        *,
+        out: tuple[list[FxValue], list[AOTDescriptor]],
+    ) -> None:
+        # unwrap a subclass into plain tensors and their size/stride if "append_symint"
+        # is True
+        if not is_traceable_wrapper_subclass(t):
+            out[0].append(_maybe_fakeify_opaque(t))
+            out[1].append(desc)
+            if (
+                append_symints
+                and isinstance(t, Tensor)
+                and isinstance(
+                    desc, (SubclassGetAttrAOTInput, SubclassGetAttrAOTOutput)
+                )
+            ):
+                sizes = enumerate_filter_symints(t.size())
+                strides = enumerate_filter_symints(t.stride())
+                out[0].extend(s for _, s in sizes)
+                out[0].extend(s for _, s in strides)
+                if isinstance(desc, AOTInput):
+                    out[1].extend(SubclassSizeAOTInput(desc, i) for i, _ in sizes)
+                    out[1].extend(SubclassStrideAOTInput(desc, i) for i, _ in strides)
+                else:
+                    out[1].extend(SubclassSizeAOTOutput(desc, i) for i, _ in sizes)
+                    out[1].extend(SubclassStrideAOTOutput(desc, i) for i, _ in strides)
+            return
+
+        attrs, _ = t.__tensor_flatten__()
+
+        SubclassGetAttr: Callable[[AOTInput | AOTOutput, str], AOTDescriptor]
+        SubclassSize: Callable[[AOTInput | AOTOutput, int], AOTDescriptor]
+        SubclassStride: Callable[[AOTInput | AOTOutput, int], AOTDescriptor]
+        if isinstance(desc, AOTInput):
+            SubclassGetAttr = SubclassGetAttrAOTInput  # type: ignore[bad-assignment]
+            SubclassSize = SubclassSizeAOTInput  # type: ignore[bad-assignment]
+            SubclassStride = SubclassStrideAOTInput  # type: ignore[bad-assignment]
+        else:
+            SubclassGetAttr = SubclassGetAttrAOTOutput  # type: ignore[bad-assignment]
+            SubclassSize = SubclassSizeAOTOutput  # type: ignore[bad-assignment]
+            SubclassStride = SubclassStrideAOTOutput  # type: ignore[bad-assignment]
+
+        for attr in attrs:
+            inner_value = getattr(t, attr)
+            n_desc: Any = SubclassGetAttr(desc, attr)
+            flatten_subclass(inner_value, n_desc, out=out)
+
+        if append_symints:
+            sizes = enumerate_filter_symints(t.size())
+            strides = enumerate_filter_symints(t.stride())
+            out[0].extend(s for _, s in sizes)
+            out[0].extend(s for _, s in strides)
+            out[1].extend(SubclassSize(desc, i) for i, _ in sizes)
+            out[1].extend(SubclassStride(desc, i) for i, _ in strides)
+
+    xs_inner: list[FxValue] = []
+    descs_inner: list[AOTDescriptor] = []
+
+    for x, desc in zip(wrapped_args, wrapped_args_descs):
+        flatten_subclass(x, desc, out=(xs_inner, descs_inner))
+
+    return xs_inner, descs_inner
+
+
+# subclass_metas is needed at runtime to compute which indices are symints in
+# the outer_size/outer_stride
+def runtime_unwrap_tensor_subclasses(
+    wrapped_args: list[Tensor | int],
+    *,
+    append_symints: bool,
+    subclass_metas: list[PlainTensorMeta | SubclassCreationMeta] | None = None,
+) -> list[int | Tensor | SymInt | CustomClassBase]:
+    def flatten_subclass(
+        x: Tensor | TraceableWrapperSubclass,
+        subclass_meta: PlainTensorMeta | SubclassCreationMeta | OpaqueMeta | None,
+        *,
+        out: list[CustomClassBase | SymInt | Tensor | int],
+    ) -> list[CustomClassBase | SymInt | Tensor | int]:
+        def append_plain_tensor_symints(tensor: Tensor, meta: PlainTensorMeta) -> None:
+            size = tensor.size()
+            if len(size) != len(meta.size_symbol_placeholders):
+                raise AssertionError(
+                    f"size length mismatch: {len(size)} != {len(meta.size_symbol_placeholders)}"
+                )
+            out.extend(
+                [
+                    r
+                    for (r, is_symint) in zip(size, meta.size_symbol_placeholders)
+                    if is_symint
+                ]
+            )
+
+            stride = tensor.stride()
+            if len(stride) != len(meta.stride_symbol_placeholders):
+                raise AssertionError(
+                    f"stride length mismatch: {len(stride)} != {len(meta.stride_symbol_placeholders)}"
+                )
+            out.extend(
+                [
+                    r
+                    for (r, is_symint) in zip(stride, meta.stride_symbol_placeholders)
+                    if is_symint
+                ]
+            )
+
+        if not is_traceable_wrapper_subclass(x):
+            out.append(x)
+            if append_symints and isinstance(subclass_meta, PlainTensorMeta):
+                append_plain_tensor_symints(x, subclass_meta)
+            return out
+
+        if not isinstance(x, Tensor):
+            raise AssertionError(f"expected Tensor, got {type(x)}")
+        if not isinstance(subclass_meta, SubclassCreationMeta):
+            raise AssertionError("subclass_meta should be a SubclassCreationMeta")
+
+        attrs, _ = x.__tensor_flatten__()
+
+        for attr in attrs:
+            inner_value = getattr(x, attr)
+            match inner_value:
+                case CustomClassBase():
+                    out.append(inner_value)
+                case Tensor():
+                    inner_meta = subclass_meta.attrs.get(attr)
+                    flatten_subclass(inner_value, inner_meta, out=out)
+                case _:
+                    raise AssertionError(
+                        f"expected Tensor or CustomClassBase, got {type(inner_value)}"
+                    )
+
+        if append_symints:
+            # outer_size
+            size = x.size()
+            symint_placeholders = compute_symint_placeholders(subclass_meta.outer_size)
+            if len(size) != len(symint_placeholders):
+                raise AssertionError(
+                    f"size length mismatch: {len(size)} != {len(symint_placeholders)}"
+                )
+            out.extend(
+                [r for (r, is_symint) in zip(size, symint_placeholders) if is_symint]
+            )
+
+            # outer_stride
+            stride = x.stride()
+            symint_placeholders = compute_symint_placeholders(
+                subclass_meta.outer_stride
+            )
+            if len(stride) != len(symint_placeholders):
+                raise AssertionError(
+                    f"stride length mismatch: {len(stride)} != {len(symint_placeholders)}"
+                )
+            out.extend(
+                [r for (r, is_symint) in zip(stride, symint_placeholders) if is_symint]
+            )
+        return out
+
+    xs_inner: list[int | Tensor | SymInt | CustomClassBase] = []
+
+    if append_symints:
+        if subclass_metas is None:
+            raise AssertionError(
+                "subclass_metas must not be None when append_symints is True"
+            )
+
+    for idx, x in enumerate(wrapped_args):
+        if not is_traceable_wrapper_subclass(x):
+            xs_inner.append(x)
+            continue
+
+        if subclass_metas is None:
+            get_plain_tensors(x, out=xs_inner)
+        else:
+            subclass_meta = subclass_metas[idx]
+            if not isinstance(subclass_meta, SubclassCreationMeta):
+                raise AssertionError(
+                    f"expected SubclassCreationMeta, got {type(subclass_meta)}"
+                )
+            flatten_subclass(x, subclass_meta, out=xs_inner)
+
+    return xs_inner
+
+
+def unwrap_tensor_subclasses_with_indices_to_original(
+    wrapped_args: list[Any],
+) -> tuple[list[Any], list[int]]:
+    ret_unwrapped = []
+    ret_indices_to_original = []
+    for i, a in enumerate(wrapped_args):
+        a_unwrapped, _ = unwrap_tensor_subclasses(
+            [a], [DummyAOTInput(9999)], append_symints=False
+        )
+        ret_unwrapped.extend(a_unwrapped)
+        n = len(a_unwrapped)
+        ret_indices_to_original.extend([i] * n)
+
+    return ret_unwrapped, ret_indices_to_original
+
+
+def remap_unwrapped_subclass_arg_indices(
+    wrapped_args: list[Any], static_input_indices: list[int]
+) -> list[int]:
+    def static_arg_slots(arg: Any, *, include_plain_tensor_symints: bool) -> list[bool]:
+        # Forwarded SymInts occupy flattened arg positions, but static input indices
+        # describe tensor/opaque slots whose value should not be copied.
+        if not is_traceable_wrapper_subclass(arg):
+            if include_plain_tensor_symints and isinstance(arg, Tensor):
+                num_symints = len(enumerate_filter_symints(arg.size())) + len(
+                    enumerate_filter_symints(arg.stride())
+                )
+                return [True] + [False] * num_symints
+            return [True]
+
+        slots = []
+        attrs, _ = arg.__tensor_flatten__()
+        for attr in attrs:
+            inner_value = getattr(arg, attr)
+            match inner_value:
+                case CustomClassBase():
+                    slots.append(True)
+                case Tensor():
+                    slots.extend(
+                        static_arg_slots(inner_value, include_plain_tensor_symints=True)
+                    )
+                case _:
+                    raise AssertionError(
+                        f"expected Tensor or CustomClassBase, got {type(inner_value)}"
+                    )
+
+        slots.extend(
+            [False]
+            * (
+                len(enumerate_filter_symints(arg.size()))
+                + len(enumerate_filter_symints(arg.stride()))
+            )
+        )
+        return slots
+
+    static_input_indices_set = set(static_input_indices)
+    new_ind = 0
+    remapped_static_indices = []
+    for i, arg in enumerate(wrapped_args):
+        slots = (
+            static_arg_slots(arg, include_plain_tensor_symints=False)
+            if is_traceable_wrapper_subclass(arg)
+            else [True]
+        )
+
+        for is_static_arg_slot in slots:
+            if i in static_input_indices_set and is_static_arg_slot:
+                remapped_static_indices.append(new_ind)
+
+            new_ind += 1
+
+    return remapped_static_indices
+
+
+# Turns a flattened list of tensor arguments into (maybe) subclass tensors.
+# This function is used both at trace time and runtime, so we have an is_runtime flag telling us which context we're in.
+def wrap_tensor_subclasses(
+    unwrapped_args: Sequence[Any],
+    *,
+    subclass_metas: list[PlainTensorMeta | SubclassCreationMeta],
+    num_fw_outs_saved_for_bw: int | None = None,
+    included_subclass_symints: bool = False,
+    is_runtime: bool = False,
+    make_subclass_override: Callable[..., Any] | None = None,
+) -> tuple[Any, ...]:
+    # pyrefly: ignore [implicit-any]
+    wrapped_args = []
+    num_args_tallied = 0
+    for subclass_meta in subclass_metas:
+        if isinstance(subclass_meta, PlainTensorMeta):
+            wrapped_args.append(unwrapped_args[subclass_meta.unwrapped_idx])
+            num_args_tallied += subclass_meta.arg_count
+        else:
+            if not isinstance(subclass_meta, SubclassCreationMeta):
+                raise AssertionError(
+                    f"expected SubclassCreationMeta, got {type(subclass_meta)}"
+                )
+            if subclass_meta.included_subclass_symints != included_subclass_symints:
+                raise AssertionError(
+                    f"included_subclass_symints mismatch: {subclass_meta.included_subclass_symints} != {included_subclass_symints}"
+                )
+
+            if make_subclass_override:
+                wrapped_args.append(
+                    make_subclass_override(subclass_meta, is_runtime, unwrapped_args)
+                )
+            else:
+                wrapped_args.append(
+                    subclass_meta.creation_fn(
+                        unwrapped_args,
+                        is_runtime=is_runtime,
+                    )
+                )
+            num_args_tallied += subclass_meta.arg_count
+
+    # Note: [Partitioner handling for Subclasses, Part 2]
+    # At the beginning of AOTAutograd, we collect metadata on the inputs and outputs of the user fw,
+    # to figure out which inputs/outputs are subclasses, and how to reconstruct the subclasses after flattening them.
+    #
+    # When this function is called at runtime in the forward,
+    # we have been passed a list of (flattened) dense-tensor fw-outs, and need to reconstruct any subclass fw outs.
+    #
+    # One reasonable question that you should ask: when should the dense_tensor -> subclass_tensor wrapping happen?
+    # Answer: we do it **inside of our compiled autograd.Function**.
+    # This seems like morally the right place: autograd happens above subclass desugaring,
+    # so autograd should see actual tensor subclasses at runtime, and not flattened dense tensors.
+    #
+    # This causes a tricky interaction though: when we run the min-cut partitioner to divvy up the joint graph
+    # into a forward and backward graph, we end up with some activations that show up as extra outputs
+    # in the compiled forward graph, that are **not** user outputs.
+    # These activations are not visible to the user, and so there's no need for us to wrap them back into subclasses.
+    #
+    # On top of that, when we first computed subclass metadata (in `run_functionalized_fw_and_collect_metadata`),
+    # we computed subclass metadata on every forward output, but this did **not** include activations
+    # created by the partitioner.
+    # as a result, `unwrapped_args` here will correspond to (*unwrapped_user_fw_outs, *activations),
+    # but `subclass_metas` will only correspond to subclass metadata on `user_fw_outs`.
+    # We then need to make sure that we return (*wrapped_user_fw_outs, *activations).
+    if num_fw_outs_saved_for_bw is not None:
+        if len(unwrapped_args) != num_args_tallied + num_fw_outs_saved_for_bw:
+            raise AssertionError(
+                f"Expected the number actual unwrapped-subclass outputs {len(unwrapped_args)} to equal "
+                f"the number of args calculated from subclasses ({num_args_tallied}) plus the number of "
+                f"additional activations saved for the backward pass ({num_fw_outs_saved_for_bw})"
+            )
+        activations = unwrapped_args[num_args_tallied:]
+        if isinstance(wrapped_args, tuple) and isinstance(activations, tuple):
+            return wrapped_args + activations
+        return tuple(list(wrapped_args) + list(activations))
+    else:
+        if len(unwrapped_args) != num_args_tallied:
+            raise AssertionError(
+                f"Expected {len(unwrapped_args)} == {num_args_tallied}"
+            )
+        return tuple(wrapped_args)
+
+
+# Given a bunch of "dense" tensor arguments, this function (potentially) wraps them into tensor subclasses.
+# This function carefully handles the inference vs. joint cases:
+# - when is_joint_structure is True, args is (primals, tangents)
+# - when is_joint_structure is False, args is [*primals]
+def wrap_tensor_subclasses_maybe_joint(
+    unwrapped_args: Sequence[Any],
+    *,
+    is_joint_structure: bool,
+    meta: ViewAndMutationMeta,
+) -> tuple[Any, ...]:
+    # Since this function is reused for both inference and joint graphs,
+    if is_joint_structure:
+        if not (isinstance(unwrapped_args, tuple) and len(unwrapped_args) == 2):
+            unwrapped_len = (
+                len(unwrapped_args)
+                if isinstance(unwrapped_args, (tuple, list))
+                else "N/A"
+            )
+            raise AssertionError(
+                f"expected tuple of length 2 for joint structure, "
+                f"got {type(unwrapped_args)} with length {unwrapped_len}"
+            )
+        if not (
+            isinstance(unwrapped_args[0], (tuple, list))
+            and isinstance(unwrapped_args[1], (tuple, list))
+        ):
+            raise AssertionError(
+                f"expected primals and tangents to be tuple or list, got {type(unwrapped_args[0])} and {type(unwrapped_args[1])}"
+            )
+        primals, tangents = unwrapped_args[0], unwrapped_args[1]
+        wrapped_primals = wrap_tensor_subclasses(
+            primals,
+            subclass_metas=meta.subclass_inp_meta,
+            included_subclass_symints=True,
+        )
+        wrapped_tangents = wrap_tensor_subclasses(
+            tangents,
+            subclass_metas=meta.subclass_tangent_meta,
+            included_subclass_symints=False,
+        )
+        return (wrapped_primals, wrapped_tangents)
+    else:
+        wrapped_args = wrap_tensor_subclasses(
+            unwrapped_args,
+            subclass_metas=meta.subclass_inp_meta,
+            included_subclass_symints=True,
+        )
+        return wrapped_args
+
+
+def compute_inner_mutated_inp_indices_from_subclass_meta(
+    fw_metadata: ViewAndMutationMeta,
+    inner_metadata: ViewAndMutationMeta,
+) -> list[int]:
+    # Note: [Recomputing subclass mutation handling]
+    #
+    # Generally, if a subclass requires grad, its components will not require grad.
+    # But for the purposes of tracking returned tensors, we should treat those component
+    # tensors as if they require grad.
+    #
+    # For example, if the subclass tensor requires grad and will be mutated in a way that
+    # requires us to handle the mutation outside of the graph, we need to return it
+    # from the forward graph. The inner_meta data won't consider the component tensors
+    # as if they need to be returned, because they don't require grad; but really, we
+    # should handle those tensors the same way we handle the subclass tensor itself; i.e.
+    # if we'd include the subclass tensor as part of the outputs, then we should also
+    # include the component tensors.
+    #
+    # To do this, we patch num_mutated_inp_runtime_indices below by expanding the inputs
+    # from the outer subclass tensors and propagating
+
+    updated_input_info = []
+    inner_idx = 0
+    if not fw_metadata.subclass_inp_meta:
+        # Sometimes we don't have subclass info, e.g. synthetic_base codepaths
+        return inner_metadata.mutated_inp_runtime_indices
+    if len(fw_metadata.subclass_inp_meta) != len(fw_metadata.input_info):
+        raise AssertionError(
+            f"subclass_inp_meta length ({len(fw_metadata.subclass_inp_meta)}) != input_info length ({len(fw_metadata.input_info)})"
+        )
+    for outer_idx, inp_meta in enumerate(fw_metadata.subclass_inp_meta):
+        if isinstance(inp_meta, PlainTensorMeta):
+            if outer_idx >= len(fw_metadata.input_info):
+                raise AssertionError(
+                    f"outer_idx ({outer_idx}) >= len(fw_metadata.input_info) ({len(fw_metadata.input_info)})"
+                )
+            if inner_metadata is not None:
+                if inner_idx >= len(inner_metadata.input_info):
+                    raise AssertionError(
+                        f"inner_idx ({inner_idx}) >= len(inner_metadata.input_info) ({len(inner_metadata.input_info)})"
+                    )
+                if (
+                    inner_metadata.input_info[inner_idx]
+                    != fw_metadata.input_info[outer_idx]
+                ):
+                    raise AssertionError(
+                        f"input_info mismatch at inner_idx={inner_idx}, outer_idx={outer_idx}: "
+                        f"{inner_metadata.input_info[inner_idx]} != {fw_metadata.input_info[outer_idx]}"
+                    )
+            updated_input_info.append(fw_metadata.input_info[outer_idx])
+            inner_idx += 1
+        else:
+            if inp_meta.original_subclass is None:
+                raise AssertionError(
+                    "inp_meta.original_subclass must not be None for SubclassCreationMeta"
+                )
+            for _ in range(inp_meta.arg_count):
+                updated_input_info.append(fw_metadata.input_info[outer_idx])
+                inner_idx += 1
+    if inner_metadata is not None:
+        if len(inner_metadata.input_info) != len(updated_input_info):
+            raise AssertionError(
+                f"inner_metadata.input_info length ({len(inner_metadata.input_info)}) "
+                f"!= updated_input_info length ({len(updated_input_info)})"
+            )
+
+    return [
+        i
+        for i, inp in enumerate(updated_input_info)
+        if inp.mutation_type == MutationType.MUTATED_OUT_GRAPH
+    ]

.venv/lib/python3.12/site-packages/torch/_functorch/_aot_autograd/to_standalone_python.py

@@ -0,0 +1,999 @@
+"""Lower a GraphModule to a self-contained Python module via AOTAutograd + Inductor.
+
+This is the AOT half of the backend contract behind ``torch.compiler.precompile``:
+
+    python_code, cache = compile_to_python(gm, example_inputs)
+
+``inductor.compile_to_python`` produces only the inner Inductor ``call`` (kernels
+for the post-AOTAutograd dense graph). This module wraps that with the prelude /
+epilogue (input-mutation reflection, output-alias regen, subclass wrap/unwrap,
+...) by COMPOSING AOTAutograd's own codegen'd runtime-wrapper source -- captured
+during compile -- rather than reimplementing it. Every wrapper is spliced verbatim as a
+real top-level ``def``, with its closed-over globals hoisted to module-scope assignments,
+so the module reads as ordinary code. These nest in the SAME order the runtime builds:
+the INNER chain wrappers (subclass / functionalized-RNG) wrap the inner ``call`` and are
+composed inside the orchestration, while the OUTER ``CompilerWrapper``s (dedup / synthetic
+base) wrap the orchestration itself (via a single-arg adapter over it). Cross-wrapper references, the inner ``call`` chain,
+public helpers, and baked metadata objects (reconstructed as source -- see
+``_emit_value``) are wired by name; a guard rejects the rare case where a wrapper def
+name or hoisted global would collide with another top-level name (a sibling wrapper or
+an inner-module binding) rather than silently rebinding one.
+The result is a standalone module exposing ``call(flat_inputs) -> outputs`` that
+runs on its own (JIT-compiling kernels); ``cache`` is an opaque acceleration (or
+None).
+
+Baked metadata is emitted as plain Python source (no pickle / base64 blobs), so the
+generated module is fully auditable and exec'ing it never invokes ``pickle.loads``.
+A leaf that cannot be expressed as source raises NotImplementedError rather than
+falling back to an opaque embedding.
+
+Contract note: the standalone ``call`` deliberately substitutes ``nullcontext`` / a
+no-op for the runtime's first-invocation context and profiler prologue, dropping the
+cold-start custom-op aliasing analysis and the profiler prologue -- both diagnostics
+with no effect on numerics (see the generated-call emission site). One caveat: that
+dropped first-invocation custom-op aliasing analysis can itself RAISE under
+``config.error_on_custom_op_aliasing`` (default on in CI), so a graph whose custom op
+violates the aliasing contract runs SILENTLY in the standalone artifact where the
+eager / compiled path would error -- an intentional trade-off, not a numerics bug.
+"""
+
+from __future__ import annotations
+
+import ast
+import re
+import threading
+from typing import Any, TYPE_CHECKING
+
+from .codegen import capture_generated_sources, GeneratedSource
+from .source_emit import _REBUILD_HELPER, emit_value
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator, Sequence
+
+    from torch.fx import GraphModule
+
+
+# Serializes compile_to_python: the wrapper-source capture is thread-local, but the
+# AOTAutograd capture pass and the inner inductor compile swap process-global cache state
+# (see the THREADING note on compile_to_python), so concurrent compiles must not overlap.
+# An RLock (not a
+# plain Lock) because this entry point is re-entrant on a single thread: a custom
+# backend or inductor pass invoked while the lock is held may call back into this
+# lowering to compile a subgraph on the SAME thread, and a plain Lock would
+# self-deadlock on that re-entry. On-thread re-entry is safe here: the capture sink and
+# the cache-state swap (CacheArtifactManager.with_fresh_cache) are each self-contained
+# per call, so a nested compile neither corrupts the outer capture nor the outer cache
+# scope.
+_COMPILE_LOCK = threading.RLock()
+
+
+# ======================================================================
+# WHAT IS GOING ON HERE: composing AOTAutograd's runtime wrappers as source
+# ======================================================================
+#
+# AOTAutograd does not hand back a single flat function. The dense graph Inductor
+# compiles (the inner ``call``) is only the arithmetic core; around it AOTAutograd
+# wraps a prelude/epilogue that does what the core cannot express: reflecting input
+# mutations back onto the caller's tensors, regenerating outputs that alias an input
+# or each other, wrapping/unwrapping tensor subclasses, de-duplicating aliased
+# inputs, and threading functionalized RNG state. At runtime AOTAutograd emits each
+# wrapper as Python *source*, exec's it (the chokepoint is _compile_and_exec_source
+# in codegen.py), and the resulting function runs while closing over a
+# globals dict supplied in-process -- i.e. a wrapper is (source text) +
+# ({local_name: live_object}).
+#
+# The objects a wrapper closes over come in a few kinds:
+#   - public runtime helpers the codegen'd source references (e.g. increment_version,
+#     gen_alias_from_base, _unwrap_tensoralias, mark_dynamo_propagated_dynamic_indices,
+#     the CUDARngStateHelper staticmethods) -- ordinary importable objects;
+#   - the inner Inductor ``call`` that the chain ultimately invokes;
+#   - sibling captured wrappers -- the next link of the runtime chain (an inner subclass /
+#     functionalized-RNG wrapper, or an outer dedup / synthetic-base wrapper, whose body
+#     calls the link it wraps -- the orchestration's outer closure for the innermost outer
+#     wrapper), plus the orchestration's output-alias and mutation epilogue helpers, which
+#     it closes over directly by reference;
+#   - per-graph metadata baked at compile time (e.g. a ViewMetaSequence for alias
+#     regen, tensor-subclass metadata) -- live objects with no import path.
+#
+# Concretely, the module emitted for ``x.view(-1)`` (an output aliasing its input) has
+# one of each (heavily trimmed; the (1)-(4) tags match the kinds listed above):
+#
+#     from ...standalone_runtime import gen_alias_from_base    # (1) public helper
+#     <inner Inductor kernels + ``def call(args): ...``>
+#     _inner_call = call                                       # (2) the inner call
+#     _vms_0 = ViewMetaSequence._from_parts(...)               # (4) metadata as source
+#     def _alias_fn(orig_inputs, fw_outs):                     # (3) sibling wrapper
+#         return [gen_alias_from_base(orig_inputs[0], fw_outs[0], False, _vms_0, ...)]
+#     _replay_aliases_ = _alias_fn                             # (3) orchestration's ref
+#     def _runtime_wrapper(_compiled_fn_, _first_ctx_, _on_before_call_, args):
+#         all_outs = _compiled_fn_(args)                       # (2) inner call invoked
+#         return _replay_aliases_(orig_inputs, all_outs)       # (3) sibling invoked
+#     def call(flat_inputs):
+#         return _runtime_wrapper(
+#             _inner_call, contextlib.nullcontext, lambda: None, list(flat_inputs))
+#
+# We do NOT reimplement any of this. We CAPTURE AOTAutograd's exact codegen'd wrapper
+# source together with the (pre-exec) globals dict each wrapper closed over: a
+# thread-local sink in codegen.py records one GeneratedSource per wrapper.
+# To trigger the capture we run AOTAutograd ourselves (under no_grad, the inference path)
+# with a capture-only inner compiler: it grabs the dense inner graph and returns a
+# placeholder callable, so AOTAutograd still codegen's the runtime-wrapper chain AROUND
+# that placeholder -- which is what the sink records. Inductor does not run in that pass;
+# it runs once afterward on the captured dense graph (via inductor.compile_to_python), and
+# the composer swaps the placeholder for the inner inductor ``call`` by object identity.
+#
+# THE COMPOSITION PROBLEM. To turn a captured wrapper into a real top-level ``def`` in
+# the standalone module we splice its source verbatim. But that source refers to each
+# global by the LOCAL ALIAS AOTAutograd happened to choose (e.g. ``compiled_fn`` for
+# the inner call), not by any importable name. So for each ``{name: obj}`` in the
+# captured globals dict we emit a top-level binding ``name = <source for obj>`` (see
+# _emit_inline) -- except when the resolved expression already IS that module-scope
+# name (an import, or ``torch``), which needs no binding. The hard part is the right-
+# hand side: given only a live object, produce source that reproduces it. That requires
+# RECOGNIZING what the object is, the job of _resolve_global and the id-keyed
+# structures it consults, in order:
+#   - inner_call_id         -> the inner ``call`` becomes ``_inner_call``
+#   - fn_id_to_name         -> a sibling wrapper's fn becomes that wrapper's own name
+#   - _known_helper_table() -> an importable helper becomes (import, expr)
+#   - anything else: reconstruct field-by-field as source (_emit_value), or raise.
+# Recognition is by id() (object identity), not value-equality: for "is this the EXACT
+# object the wrapper closed over," == is the wrong tool (functions don't compare by
+# value, and an equal-but-different object would mis-resolve). Value-equality IS used,
+# but later and for a different job -- _emit_value round-trip-checks reconstructed
+# metadata (rebuilt == obj) before trusting it. Every hoisted name is _reserve'd: a
+# collision with a sibling wrapper's name or an inner-module binding fails loudly
+# rather than silently rebinding.
+#
+# WHY THIS IS SAFE ACROSS PROCESSES AND MACHINES. Every id() above is consulted ONLY
+# here, during composition, in the process that just ran the compile -- where all the
+# candidate objects (helpers, the inner call, sibling wrappers) are simultaneously
+# alive, held by the GeneratedSource records and the captured globals dicts, so no
+# address can be freed and reused mid-pass. Nothing the composer emits carries an id()
+# value, a live object, or any thread-local capture state: it emits only import lines,
+# ``name = expr`` bindings, and verbatim def source (the inner Inductor source is
+# likewise spliced as text). Grep the GENERATED module and there is no ``id(`` to
+# find. By the time the user holds the Python, all the process/thread-local state the
+# composer leaned on is gone; what ships is imports + name bindings + verbatim code.
+# Load it on another machine with the same torch version and the imports resolve by
+# name and the bindings reconstruct -- identity was a compile-time recognition device,
+# never a serialized artifact (live tensors / pickle / base64 blobs are rejected
+# outright rather than embedded).
+#
+# So the one genuine cross-machine contract is not id() but that the *names* the
+# artifact imports still resolve on load. Helpers are emitted as either ``import
+# torch`` (the torch module and stable public paths, e.g.
+# torch.autograd.graph.increment_version) or an import from the single small surface
+# standalone_runtime.py (for the AOTAutograd-area internals -- plus CUDARngStateHelper,
+# re-exported there for import-ordering -- whose locations are not themselves a stable
+# contract). That file's IDENTITY CONTRACT -- re-exports must preserve object id --
+# exists purely so the COMPOSER's id-lookup keeps matching; it is a compile-time
+# requirement, and the runtime artifact has no id dependency of its own.
+# ======================================================================
+
+
+# Global objects the codegen'd wrappers close over that are reproducible as an
+# import in the standalone module (rather than reconstructed field-by-field). Maps
+# object id -> (import_statement, expression). Built lazily to avoid import cycles.
+def _known_helper_table() -> dict[int, tuple[str, str]]:
+    # Generated artifacts import runtime helpers from the single stable surface
+    # ``standalone_runtime`` (not scattered AOTAutograd internals).
+    import torch
+
+    from . import standalone_runtime as rt
+
+    _RT = "from torch._functorch._aot_autograd.standalone_runtime import"
+    table: dict[int, tuple[str, str]] = {
+        id(torch): ("import torch", "torch"),
+        id(rt.normalize_as_list): (f"{_RT} normalize_as_list", "normalize_as_list"),
+        id(rt.mark_dynamo_propagated_dynamic_indices): (
+            f"{_RT} mark_dynamo_propagated_dynamic_indices",
+            "mark_dynamo_propagated_dynamic_indices",
+        ),
+        id(torch.autograd.graph.increment_version): (
+            "import torch",
+            "torch.autograd.graph.increment_version",
+        ),
+        id(rt.gen_alias_from_base): (
+            f"{_RT} gen_alias_from_base",
+            "gen_alias_from_base",
+        ),
+        id(rt._unwrap_tensoralias): (
+            f"{_RT} _unwrap_tensoralias",
+            "_unwrap_tensoralias",
+        ),
+        id(rt.CUDARngStateHelper.get_torch_state_as_tuple): (
+            f"{_RT} CUDARngStateHelper",
+            "CUDARngStateHelper.get_torch_state_as_tuple",
+        ),
+        id(rt.CUDARngStateHelper.set_new_offset): (
+            f"{_RT} CUDARngStateHelper",
+            "CUDARngStateHelper.set_new_offset",
+        ),
+    }
+    return table
+
+
+_MODULE_HEADER = """\
+# Generated by torch._functorch.aot_autograd.compile_to_python -- do not edit.
+#
+# Self-contained, executable module exposing ``call(flat_inputs) -> outputs`` for
+# the post-AOTAutograd graph. The Inductor kernels JIT-compile from the inlined
+# source on first call (no cache needed). The prelude/epilogue is AOTAutograd's own
+# codegen'd runtime wrappers, not reimplemented: each (the orchestration and any chain
+# wrappers) is spliced as a real top-level ``def`` with its closed-over globals (inner
+# ``call``, sibling wrappers, public helpers, baked metadata reconstructed as source)
+# hoisted to module-scope assignments -- so results match eager. The companion opaque
+# cache is only an acceleration; this module never reads it.
+"""
+
+
+def _resolve_global(
+    obj: object,
+    helper_table: dict[int, tuple[str, str]],
+    inner_call_id: int | None,
+    fn_id_to_name: dict[int, str],
+    imports: set[str],
+    orch_closure_id: int | None = None,
+    orch_entry_name: str | None = None,
+) -> str:
+    """Return a Python expression (valid in the generated module) that reproduces
+    ``obj``, recording any needed import. Raises NotImplementedError if ``obj`` is
+    neither the inner call, a sibling wrapper, a known helper, nor source-
+    reconstructible (see ``_emit_value``)."""
+    if inner_call_id is not None and id(obj) == inner_call_id:
+        return "_inner_call"
+    # An OUTER wrapper (dedup / synthetic base) closes over the orchestration's outer
+    # closure as its inner. That closure is not a captured wrapper and has no import
+    # path, so wire it to the single-arg orchestration entry adapter the composer emits.
+    if orch_closure_id is not None and id(obj) == orch_closure_id:
+        if orch_entry_name is None:
+            raise AssertionError("expected orch_entry_name to be not None")
+        return orch_entry_name
+    if id(obj) in fn_id_to_name:
+        return fn_id_to_name[id(obj)]
+    if id(obj) in helper_table:
+        import_stmt, expr = helper_table[id(obj)]
+        if import_stmt:
+            imports.add(import_stmt)
+        return expr
+    # Not a wired reference (inner call / sibling wrapper / helper): emit ``obj`` as
+    # plain reconstruction source. Raises if it is not source-expressible.
+    return emit_value(obj, imports)
+
+
+def _module_level_names(tree: ast.Module) -> set[str]:
+    """Names bound at module scope by a parsed module. Used to seed ``_reserve`` so an
+    inlined wrapper's def name or hoisted global (chain wrapper or orchestration) cannot
+    silently shadow a top-level name the inner Inductor module already binds."""
+    names: set[str] = set()
+    for n in tree.body:
+        if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            names.add(n.name)
+        elif isinstance(n, ast.Assign):
+            # Walk each target so tuple/list/starred unpacking (``a, b = ...`` /
+            # ``first, *rest = ...``) is covered, not just bare-name targets.
+            for t in n.targets:
+                names.update(x.id for x in ast.walk(t) if isinstance(x, ast.Name))
+        elif isinstance(n, ast.AnnAssign) and isinstance(n.target, ast.Name):
+            names.add(n.target.id)
+        elif isinstance(n, (ast.Import, ast.ImportFrom)):
+            names.update(a.asname or a.name.split(".")[0] for a in n.names)
+        elif isinstance(n, ast.Delete):
+            # Inductor's inner module does ``async_compile = AsyncCompile()`` then
+            # ``del async_compile`` at module scope; a del'd name does not survive, so it
+            # must not be reserved (else a hoisted wrapper global of the same name would
+            # trip a spurious collision). Body order is assign-then-del, so removing here
+            # leaves only names that actually persist.
+            for t in n.targets:
+                names.difference_update(
+                    x.id for x in ast.walk(t) if isinstance(x, ast.Name)
+                )
+    return names
+
+
+def _compose_standalone_module(
+    inner_python: str, captured: list[GeneratedSource], inner_call_obj: Any
+) -> str:
+    """Compose the inner Inductor ``call`` with AOTAutograd's captured runtime
+    wrappers into one standalone module exposing ``call(flat_inputs) -> outputs``.
+
+    Every wrapper (chain wrappers and the orchestration) is spliced as a real top-level
+    ``def`` with its closed-over globals hoisted to module-scope assignments (resolved
+    here). They are chained by name in the SAME nesting the runtime builds: the
+    orchestration is invoked with the INNER InductorWrapper chain head (subclass / RNG)
+    as its inner, and any OUTER ``CompilerWrapper`` (dedup / synthetic base, applied
+    AROUND the orchestration in ``graph_compile._aot_stage2c_make_inference_function``)
+    wraps a single-arg adapter over the orchestration.
+
+    ``inner_call_obj`` is the placeholder the capture pass returned for the inner call;
+    its identity is authoritative (see the note at the inner-call site below).
+    """
+    # The capture sink is duration-scoped over the inner inductor compile, with no
+    # originating-graph id at install time, so a re-entrant on-thread AOTAutograd /
+    # inductor lowering during that window that codegen's wrappers into THIS sink would
+    # append ITS wrappers here too. (A nested compile_to_python installs its OWN sink via
+    # capture_generated_sources, so its wrappers go there, not here -- it is not this
+    # case.) Each captured wrapper is tagged at append time with its TracingContext
+    # identity (origin_id), which separates such a foreign lowering when it ran under a
+    # DISTINCT TracingContext. A same-context re-entrant lowering reuses the ambient
+    # TracingContext via try_get() and so shares this origin_id; that case is instead
+    # caught by the orchestration count/wiring guards below (a second orchestration trips
+    # the len() != 1 check). Filter to the target graph's origin before composing. The
+    # target is the origin of the LAST captured orchestration wrapper: a foreign lowering
+    # appends its orchestration before the outer one finishes, so the final orchestration
+    # is always the outer/target one.
+    orchestrations = [
+        g for g in captured if g.artifact_name == "runtime_wrapper_orchestration"
+    ]
+    if orchestrations:
+        # target_origin is None only without an ambient TracingContext, which the real
+        # precompile path never hits (capture always runs under one); in that defensive
+        # case the filter keeps every None-origin wrapper and the count/wiring guards
+        # below remain the backstop.
+        target_origin = orchestrations[-1].origin_id
+        captured = [g for g in captured if g.origin_id == target_origin]
+
+    # Backward wrappers are out of scope for forward lowering; reject them up front.
+    # Every other wrapper that can appear in a composable (cacheable) forward graph is
+    # codegen'd as source and captured here. The one non-codegen'd wrapper,
+    # FakifiedOutWrapper, only activates under fakify_first_call, which makes the graph
+    # non-cacheable -- so such a graph is rejected before it ever reaches composition.
+    unsupported = [g.artifact_name for g in captured if "backward" in g.artifact_name]
+    if unsupported:
+        raise NotImplementedError(
+            "aot_autograd.compile_to_python cannot yet compose these runtime "
+            f"wrappers into standalone source: {sorted(set(unsupported))}."
+        )
+
+    orchestration = [
+        g for g in captured if g.artifact_name == "runtime_wrapper_orchestration"
+    ]
+    if len(orchestration) != 1:
+        raise NotImplementedError(
+            "aot_autograd.compile_to_python expected exactly one forward "
+            f"orchestration wrapper, captured {len(orchestration)}."
+        )
+    orch = orchestration[0]
+    non_orch = [g for g in captured if g is not orch]
+
+    # The generated ``call`` invokes the orchestration POSITIONALLY by its own name (see
+    # the bottom of this function): _runtime_wrapper(chain_head, contextlib.nullcontext,
+    # lambda: None, flat_inputs). That mapping is hardcoded to the codegen'd signature in
+    # runtime_wrappers.py (``def _runtime_wrapper(_compiled_fn_, _first_ctx_,
+    # _on_before_call_, args)``). Verify the captured signature still matches so a future
+    # rename/reorder fails loudly here instead of silently passing wrong arguments.
+    expected_orch_params = ["_compiled_fn_", "_first_ctx_", "_on_before_call_", "args"]
+    orch_def = next(
+        (
+            n
+            for n in ast.walk(ast.parse(orch.source))
+            if isinstance(n, ast.FunctionDef) and n.name == orch.fn_name
+        ),
+        None,
+    )
+    args_node = orch_def.args if orch_def is not None else None
+    if args_node is None:
+        orch_params = None
+    else:
+        # Compare the FULL signature, not just positional params: the standalone call is
+        # purely positional, so a keyword-only / *args / **kwargs param (e.g. an added
+        # kw-only-with-default) would be silently dropped. Surface any such param so it
+        # trips this guard rather than passing.
+        orch_params = [a.arg for a in (*args_node.posonlyargs, *args_node.args)]
+        orch_params += [a.arg for a in args_node.kwonlyargs]
+        if args_node.vararg is not None:
+            orch_params.append("*" + args_node.vararg.arg)
+        if args_node.kwarg is not None:
+            orch_params.append("**" + args_node.kwarg.arg)
+    if orch_params != expected_orch_params:
+        raise NotImplementedError(
+            "aot_autograd.compile_to_python: the orchestration wrapper signature "
+            f"changed (expected {expected_orch_params}, got {orch_params}); the "
+            "standalone module invokes it positionally and must be updated to match."
+        )
+
+    helper_table = _known_helper_table()
+    # Every wrapper is inlined (below) as a real def at module scope under its OWN codegen'd
+    # name, so references resolve to that name. Note these names are NOT distinct in general
+    # -- the subclass, dedup, and debug-assert chain wrappers all codegen ``inner_fn``; what
+    # holds today is that at most one chain wrapper appears per composable forward graph (see
+    # the test note on multi-link chains), so the names don't actually clash. ``_reserve``
+    # fails loudly if that ever stops holding (the old ``_wrapper_{i}`` scheme could carry
+    # multiple same-named wrappers in private exec namespaces; inlining deliberately cannot).
+    fn_id_to_name = {id(g.fn): g.fn_name for g in non_orch}
+
+    # A chain wrapper references the inner it wraps via one of these globals
+    # (subclass/dedup use ``compiled_fn``; the functionalized-RNG wrapper uses
+    # ``_compiled_fn_``). The orchestration takes its inner as a call-time arg, not a
+    # global, so it is never a chain wrapper. MAINTAINERS: if AOTAutograd adds a
+    # forward chain wrapper that names its inner via a new global, add that name here,
+    # otherwise inner-call/chain-head detection silently bypasses it.
+    _INNER_NAMES = ("compiled_fn", "_compiled_fn_")
+
+    def _inner_ref(g: GeneratedSource) -> Any:
+        for nm in _INNER_NAMES:
+            if nm in g.globals_dict:
+                return g.globals_dict[nm]
+        return None
+
+    # The inner Inductor call is AUTHORITATIVE: it is the placeholder object the capture
+    # pass returned (threaded in as ``inner_call_obj``), NOT inferred from capture order.
+    # This is what lets the composer tell the inner call apart from the orchestration's
+    # own outer closure -- both surface as some wrapper's inner-ref yet neither is a
+    # captured wrapper fn -- which is precisely how INNER wrappers (subclass / RNG,
+    # wrapping the inner call, composed INSIDE the orchestration) are distinguished from
+    # OUTER wrappers (dedup / synthetic base, ``CompilerWrapper``s applied AROUND the
+    # orchestration in graph_compile._aot_stage2c_make_inference_function).
+    inner_call_id: int = id(inner_call_obj)
+
+    # Name of the single-arg adapter emitted over the orchestration; the innermost outer
+    # wrapper closes over the orchestration's outer closure and is wired to this name.
+    _ORCH_ENTRY = "_orchestration_entry"
+
+    # The orchestration's outer closure is the object outer wrappers wrap. The composer
+    # never captures it directly (the captured orchestration ``fn`` is the inner
+    # ``_codegen_runtime_wrapper``), so recognize it structurally: an inner-ref that is
+    # neither the inner call nor any captured wrapper's fn can only be that closure.
+    orch_closure_ids = {
+        id(_inner_ref(g))
+        for g in non_orch
+        if _inner_ref(g) is not None
+        and id(_inner_ref(g)) != inner_call_id
+        and id(_inner_ref(g)) not in fn_id_to_name
+    }
+    if len(orch_closure_ids) > 1:
+        raise NotImplementedError(
+            "aot_autograd.compile_to_python: captured multiple wrappers whose inner "
+            "reference is neither the inner call nor a captured wrapper; cannot tell "
+            "which wraps the orchestration."
+        )
+    orch_closure_id: int | None = next(iter(orch_closure_ids), None)
+
+    # Walk the OUTER chain outward from the orchestration closure: the innermost outer
+    # wrapper wraps the closure, the next wraps that wrapper's fn, and so on. Everything
+    # else is inner-side -- the subclass / RNG chain wrappers plus the alias / mutation
+    # epilogue helpers the orchestration closes over (which reference no inner at all).
+    outer_wrappers: list[GeneratedSource] = []
+    if orch_closure_id is not None:
+        target_id: int | None = orch_closure_id
+        while target_id is not None:
+            nxt = next(
+                (
+                    g
+                    for g in non_orch
+                    if g not in outer_wrappers
+                    and _inner_ref(g) is not None
+                    and id(_inner_ref(g)) == target_id
+                ),
+                None,
+            )
+            if nxt is None:
+                break
+            outer_wrappers.append(nxt)
+            target_id = id(nxt.fn)
+    outer_ids = {id(g) for g in outer_wrappers}
+    inner_side = [g for g in non_orch if id(g) not in outer_ids]
+
+    # Chain head passed to the orchestration: the outermost INNER InductorWrapper (last
+    # inner-side wrapper that wraps via an inner reference), else the inner call. Computed
+    # up front (a pure capture-order check) so the order-inversion guard below fires
+    # before the later name-uniqueness guard -- a mis-ordered chain is the more specific
+    # diagnosis.
+    chain_head = "_inner_call"
+    chain_head_g: GeneratedSource | None = None
+    for g in inner_side:
+        if _inner_ref(g) is not None:
+            chain_head = fn_id_to_name[id(g.fn)]
+            chain_head_g = g
+
+    # "Last with an inner-ref == outermost" holds only when INNER capture order is
+    # innermost-to-outermost (it is today: subclass before functionalized-RNG). Back that
+    # assumption with a guard: the true outermost inner wrapper is the one NO other inner
+    # wrapper wraps, i.e. whose fn is not referenced as another inner wrapper's inner. If
+    # the chosen head is itself wrapped, capture order inverted and the chain would be
+    # mis-ordered -- reject rather than silently emit a wrong chain (the wiring guard
+    # below would not catch this, since every wrapper is still referenced somewhere).
+    referenced_inner_ids = {
+        id(_inner_ref(g)) for g in inner_side if _inner_ref(g) is not None
+    }
+    if chain_head_g is not None and id(chain_head_g.fn) in referenced_inner_ids:
+        raise NotImplementedError(
+            "aot_autograd.compile_to_python: the selected chain head is itself wrapped "
+            "by another captured wrapper, so capture order is not innermost-to-outermost "
+            "as assumed; refusing to emit a mis-ordered runtime-wrapper chain."
+        )
+
+    imports: set[str] = set()
+
+    # Parse the inner module once: to verify it binds a module-level ``call`` (the
+    # inner-call contract, checked below) and to collect its top-level names so no inlined
+    # wrapper's def name or hoisted global can silently shadow one.
+    inner_tree = ast.parse(inner_python)
+    inner_module_names = _module_level_names(inner_tree)
+
+    # Every runtime wrapper is inlined: its def is spliced at module scope and its
+    # closed-over globals hoisted to top-level assignments (no exec / private namespace).
+    # So every emitted top-level name -- each wrapper's def name and each hoisted global --
+    # must be unique and must not shadow a name the inner Inductor module binds. This holds
+    # in practice because at most one chain wrapper appears per composable forward graph, so
+    # its def name (``inner_fn`` is shared across subclass/dedup/debug-assert wrappers) and
+    # the inner-ref global ``compiled_fn`` each occur once, and metadata globals are
+    # per-wrapper suffixed. ``_reserve`` guards it: a collision fails loudly (rename/namespace
+    # needed) rather than silently rebinding a name.
+    emitted_names = set(inner_module_names) | {
+        "call",
+        "_inner_call",
+        "_rebuild",
+        "contextlib",
+        _ORCH_ENTRY,
+    }
+
+    def _reserve(name: str) -> None:
+        if name in emitted_names:
+            raise NotImplementedError(
+                "aot_autograd.compile_to_python: generated top-level name "
+                f"{name!r} collides with another top-level name in the composed module; "
+                "inlining the runtime wrappers would shadow a binding."
+            )
+        emitted_names.add(name)
+
+    # Reserve every wrapper def name up front (before hoists) so a hoisted global cannot
+    # shadow a def and two wrappers cannot share a name.
+    for _g in (*non_orch, orch):
+        _reserve(_g.fn_name)
+
+    def _resolve_globals(globals_dict: dict[str, object]) -> list[tuple[str, str]]:
+        # Resolve each global a wrapper closes over to a standalone source expression.
+        # ``globals_dict`` is the pre-exec snapshot from codegen.py, so the
+        # interpreter ``__builtins__`` is absent; the skip is kept defensively in case a
+        # future caller hands us a post-exec live dict.
+        out: list[tuple[str, str]] = []
+        for gname, gobj in globals_dict.items():
+            if gname == "__builtins__":
+                continue
+            expr = _resolve_global(
+                gobj,
+                helper_table,
+                inner_call_id,
+                fn_id_to_name,
+                imports,
+                orch_closure_id,
+                _ORCH_ENTRY,
+            )
+            out.append((gname, expr))
+        return out
+
+    def _emit_inline(source: str, globals_dict: dict[str, object]) -> str:
+        # Splice the wrapper's def verbatim at module scope, hoisting each closed-over global
+        # to a top-level assignment (skipping a name already module-available -- an imported
+        # helper or ``torch`` -- detected as gname == its resolved expr). No exec / private
+        # namespace: the def reads as ordinary code and is referenced by its own name. Each
+        # hoisted name is ``_reserve``'d so a collision fails loudly rather than rebinding.
+        hoists: list[str] = []
+        for gname, expr in _resolve_globals(globals_dict):
+            if gname == expr:
+                continue  # already at module scope (an import / ``torch``)
+            _reserve(gname)
+            hoists.append(f"{gname} = {expr}")
+        return "\n".join(hoists + [source, ""])
+
+    # Inner-side wrappers first (subclass / RNG chain wrappers innermost-to-outermost,
+    # plus the epilogue helpers), then the orchestration, then the outer wrappers -- all
+    # spliced as real defs. An inner wrapper's hoisted inner-ref (``compiled_fn``)
+    # references ``_inner_call`` / a sibling emitted earlier; an outer wrapper's inner-ref
+    # references the orchestration entry adapter / a sibling emitted earlier -- so order
+    # is satisfied.
+    inner_blocks = [_emit_inline(g.source, g.globals_dict) for g in inner_side]
+    orch_block = _emit_inline(orch.source, orch.globals_dict)
+    outer_blocks = [_emit_inline(g.source, g.globals_dict) for g in outer_wrappers]
+
+    # Imports (helper table + whatever emit_value added) are emitted BEFORE the inner
+    # module and the wrapper blocks, so a later top-level binding of the same name -- an
+    # inner-module binding or a hoisted wrapper global -- would shadow the import. And
+    # _emit_inline skips hoisting a global whose resolved expr already equals its own name
+    # (an imported helper referenced as ``gname == expr``), so such a wrapper would then
+    # silently bind to the shadowing object instead of the helper. ``from X import Y``
+    # names bind a specific (non-module) object and are the ones at risk; plain ``import
+    # mod`` names resolve to the same singleton module no matter who imports them, so a
+    # duplicate binding is benign and is left unchecked (else ``import torch`` -- which the
+    # inner module also emits -- would trip a spurious collision). ``_reserve`` fails loudly
+    # if an inner-module name or a hoisted global collides with one of these import names.
+    for stmt in sorted(imports):
+        node = ast.parse(stmt).body[0]
+        if isinstance(node, ast.ImportFrom):
+            for alias in node.names:
+                _reserve(alias.asname or alias.name)
+
+    # The final ``call`` invokes the outermost outer wrapper (else the orchestration
+    # directly). Build that line now so the wiring guard's corpus includes it -- the
+    # outermost outer wrapper is referenced ONLY there.
+    if outer_wrappers:
+        outermost_name = fn_id_to_name[id(outer_wrappers[-1].fn)]
+        final_invoke = f"    return {outermost_name}(list(flat_inputs))"
+    else:
+        final_invoke = (
+            f"    return {orch.fn_name}(\n"
+            f"        {chain_head}, contextlib.nullcontext, lambda: None, "
+            "list(flat_inputs)\n    )"
+        )
+
+    # The single-arg adapter over the orchestration (emitted only when outer wrappers
+    # wrap it). The outer wrappers call their inner as ``fn(args)``; this adapts the
+    # orchestration's positional (_compiled_fn_, _first_ctx_, _on_before_call_, args)
+    # signature to that. When there are no outer wrappers the orchestration is invoked
+    # directly in ``call`` (see final_invoke).
+    orch_invoke_comment = [
+        "    # The 2nd/3rd positional args INTENTIONALLY substitute contextlib.nullcontext",
+        "    # for the runtime's first-invocation context (_FirstInvocationContext) and a",
+        "    # no-op for the profiler-prologue exit. This drops two cold-start diagnostics:",
+        "    # the first-call custom-op aliasing analysis (_AnalyzeCustomOpInputOutputMode,",
+        "    # active when check_custom_op_aliasing is set, which can even RAISE under",
+        "    # error_on_custom_op_aliasing) and the profiler prologue. Neither affects",
+        "    # numerics, so this is not a bug -- the standalone artifact deliberately omits",
+        "    # them. (See the positional-mapping note in _compose_standalone_module.)",
+    ]
+    entry_block: list[str] = []
+    if outer_wrappers:
+        entry_block = [
+            f"def {_ORCH_ENTRY}(args):",
+            "    # Single-arg adapter so the CompilerWrappers applied AROUND the",
+            "    # orchestration (dedup / synthetic base) can invoke it as ``fn(args)``.",
+            *orch_invoke_comment,
+            f"    return {orch.fn_name}(",
+            f"        {chain_head}, contextlib.nullcontext, lambda: None, args",
+            "    )",
+            "",
+        ]
+
+    # _INNER_NAMES detection is a hardcoded allowlist (see above). If AOTAutograd adds
+    # a forward wrapper that names its inner via an unrecognized global, that wrapper
+    # is captured but may never be wired into the module -- silently composing a
+    # structurally-wrong result. Enforce that every captured non-orch wrapper is
+    # actually referenced somewhere: as the inner chain head, in the final ``call``
+    # (the outermost outer wrapper), or by name in another block (another wrapper's
+    # globals, the orchestration's epilogue helpers -- e.g. ``_alias_fn`` /
+    # ``_apply_mutations`` -- or the entry adapter). A wrapper whose name appears in no
+    # other block went unwired, so reject rather than emit a wrong module.
+    block_of = {id(g): b for g, b in zip(inner_side, inner_blocks)}
+    block_of.update({id(g): b for g, b in zip(outer_wrappers, outer_blocks)})
+    other_text = "\n".join(
+        inner_blocks + [orch_block] + entry_block + outer_blocks + [final_invoke]
+    )
+    for g in non_orch:
+        name = fn_id_to_name[id(g.fn)]
+        own = block_of[id(g)]
+        elsewhere = other_text.replace(own, "", 1)
+        # Whole-token match: ``name`` is a wrapper def name (e.g. ``inner_fn``); a raw
+        # substring test would treat ``inner_fn`` as wired whenever a longer token like
+        # ``inner_fn2`` is referenced, silently defeating this guard.
+        wired = re.search(r"\b" + re.escape(name) + r"\b", elsewhere) is not None
+        if name != chain_head and not wired:
+            raise NotImplementedError(
+                "aot_autograd.compile_to_python could not wire captured runtime "
+                f"wrapper {g.fn_name!r} into the module (an inner-call global may be "
+                "unrecognized; see _INNER_NAMES)."
+            )
+
+    # The module splices ``_inner_call = call`` below, relying on inner_python binding a
+    # module-level ``call`` entry point. Inductor emits this in one of two forms: the
+    # flat path defines ``def call(args):`` (FunctionDef) while the graph_partition Runner
+    # path binds ``call = runner.call`` (Assign with a Name target). Verify one is present
+    # so a future inductor codegen drift fails loudly here -- like the orchestration /
+    # chain / wiring guards above -- instead of surfacing as a bare NameError at exec of
+    # the generated module. (``inner_tree`` was parsed once up front.)
+    binds_call = any(
+        (isinstance(n, ast.FunctionDef) and n.name == "call")
+        or (
+            isinstance(n, ast.Assign)
+            and any(isinstance(t, ast.Name) and t.id == "call" for t in n.targets)
+        )
+        for n in inner_tree.body
+    )
+    if not binds_call:
+        raise NotImplementedError(
+            "compile_to_python: inner Inductor module does not bind a module-level "
+            "'call' entry point (the inner-call contract); the standalone module "
+            "splices ``_inner_call = call`` and must be updated to match."
+        )
+
+    # Only emit the _rebuild helper if a baked value actually reconstructs through it.
+    needs_rebuild = any(
+        "_rebuild(" in b for b in (*inner_blocks, orch_block, *outer_blocks)
+    )
+
+    # ``call`` invokes the orchestration directly when nothing wraps it; when outer
+    # wrappers do, its body just calls the outermost of them (which drives the entry
+    # adapter, then the orchestration) -- so the orchestration-substitution comment lives
+    # on whichever site actually invokes the orchestration.
+    if outer_wrappers:
+        call_body = [
+            "    # Invokes the outer CompilerWrapper chain (dedup / synthetic base), which",
+            f"    # wraps {_ORCH_ENTRY} (the orchestration adapter).",
+            final_invoke,
+        ]
+    else:
+        call_body = [
+            "    # AOTAutograd orchestration: disables grad, invokes the inner chain,",
+            "    # bumps mutated-input versions, applies the output epilogue.",
+            "    #",
+            *orch_invoke_comment,
+            final_invoke,
+        ]
+
+    parts = [
+        _MODULE_HEADER,
+        "import contextlib",
+        *sorted(imports),
+        "",
+        "",
+        *(_REBUILD_HELPER if needs_rebuild else []),
+        "# " + "=" * 70,
+        "# Inner Inductor output code (kernels + ``call``)",
+        "# " + "=" * 70,
+        inner_python,
+        "_inner_call = call",
+        "",
+        "# " + "=" * 70,
+        "# AOTAutograd runtime wrappers (codegen'd): each inlined as a real def with its",
+        "# closed-over globals hoisted to module scope -- inner chain wrappers first, then",
+        "# the orchestration, then any outer wrappers (dedup / synthetic base) that wrap it",
+        "# " + "=" * 70,
+        *inner_blocks,
+        orch_block,
+        *entry_block,
+        *outer_blocks,
+        "",
+        "def call(flat_inputs):  # noqa: F811",
+        *call_body,
+        "",
+    ]
+    return "\n".join(parts)
+
+
+def _find_effectful_op(gm: GraphModule, get_effect: Any) -> Any:
+    """Return the first effectful op target reachable from ``gm``, or None.
+
+    The target may be an ``OpOverload`` (e.g. ``aten::_print``) or a
+    ``HigherOrderOperator`` -- ``call_torchbind`` / ``hop_print`` /
+    ``invoke_leaf_function`` are registered ``_EffectType.ORDERED`` HOPs, not
+    OpOverloads -- so both are checked (``get_effect`` returns None for a
+    non-effectful HOP like ``cond``).
+
+    Walks the graph and descends into any child GraphModule a node references -- a
+    HOP (cond/while_loop/scan) holds its body as a get_attr'd submodule or passes it
+    directly as a node arg -- so an effect nested inside a HOP subgraph is caught, not
+    just effects at the top level."""
+    import torch
+    from torch.fx import GraphModule as _GraphModule
+
+    seen: set[int] = set()
+
+    def _scan(g: _GraphModule) -> Any:
+        if id(g) in seen:
+            return None
+        seen.add(id(g))
+        for node in g.graph.nodes:
+            if (
+                node.op == "call_function"
+                and isinstance(
+                    node.target,
+                    (torch._ops.OpOverload, torch._ops.HigherOrderOperator),
+                )
+                and get_effect(node.target) is not None
+            ):
+                return node.target
+            for sub in _iter_subgraphs(g, node):
+                found = _scan(sub)
+                if found is not None:
+                    return found
+        return None
+
+    def _walk_values(value: Any) -> Iterator[_GraphModule]:
+        # A GraphModule can appear as a direct node arg OR nested one level (or more)
+        # inside a list/tuple/dict arg -- some HOPs pass their branch/body callables
+        # inside a container -- so descend into containers before the isinstance check,
+        # otherwise the recursive effect scan would never enter that nested subgraph.
+        if isinstance(value, _GraphModule):
+            yield value
+        elif isinstance(value, (list, tuple)):
+            for item in value:
+                yield from _walk_values(item)
+        elif isinstance(value, dict):
+            for item in value.values():
+                yield from _walk_values(item)
+
+    def _iter_subgraphs(g: _GraphModule, node: Any) -> Iterator[_GraphModule]:
+        # A child graph reaches a node either as an attribute fetched by get_attr or
+        # as a (possibly container-nested) argument (the form HOPs use for their
+        # branch/body callables). make_fx emits FLAT get_attr targets (e.g.
+        # true_graph_0) since _scan recurses per-GraphModule, so a plain getattr
+        # suffices (no dotted walk needed here).
+        if node.op == "get_attr":
+            attr = getattr(g, node.target, None)
+            if isinstance(attr, _GraphModule):
+                yield attr
+        for arg in (*node.args, *node.kwargs.values()):
+            yield from _walk_values(arg)
+
+    return _scan(gm)
+
+
+def _graph_has_dynamic_shapes(gm: GraphModule) -> bool:
+    """True if any placeholder is itself a SymInt or carries symbolic (SymInt) size,
+    stride, or storage-offset metadata -- i.e. the graph was traced with dynamic dims.
+    Drives the shapes mode for the capture pass: dynamic graphs stay dynamic, static
+    graphs specialize so the composer can bake their (static) view metadata. Strides and
+    storage offset are checked too, not just sizes: a graph dynamic solely via symbolic
+    strides has static sizes, and treating it as static would silently specialize the
+    artifact to the example strides. (Unbacked symints appearing only in intermediates,
+    not on any placeholder, are still missed here, but such a graph fails loudly
+    downstream when emit_value rejects the still-symbolic metadata.)"""
+    import torch
+
+    def _is_symbolic(v: Any) -> bool:
+        return isinstance(v, torch.SymInt)
+
+    for node in gm.graph.nodes:
+        if node.op != "placeholder":
+            continue
+        val = node.meta.get("val")
+        if _is_symbolic(val):
+            return True
+        if isinstance(val, torch.Tensor) and (
+            any(_is_symbolic(s) for s in val.shape)
+            or any(_is_symbolic(s) for s in val.stride())
+            or _is_symbolic(val.storage_offset())
+        ):
+            return True
+    return False
+
+
+def compile_to_python(
+    gm: GraphModule,
+    example_inputs: Sequence[Any],
+    *,
+    options: dict[str, Any] | None = None,
+) -> tuple[str, bytes | None]:
+    """Compile ``gm`` to ``(python_code, cache)``; see the module docstring.
+
+    THREADING: serialized by a process-global lock (``_COMPILE_LOCK``). The wrapper-source
+    capture is thread-local, but the AOTAutograd pass and the inner inductor compile both
+    swap process-global cache state (``CacheArtifactManager.with_fresh_cache()``); a
+    concurrent compile on another thread would corrupt the captured wrappers or cache
+    artifacts, so concurrent calls (including via ``torch.compiler.precompile``) are
+    serialized rather than run in parallel.
+    """
+    import copy
+
+    import torch
+    from torch._higher_order_ops.effects import _get_effect
+    from torch._inductor import compile_to_python as _inductor_compile_to_python
+    from torch._inductor.compile_fx import compile_fx
+    from torch._inductor.standalone_compile import (
+        _resolve_ignore_shape_env,
+        _standalone_context,
+    )
+    from torch.fx.graph_module import _share_torchbind_and_process_group_on_deepcopy
+
+    from .utils import make_boxed_func
+
+    # Validate up front: this layer dereferences ``gm.graph`` (the effectful-op scan
+    # below) before reaching inductor's own type-check, so a non-GraphModule would
+    # otherwise surface as an opaque AttributeError instead of this clear contract error.
+    if not isinstance(gm, torch.fx.GraphModule):
+        raise TypeError(
+            "aot_autograd.compile_to_python expects a post-AOTAutograd "
+            f"torch.fx.GraphModule, got {type(gm)}."
+        )
+
+    # Effectful ops thread effect tokens through a calling convention the standalone
+    # composition does not reproduce (and their with_effects HOP is non-cacheable);
+    # reject them up front with a concrete reason. Not supported yet. (Detected here
+    # too, not only in torch.compiler.precompile's capture-time guard, so direct callers of
+    # this lowering get the same clear failure rather than a silently-wrong artifact.)
+    # Scan recursively: a HOP (cond/while_loop/scan) carries its body as a child
+    # GraphModule referenced by a get_attr node (or passed directly as a node arg), so
+    # effects nested in such a subgraph would be missed by a top-level-only scan.
+    effectful = _find_effectful_op(gm, _get_effect)
+    if effectful is not None:
+        raise NotImplementedError(
+            "aot_autograd.compile_to_python cannot lower this graph to standalone "
+            f"source: it contains an effectful op ({effectful}), which is not "
+            "supported yet."
+        )
+
+    with _COMPILE_LOCK:
+        # Run AOTAutograd ONCE to do two things: (1) produce the dense, decomposed,
+        # functionalized inner graph, and (2) codegen its runtime-wrapper chain, which the
+        # thread-local ``capture_generated_sources`` sink records. A capture-only inner
+        # compiler grabs the dense graph and returns a placeholder boxed callable, so
+        # AOTAutograd still builds and codegen's the wrappers AROUND it -- that codegen is
+        # what we capture. Inductor is NOT run in this pass; it runs exactly once below, on
+        # the captured dense graph, via the ``_inductor_compile_to_python`` call (which
+        # drives inductor's ``compile_fx_inner`` directly, not a re-entry into AOTAutograd).
+        # The composer swaps the placeholder (the wrappers' inner reference) for the
+        # inner inductor ``call`` by object identity, so the placeholder is only a
+        # compile-time token and never runs.
+        captured: list[GeneratedSource] = []
+        dense: dict[str, Any] = {}
+
+        def _capture_inner_compile(dense_gm, dense_inputs, **kwargs):
+            if "gm" in dense:
+                raise NotImplementedError(
+                    "aot_autograd.compile_to_python does not support a graph whose "
+                    "AOTAutograd lowering emits more than one inner forward graph."
+                )
+            dense["gm"] = dense_gm
+            # Retain the placeholder's IDENTITY: it is the authoritative inner call the
+            # runtime-wrapper chain closes over. The composer needs it to tell the inner
+            # call apart from the orchestration's own outer closure (both surface as a
+            # wrapper's inner-ref yet neither is a captured wrapper fn), which is what
+            # separates INNER wrappers from the OUTER dedup / synthetic-base wrappers.
+            placeholder = make_boxed_func(dense_gm.forward)
+            dense["placeholder"] = placeholder
+            return placeholder
+
+        # Drive inductor's own ``compile_fx`` (i.e. its exact AOTAutograd invocation --
+        # decomposition table + aot config) but swap in the capture inner compiler so the
+        # dense graph is intercepted before codegen and no inductor compile happens. Using
+        # compile_fx (rather than calling aot_autograd directly) guarantees the dense graph
+        # matches what the step-2 inductor compile below expects. Pick the shapes mode from
+        # the graph (there is no dynamic_shapes knob): a symbolically-traced graph uses
+        # ``"from_graph"`` to stay dynamic, a static one ``"from_example_inputs"`` to
+        # specialize -- matching what the composer can bake (symbolic view metadata is
+        # rejected downstream). no_grad pins the inference path (one forward module).
+        # Deepcopy first so compile_fx cannot mutate the caller's gm (torchbind
+        # ProcessGroups smuggled through as shared references). Note: the raw-collective /
+        # torchbind rewrites are inductor-lowering prereqs and belong to the step-2 inductor
+        # compile, which applies them to the dense graph -- not duplicated here.
+        shapes_mode = (
+            "from_graph" if _graph_has_dynamic_shapes(gm) else "from_example_inputs"
+        )
+        with (
+            torch.no_grad(),
+            _standalone_context(gm, shapes_mode, aot=False),
+            capture_generated_sources(captured),
+        ):
+            with _share_torchbind_and_process_group_on_deepcopy():
+                gm_owned = copy.deepcopy(gm)
+            compile_fx(
+                gm_owned,
+                example_inputs,
+                # Placeholder returns a boxed callable, not a full OutputCode; AOTAutograd
+                # only wraps it (never inductor-post-compiles it), so this is fine at runtime.
+                inner_compile=_capture_inner_compile,  # pyrefly: ignore[bad-argument-type]
+                ignore_shape_env=_resolve_ignore_shape_env(shapes_mode),
+            )
+        if "gm" not in dense:
+            raise RuntimeError(
+                "aot_autograd.compile_to_python: AOTAutograd never reached the inner "
+                "forward compiler, so no dense graph was captured."
+            )
+
+        inner_python, cache = _inductor_compile_to_python(
+            dense["gm"], example_inputs, options=options
+        )
+        source = _compose_standalone_module(
+            inner_python, captured, dense["placeholder"]
+        )
+    return source, cache
+
+
+def load_from_python(
+    python_code: str, cache: bytes | None = None
+) -> Callable[..., Any]:
+    """Load the module emitted by ``compile_to_python`` into a runnable ``call`` -- the
+    inverse of ``compile_to_python``: (python_code, cache) in, runnable ``call`` out.
+
+    The composed module is self-contained -- the inductor kernels and the pure-Python
+    runtime wrappers are inlined -- so this delegates straight to the inductor loader:
+    ``python_code`` runs standalone (kernels JIT-compile on first use), and ``cache`` (the
+    inductor accelerator bundle this layer forwards) warms the kernel caches so exec loads
+    the precompiled binaries instead of recompiling. There is no separate aot-level load
+    step: exec'ing the module yields the aot-composed top-level ``call`` directly, and the
+    wrappers carry no kernels to load.
+    """
+    from torch._inductor import load_from_python as _inductor_load_from_python
+
+    return _inductor_load_from_python(python_code, cache)

.venv/lib/python3.12/site-packages/torch/_functorch/_aot_autograd/utils.py

@@ -0,0 +1,907 @@
+"""
+Contains various utils for AOTAutograd, including those for handling collections.
+"""
+
+import copy
+import dataclasses
+import logging
+import operator
+import sys
+import warnings
+from collections.abc import Callable, Sequence
+from contextlib import nullcontext
+from functools import partial, wraps
+from typing import Any, overload, TYPE_CHECKING
+from typing_extensions import ParamSpec, TypeVar, TypeVarTuple, Unpack
+
+import torch
+import torch.utils._pytree as pytree
+from torch._library.fake_class_registry import FakeScriptObject
+from torch._library.opaque_object import is_custom_class_obj
+from torch._logging import getArtifactLogger
+from torch._subclasses.fake_tensor import is_fake_tensor
+from torch._subclasses.functional_tensor import FunctionalTensor
+from torch.fx.experimental._backward_state import BackwardState
+from torch.fx.experimental.proxy_tensor import py_sym_types
+
+
+_T = TypeVar("_T")
+if TYPE_CHECKING:
+    from torch.distributed._functional_collectives import AsyncCollectiveTensor
+
+    from .schemas import AOTConfig, ViewAndMutationMeta
+
+
+KNOWN_TYPES = [
+    torch.Tensor,
+    BackwardState,
+    int,
+    str,
+    float,
+    bool,
+    type(None),
+    *py_sym_types,
+    FakeScriptObject,
+    torch.ScriptObject,
+]
+
+aot_graphs_effects_log = getArtifactLogger(__name__, "aot_graphs_effects")
+annotation_log = getArtifactLogger(__name__, "annotation")
+
+strict_zip = partial(zip, strict=True)
+
+
+def get_loaded_async_collective_tensor_type() -> type["AsyncCollectiveTensor"] | None:
+    """Return the ACT type if distributed collectives are already loaded."""
+    if "torch.distributed._functional_collectives" not in sys.modules:
+        return None
+    from torch.distributed._functional_collectives import AsyncCollectiveTensor
+
+    return AsyncCollectiveTensor
+
+
+def import_async_collective_tensor_type() -> type["AsyncCollectiveTensor"]:
+    """Import and return the ACT type."""
+    from torch.distributed._functional_collectives import AsyncCollectiveTensor
+
+    return AsyncCollectiveTensor
+
+
+def is_async_collective_tensor_type(pytype: type) -> bool:
+    """Whether pytype is the AsyncCollectiveTensor type (False if not loaded)."""
+    act = get_loaded_async_collective_tensor_type()
+    return act is not None and pytype is act
+
+
+def partial_flatten_asdict(obj: object) -> Any:
+    if dataclasses.is_dataclass(obj):
+        return {
+            field.name: getattr(obj, field.name) for field in dataclasses.fields(obj)
+        }
+    elif isinstance(obj, (list, tuple)):
+        return obj.__class__([partial_flatten_asdict(item) for item in obj])
+    elif isinstance(obj, dict):
+        return {k: partial_flatten_asdict(v) for k, v in obj.items()}
+    else:
+        return obj
+
+
+@overload
+def normalize_as_list(x: _T) -> list[_T]: ...
+@overload
+def normalize_as_list(x: tuple[_T, ...]) -> list[_T]: ...
+@overload
+def normalize_as_list(x: list[_T]) -> list[_T]: ...
+
+
+def normalize_as_list(x: object) -> list[object]:
+    if isinstance(x, tuple):
+        return list(x)
+    elif isinstance(x, list):
+        return x
+    return [x]
+
+
+def _get_autocast_states() -> list[Any]:
+    return [
+        torch.is_autocast_enabled("cuda"),
+        torch.is_autocast_enabled("cpu"),
+        torch.get_autocast_dtype("cuda"),
+        torch.get_autocast_dtype("cpu"),
+        torch.is_autocast_cache_enabled(),
+    ]
+
+
+def make_boxed_func(f: Callable[..., Any]) -> Callable[[list[Any]], Any]:
+    @simple_wraps(f)
+    def g(args: list[Any]) -> Any:
+        return f(*args)
+
+    # pyrefly: ignore[missing-attribute]
+    g._boxed_call = True
+    return g
+
+
+def make_boxed_compiler(
+    compiler: Callable[..., Any],
+) -> Callable[..., Any]:
+    @wraps(compiler)
+    def f(fx_g: Any, inps: Any) -> Any:
+        out_f = compiler(fx_g, inps)
+        fx_g = make_boxed_func(out_f)
+        return fx_g
+
+    return f
+
+
+def call_func_at_runtime_with_args(
+    f: Callable[..., Any],
+    args: Sequence[Any],
+    steal_args: bool = False,
+    disable_amp: bool = False,
+) -> list[Any]:
+    if not steal_args:
+        args = list(args)
+    if not isinstance(args, list):
+        raise AssertionError(f"args must be a list, got {type(args)}")
+
+    context = torch._C._DisableAutocast if disable_amp else nullcontext
+    with context():
+        if getattr(f, "_boxed_call", False):
+            out = normalize_as_list(f(args))
+        else:
+            # TODO: Please remove soon
+            # https://github.com/pytorch/pytorch/pull/83137#issuecomment-1211320670
+            warnings.warn(
+                "Your compiler for AOTAutograd is returning a function that doesn't take boxed arguments. "
+                "Please wrap it with functorch.compile.make_boxed_func or handle the boxed arguments yourself. "
+                "See https://github.com/pytorch/pytorch/pull/83137#issuecomment-1211320670 for rationale.",
+                stacklevel=2,
+            )
+            out = normalize_as_list(f(*args))
+    return out
+
+
+# Inspired by autodidax (thanks!)
+class PytreeThunk:
+    spec: pytree.TreeSpec | None = None
+    # These are some kinda dumb microoptimizations that save about 3-4 us of overhead.
+    is_simple: bool | None = (
+        None  # if the output spec is a tuple/list, we won't bother unflattening it.
+    )
+    is_really_simple: bool | None = None  # if the output spec is a LeafSpec
+
+    def set(self, spec: pytree.TreeSpec) -> None:
+        if not (self.spec is None or self.spec == spec):
+            raise AssertionError(f"spec mismatch: existing={self.spec}, new={spec}")
+        if spec is None:
+            raise AssertionError("spec must not be None")
+        self.spec: pytree.TreeSpec = spec
+        if self.spec.type in {tuple, list} and all(
+            child.is_leaf() for child in spec.children()
+        ):
+            self.is_simple = True
+        if self.spec.is_leaf():
+            self.is_really_simple = True
+
+    def unflatten(self, x: Sequence[Any]) -> Any:
+        if self.is_really_simple:
+            return x[0]
+        if self.is_simple:
+            return x
+        if self.spec is None:
+            raise AssertionError("spec must be set before calling unflatten")
+        return pytree.tree_unflatten(x, self.spec)
+
+
+# Creates a function that returns flattened inputs and outputs
+# Also returns the output tree spec, which is needed to recover the "unflattened"
+# output tree structure later.
+def create_tree_flattened_fn(
+    fn: Callable[..., Any],
+    args: Sequence[Any],
+    kwargs: dict[str, Any] | None = None,
+) -> tuple[Callable[..., list[Any]], PytreeThunk]:
+    if kwargs is None:
+        kwargs = {}
+    # Save the args_spec for flat_tensor_args to unflatten while tracing
+    _, tensor_args_spec = pytree.tree_flatten((args, kwargs))
+    out_spec = PytreeThunk()
+
+    def flat_fn(*flat_args: Any) -> list[Any]:
+        # The input are flattened tensor args. Prepare the args in the
+        # order that original function expects. Add static args as well.
+        # They will appear as tensor constants in the traced graph.
+        nonlocal out_spec
+        args, kwargs = pytree.tree_unflatten(flat_args, tensor_args_spec)
+        tree_out = fn(*args, **kwargs)
+        flat_out, spec = pytree.tree_flatten(tree_out)
+        for i in flat_out:
+            is_known_type = isinstance(i, tuple(KNOWN_TYPES)) or is_custom_class_obj(i)
+            if not is_known_type:
+                raise RuntimeError(
+                    f"Found {type(i)} in output, which is not a known type. "
+                    "If this type holds tensors, you need to register a pytree for it. "
+                    "See https://github.com/pytorch/functorch/issues/475 for a brief "
+                    "explanation why. If you don't need to register a pytree, please "
+                    "leave a comment explaining your use case and we'll make this more "
+                    "ergonomic to deal with"
+                )
+        out_spec.set(spec)
+        return flat_out
+
+    # Can't use functools.wraps here because the wrapper has different
+    # calling convention
+    if hasattr(fn, "_orig_mod"):
+        # pyrefly: ignore[missing-attribute]
+        flat_fn._orig_mod = fn._orig_mod
+
+    return flat_fn, out_spec
+
+
+# This function takes in a tensor t, and returns one of t, t.view(), or t.clone().
+# When tracing the joint forward + backward, for any inputs in the graph that are mutated,
+# we need to clone them first (and similarly for metadata-only mutations, we need to view them first).
+# The idea is that when we trace the backward, we need to pass in the *original* primals
+# to autograd.grad(), before they were mutated.
+# Note: when we have synthetic base inputs, we need to clone them *before* creating views off of them.
+# This means that "idx" here represents the index of the (potentially) synthetic base.
+# What we need to do is:
+# (1) map the current (post-synthetic-base calling convention) input argument index
+#     to int index pre-synthetic-base-calling-convention.
+# (2) There could be multiple, if this index corresponds to a synthetic base
+#     that has multiple input aliases.
+# (3) If any of those corresponding inputs get metadata mutations, then we clone the base.
+def maybe_to_fresh_input(idx: int, t: Any, meta: "ViewAndMutationMeta") -> Any:
+    if not isinstance(t, torch.Tensor):
+        return t
+    if idx in meta.mutated_inp_runtime_indices:
+        # We only need to bother cloning mutated inputs that participate in autograd.
+        if meta.input_info[idx].requires_grad and meta.input_info[idx].mutates_data:
+            # Make sure the primal we pass to autograd.grad()
+            # sees the tensor before the mutation
+            return t.clone()
+        if meta.input_info[idx] and meta.input_info[idx].mutates_metadata:
+            # Make sure the primal we pass to autograd.grad()
+            # sees the tensor before the metadata mutation
+            return t.view(t.shape)
+    return t
+
+
+def is_with_effects(node: torch.fx.Node) -> bool:
+    if (
+        node.op == "call_function"
+        and node.target is torch.ops.higher_order.with_effects
+    ):
+        return True
+    elif (
+        node.op == "call_function"
+        and node.target is torch.ops.higher_order.invoke_subgraph
+    ):
+        # Check if subgraph has effects by looking in the cache
+        from torch._guards import InvokeSubgraphCache, TracingContext
+
+        tracing_ctx = TracingContext.try_get()
+        if tracing_ctx:
+            invoke_subgraph_cache = tracing_ctx.hop_dispatch_set_cache.get_cache(
+                torch.ops.higher_order.invoke_subgraph
+            )
+            if invoke_subgraph_cache:
+                if not isinstance(invoke_subgraph_cache, InvokeSubgraphCache):
+                    raise AssertionError(
+                        f"expected InvokeSubgraphCache, got {type(invoke_subgraph_cache)}"
+                    )
+                # pyrefly: ignore[bad-argument-type]
+                effects = invoke_subgraph_cache.get_effects(node.args[1])
+                return effects is not None
+    return False
+
+
+def unlift_tokens(
+    fw_module: torch.fx.GraphModule,
+    fw_metadata: "ViewAndMutationMeta",
+    aot_config: "AOTConfig",
+    bw_module: torch.fx.GraphModule | None = None,
+) -> None:
+    # Remove the tokens from the inputs/outputs of the graph since inductor does
+    # not want these extra inputs/outputs, and replace them with
+    # _make_token() to create a token, and _sink_tokens() to collect the
+    # tokens.  See Note [Side-Effectful Tokens in AOTAutograd]
+    # Logic:
+    # 1. In the case of with_effects:
+    #   Before:
+    #   ```
+    #   def forward(self, token, arg1_1):
+    #       with_effects = torch.ops.higher_order.with_effects(token, ...)
+    #       getitem = with_effects[0]
+    #       getitem_1 = with_effects[0]
+    #       return (getitem, getitem_1)
+    #   ```
+    #
+    #   After:
+    #   ```
+    #   def forward(self, arg1_1):
+    #       _make_token_default = torch.ops.prims._make_token.default()
+    #       with_effects = torch.ops.higher_order.with_effects(_make_token_default, ...)
+    #       getitem = with_effects[0]
+    #       getitem_1 = with_effects[0]
+    #       _sink_tokens_default = torch.ops.prims._sink_tokens.default([getitem]);
+    #       return (getitem_1,)
+    #   ```
+    #
+    # 2. In the case of an invoke_subgraph node, we will use the
+    # InvokeSubgraphCache to determine if the subgraph has effects. Then we will
+    # turn it into a `with_effects` node. This is so that at the toplevel graph,
+    # the nodes will have the correct with_effects threading. We will apply this
+    # pass recursively to submodules so the tokens will be removed from the
+    # subgraph's inputs.
+    #
+    #   Before:
+    #   ```
+    #   def forward(self, token, arg1_1):
+    #       repeated_subgraph0 = self.repeated_subgraph0
+    #       invoke_subgraph = torch.ops.higher_order.invoke_subgraph(
+    #           repeated_subgraph0, 'subgraph_0', token, x, arg1_1)
+    #       getitem = invoke_subgraph[0]
+    #       getitem_1 = invoke_subgraph[1]
+    #       return (getitem, getitem1)
+    #   ```
+    #
+    #   After:
+    #   ```
+    #   def forward(self, arg1_1):
+    #       _make_token_default = torch.ops.prims._make_token.default()
+    #       repeated_subgraph0 = self.repeated_subgraph0
+    #       with_effects_1 = torch.ops.higher_order.with_effects(
+    #           _make_token_default, torch.ops.higher_order.invoke_subgraph,
+    #           repeated_subgraph0, 'subgraph_0', arg1_1)
+    #       getitem = with_effects_1[0]
+    #       getitem_1 = with_effects_1[1];  with_effects_1 = None
+    #       _sink_tokens_default = torch.ops.prims._sink_tokens.default([getitem])
+    #       return (getitem_1,)
+    #   ```
+    #
+    # 3. The toplevel module should have the following invariants:
+    #   forward:
+    #     expected_num_erased_inputs == len(fw_metadata.tokens)
+    #     expected_num_erased_outputs == len(fw_metadata.tokens)
+    #   backward:
+    #     expected_num_erased_inputs == fw_metadata.num_backward_tokens
+    #     expected_num_erased_outputs == fw_metadata.num_backward_tokens
+    num_forward_tokens = len(fw_metadata.tokens)
+    num_backward_tokens = fw_metadata.num_backward_tokens
+
+    def replace_input_token_with_make_token(
+        module: torch.fx.GraphModule, node: torch.fx.Node
+    ) -> None:
+        with module.graph.inserting_before(node):
+            new_token_node = module.graph.call_function(
+                torch.ops.prims._make_token.default, ()
+            )
+            new_token_node.meta["val"] = torch.tensor([])
+            new_token_node.meta["tensor_meta"] = torch.tensor([])
+            node.replace_all_uses_with(new_token_node)
+            module.graph.erase_node(node)
+
+    def get_output_tokens(node: torch.fx.Node) -> set[torch.fx.Node]:
+        output_tokens = set()
+        for user in list(node.users.keys()):
+            # Check if this is a getitem accessing index 0 (the token)
+            if (
+                user.op == "call_function"
+                and user.target is operator.getitem
+                and len(user.args) > 1
+                and user.args[1] == 0
+            ):
+                # Check if this getitem is used in an output
+                for user_user in list(user.users.keys()):
+                    if user_user.op == "output":
+                        output_tokens.add(user)
+        return output_tokens
+
+    def _unlift_tokens_from_module_helper(
+        module: torch.fx.GraphModule,
+        subgraph_str: str,
+        expected_num_erased: int | None,
+    ) -> None:
+        input_token_nodes = set()
+        output_token_nodes = set()
+
+        for node in module.graph.nodes:
+            if (
+                node.op == "call_function"
+                and node.target is torch.ops.higher_order.with_effects
+            ):
+                if node.args[0].op == "placeholder":
+                    input_token_nodes.add(node.args[0])
+                    replace_input_token_with_make_token(module, node.args[0])
+
+                tokens_from_with_effects = get_output_tokens(node)
+                output_token_nodes = output_token_nodes | tokens_from_with_effects
+
+            elif (
+                node.op == "call_function"
+                and node.target is torch.ops.higher_order.invoke_subgraph
+            ):
+                subgraph_node, identifier, *operands = node.args
+
+                # Check if subgraph has effects by looking in the cache
+                from torch._guards import InvokeSubgraphCache, TracingContext
+
+                effects = None
+                tracing_ctx = TracingContext.try_get()
+                if tracing_ctx:
+                    invoke_subgraph_cache = (
+                        tracing_ctx.hop_dispatch_set_cache.get_cache(
+                            torch.ops.higher_order.invoke_subgraph
+                        )
+                    )
+                    if invoke_subgraph_cache:
+                        if not isinstance(invoke_subgraph_cache, InvokeSubgraphCache):
+                            raise AssertionError(
+                                f"expected InvokeSubgraphCache, got {type(invoke_subgraph_cache)}"
+                            )
+                        effects = invoke_subgraph_cache.get_effects(identifier)
+
+                if effects is not None:
+                    # Wrap invoke_subgraph with with_effects
+                    # Before: invoke_subgraph(subgraph, id, token, *args) -> (token_out, result)
+                    # After: with_effects(token, invoke_subgraph, subgraph, id, *args) -> (token_out, result)
+                    #
+                    # Note: The subgraph itself will be unlifted separately when we iterate
+                    # through named_modules() below.
+
+                    num_tokens = len(effects)
+                    if num_tokens != 1:
+                        raise AssertionError(
+                            f"Multiple token subgraph NYI, got {num_tokens} tokens"
+                        )
+                    token_args = operands[:num_tokens]
+                    non_token_args = operands[num_tokens:]
+
+                    # Create with_effects wrapper around invoke_subgraph
+                    # with_effects(token, op, *args) where op is invoke_subgraph
+                    # Pass the subgraph and non-token args to invoke_subgraph
+                    with module.graph.inserting_before(node):
+                        new_node = module.graph.call_function(
+                            torch.ops.higher_order.with_effects,
+                            # pyrefly: ignore [bad-argument-type]
+                            (
+                                token_args[0],  # pyrefly: ignore[bad-argument-type]
+                                torch.ops.higher_order.invoke_subgraph,
+                                subgraph_node,
+                                identifier,
+                                *tuple(non_token_args),
+                            ),
+                        )
+                        node.replace_all_uses_with(new_node)
+                        new_node.meta = node.meta
+                        module.graph.erase_node(node)
+
+                    for token in token_args:
+                        if token.op == "placeholder":
+                            input_token_nodes.add(token)
+                            replace_input_token_with_make_token(module, token)
+
+                    # Get output tokens from the new with_effects node
+                    tokens_from_invoke_subgraph = get_output_tokens(new_node)
+                    output_token_nodes = (
+                        output_token_nodes | tokens_from_invoke_subgraph
+                    )
+
+        if not output_token_nodes and not input_token_nodes:
+            return
+
+        output_node = next(reversed(module.graph.find_nodes(op="output")))
+        if output_node is None:
+            raise AssertionError("output node not found in graph")
+        with module.graph.inserting_before(output_node):
+            module.graph.call_function(
+                torch.ops.prims._sink_tokens.default,
+                (list(output_token_nodes),),
+            )
+        new_out_args = tuple(
+            [out for out in output_node.args[0] if out not in output_token_nodes]
+        )
+        output_node.args = (new_out_args,)
+
+        if expected_num_erased:
+            if len(input_token_nodes) != expected_num_erased:
+                raise AssertionError(
+                    f"{subgraph_str} num_erased_inputs:{len(input_token_nodes)} "
+                    f"{input_token_nodes} != expected {expected_num_erased} \n"
+                    f"{fw_module.print_readable(print_output=False)}"
+                )
+            if len(output_token_nodes) != expected_num_erased:
+                raise AssertionError(
+                    f"{subgraph_str} num_erased_outs:{len(output_token_nodes)} "
+                    f"{output_token_nodes} != expected {expected_num_erased} \n"
+                    f"{fw_module.print_readable(print_output=False)}"
+                )
+
+        module.recompile()
+
+    def unlift_tokens_from_module(
+        module: torch.fx.GraphModule, subgraph_str: str, expected_num_erased: int
+    ) -> None:
+        for name, m in module.named_modules():
+            if isinstance(m, torch.fx.GraphModule):
+                if name == "":
+                    _unlift_tokens_from_module_helper(
+                        m, subgraph_str, expected_num_erased
+                    )
+                else:
+                    # Subgraph -- we may or may not have effects applied
+                    _unlift_tokens_from_module_helper(m, f"{subgraph_str}_{name}", None)
+
+    if num_forward_tokens > 0:
+        if aot_config.enable_log:
+            from torch._dynamo.utils import lazy_format_graph_code
+
+            aot_graphs_effects_log.debug(
+                "%s",
+                lazy_format_graph_code(
+                    "Forward graph before unlifting tokens",
+                    fw_module,
+                    aot_config.aot_id,
+                    include_stride=True,
+                    include_device=True,
+                    colored=True,
+                ),
+            )
+        unlift_tokens_from_module(
+            fw_module,
+            "forward",
+            num_forward_tokens,
+        )
+
+    if bw_module is not None and num_backward_tokens > 0:
+        if aot_config.enable_log:
+            from torch._dynamo.utils import lazy_format_graph_code
+
+            aot_graphs_effects_log.debug(
+                "%s",
+                lazy_format_graph_code(
+                    "Backward graph before unlifting tokens",
+                    bw_module,
+                    aot_config.aot_id,
+                    include_stride=True,
+                    include_device=True,
+                    colored=True,
+                ),
+            )
+        unlift_tokens_from_module(bw_module, "backward", num_backward_tokens)
+
+    # This is sad, but we need to update the metadata to get rid of
+    # the tokens.
+    fw_metadata.tokens = {}
+    fw_metadata.num_backward_tokens = 0
+
+
+def root_module_when_exporting_non_strict(
+    flat_fn: Callable[..., Any],
+) -> torch.nn.Module | None:
+    # When exporting in non-strict mode, we wrap the root module in a specific pattern.
+    # See `_aot_export_non_strict` in torch.export._trace.py.
+    # We look for that wrapping pattern here.
+    if hasattr(flat_fn, "_orig_mod") and hasattr(flat_fn._orig_mod, "_export_root"):
+        return flat_fn._orig_mod._export_root
+    else:
+        return None
+
+
+def _is_forward_node_with_seq_nr(node: torch.fx.Node) -> bool:
+    # For now, assume that if nn_module_stack_metadata is populated, this
+    # node is from the forward. Ignore nodes without `seq_nr`.
+    # TODO(future): there is likely a less brittle way to do this by walking
+    # the descendants of graph inputs corresponding to fwd inputs, didn't
+    # seem obvious at first glance on how to partition graph inputs into
+    # fwd vs bwd without relying on string names.
+    return node.meta.get("partitioner_tag") != "is_backward" and "seq_nr" in node.meta
+
+
+def _is_backward_node_with_seq_nr(node: torch.fx.Node) -> bool:
+    # For now, assume that if nn_module_stack_metadata is not populated,
+    # this node is from the backward. Ignore nodes without `seq_nr`.
+    # TODO(future): there is likely a less brittle way to do this, same
+    # as with the forward.
+    return node.meta.get("partitioner_tag") == "is_backward" and "seq_nr" in node.meta
+
+
+def _collect_fwd_nodes_from_subgraph(
+    fx_g: torch.fx.GraphModule, fwd_seq_nr_to_node: dict[str, torch.fx.Node]
+) -> None:
+    """Collect forward nodes from a single subgraph into the global mapping."""
+    for node in fx_g.graph.nodes:
+        if not _is_forward_node_with_seq_nr(node):
+            continue
+        seq_nr = node.meta["seq_nr"]
+        if seq_nr in fwd_seq_nr_to_node:
+            # If we already saw an op with the current `seq_nr`, that means
+            # that the current op did not create an autograd node, and there
+            # is no corresponding backward node, so we skip.
+            continue
+        fwd_seq_nr_to_node[seq_nr] = node
+
+
+def _copy_metadata_to_bw_nodes_in_subgraph(
+    fx_g: torch.fx.GraphModule, fwd_seq_nr_to_node: dict[str, torch.fx.Node]
+) -> None:
+    """Copy metadata from forward nodes to backward nodes in a single subgraph."""
+    for node in fx_g.graph.nodes:
+        annotation_log.debug("node: %s", node.name)
+        seq_nr = node.meta.get("seq_nr")
+        annotation_log.debug("seq_nr: %s", seq_nr)
+
+        if not _is_backward_node_with_seq_nr(node):
+            continue
+
+        # We exclude gradient accumulation nodes from copying tags
+        if node.meta.get("is_gradient_acc", False):
+            annotation_log.debug("is_gradient_acc")
+            continue
+
+        # fwd_node should always exist, but handle non-existence just in case
+        fwd_node = fwd_seq_nr_to_node.get(node.meta["seq_nr"])
+        if fwd_node is not None:
+            node.meta["fwd_nn_module_stack"] = fwd_node.meta.get("nn_module_stack")
+            node.meta["fwd_source_fn_stack"] = fwd_node.meta.get("source_fn_stack")
+            # TODO: better to change to a specific field of custom?
+            custom = fwd_node.meta.get("custom")
+            if custom is not None:
+                # Merge rather than overwrite so bw-only keys survive
+                # fw keys win on conflict.
+                node.meta["custom"] = {
+                    **node.meta.get("custom", {}),
+                    **copy.deepcopy(custom),
+                }
+
+
+def copy_fwd_metadata_to_bw_nodes(fx_g: torch.fx.GraphModule) -> None:
+    """
+    Input: `fx_g` which contains the joint fwd+bwd FX graph created by
+    aot_autograd.
+
+    This function walks the graph and copies over metadata from forward nodes
+    to backward nodes, using the `seq_nr` field as a one-to-many mapping
+    from forward node to backward node. This metadata is useful for performance
+    profiling and debugging.
+
+    This function supports matching forward and backward nodes across different
+    subgraphs (e.g., in recursive submodules from HOPs), enabling backward nodes
+    in any submodule to match forward nodes in any submodule.
+    """
+
+    # Build a global mapping of seq_nr to forward nodes across all subgraphs
+    fwd_seq_nr_to_node: dict[str, torch.fx.Node] = {}
+
+    # First pass: collect all forward nodes from all subgraphs
+    for submod in fx_g.modules():
+        if isinstance(submod, torch.fx.GraphModule):
+            _collect_fwd_nodes_from_subgraph(submod, fwd_seq_nr_to_node)
+
+    if annotation_log.isEnabledFor(logging.DEBUG):
+        for k, v in fwd_seq_nr_to_node.items():
+            annotation_log.debug("forward:: key: %s, value: %s", k, v)
+
+    # Second pass: copy metadata to backward nodes in all subgraphs
+    # using the global forward mapping
+    for submod in fx_g.modules():
+        if isinstance(submod, torch.fx.GraphModule):
+            _copy_metadata_to_bw_nodes_in_subgraph(submod, fwd_seq_nr_to_node)
+
+
+def register_buffer_assignment_hook(
+    mod: torch.nn.Module, assigned_buffers: dict[str, str]
+) -> Any:
+    """
+    Register a hook that intercepts buffer assignments.
+    This is used to detect when a buffer is assigned to, and then we can
+    map that buffer to the corresponding proxy node in the graph.
+    """
+
+    def _map_assigned_buffer_to_proxy(
+        _mod: torch.nn.Module, name: str, buffer: Any
+    ) -> Any:
+        # We intercept buffer assignments on the root module through this hook.
+        if _mod._buffers is mod._buffers:
+            # either buffer is a functional tensor, which wraps a fake tensor
+            if isinstance(buffer, FunctionalTensor):
+                buffer = buffer.from_functional()
+            # or buffer is a fake tensor
+            if not is_fake_tensor(buffer):
+                raise AssertionError(f"expected FakeTensor, got {type(buffer)}")
+            # The fake tensor in turn is associated with a proxy node.
+            proxy_mode = torch.fx.experimental.proxy_tensor.get_proxy_mode()
+            if proxy_mode is None:
+                raise AssertionError("proxy_mode must not be None")
+            proxy = torch.fx.experimental.proxy_tensor.get_proxy_slot(
+                buffer, proxy_mode.tracer
+            ).proxy.node
+            # We map the assigned buffer to this proxy node.
+            assigned_buffers[name] = proxy.name
+        return buffer
+
+    return torch.nn.modules.module.register_module_buffer_registration_hook(
+        _map_assigned_buffer_to_proxy
+    )
+
+
+def contain_metadata_mutation_ops(module: torch.fx.GraphModule) -> bool:
+    """
+    Checks if the module contains any metadata mutation ops.
+    """
+    for node in module.graph.nodes:
+        if (
+            node.op == "call_function"
+            and hasattr(node.target, "tags")
+            and torch.Tag.inplace_view in node.target.tags
+        ):
+            return True
+    return False
+
+
+_GRAPHSAFE_RNG_DEVICE_TYPES: set[str] = {"cuda"}
+
+
+def register_graphsafe_rng_device_type(device_type: str) -> None:
+    """Register a device type as supporting graphsafe RNG operations.
+
+    The device backend module (``torch.<device_type>``) must provide:
+    - ``_get_generator(device: torch.device) -> Generator``: return the default
+      generator for the given device. The generator must implement
+      ``graphsafe_get_state()``, ``graphsafe_set_state(state)``, and
+      ``clone_state()``.
+    - ``get_rng_state(device_index: int) -> Tensor``: return the current RNG
+      state tensor.
+
+    Args:
+        device_type: The device type string (e.g. "cuda", "xpu").
+    """
+    from torch._prims.rng_prims import register_graphsafe_rng_dispatch
+
+    key_name = torch._C._dispatch_key_for_device(device_type)
+    dispatch_key = getattr(torch._C.DispatchKey, key_name)
+    _GRAPHSAFE_RNG_DEVICE_TYPES.add(device_type)
+    register_graphsafe_rng_dispatch(dispatch_key)
+
+
+def supports_graphsafe_rng(device: torch.device) -> bool:
+    """Check whether a device supports graphsafe RNG operations."""
+    return device.type in _GRAPHSAFE_RNG_DEVICE_TYPES
+
+
+def get_default_generator(device: torch.device) -> Any:
+    """Get the default RNG generator for a device.
+
+    Calls ``torch.<device_type>._get_generator(device)``.
+    """
+    device_mod = getattr(torch, device.type, None)
+    if device_mod is None or not hasattr(device_mod, "_get_generator"):
+        raise AssertionError(
+            f"Device type '{device.type}' does not implement _get_generator. "
+            f"Registered graphsafe RNG types: {sorted(_GRAPHSAFE_RNG_DEVICE_TYPES)}."
+        )
+    return device_mod._get_generator(device)
+
+
+def get_device_rng_state(device: torch.device) -> torch.Tensor:
+    """Get the RNG state tensor for a device."""
+    device_mod = getattr(torch, device.type, None)
+    if device_mod is not None and hasattr(device_mod, "get_rng_state"):
+        idx = device.index if device.index is not None else 0
+        return device_mod.get_rng_state(idx)
+    return torch.get_rng_state()
+
+
+def top_saved_tensors_hooks() -> Any:
+    return torch._C._autograd._top_saved_tensors_default_hooks(True)
+
+
+def saved_tensors_hooks_are_inlineable(hooks: Any) -> bool:
+    if not hooks:
+        return False
+    pack, unpack = hooks
+    return isinstance(pack, torch.fx.GraphModule) and isinstance(
+        unpack, torch.fx.GraphModule
+    )
+
+
+_P = ParamSpec("_P")
+_T = TypeVar("_T")
+_S = TypeVar("_S")
+
+
+def without_output_descs(f: Callable[_P, tuple[_T, _S]]) -> Callable[_P, _T]:
+    @wraps(f)
+    @simple_wraps(f)
+    def inner(*args: _P.args, **kwargs: _P.kwargs) -> _T:
+        return f(*args, **kwargs)[0]
+
+    return inner
+
+
+_P2 = ParamSpec("_P2")
+_R = TypeVar("_R")
+_R2 = TypeVar("_R2")
+
+
+def simple_wraps(
+    f: Callable[_P, _R],
+) -> Callable[[Callable[_P2, _R2]], Callable[_P2, _R2]]:
+    # NB: omit ('__module__', '__name__', '__qualname__') for ease of
+    # debugging
+    return wraps(f, assigned=("__doc__", "__annotations__", "__type_params__"))
+
+
+_Ts = TypeVarTuple("_Ts")
+
+
+def call_and_expect_output_descs(
+    fn: Callable[[*_Ts], tuple[Any, Any]], args: tuple[Unpack[_Ts]]
+) -> tuple[Any, Any]:
+    from .descriptors import AOTOutput
+
+    outs_pair = fn(*args)
+    if not (isinstance(outs_pair, tuple) and len(outs_pair) == 2):
+        raise AssertionError(
+            f"expected tuple of length 2, got {type(outs_pair)} with value {outs_pair}"
+        )
+    outs, outs_descs = outs_pair
+    # The Tensor tests protects against the test when there are no outputs
+    out_vals, out_spec = pytree.tree_flatten(outs)
+    out_desc_vals, out_desc_spec = pytree.tree_flatten(outs_descs)
+    if out_spec != out_desc_spec:
+        raise AssertionError(
+            f"output spec mismatch: {fn_wrappers(fn)}, outs={outs}, outs_descs={outs_descs}, "
+            f"out_spec={out_spec}, out_desc_spec={out_desc_spec}"
+        )
+    if any(isinstance(x, AOTOutput) for x in out_vals):
+        raise AssertionError(
+            f"unexpected AOTOutput in out_vals: {fn_wrappers(fn)}, outs={outs}, "
+            f"outs_descs={outs_descs}, out_vals={out_vals}"
+        )
+    if not all(
+        isinstance(d, AOTOutput)
+        for (x, d) in zip(out_vals, out_desc_vals)
+        if isinstance(x, (torch.Tensor, torch.SymInt)) or type(x) is int
+    ):
+        raise AssertionError(
+            f"expected all descriptors to be AOTOutput: {fn_wrappers(fn)}, outs={outs}, "
+            f"outs_descs={outs_descs}, out_vals={out_vals}, out_desc_vals={out_desc_vals}"
+        )
+    return outs_pair
+
+
+def fn_wrappers(fn: Callable[..., Any]) -> list[Callable[..., Any]]:
+    fns = [fn]
+    f = fn
+    while hasattr(f, "__wrapped__"):
+        f = f.__wrapped__
+        fns.append(f)
+    return fns
+
+
+def _is_primal(node: torch.fx.Node) -> bool:
+    return (
+        node.op == "placeholder"
+        and "tangents" not in str(node.target)
+        and not _is_bwd_seed_offset(node)
+        and not _is_fwd_seed_offset(node)
+    )
+
+
+def _is_tangent(node: torch.fx.Node) -> bool:
+    return node.op == "placeholder" and "tangents" in str(node.target)
+
+
+def _is_bwd_seed_offset(node: torch.fx.Node) -> bool:
+    return node.op == "placeholder" and (
+        "bwd_seed" in str(node.target) or "bwd_base_offset" in str(node.target)
+    )
+
+
+def _is_fwd_seed_offset(node: torch.fx.Node) -> bool:
+    return node.op == "placeholder" and (
+        "fwd_seed" in str(node.target) or "fwd_base_offset" in str(node.target)
+    )

.venv/lib/python3.12/site-packages/torch/_functorch/aot_autograd.py

@@ -0,0 +1,1971 @@
+from __future__ import annotations
+
+import contextlib
+import dataclasses
+import itertools
+import time
+from contextlib import nullcontext
+from functools import wraps
+from typing import Any, cast, Literal, TYPE_CHECKING
+from typing_extensions import ParamSpec, TypeVar
+from unittest.mock import patch
+
+import torch
+import torch._dynamo.logging
+import torch.nn as nn
+import torch.utils._pytree as pytree
+import torch.utils.dlpack
+from torch import Tensor
+from torch._decomp.decompositions_for_rng import PhiloxStateTracker, rng_decompositions
+from torch._dispatch.python import enable_python_dispatcher
+from torch._dynamo import compiled_autograd
+from torch._dynamo.utils import (
+    CompileEventLogger,
+    dynamo_timed,
+    preserve_rng_state,
+    set_feature_use,
+)
+from torch._guards import detect_fake_mode
+from torch._inductor.codecache import resolve_pre_grad_pass_timing
+
+# Runtime annotation consumers still resolve BoxedBool from module globals.
+from torch._subclasses import FakeTensorMode
+from torch._subclasses.fake_tensor import maybe_get_fake_mode
+from torch.export._tree_utils import reorder_kwargs
+from torch.fx.experimental.proxy_tensor import make_fx
+
+from . import config
+from ._aot_autograd import autograd_cache
+from ._aot_autograd.autograd_cache import (
+    AOTAutogradCache,
+    should_use_local_autograd_cache,
+    should_use_remote_autograd_cache,
+)
+from ._aot_autograd.collect_metadata_analysis import (
+    run_functionalized_fw_and_collect_metadata,
+)
+from ._aot_autograd.descriptors import (
+    AOTInput,
+    BufferAOTInput,
+    DifferentiableAOTInput,
+    ParamAOTInput,
+    PlainAOTInput,
+)
+from ._aot_autograd.frontend_utils import (
+    _detect_attribute_assignment,
+    _try_get_metadata_from_dynamo,
+    construct_fake_mode,
+    process_inputs,
+)
+from ._aot_autograd.functional_utils import (  # noqa: F401
+    _check_if_mutation_can_be_in_graph,
+    are_all_mutations_hidden_from_autograd,
+    are_all_mutations_under_no_grad_or_inference_mode,
+    assert_functional_graph,
+    from_fun,
+    gen_alias_from_base,
+    has_data_mutation,
+    has_metadata_mutation,
+    is_fun,
+    sync_functional_tensor,
+    to_fun,
+)
+from ._aot_autograd.graph_capture_wrappers import (  # noqa: F401
+    aot_dispatch_subclass,
+    create_functional_call,
+    create_functionalized_fn,
+    create_functionalized_rng_ops_wrapper,
+    create_joint,
+    fn_input_mutations_to_outputs,
+    fn_prepped_for_autograd,
+)
+from ._aot_autograd.graph_compile import (
+    aot_stage1_graph_capture,
+    aot_stage2_compile,
+    aot_stage2_export,
+)
+from ._aot_autograd.input_output_analysis import (  # noqa: F401
+    compute_overlapping_inputs,
+    create_graph_signature,
+    create_synthetic_base_metadata,
+    remove_dupe_metadata,
+)
+from ._aot_autograd.logging_utils import (  # noqa: F401
+    callback_set,
+    describe_input,
+    format_guard_bug_msg,
+    get_aot_compilation_context,
+    get_aot_graph_name,
+    get_graph_being_compiled,
+    graph_being_compiled,
+    model_name,
+    nth_graph,
+    set_model_name,
+    setup_stacktrace_preservation_hooks,
+    track_graph_compiling,
+)
+from ._aot_autograd.runtime_wrappers import (  # noqa: F401
+    AOTDedupeWrapper,
+    AOTSyntheticBaseWrapper,
+    SerializableCompiledFunction,
+)
+from ._aot_autograd.schemas import (  # noqa: F401
+    ActInputPath,
+    AOTConfig,
+    AOTDispatchCompiler,
+    AOTGraphCapture,
+    AOTState,
+    BackwardSignature,
+    FakifiedFlatArgs,
+    FQN,
+    GraphInputName,
+    GraphOutputName,
+    GraphSignature,
+    InputAliasInfo,
+    JointWithDescriptors,
+    MutationType,
+    OpaqueMeta,
+    OutputAliasInfo,
+    OutputType,
+    SerializableAOTDispatchCompiler,
+    SubclassCreationMeta,
+    SubclassMeta,
+    TensorAlias,
+    ViewAndMutationMeta,
+)
+from ._aot_autograd.subclass_utils import (  # noqa: F401
+    requires_subclass_dispatch,
+    unwrap_tensor_subclasses,
+    unwrap_tensor_subclasses_with_indices_to_original,
+    wrap_tensor_subclasses,
+    wrap_tensor_subclasses_maybe_joint,
+)
+from ._aot_autograd.to_standalone_python import (  # noqa: F401
+    compile_to_python,
+    load_from_python,
+)
+from ._aot_autograd.utils import (  # noqa: F401
+    _get_autocast_states,
+    call_func_at_runtime_with_args,
+    create_tree_flattened_fn,
+    KNOWN_TYPES,
+    make_boxed_compiler,
+    make_boxed_func,
+    maybe_to_fresh_input,
+    normalize_as_list,
+    partial_flatten_asdict,
+    PytreeThunk,
+    root_module_when_exporting_non_strict,
+    simple_wraps,
+    strict_zip,
+)
+from .partitioners import default_partition
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Sequence
+
+    from torch._inductor.compile_fx import CompilerConfigExtra
+    from torch._inductor.output_code import OutputCode
+    from torch._inductor.utils import InputType
+    from torch._ops import OpOverload
+    from torch.fx.experimental.symbolic_shapes import ShapeEnv
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+zip = strict_zip
+
+# This global counter increments every time we compile a graph with
+# AOTAutograd.  You can use this to correlate runtime error messages
+# with compile time (e.g., if you get an error at runtime saying
+# compiled graph 3 failed, you can set a breakpoint at compile time
+# for this graph number to investigate further at compile time.)
+#
+# NB: this is different from get_aot_compilation_context, which tracks
+# each underlying graph that is compiled.  In contrast, AOT_COUNTER
+# corresponds to top-level invocations of aot_module/aot_function;
+# one counter is allocated per entire compiled block (but this block
+# may involve compiling multiple subgraphs; e.g., for forwards/backwards)
+AOT_COUNTER = itertools.count()
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+# AOT Autograd contains a pretty non-trivial amount of logic to handle edge cases around aliasing and mutation
+# that are external to the graph (they show up as side effects in some way when you run the graph).
+#
+# Take a look at `test_aotdispatch.py TestAOTAutograd.test_input_mutation*` tests for some examples functions
+# and what they're compiled graphs looks like.
+# Below is a very long comment detailing several edge cases, and showing how AOT Autograd handles them.
+#
+# Note [AOT Autograd: input data mutations]
+#
+# If we compile a function that mutates inputs, then those input mutations are real side effects
+# that a user expects to see after running the compiled graph.
+# However, the graph that we want to send to a backend needs to be *entirely* functional.
+# The way we reconcile this difference is that we remove the mutations completely from the graph that we compile
+# but we update the graph to return (updated_inputs, user_outputs).
+# In the epilogue that runs after the compiled graph is executed, we copy the updated inputs back to the originals.
+#
+# Example: original user code:
+# def f(x):
+#     x.mul_(2)
+#     out = x.mul(3)
+#     return out
+#
+# After AOT Autograd compiles, we end up with a:
+# (a) compiled graph
+# (b) autograd.Function.forward() method, that executes the compiled graph
+# (c) wrapper function, that calls the autograd.Function.forward() and performs the epilogue
+#
+# The output of (a, b, c) are all written below.
+#
+# def compiled_forward_graph(x):
+#     x_updated = x.mul(2)
+#     out = x_updated.mul(3)
+#     return x_updated, out
+#
+# # x_updated gets a gradient in the compiled backward
+# def compiled_backward_graph(grad_x_updated, grad_out):
+#     grad_x = ...
+#     return grad_x
+#
+# def autograd.Function.forward(x):
+#     x_updated, out = compiled_forward_graph(x)
+#     return x_updated, out
+#
+# def compiled_wrapper(x):
+#     x_updated, out = autograd.Function.apply(x)
+#     x.copy_(x_updated)
+#     return out
+#
+# Another important thing to note is that updated inputs (due to data mutations) *do* participate
+# in the compiled backward graph! Since the compiled forward graph gets N extra outputs
+# (due to updated inputs showing up as graph outputs),
+# The compiled backward gets an additional N inputs.
+# That way, during the x.copy_(x_updated) bit in the epilogue, gradients will flow from the updated input
+# back to the original input.
+
+
+# Note [AOT Autograd: input metadata mutations]
+#
+# For the same reason as input mutations, we also don't put input metadata mutations in the graph.
+# Instead, we return the updated version of the input (a view), and mutate the input's metadata outside of the graph
+#
+# Example: original user code:
+# def f(x):
+#     x.t_()
+#     out = x.mul(3)
+#     return out
+#
+# AOT Autograd output (compiled graph, autograd.Function.forward(), wrapper function):
+# def compiled_forward_graph(x):
+#     x_updated = x.t()
+#     out = x_updated.mul(3)
+#     return x_updated, out
+#
+# # x_updated does *not* get a gradient in the compiled backward
+# def compiled_backward_graph(grad_out):
+#     grad_x = ...
+#     return grad_x
+#
+# def autograd.Function.forward(x):
+#     x_updated, out = compiled_forward_graph(x)
+#     return x_updated, out
+#
+# def compiled_wrapper(x):
+#     x_updated, out = autograd.Function.apply(x)
+#     x.as_strided_(x_updated)
+#     return out
+
+
+# Note [AOT Autograd: outputs aliasing inputs or intermediates!]
+#
+# AOT Autograd needs special handling for outputs that alias graph inputs or intermediates!
+# Why?
+# (1) autograd.Function.forward() has a limitation, where views that returned in the forward cannot later be mutated.
+# (2) views don't need to be compiled in the graph anyway - it's cheap to generate them outside of the compiled graph,
+#     in an epilogue.
+# For outputs that alias inputs, we do the following:
+# (a) *still* return the aliased output as a graph output
+# (b) In the AOT Autograd wrapper/epilogue, we don't return that aliased output. Instead, we use it to regenerate the output.
+#
+# For outputs that alias *intermediates*, we do the following:
+# (a) Return the output in the compiled forward, **and** return it's ._base (a graph intermediates) as an output in the forward
+# (b) Use (output, graph_intermediate) to regenerate the alias, and return that to the user (instead of the compiled fw output).
+# You might wonder why we return the aliased output directly in the graph (and making the graph compute it),
+# only to not return it and instead generate a fresh alias off of the intermediate,
+# instead of (say) just storing metadata about the size/stride of the output somewhere to generate the alias. There are two reasons:
+# (1) Getting the actual alias tensor allows us to use view-replay to generate the alias, instead of an as_strided() call
+# (2) Inductor (and other backends) are free to change the memory format of graph outputs, if it results in better performance.
+#     This can result in problems if a user later tries to .view() that output expecting it to have one set of strides,
+#     when it has a different set of strides.
+#     By including the view op directly in the graph, inductor takes that into account when deciding what memory format
+#     the graph intermediate should be.
+#
+# Another important thing to note is how our traced backward() graph handles aliases.
+# (this applies to outputs aliasing inputs, outputs aliasing intermediates,
+#  *and* updated inputs returned in the compiled forward due to metadata-only mutations).
+# Any outputs that alias (either inputs or intermediates) do NOT participate in the compiled backward graph
+# It would be wasteful to include them in the compiled backward(), because we regenerate them eagerly
+# at the end of the forward.
+#
+# Example: original user code:
+# def f(x):
+#     out1 = x.t()
+#     intermediate = x.mul(2)
+#     out2 = intermediate.view(-1)
+#     return out1, out2
+#
+# AOT Autograd output (compiled graph, autograd.Function.forward(), wrapper function):
+# def compiled_forward_graph(x):
+#     out1 = x.t()
+#     intermediate = x.mul(2)
+#     out2 = intermediate.view(-1)
+#     # the compiled graph also returns the intermediate
+#     return out1, out2, intermediate
+#
+# # intermediate gets a gradient in the compiled backward.
+# # both output aliases (out1 and out2) do not.
+# def compiled_backward_graph(grad_intermediate):
+#     grad_x = ...
+#     return grad_x
+#
+# def autograd.Function.forward(x):
+#     out1, out2, intermediate = compiled_forward_graph(x)
+#     return out1, out2, intermediate
+#
+# def compiled_wrapper(x):
+#     out1, out2, intermediate = autograd.Function.apply(x)
+#     # regenerate out1 from the input
+#     out1_regenerated = out1._view_func(x)
+#     # regenerate out1 from the intermediate
+#     out2_regenerated = out2._view_func(intermediate)
+#     return out1_regenerated, out2_regenerated
+
+
+# Note [AOT Autograd: mutations to inputs that alias other inputs]
+#
+# Another edge case that is (only partially) handled today is when an input is mutated, but itself aliases another input.
+# AOT Autograd needs to **ensure** that functionalization knows that the two inputs are aliased to each other.
+# That way, when the aliased input is accessed later in the graph, functionalization knows to "update" the alias
+# given the mutation that occurred.
+#
+# This is handled by updating the calling convention: we create a "synthetic base" that becomes a new input
+# in the compiled function, and we regenerate the original (aliased) inputs directly off of the base
+# inside of the compiled function.
+#
+# This logic is fully encapsulated in aot_wrapper_synthetic_base()
+#
+# Example: original user code:
+# def f(x, x_view):
+#     x.mul_(2)
+#     out = x * x_view
+#     return out
+# f(x, x.view(-1))
+#
+# AOT Autograd output (compiled graph, autograd.Function.forward(), wrapper function):
+# def compiled_forward_graph(base)
+#     x = generate_x(base)
+#     x_view = generate_x_view(base)
+#     x_updated = x.mul(2)
+#     x_view_updated = x_updated.view(-1)
+#     out = x_updated * x_view_updated
+#     return x_updated, out
+#
+# # The calling convention change from (aliases) -> (base) happens
+# # *outside* of the autograd.Function.forward().
+# # That means the forward() only has 1 input (base),
+# # and the backward() only has 1 output (grad_base)
+# def compiled_backward_graph(grad_out):
+#     grad_base = ...
+#     return grad_base
+#
+# def autograd.Function.forward(base):
+#     x_updated, out = compiled_forward_graph(base)
+#     return x_updated, out
+#
+# # The compiled wrapper is where we create synthetic bases.
+# # The info on which inputs are mutated is also tracked *before* synthetic base creation.
+# def compiled_wrapper(x, x_view):
+#     base = merge_view_inputs(x, x_view)
+#     x_updated, out = autograd.Function.apply(base)
+#     # x and x_view are aliased in eager mode, so this mutation to x will automatically affect x_view.
+#     x.copy_(x_updated)
+#     return out
+
+
+# Note [AOT Autograd: Views to avoid tangents aliasing inputs]
+#
+# We view every forward output when creating out tangent tensors to handle the problematic
+# case in which a subclass does extra aliasing between graph outputs/inputs in a way that
+# is not visible above the subclass.
+#
+# Ordinarily, when constructing the joint function that we want to trace in AOTAutograd,
+# we're guaranteed that the tangent tensors that we pass
+# into the joint are distinct tensors from the primals. This is because when
+# decide which forward outputs to create tangents for, we only create tangents
+# for forward outputs that are not aliases of inputs (See Note
+# [AOT Autograd: outputs aliasing inputs or intermediates!]).
+#
+# However, when wrapper tensor subclasses enter the picture, it is possible
+# to have an output of the forward that is a subclass that is not an
+# input / alias of an input, but one of its inner tensors is an alias!
+# NestedTensor is an example: Performing an out-of-place pointwise op on a
+# NestedTensor constructs a fresh NestedTensor that holds onto the input's
+# offsets tensor directly.
+#
+# Having tangent tensors that are the same as the (primal) forward inputs,
+# can cause problems during tracing as make_fx() will specialize on our
+# duplicate inputs: If we passed in the same tensor for primals_1 and
+# tangents_1 during tracing, make_fx() will happily sub out all usages of
+# tangents_1 with primals_1 in the graph, which is not what we want.
+#
+# To work around this, we view every forward output when creating out tangent
+# tensors so that tangents can never be the same as forward inputs even if
+# forward inputs alias forward outputs.
+
+# Note [Side-Effectful Tokens in AOTAutograd]
+#
+# We allow some side-effectful operators in
+# the post-AOTAutograd (functional) graph, such as prints and torchbind operations.
+# To ensure that these side-effects are compatible to future graph passes that
+# assume that the graph is functional, we will thread "effect tokens" to show
+# data dependence between these side-effectful operators. Practically speaking,
+# effect tokens are just dummy values (torch.tensor([])). The graph would look
+# like the following:
+#
+# def gm(self, token0, reader):
+#    token1, frame = with_token(ordered_effect_op, (reader,), token0)
+#    frame = frame * 2
+#    token2, frame2 = with_token(ordered_effect_op, (reader,), token1)
+#    frame2 = frame2 * 2
+#    return token2, frame, frame2
+#
+# We will pass the token as an input to the graph, thread it through
+# side-effectful operators using the `with_effects` high order operator, and then
+# return the updated token as an output.
+# So the signature of the graph input would look something like
+# (*tokens, *params_buffers, *user_inputs), and the signature of the graph
+# output would look something like (*tokens, *outputs).
+#
+# However, Inductor does not want the concept of tokens in the final generated
+# code's input and output. Since changing the graph signature inside of inductor
+# is difficult, after generating the forward graph, we will run a pass to
+# remove the tokens from the input and generate the following graph for Inductor, where
+# the tokens are created and sunk within the graph, rather than as inputs and
+# outputs:
+#
+# def gm(self, reader):
+#    token0 = torch.ops.prims._make_token()
+#    token1, frame = with_token(ordered_effect_op, (reader,), token0)
+#    frame = frame * 2
+#    token2, frame2 = with_token(ordered_effect_op, (reader,), token1)
+#    frame2 = frame2 * 2
+#    sink_token = torch.ops.prims._sink_tokens([token2])
+#    return frame, frame2
+
+#
+#
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+aot_autograd_decompositions: dict[OpOverload, Callable[..., Any]] = {}
+
+
+def create_aot_state(
+    stack: contextlib.ExitStack,
+    flat_fn: Callable[_P, _R],
+    fake_flat_args: FakifiedFlatArgs,
+    flat_args_descs: list[AOTInput],
+    aot_config: AOTConfig,
+    fake_mode: FakeTensorMode,
+    shape_env: ShapeEnv | None,
+) -> AOTState:
+    """
+    Traces the forward and backward graphs of the attr:`flat_fn` to generate a
+    joint graph. The joint graph is an Fx graph with Aten ops. Please refer to
+    the tracing mechanism to understand the graph capturing details.
+
+    The joint graph is then passed through attr:`partition_fn` to isolate the
+    forward and backward portions, which are then respectively compiled via the
+    provided attr:`fw_compiler` and attr:`bw_compiler`.
+
+    The resulting compiled forward and backward graphs are then wrapped up in a
+    ``torch.autograd.Function`` object.
+
+    The calling convention here is that the first aot_config.num_params_buffers
+    inputs in flat_args are parameters and buffers, and the rest are inputs.
+
+    We use this to assume that parameters/buffer's shapes don't change.
+    """
+
+    # Old name for now to avoid messing with stats.  Also, note this is pushed
+    # on the stack, so it extends BEYOND this function
+    stack.enter_context(
+        dynamo_timed("create_aot_dispatcher_function", log_pt2_compile_event=True)
+    )
+
+    # This is the main entry point.
+    # TODO: Chillee argues that dynamo itself should pass in fake tensors to
+    # the list of arguments when compiling; at the moment we do not do this
+
+    decompositions = aot_config.decompositions or {}
+    decompositions = {
+        **aot_autograd_decompositions,
+        **decompositions,
+    }
+
+    if config.functionalize_rng_ops:
+        # Update the decompositions with functionalized random decompositions
+        decompositions = {
+            **rng_decompositions,
+            **decompositions,
+        }
+
+    aot_config = dataclasses.replace(
+        aot_config,
+        decompositions=cast("dict[OpOverload, Callable[..., Any]]", decompositions),
+    )
+
+    # Check flat_args to see if they're already fake.  If so, use that fake
+    # mode instead.
+
+    python_dispatcher_mode = (
+        enable_python_dispatcher() if shape_env is not None else nullcontext()
+    )
+
+    # See NOTE: [Deferring tensor pack/unpack hooks until runtime]
+    # If any saved tensor hooks are active, we **don't** want to trace them.
+    # Instead, we'll let them run at runtime, around the custom autograd.Function
+    # that we generate in torch.compile.
+    stack.enter_context(torch.autograd.set_multithreading_enabled(False))
+    stack.enter_context(preserve_rng_state())
+    stack.enter_context(fake_mode)
+    stack.enter_context(python_dispatcher_mode)
+    stack.enter_context(PhiloxStateTracker())
+    stack.enter_context(
+        torch._dynamo.utils._disable_saved_tensors_hooks_during_tracing()
+    )
+
+    from torch._library.fake_class_registry import FakeScriptObject, maybe_to_fake_obj
+    from torch._library.opaque_object import is_custom_class
+
+    # Tracing may mutate the states the fake script object,
+    # so we need to duplicate the fake script objects so that subsequent tracing
+    # won't be affected.
+    def _dup_fake_script_obj(fake_flat_args: FakifiedFlatArgs) -> list[Any]:
+        return [
+            maybe_to_fake_obj(detect_fake_mode(fake_flat_args), arg.real_obj)
+            if isinstance(arg, FakeScriptObject) or is_custom_class(type(arg))
+            else arg
+            for arg in fake_flat_args
+        ]
+
+    needs_autograd = any(
+        x.requires_grad for x in fake_flat_args if isinstance(x, Tensor)
+    )
+
+    with enable_python_dispatcher():
+        # Patch set_rng_state as set_rng_state with fake tensors is
+        # nonsensical. This does not affect the collection of metadata.
+        with patch("torch.cuda.set_rng_state", lambda *args: None):
+            mod = root_module_when_exporting_non_strict(flat_fn)
+            if mod is not None:
+                ctx = _detect_attribute_assignment(mod)
+            else:
+                ctx = nullcontext()
+
+            if torch._functorch.config.fake_tensor_propagate_real_tensors:
+                # Running dynamo_timed causes fake tensor issues when
+                # propagate real tensor is switched on.
+                dynamo_timed_ctx = nullcontext()
+            else:
+                dynamo_timed_ctx = dynamo_timed(
+                    "aot_collect_metadata", log_pt2_compile_event=True
+                )
+
+            with (
+                dynamo_timed_ctx,
+                ctx,
+                torch._dynamo.eval_frame._use_eager_on_nested_compile(),
+            ):
+                fw_metadata = run_functionalized_fw_and_collect_metadata(
+                    flat_fn,
+                    flat_args_descs=flat_args_descs,
+                    static_input_indices=aot_config.static_input_indices,
+                    keep_input_mutations=aot_config.keep_inference_input_mutations,
+                    pre_dispatch=aot_config.pre_dispatch,
+                )(*_dup_fake_script_obj(fake_flat_args))
+
+            req_subclass_dispatch = requires_subclass_dispatch(
+                fake_flat_args, fw_metadata
+            )
+            CompileEventLogger.try_add_pt2_compile(
+                "backend_compile", requires_subclass_dispatch=req_subclass_dispatch
+            )
+
+            output_and_mutation_safe = not any(
+                x.requires_grad
+                # view-type operations preserve requires_grad even in no_grad.
+                # Do not count aliases of inputs with requires_grad as reason to make a training graph,
+                # as AOTAutograd will perform view-replay to regenerate the view outputs at runtime,
+                # setting their grad_fn properly.
+                and not (
+                    x.output_type in (OutputType.alias_of_input, OutputType.is_input)
+                    and x.base_idx is not None
+                    and fw_metadata.input_info[x.base_idx].requires_grad
+                )
+                for x in fw_metadata.output_info
+            ) and not any(
+                x.requires_grad
+                and x.mutates_data
+                and not x.mutations_under_no_grad_or_inference_mode
+                and not x.mutations_hidden_from_autograd
+                for x in fw_metadata.input_info
+            )
+
+            if needs_autograd and output_and_mutation_safe:
+                # We realized that none of the outputs require grad,
+                # and none of the inputs that require grad are mutated.
+                # so we actually have an inference graph.
+                needs_autograd = False
+
+    if fw_metadata.num_intermediate_bases > 0:
+        if req_subclass_dispatch:
+            raise AssertionError(f"""\
+torch.compile is currently being used with tensor subclass inputs.
+We are attempting to a compile a graph with two graph outputs
+that alias one another, specifically output indices:
+
+    {[i for i, x in enumerate(fw_metadata.output_info) if x.output_type == OutputType.alias_of_intermediate]}
+
+ANY output aliasing (even for regular tensors) is currently unsupported if
+there are any subclass outputs. If you run into this, please file a github
+issue""")
+
+    if aot_config.is_export:
+        # aot_export: ban input metadata mutations for now to keep shared code paths simpler.
+        # Keeping .resize_() in the graph will require some work
+        # Allowing it but keeping the graph functional will require some calling convention changes.
+        if len([x for x in fw_metadata.input_info if x.mutates_metadata]) != 0:
+            raise RuntimeError(
+                f"""\
+Found an input that received a metadata mutation, through e.g. a call to `.resize_()` or `.transpose_()`.
+This is currently banned in the aot_export workflow. If you need this functionality, please file a github issue.
+
+fw_metadata={str(fw_metadata)}"""
+            )
+        # In export, banning data mutations on inputs that require grad for now.
+        # This should be rare, and is tricky to get right. When we trace the backward,
+        # we currently trace with autograd.grad instead of .backward(), which makes it difficult
+        # to ensure that we run autograd all the way through the input **before** it saw the mutation.
+        if (
+            len(
+                [
+                    x
+                    for x in fw_metadata.input_info
+                    if x.requires_grad and x.mutates_data
+                ]
+            )
+            != 0
+            and aot_config.export_trace_joint
+        ):
+            raise RuntimeError(
+                f"""\
+Found a graph input that requires gradients, and received a mutation.
+This is currently banned in the aot_export workflow. If you need this functionality, please file a github issue.
+
+fw_metadata={str(fw_metadata)}"""
+            )
+        if req_subclass_dispatch:
+            raise RuntimeError(
+                """\
+aot_export is not currently supported with traceable tensor subclass.
+If you need this feature, please comment on <CREATE_ISSUE_LINK>"""
+            )
+
+        # Need to decide on a strategy for functionalized RNG: toggling via global config seems bad,
+        # and turning it on will require a non-trivial calling convention change for any export runtime.
+        if config.functionalize_rng_ops:
+            raise RuntimeError(
+                """\
+Functionalized RNG is not currently supported in the aot_export workflow. Please file a github issue,
+or otherwise set torch._functorch.config.functionalize_rng_ops = False."""
+            )
+
+    return AOTState(
+        needs_autograd=needs_autograd,
+        flat_args=_dup_fake_script_obj(fake_flat_args),
+        flat_args_descs=flat_args_descs,
+        fw_metadata=fw_metadata,
+        # Packaging this just for later use
+        aot_config=aot_config,
+        stack=stack,
+        fake_mode=fake_mode,
+    )
+
+
+def aot_function(
+    fn: Callable[_P, _R],
+    fw_compiler: AOTDispatchCompiler,
+    bw_compiler: AOTDispatchCompiler | None = None,
+    partition_fn: Callable[..., Any] = default_partition,
+    decompositions: dict[OpOverload, Callable[..., Any]] | None = None,
+    num_params_buffers: int = 0,
+    keep_inference_input_mutations: bool = False,
+    inference_compiler: AOTDispatchCompiler | None = None,
+    *,
+    # Whether or not to trace with dynamic shapes
+    dynamic: bool = False,
+    enable_log: bool = True,
+    disable_functionalization: bool = False,
+    _disable_torch_fn_metadata_mode: bool = False,
+) -> Callable[_P, Any]:
+    """
+    Traces the forward and backward graph of :attr:`fn` using torch dispatch
+    mechanism, and then compiles the generated forward and backward graphs
+    through :attr:`fw_compiler` and :attr:`bw_compiler`.
+
+    :func:`aot_function` traces the forward and backward graph ahead of time,
+    and generates a joint forward and backward graph.  :attr:`partition_fn` is
+    then used to separate out forward and backward graphs. The partitioner
+    function can be used to perform optimizations such as recomputation. One can
+    set `decompositions` dictionary to decompose the operators into a sequence
+    of core or simpler operators supported by the backend compilers.
+
+    .. warning::
+        This API is experimental and likely to change.
+
+    Args:
+        fn (Callable): A Python function that takes one or more arguments. Must
+            return one or more Tensors.
+        fw_compiler (Callable): A Python function that accepts an Fx graph with
+            Aten ops and input args, and returns a Callable that semantically is
+            equivalent to the input Fx graph.
+        bw_compiler (Optional[Callable]): A Python function that accepts an
+            Fx graph with Aten ops and input args, and returns a Callable that
+            semantically is equivalent to the input Fx graph.  Default: None
+            (when None, it defaults to the :attr:`fw_compiler`)
+        partition_fn (Callable): A Python function that takes a joint forward
+            and backward graph, and partitions it into separate forward and
+            backward graphs.
+        decompositions (Dict): A dictionary to define the decomposition of
+            larger Aten ops into simpler or core Aten ops.
+        inference_compiler (Optional[Callable]): A Python function that accepts an
+            Fx graph with Aten ops and input args, and returns a Callable that
+            semantically is equivalent to the input Fx graph. inference_compiler is invoked
+            if no autograd is needed. Default: None
+            (when None, it defaults to the :attr:`fw_compiler`)
+    Returns:
+        Returns a ``Callable`` that retains the eager behavior of the original
+        :attr:`fn`, but with forward and backward graph compiled via
+        :attr:`fw_compile` and :attr:`bw_compile`.
+
+    A simple example usage of :func:`aot_function` is as follows. This example
+    will print the forward and backward graphs of the function ``fn``
+
+        >>> fn = lambda x: x.sin().cos()
+        >>> def print_compile_fn(fx_module, args):
+        >>>     print(fx_module)
+        >>>     return fx_module
+        >>> aot_fn = aot_function(fn, print_compile_fn)
+        >>> x = torch.randn(4, 5, requires_grad=True)
+        >>> aot_fn(x)
+    """
+
+    aot_config = AOTConfig(
+        fw_compiler=None,
+        bw_compiler=None,
+        inference_compiler=None,
+        partition_fn=None,
+        decompositions=decompositions,
+        num_params_buffers=num_params_buffers,
+        aot_id=next(AOT_COUNTER),
+        keep_inference_input_mutations=keep_inference_input_mutations,
+        dynamic_shapes=dynamic,
+        aot_autograd_arg_pos_to_source=None,
+        is_export=False,
+        no_tangents=False,
+        enable_log=enable_log,
+        disable_functionalization=disable_functionalization,
+        _disable_torch_fn_metadata_mode=_disable_torch_fn_metadata_mode,
+    )
+    cached_res = None
+
+    @wraps(fn)
+    def returned_function(*args: _P.args, **kwargs: _P.kwargs) -> Any:
+        nonlocal cached_res
+        # Now flatten the tensor args
+        flat_args = pytree.arg_tree_leaves(*args, **kwargs)
+
+        # Compile the function and save it in the cache
+        if cached_res is None:
+            flat_fn, out_spec = create_tree_flattened_fn(fn, args, kwargs)
+            (fake_mode, shape_env) = construct_fake_mode(flat_args, aot_config)
+            fake_flat_args: FakifiedFlatArgs
+            fake_flat_args, act_input_paths = process_inputs(
+                flat_args, aot_config, fake_mode, shape_env
+            )
+            # TODO: We actually could use the pytree path to make better descs.
+            # Also, the descs here are bad if you do aot_module.
+            fake_flat_args_descs: list[AOTInput] = [
+                PlainAOTInput(i) for i in range(len(fake_flat_args))
+            ]
+            with contextlib.ExitStack() as stack:
+                aot_state = create_aot_state(
+                    stack,
+                    flat_fn,
+                    fake_flat_args,
+                    fake_flat_args_descs,
+                    aot_config,
+                    fake_mode,
+                    shape_env,
+                )
+                aot_state.fw_metadata.act_input_paths = act_input_paths
+                aot_graph_capture = aot_stage1_graph_capture(aot_state, flat_fn)
+                compiled_fn, _ = aot_stage2_compile(
+                    aot_state,
+                    aot_graph_capture,
+                    partition_fn,
+                    fw_compiler,
+                    bw_compiler,
+                    inference_compiler,
+                )
+            cached_res = (compiled_fn, out_spec)
+
+        cached_fn, out_spec = cached_res
+        out = cached_fn(flat_args)
+        return out_spec.unflatten(out)
+
+    return returned_function
+
+
+def aot_module(mod: nn.Module, *args: Any, **kwargs: Any) -> nn.Module:
+    """
+    Traces the forward and backward graph of :attr:`mod` using torch dispatch
+    tracing mechanism. It is wrapper function, that underneath uses
+    :func:`aot_function` to perform tracing and compilation.
+
+    :func:`aot_module` lifts the parameters and buffers of ``nn.Module`` as inputs
+    to a new callable which is then compiled through :func:`aot_function`.
+
+    .. warning::
+        This API is experimental and likely to change.
+
+    Args:
+        mod (Callable): A ``nn.Module`` module.
+        args : args to be passed to :func:`aot_function`
+        kwargs : kwargs to be passed to :func:`aot_function`
+
+    Returns:
+        Returns a ``nn.Module`` that retains the eager behavior of the original
+        :attr:`mod`, but with forward and backward graph compiled.
+
+    """
+    # See Note: [Fake Modules and AOTAutograd]
+    torch._dynamo.utils.assert_no_fake_params_or_buffers(mod)
+
+    def functional_call(
+        named_params: dict[str, torch.nn.Parameter],
+        named_buffers: dict[str, torch.Tensor],
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        params_and_buffers = {**named_params, **named_buffers}
+        return torch.func.functional_call(mod, params_and_buffers, args, kwargs)
+
+    named_params = dict(mod.named_parameters(remove_duplicate=False))
+    named_buffers = dict(mod.named_buffers(remove_duplicate=False))
+    num_params_buffers = len(named_params) + len(named_buffers)
+    compiled_f = aot_function(
+        functional_call,
+        *args,
+        # pyrefly: ignore[bad-keyword-argument]
+        num_params_buffers=num_params_buffers,
+        **kwargs,
+    )
+
+    class AOTModule(nn.Module):
+        def __init__(self) -> None:
+            super().__init__()
+            self.orig_module = mod
+
+        def forward(self, *args: Any, **kwargs: Any) -> Any:
+            return compiled_f(
+                named_params,
+                named_buffers,
+                *args,
+                **kwargs,
+            )
+
+    return AOTModule()
+
+
+def autograd_cache_key(
+    graph,
+    example_inputs,
+    ignore_shape_env: bool,
+    decompositions,
+    compiler_config_extra: CompilerConfigExtra,
+    keep_inference_input_mutations: bool = False,
+    disable_functionalization: bool = False,
+):
+    (
+        _params_buffers_flat,
+        _params_spec,
+        _buffers_spec,
+        full_args,
+        _full_args_descs,
+        aot_config,
+    ) = prepare_aot_config(
+        graph,
+        example_inputs,
+        decompositions,
+        keep_inference_input_mutations,
+        ignore_shape_env,
+        force_non_lazy_backward_lowering=config.force_non_lazy_backward_lowering,
+        disable_functionalization=disable_functionalization,
+    )
+
+    fake_mode, shape_env = construct_fake_mode(full_args, aot_config)
+    fake_flat_args, act_input_paths = process_inputs(
+        full_args, aot_config, fake_mode, shape_env, ignore_shape_env
+    )
+
+    return autograd_cache.autograd_cache_key(
+        graph, fake_flat_args, aot_config, compiler_config_extra, act_input_paths
+    )
+
+
+def prepare_aot_config(
+    mod: nn.Module,
+    args: Iterable[Any],
+    decompositions: dict[OpOverload, Callable[..., Any]] | None,
+    keep_inference_input_mutations: bool,
+    ignore_shape_env: bool,
+    *,
+    force_non_lazy_backward_lowering: bool = False,
+    disable_functionalization: bool = False,
+    _disable_torch_fn_metadata_mode: bool = False,
+) -> tuple[
+    list[torch.nn.Parameter | Tensor],
+    list[str],
+    list[str],
+    list[Any],
+    list[Any],
+    AOTConfig,
+]:
+    # TODO: There's something a bit suspicious here; typically simplified
+    # module shouldn't actually have any parameters...
+    params = dict(mod.named_parameters(remove_duplicate=False))
+    buffers = dict(dict(mod.named_buffers(remove_duplicate=False)))
+
+    params_flat, params_spec = list(params.values()), list(params.keys())
+    params_len = len(params_flat)
+
+    buffers_flat, buffers_spec = list(buffers.values()), list(buffers.keys())
+    buffers_len = len(buffers_flat)
+
+    params_buffers = {**params, **buffers}
+    params_buffers_flat = params_flat + buffers_flat
+
+    full_args = [*params_flat, *buffers_flat, *args]
+
+    # OK, set up the descs
+
+    full_args_descs: list[DifferentiableAOTInput] = []
+    full_args_descs.extend(ParamAOTInput(fqn) for fqn in params_spec)
+    full_args_descs.extend(BufferAOTInput(fqn) for fqn in buffers_spec)
+
+    # TODO: These tracing_context fields should become unnecessary once we
+    # always maintain sources on all arguments
+    if tracing_context := torch._guards.TracingContext.try_get():
+        # NB: TracingContext misnames this, the "params" here also contains
+        # buffers
+        tracing_context.params_flat = params_buffers_flat
+        (
+            tracing_context.params_flat_unwrap_subclasses,
+            tracing_context.params_unwrapped_to_flat_index,
+        ) = unwrap_tensor_subclasses_with_indices_to_original(params_buffers_flat)
+
+    # TODO: Might be nice to hold on to the Dynamo source here in full_args_descs!
+    (
+        aot_autograd_arg_pos_to_source,
+        static_input_indices,
+    ) = _try_get_metadata_from_dynamo(
+        mod, params_buffers.keys(), len(full_args), full_args_descs
+    )
+
+    dynamic_shapes = False
+    for x in full_args:
+        fake_mode = maybe_get_fake_mode(x)
+        if fake_mode is not None:
+            dynamic_shapes = fake_mode.shape_env is not None
+            break
+
+    aot_config = AOTConfig(
+        fw_compiler=None,
+        bw_compiler=None,
+        inference_compiler=None,
+        partition_fn=None,
+        decompositions=decompositions,
+        num_params_buffers=params_len + buffers_len,
+        aot_id=next(AOT_COUNTER),
+        keep_inference_input_mutations=keep_inference_input_mutations,
+        dynamic_shapes=dynamic_shapes,
+        # pyrefly: ignore[bad-argument-type]
+        aot_autograd_arg_pos_to_source=aot_autograd_arg_pos_to_source,
+        static_input_indices=static_input_indices,
+        is_export=False,
+        no_tangents=False,
+        cache_info=None,
+        ignore_shape_env=ignore_shape_env,
+        precompile_backend_id=getattr(mod, "_backend_id", None),
+        force_non_lazy_backward_lowering=force_non_lazy_backward_lowering,
+        disable_functionalization=disable_functionalization,
+        _disable_torch_fn_metadata_mode=_disable_torch_fn_metadata_mode,
+    )
+
+    return (
+        params_buffers_flat,
+        params_spec,
+        buffers_spec,
+        full_args,
+        full_args_descs,
+        aot_config,
+    )
+
+
+def prepare_aot_module_simplified(
+    mod: nn.Module,
+    args: Iterable[Any],
+    kwargs: dict[str, Any] | None,
+    decompositions: dict[OpOverload, Callable[..., Any]] | None,
+    keep_inference_input_mutations: bool,
+    ignore_shape_env: bool,
+    flatten: bool,
+    *,
+    force_non_lazy_backward_lowering: bool = False,
+    disable_functionalization: bool = False,
+    _record_nn_module_stack: bool = False,
+    _disable_torch_fn_metadata_mode: bool = False,
+) -> tuple[
+    Any,
+    list[torch.nn.Parameter | Tensor],
+    list[str],
+    list[str],
+    FakifiedFlatArgs,
+    list[Any],
+    AOTConfig,
+    FakeTensorMode,
+    ShapeEnv | None,
+    pytree.TreeSpec | None,
+    PytreeThunk | None,
+    list[ActInputPath],
+]:
+    if not flatten:
+        if kwargs is not None:
+            raise AssertionError("kwargs must be None when flatten=False")
+    elif kwargs is None:
+        kwargs = {}
+
+    (
+        params_buffers_flat,
+        params_spec,
+        buffers_spec,
+        full_args,
+        full_args_descs,
+        aot_config,
+    ) = prepare_aot_config(
+        mod,
+        args,
+        decompositions,
+        keep_inference_input_mutations,
+        ignore_shape_env,
+        force_non_lazy_backward_lowering=force_non_lazy_backward_lowering,
+        disable_functionalization=disable_functionalization,
+        _disable_torch_fn_metadata_mode=_disable_torch_fn_metadata_mode,
+    )
+
+    params_buffers_spec = params_spec + buffers_spec
+
+    # NB: This doesn't change the in/out convention, except adding the
+    # parameters as explicit arguments
+    functional_call = create_functional_call(
+        mod,
+        params_buffers_spec,
+        aot_config.num_params_buffers,
+        strict_out_tuple=not flatten,
+        # We need this for export to run ModuleStackTracer
+        # instead of PythonKeyTracer
+        store_orig_mod=_record_nn_module_stack,
+    )
+
+    in_spec, out_spec = None, None
+    if flatten:
+        functional_call, out_spec = create_tree_flattened_fn(
+            functional_call, full_args, kwargs
+        )
+        full_args, in_spec = pytree.tree_flatten((full_args, kwargs))
+
+    # TODO: it would be better to put pytree information in here
+    full_args_descs.extend(
+        PlainAOTInput(i) for i in range(len(full_args) - len(full_args_descs))
+    )
+
+    fake_mode, shape_env = construct_fake_mode(full_args, aot_config)
+    # NB: full_args_descs not needed here, fake_flat_args is 1:1 with full_args
+    fake_flat_args, act_input_paths = process_inputs(
+        full_args, aot_config, fake_mode, shape_env, ignore_shape_env
+    )
+
+    return (
+        functional_call,
+        params_buffers_flat,
+        params_spec,
+        buffers_spec,
+        fake_flat_args,
+        full_args_descs,
+        aot_config,
+        fake_mode,
+        shape_env,
+        in_spec,
+        out_spec,
+        act_input_paths,
+    )
+
+
+def aot_module_simplified(
+    mod: torch.fx.GraphModule | torch._dynamo.utils.GmWrapper,
+    args: Sequence[Any],
+    fw_compiler: AOTDispatchCompiler,
+    bw_compiler: AOTDispatchCompiler | None = None,
+    partition_fn: Callable[..., Any] = default_partition,
+    decompositions: dict[OpOverload, Callable[..., Any]] | None = None,
+    keep_inference_input_mutations: bool = False,
+    inference_compiler: AOTDispatchCompiler | None = None,
+    # TODO: This doesn't seem to be used in any nontrivial way, check if it's
+    # actually needed
+    compiler_config_extra: CompilerConfigExtra | None = None,
+    ignore_shape_env: bool = False,
+    disable_functionalization: bool = False,
+    # Optional callback to run passes on the module at the start of AOT autograd.
+    pre_grad_passes: Callable[
+        [torch.fx.GraphModule, Sequence[InputType]], torch.fx.GraphModule
+    ]
+    | None = None,
+    compile_region_name: str | None = None,
+) -> Callable[..., Any]:
+    """
+    This is the simplified or low overhead version of aot_module. For frontends
+    like TorchDynamo, the input functions/modules to AOT are static and have
+    unpacked inputs/outputs. This gives us an opportunity to remove the
+        (1) pytree overhead to parse inputs/outputs,
+        (2) AOT Autograd cache,
+        (3) Reading of params/buffers in every forward call
+
+    :func:`aot_module_simplified` removes these overheads.
+    """
+
+    pre_grad_pass_timing: Literal["early", "late"] = resolve_pre_grad_pass_timing()
+
+    if (
+        pre_grad_pass_timing == "early"
+        and pre_grad_passes
+        and isinstance(mod, torch.fx.GraphModule)
+    ):
+        mod = pre_grad_passes(mod, args)
+
+    with contextlib.ExitStack() as stack:
+        (
+            functional_call,
+            params_buffers_flat,
+            _params_spec,
+            _buffers_spec,
+            fake_flat_args,
+            full_args_descs,
+            aot_config,
+            fake_mode,
+            shape_env,
+            _in_spec,
+            _out_spec,
+            act_input_paths,
+        ) = prepare_aot_module_simplified(
+            mod,
+            args,
+            None,
+            decompositions,
+            keep_inference_input_mutations,
+            ignore_shape_env,
+            flatten=False,
+            force_non_lazy_backward_lowering=config.force_non_lazy_backward_lowering,
+            disable_functionalization=disable_functionalization,
+        )
+
+        compiled_fn = None
+
+        if (
+            isinstance(fw_compiler, SerializableAOTDispatchCompiler)
+            or torch._functorch.config.force_autograd_cache
+        ):
+            local = should_use_local_autograd_cache()
+            remote = should_use_remote_autograd_cache()
+            if local or remote:
+                set_feature_use("aot_autograd_remote_cache", remote)
+                compiled_fn, aot_config = AOTAutogradCache.try_load(
+                    mod,
+                    fake_flat_args,
+                    aot_config,
+                    compiler_config_extra,
+                    local,
+                    remote,
+                    act_input_paths,
+                    compile_region_name=compile_region_name,
+                )
+
+        if compiled_fn is None:
+            if (
+                pre_grad_pass_timing == "late"
+                and pre_grad_passes
+                and isinstance(mod, torch.fx.GraphModule)
+            ):
+                mod = pre_grad_passes(mod, args)
+
+            stack.enter_context(compiled_autograd._disable())
+            aot_state = create_aot_state(
+                stack,
+                functional_call,
+                fake_flat_args,
+                full_args_descs,
+                aot_config,
+                fake_mode,
+                shape_env,
+            )
+            aot_state.fw_metadata.act_input_paths = act_input_paths
+            aot_graph_capture = aot_stage1_graph_capture(aot_state, functional_call)
+            compiled_fn, _ = aot_stage2_compile(
+                aot_state,
+                aot_graph_capture,
+                partition_fn,
+                fw_compiler,
+                bw_compiler,
+                inference_compiler,
+            )
+    if compiled_fn is None:
+        raise AssertionError("compiled_fn must not be None")
+    if isinstance(mod, torch._dynamo.utils.GmWrapper):
+        # This function is called by the flatten_graph_inputs wrapper, which boxes
+        # the inputs so that they can be freed before the end of this scope.
+        # For overhead reasons, this is not the default wrapper, see comment:
+        # https://github.com/pytorch/pytorch/pull/122535/files#r1560096481
+        @simple_wraps(compiled_fn)
+        def forward(runtime_args: list[Any]) -> Any:
+            flat_args = []
+            flat_args.extend(params_buffers_flat)
+            flat_args.extend(runtime_args)
+            runtime_args.clear()
+            if compiled_fn is None:
+                raise AssertionError("compiled_fn must not be None")
+            return compiled_fn(flat_args)
+
+    else:
+        # TODO: There is something deeply wrong here; compiled_fn running with
+        # the boxed calling convention, but aot_module_simplified somehow
+        # historically returned a function that was not the boxed calling
+        # convention.  This should get fixed...
+        # NB: GraphModule/nn.Module rely on the non-boxed calling convention here
+        @simple_wraps(compiled_fn)
+        def forward(*runtime_args: tuple[Any]) -> Any:
+            full_args = []
+            full_args.extend(params_buffers_flat)
+            # pyrefly: ignore[bad-argument-type]
+            full_args.extend(runtime_args)
+            if compiled_fn is None:
+                raise AssertionError("compiled_fn must not be None")
+            return compiled_fn(full_args)
+
+    # Just for convenience
+    forward.zero_grad = mod.zero_grad  # type: ignore[attr-defined]
+    forward.named_parameters = mod.named_parameters  # type: ignore[attr-defined]
+    forward.named_buffers = mod.named_buffers  # type: ignore[attr-defined]
+
+    # Add a serialize function
+    def grab_serialize_fn(fn: Any) -> Callable[..., Any] | None:
+        if isinstance(fn, SerializableCompiledFunction):
+            return fn.serialize_fn
+        elif hasattr(fn, "__wrapped__"):
+            return grab_serialize_fn(fn.__wrapped__)
+        else:
+            return None
+
+    forward.serialize = grab_serialize_fn(forward)  # type: ignore[attr-defined]
+    return forward
+
+
+def boxed_nop_preserve_node_meta(
+    gm: torch.fx.GraphModule, example_inputs: Sequence[InputType]
+) -> Any:
+    def run(args: list[Any]) -> OutputCode:
+        with torch.fx.traceback.preserve_node_meta():
+            return torch.fx.Interpreter(gm).boxed_run(args)
+
+    run._boxed_call = True  # type: ignore[attr-defined]
+    return run
+
+
+def aot_export_joint_with_descriptors(
+    stack: contextlib.ExitStack,
+    mod: nn.Module,
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any] | None = None,
+    *,
+    decompositions: dict[OpOverload, Callable[..., Any]] | None = None,
+    keep_inference_input_mutations: bool = False,
+    ignore_shape_env: bool = False,
+    disable_functionalization: bool = False,
+    _record_nn_module_stack: bool = False,
+    _disable_torch_fn_metadata_mode: bool = False,
+) -> JointWithDescriptors:
+    """
+    This API captures the joint graph for an nn.Module.  However, unlike
+    aot_export_joint_simple or aot_export_module(trace_joint=True), the
+    calling convention of the produced joint graph follows no fixed positional
+    schema; for example, you cannot rely on the second argument of the traced
+    joint graph to correspond to the second argument of the module you traced.
+    However, the inputs and outputs of the traced graph are schematized
+    with **descriptors**, annotated on meta['desc'] on the placeholder and
+    return FX nodes, which you can use to determine the meaning of arguments.
+
+    The major benefit of using this export rather than aot_export_joint_simple
+    is that we have feature parity with all situations that torch.compile
+    supports (via aot_module_simplified), including handling for more
+    complicated cases such as multiple differentiable outputs, input mutations
+    that must be handled outside of the graph, tensor subclasses, etc.
+
+    What can you do with one of these joint graphs with descriptors?  The
+    motivating use case (autoparallel) involves taking the joint graph, doing
+    optimizations on it, and then turning it back into a callable so it can be
+    torch.compile'd at a later point in time.  This cannot be done as a
+    traditional torch.compile joint graph pass for two reasons:
+
+        1. The sharding of parameters must be decided before parameter
+           initialization / checkpoint load, far before torch.compile would
+           ordinarily run.
+
+        2. We need to change the meaning of parameters (e.g., we might replace
+           a replicated parameter with a sharded version of it, changing its
+           input size).  torch.compile is ordinarily semantics preserving, and
+           not allowed to change the meaning of inputs.
+
+    Some descriptors can be quite exotic, so we recommend thinking carefully
+    if there is a safe fallback you can apply to descriptors you don't understand.
+    For example, you should have some way to handle not finding a particular
+    input exactly as is in the final FX graph inputs.
+
+    Note: When using this API, you must create and enter an ExitStack context
+    manager, which will be passed into this function.  This context manager
+    must remain active if you call the compile function to finish compilation.
+    (TODO: We may relax this requirement by having AOTAutograd keep track of
+    how to reconstruct all the context managers at a later point in time.)
+
+    NB: You're not obligated to do a /full/ compile in stage2; instead you can
+    leave the forward/backward compilers unspecified in which case the
+    partitioned FX graphs will directly run.  The overall autograd Function
+    can be allowed in graph so you can reprocess it in the context of a
+    (potentially larger) compiled region later.
+
+    NB: These APIs do NOT hit cache, as we only ever cache the final compile results,
+    not the intermediate export result.
+
+    NB: If the passed nn.Module has parameters and buffers on it, we will
+    generate extra implicit parameter/buffer arguments and assign ParamAOTInput
+    and BufferAOTInput descriptors to them.  However, if you generate the input
+    nn.Module from a mechanism like Dynamo, you will NOT get these descriptors
+    (because Dynamo will already have taken care of lifting the parameters/buffers
+    into arguments!)  In that case, it would be necessary to analyze the Sources
+    of the inputs to determine if inputs are parameters and their FQNs.
+    """
+
+    (
+        functional_call,
+        _params_buffers_flat,
+        params_spec,
+        buffers_spec,
+        fake_flat_args,
+        full_args_descs,
+        aot_config,
+        fake_mode,
+        shape_env,
+        in_spec,
+        out_spec,
+        act_input_paths,
+    ) = prepare_aot_module_simplified(
+        mod,
+        args,
+        kwargs,
+        # In contrast, decompositions are needed at this stage.
+        decompositions,
+        keep_inference_input_mutations,
+        ignore_shape_env,
+        flatten=True,
+        # Without this, we will attempt to "compile" the backward lazily
+        # at runtime, but this is pointless because it's just boxed_nop,
+        # it's trivial.  But this will get Inductor confused about scoping
+        # Metric(s) {'is_forward'} have already been set in the current
+        # context.
+        force_non_lazy_backward_lowering=True,
+        disable_functionalization=disable_functionalization,
+        _record_nn_module_stack=_record_nn_module_stack,
+        _disable_torch_fn_metadata_mode=_disable_torch_fn_metadata_mode,
+    )
+
+    # TODO: Maybe this should be in create_aot_state?  Not sure, that would
+    # increase its scope
+    stack.enter_context(compiled_autograd._disable())
+
+    aot_state = create_aot_state(
+        stack,
+        functional_call,
+        fake_flat_args,
+        full_args_descs,
+        aot_config,
+        fake_mode,
+        shape_env,
+    )
+    aot_state.fw_metadata.act_input_paths = act_input_paths
+
+    # NB: no cache lookup!
+    aot_graph_capture = aot_stage1_graph_capture(aot_state, functional_call)
+
+    if out_spec is None or out_spec.spec is None:
+        raise AssertionError("out_spec and out_spec.spec must not be None")
+    if in_spec is None:
+        raise AssertionError("in_spec must not be None")
+    return JointWithDescriptors(
+        _aot_state=aot_state,
+        _aot_graph_capture=aot_graph_capture,
+        params_spec=params_spec,
+        buffers_spec=buffers_spec,
+        in_spec=in_spec,
+        out_spec=out_spec.spec,
+    )
+
+
+def aot_compile_joint_with_descriptors(
+    jd: JointWithDescriptors,
+    *,
+    partition_fn: Callable[..., Any] = default_partition,
+    fw_compiler: AOTDispatchCompiler = boxed_nop_preserve_node_meta,
+    bw_compiler: AOTDispatchCompiler | None = boxed_nop_preserve_node_meta,
+    serializable: bool = False,
+) -> Callable[..., Any]:
+    """
+    Companion function for aot_export_joint_with_descriptors which compiles the joint
+    graph into a callable function that follows a standard calling convention.
+    params_flat all are arguments.
+
+    Note: We do NOT instantiate the module; this gives you the flexibility to subclass it and
+    customize its behavior without having to worry about FQN rebinding.
+
+    Args:
+        serializable: If True, configures the compilation to produce a serializable
+            callable by leveraging AOTAutogradCache machinery. This sets up the
+            necessary cache_info and patches config options required for serialization.
+            When True, this function will always return a BundledAOTAutogradSerializableCallable.
+    """
+    # TODO: Consider if we should allow_in_graph the result by default.
+    from torch._dynamo.aot_compile_types import (
+        BundledAOTAutogradSerializableCallable,
+        SerializableCallable,
+    )
+    from torch._functorch._aot_autograd.schemas import AOTAutogradCacheInfo
+    from torch._guards import detect_fake_mode
+    from torch._inductor.output_code import OutputCode
+
+    fw_compiler = SerializableAOTDispatchCompiler(OutputCode, fw_compiler)
+
+    cache_ctx = nullcontext()
+    if serializable:
+        jd._aot_state.aot_config = dataclasses.replace(
+            jd._aot_state.aot_config,
+            cache_info=AOTAutogradCacheInfo(
+                jd.cache_hash(),
+                time.time_ns(),
+                forward_symints=[],
+            ),
+        )
+        cache_ctx = torch._functorch.config.patch(
+            {
+                "strict_autograd_cache": True,
+                "bundled_autograd_cache": True,
+                "force_non_lazy_backward_lowering": True,
+                "bypass_autograd_cache_key": True,
+            }
+        )
+
+    # Set up a TracingContext if one isn't already available.
+    # This is needed for compilers (like regional_inductor) that call
+    # standalone_compile with dynamic_shapes="from_tracing_context".
+    tracing_context = torch._guards.TracingContext.try_get()
+    if tracing_context is None:
+        fake_mode = detect_fake_mode(jd._aot_state.flat_args)
+        if fake_mode is not None:
+            tracing_context = torch._guards.TracingContext(fake_mode)
+            tracing_ctx = torch._guards.tracing(tracing_context)
+        else:
+            tracing_ctx = nullcontext()
+    else:
+        tracing_ctx = nullcontext()
+
+    with cache_ctx, tracing_ctx:
+        compiled_fn, _ = aot_stage2_compile(
+            jd._aot_state,
+            jd._aot_graph_capture,
+            partition_fn,
+            fw_compiler,
+            bw_compiler,
+        )
+
+    if not isinstance(compiled_fn, SerializableCallable) and hasattr(
+        compiled_fn, "serialize"
+    ):
+        compiled_fn = BundledAOTAutogradSerializableCallable(compiled_fn)
+
+    # Cribbed from torch/export/pt2_archive/_package.py
+    @simple_wraps(compiled_fn)
+    @torch._dynamo.nonstrict_trace  # allow recursive compilation
+    def unflattened_compiled_fn(*args: Any, **kwargs: Any) -> Any:
+        flat_inputs = pytree.tree_flatten((args, reorder_kwargs(kwargs, jd.in_spec)))[0]
+        # TODO: do I need to filter? I hope not!
+        flat_outputs = compiled_fn(flat_inputs)
+        return pytree.tree_unflatten(flat_outputs, jd.out_spec)
+
+    return unflattened_compiled_fn
+
+
+def aot_export_module(
+    mod: nn.Module,
+    args: Iterable[Any],
+    *,
+    decompositions: dict[OpOverload, Callable[..., Any]] | None = None,
+    # If true, we'll return a joint forward-backward graph,
+    # As well as metadata on the loss + gradients in the backward.
+    trace_joint: bool,
+    # If trace_joint is True, we expect your module to return a scalar loss.
+    # Your module can return multiple outputs, so you must specify which output the loss is.
+    output_loss_index: int | None = None,
+    pre_dispatch: bool = False,
+    # If None, will be inferred from inputs and mod.graph.nodes if mod is a graph module, but the inferred result might be wrong.
+    dynamic_shapes: bool | None = None,
+    kwargs: dict[str, Any] | None = None,
+) -> tuple[Callable[..., Any] | torch.fx.GraphModule, GraphSignature]:
+    """
+    This function takes in a module, and returns:
+    (1) an FX graph that can be exported
+    (2) some metadata about the graph
+
+    If `trace_joint=True` we will return a joint graph of the forward + backward.
+
+    The traced FX graph will have the following properties compared to the original module:
+    (1) Inputs and outputs to the module will be pytree-flattened
+    (2) Parameters and buffers on the module will be lifted into graph inputs,
+        graph_inputs = (*parameters, *buffers, *user_inputs)
+    (3) The graph will be fully functionalized
+    (4) Any input mutations will be converted into additional outputs in the graph,
+        meaning whoever calls this graph is responsible for applying the mutations
+        back to the original inputs.
+    (5) If is_joint is provided the graph will return parameter gradients in addition to user outputs.
+        The graph output will look like:
+        graph_outputs = (*updated_inputs, *user_outputs, *param_gradients)
+
+    There are also several restrictions on what modules can use this API. In particular:
+    (1) If trace_joint is specified, we expect the loss function to be **fused**
+        into the module forward. One of the outputs to the forward must be a scalar loss,
+        which is specified with `output_loss_index`.
+        All other outputs to the forward are presumed to not require gradients.
+    (2) This API cannot capture optimizers (although in theory we could build an API for this).
+    (3) Metadata mutations on params/buffers/inputs are banned.
+    (4) Data mutations on anything that requires gradients are banned (parameters)
+    (5) If an input is mutated, it is not allowed to alias any other inputs.
+    (6) Parameters must not be duplicated.
+    """
+    if pre_dispatch and trace_joint:
+        raise RuntimeError("pre_dispatch is not supported when trace_joint is True.")
+    named_parameters = dict(mod.named_parameters(remove_duplicate=False))
+    named_buffers = dict(mod.named_buffers(remove_duplicate=False))
+
+    params_and_buffers = {
+        **dict(named_parameters),
+        **dict(named_buffers),
+    }
+    params_and_buffers_flat, params_spec = pytree.tree_flatten(params_and_buffers)
+    params_and_buffers_flat = tuple(params_and_buffers_flat)
+    params_len = len(params_and_buffers_flat)
+
+    kwargs = kwargs or {}
+
+    functional_call = create_functional_call(
+        mod, params_spec, params_len, store_orig_mod=True
+    )
+
+    num_fw_outs = None
+
+    if trace_joint:
+        # This helper effectively just adds some extra asserts about what the backward will look like:
+        # Outputs must include a scalar loss, that we compute gradients w.r.t.
+        # We don't compute gradients w.r.t. anything else: so just in case we detach()
+        # and other output tensors.
+        def fn_to_trace(*args: Any) -> Any:
+            nonlocal num_fw_outs
+            out = functional_call(*args)
+            if output_loss_index is None:
+                raise RuntimeError(
+                    """\
+If trace_joint=Trueit is required that one of your forward outputs must be a scalar loss.
+You must specify the which (index) output is the loss with output_loss_index."""
+                )
+            if isinstance(out, (torch.Tensor)):
+                out = (out,)
+            if not isinstance(out, (tuple, list)):
+                raise RuntimeError(
+                    f"Expected forward output to be either a tensor or a list/tuple of tensors. found {type(out)}"
+                )
+
+            for i, o in enumerate(out):
+                # We only want to create a backward graph w.r.t. the loss that the user passed in.
+                # This implies that every other output should not require gradients.
+                # Instead of making this an error (and forcing the user to detach all other outputs
+                # of their forward),
+                # we'll automatically detach them here.
+                if o.requires_grad and i != output_loss_index:
+                    raise RuntimeError(
+                        f"""\
+Found an output of the forward that requires gradients, that was not the scalar loss.
+We require all outputs to the forward that are not the scalar loss to not require gradient,
+because we will only compute a backward graph against the scalar loss.
+You can fix this by calling .detach() on each of your forward outputs that is not the loss.
+You specified that output index {output_loss_index} is the loss, but we found that
+the output at index {i} requires gradients."""
+                    )
+            out_loss = out[output_loss_index]
+            num_fw_outs = len(out)
+            if not out_loss.requires_grad:
+                raise RuntimeError(
+                    f"""\
+The output at index {output_loss_index} was marked as the loss, but it does not require gradients"""
+                )
+            if out_loss.numel() != 1:
+                raise RuntimeError(
+                    f"""\
+We require the output marked as the loss (at index {output_loss_index}) to be a scalar, but it has shape {out_loss.shape}"""
+                )
+            return out
+
+        ctx = nullcontext
+    else:
+        # Run under no_grad, so our tracing machinery only traces an inference graph.
+        # However if pre_dispatch=True, we want to correctly trace set_grad_enabled calls for training.
+        ctx = nullcontext if pre_dispatch else torch.no_grad
+        fn_to_trace = functional_call
+
+    full_args = []
+    # First, the params
+    # NB: It is REQUIRED that parameters come first, Inductor infers "fixed"
+    # parameters by looking at the difference in parameter count outside
+    # and inside AOTAutograd, and assumes the prefix of arguments are fixed
+    # arguments
+    full_args.extend(params_and_buffers_flat)
+    # Next, the input args
+    full_args.extend(args)
+
+    with ctx():
+        fx_g, metadata, in_spec, out_spec = _aot_export_function(
+            fn_to_trace,
+            tuple(full_args),
+            decompositions=decompositions,
+            num_params_buffers=params_len,
+            no_tangents=True,
+            pre_dispatch=pre_dispatch,
+            dynamic_shapes=dynamic_shapes,
+            trace_joint=trace_joint,
+            kwargs=kwargs,
+        )
+
+    # TODO: subsume this path with the aot_stage2_graph_capture path
+    if trace_joint:
+
+        @wraps(functional_call)
+        def flattened_joint(*args: Any) -> Any:
+            # The idea here is that the joint graph that AOTAutograd creates has some strict properties:
+            # (1) It accepts two arguments (primals, tangents), and pytree_flattens them
+            # (2) It returns a tuple of (fw_outs, gradients)
+            # This is a very useful convention for anyone who wants to partition the joint graph
+            # into a separate forward and backward graph.
+            # However,
+            # (1) for people exporting a single joint graph, it would be preferable not to have
+            #     any pytrees in the graph.
+            # (2) We are guaranteed in the aot_export_module case that the forward outputs a loss,
+            #     and there are therefore no tangents that are needed to run the joint graph.
+            # (3) AOTAutograd creates a grad_input for every input in the forward,
+            #     including None's for inputs that are not grad-requiring tensors.
+            #     we don't want these in our export graph.
+            #     and there are therefore no tangents that are needed to run the joint graph.
+            # This function "fixes" both of the above by removing any tangent inputs,
+            # and removing pytrees from the original FX graph.
+            fake_tangents = [
+                None
+                for _ in range(
+                    metadata.num_outputs + metadata.num_mutated_inp_runtime_indices
+                )
+            ]
+            fw_outs, gradients = fx_g(args, fake_tangents)
+            if len(gradients) != len(args):
+                raise AssertionError(
+                    f"len(gradients)={len(gradients)} != len(args)={len(args)}"
+                )
+            output_gradients = []
+            for a, grad in zip(args, gradients):
+                if isinstance(a, torch.Tensor) and a.requires_grad:
+                    if grad is None:
+                        raise AssertionError("""\
+Found a parameter that did not receive a gradient.
+"This is most likely a bug, but if this needs to be supported please comment on this Github issue:
+https://github.com/pytorch/pytorch/issues/101192
+""")
+                    output_gradients.append(grad)
+                else:
+                    if grad is not None:
+                        raise AssertionError(
+                            f"expected grad to be None for non-tensor or non-requires_grad input, got {type(grad)}"
+                        )
+            return *fw_outs, *output_gradients
+
+        fx_g = make_fx(flattened_joint, record_module_stack=True)(*full_args)
+
+    user_args_flat = pytree.arg_tree_leaves(*args, **kwargs)
+    if out_spec is None:
+        raise AssertionError("out_spec must not be None")
+    return fx_g, create_graph_signature(
+        # type: ignore[bad-argument-type]
+        fx_g,
+        metadata,
+        in_spec,
+        out_spec,
+        user_args_flat=user_args_flat,
+        params_and_buffers_flat=list(params_and_buffers_flat),
+        param_names=list(named_parameters.keys()),
+        buffer_names=list(named_buffers.keys()),
+        trace_joint=trace_joint,
+        num_user_fw_outs=num_fw_outs,
+        loss_index=output_loss_index,
+    )
+
+
+def aot_export_joint_simple(
+    func: Callable[..., Any],
+    args: tuple[Any, ...],
+    *,
+    trace_joint: bool,
+    # It looks like the main consequence of this API is that for dynamic shapes,
+    # it will assume that params/buffers are static.
+    # With the new inferred dynamic shapes API, maybe this doesn't matter?
+    num_params_buffers: int = 0,
+    decompositions: dict[OpOverload, Callable[..., Any]] | None = None,
+) -> Callable[..., Any]:
+    """
+    A simplified version of export. Used by higher order operators.
+
+    This function makes a high-level "no calling convention changes" guarantee:
+    - If no inputs require grad (so we export an inference graph),
+      there are *no* calling convention change between the exported graph, and "func".
+    - If at least one input requires grad (so we trace out and export a joint fw-bw graph),
+      Then if you were partition the graph into a separate forward and backward graph,
+      The forward graph will have no calling convention changes compared to "func".
+
+    The above also relies on some strong restrictions around which functions this API accepts:
+    (1) `args` cannot contain any pytrees (they must have been pytree_flattened already)
+    (2) `func` cannot mutate any inputs
+    (3) The outputs of `func` cannot alias any inputs.
+
+    Note: this function is only lightly tested today. It will probably be tested more heavily by higher order ops.
+    """
+    if trace_joint:
+        ctx = nullcontext
+    else:
+        # Run under no_grad, so our tracing machinery only traces an inference graph.
+        ctx = torch.no_grad
+
+    with ctx():
+        fx_g, metadata, in_spec, out_spec = _aot_export_function(
+            func,
+            args,
+            decompositions=decompositions,
+            trace_joint=trace_joint,
+        )
+        in_spec, _kw_in_spec = in_spec.children()
+    # At this point, we can just directly return the (joint or inference graph) that we traced.
+    # First though: a bunch of assertions to make sure that our graph doesn't require
+    # any calling convention changes compared to the original function.
+    # These restrictions are *in addition to* the general restrictions on export.
+
+    # No input mutations
+    if (
+        len([x for x in metadata.input_info if x.mutates_data or x.mutates_metadata])
+        != 0
+    ):
+        raise RuntimeError(
+            f"aot_export_joint_simple does not support input mutations. {str(metadata)}"
+        )
+    # No output aliasing
+    if (
+        len([x for x in metadata.output_info if x.output_type != OutputType.non_alias])
+        != 0
+    ):
+        raise RuntimeError(
+            f"aot_export_joint_simple does not support outputs that alias inputs. {str(metadata)}"
+        )
+    # No pytrees
+    if in_spec.is_leaf():
+        raise RuntimeError(
+            f"aot_export_joint_simple requires inputs to be a single list/tuple. in_spec={str(in_spec)}"
+        )
+    if not all(child.is_leaf() for child in in_spec.children()):
+        raise RuntimeError(
+            f"aot_export_joint_simple requires individual inputs not to be pytrees. in_spec={str(in_spec)}"
+        )
+
+    if out_spec is None:
+        raise AssertionError("out_spec must not be None")
+    if out_spec.is_leaf():
+        raise RuntimeError(
+            f"aot_export_joint_simple requires outputs to be a single list/tuple. out_spec={str(out_spec)}"
+        )
+    if not all(child.is_leaf() for child in out_spec.children()):
+        raise RuntimeError(
+            f"aot_export_joint_simple requires individual outputs not to be pytrees. out_spec={str(out_spec)}"
+        )
+    # TODO: we might have to temporarily patch config.functionalize_rng
+    # so that it doesn't run when we're exporting a higher order op.
+
+    if config.debug_assert:
+        # Smoke test that after partitioning, we can run the forward without any calling convention changes.
+        fw_module, _bw_module = default_partition(
+            # type: ignore[bad-argument-type]
+            fx_g,
+            args,
+            # type: ignore[unknown-name]
+            num_fwd_outputs=len(fw_metadata.output_infos),  # noqa: F821
+        )
+        # Attempt to run the fw_module with the original user inputs
+        fake_mode = detect_fake_mode(args)
+        if fake_mode is None:
+            fake_mode = FakeTensorMode()
+        with fake_mode:
+            fw_module(*args)
+    return fx_g
+
+
+# Private for now because we aren't providing a contract on what to return
+# for joint graphs (we could when there's a clearer use case)
+# In the future, we may need to add more export API's that provide their own strong guarantees.
+# This is meant as a general helper function for handling various export-y use cases.
+def _aot_export_function(
+    func: Callable[..., Any],
+    args: tuple[Any, ...],
+    *,
+    num_params_buffers: int = 0,
+    decompositions: dict[OpOverload, Callable[..., Any]] | None = None,
+    # If we're exporting a joint graph and we don't want any tangent inputs in the graph
+    # (because we are backpropping through a scalar 1 loss),
+    # we need to explicitly specify not to include tangents in the graph.
+    # It's not enough just to check that our tangent is a scalar, since we also
+    # need to know if it is a 1 (no need to make it a graph input), or something else
+    # (requiring it to be a graph input).
+    # We don't know this info at trace time though, so we need to make it an explicit config.
+    no_tangents: bool = False,
+    pre_dispatch: bool = False,
+    # If None, `dynamic_shapes` will be inferred from inputs, but the inferred result might be wrong.
+    dynamic_shapes: bool | None = None,
+    keep_input_mutations: bool = False,
+    # Under export, configures whether we are getting inference or training IR
+    trace_joint: bool = False,
+    kwargs: dict[str, Any] | None = None,
+) -> tuple[
+    Callable[..., Any], ViewAndMutationMeta, pytree.TreeSpec, pytree.TreeSpec | None
+]:
+    kwargs = kwargs or {}
+
+    flat_fn, out_spec = create_tree_flattened_fn(func, args, kwargs)
+    flat_args, in_spec = pytree.tree_flatten((args, kwargs))
+
+    fake_mode = None
+    if dynamic_shapes is None:
+        # Try to infer `dynamic_shapes from inputs and graph nodes
+        fake_mode = detect_fake_mode(flat_args)
+        if (
+            fake_mode is None
+            and hasattr(func, "_orig_mod")
+            and isinstance(func._orig_mod, torch.fx.GraphModule)
+        ):
+            vals = [
+                node.meta["val"]
+                for node in func._orig_mod.graph.nodes
+                if "val" in node.meta
+            ]
+            fake_mode = detect_fake_mode(vals)
+        dynamic_shapes = fake_mode is not None and fake_mode.shape_env is not None
+
+    # The export use case doesn't care about several bits of AOTConfig
+    # (1) compilers (we just export the graph)
+    # (2) partitioners (export is only full graph, user can partition themselves)
+    aot_config = AOTConfig(  # type: ignore[arg-type]
+        fw_compiler=None,
+        bw_compiler=None,
+        inference_compiler=None,
+        partition_fn=None,
+        decompositions=decompositions,
+        num_params_buffers=num_params_buffers,
+        aot_id=next(AOT_COUNTER),
+        keep_inference_input_mutations=keep_input_mutations,
+        dynamic_shapes=dynamic_shapes,
+        aot_autograd_arg_pos_to_source=None,
+        is_export=True,
+        no_tangents=no_tangents,
+        pre_dispatch=pre_dispatch,
+        export_trace_joint=trace_joint,
+    )
+    if fake_mode is None:
+        fake_mode, shape_env = construct_fake_mode(flat_args, aot_config)
+    else:
+        shape_env = fake_mode.shape_env
+    fake_flat_args, act_input_paths = process_inputs(
+        flat_args, aot_config, fake_mode, shape_env
+    )
+    # TODO: Improve the descs here with pytree information
+    fake_flat_args_descs: list[AOTInput] = [
+        PlainAOTInput(i) for i in range(len(fake_flat_args))
+    ]
+
+    with contextlib.ExitStack() as stack:
+        aot_state = create_aot_state(
+            stack,
+            flat_fn,
+            fake_flat_args,
+            fake_flat_args_descs,
+            aot_config,
+            fake_mode,
+            shape_env,
+        )
+        aot_state.fw_metadata.act_input_paths = act_input_paths
+        aot_graph_capture = aot_stage1_graph_capture(aot_state, flat_fn)
+        fx_g, meta = aot_stage2_export(aot_state, aot_graph_capture)
+
+    return fx_g, meta, in_spec, out_spec.spec
+
+
+compiled_function = aot_function
+compiled_module = aot_module

.venv/lib/python3.12/site-packages/torch/_functorch/apis.py

@@ -0,0 +1,510 @@
+# NOTE: We allow Dynamo to see this file (via torch/_dynamo/trace_rules.py) so that it can
+#       trace through functorch transforms.
+#       Currently, we can't allow Dynamo to see `eager_transforms.py`/`vmap.py` as that break a lot of thing
+#       and there isn't a mechanism to selectively expose only some functions (eg. grad) from a file
+#       to Dynamo.
+
+from __future__ import annotations
+
+import functools
+from typing import Any, TYPE_CHECKING
+from typing_extensions import ParamSpec, TypeVar
+
+from torch._functorch.utils import argnums_t, exposed_in
+from torch._functorch.vmap import (
+    _check_out_dims_is_int_or_int_pytree,
+    _check_randomness_arg,
+    _chunked_vmap,
+    _process_batched_inputs,
+    Callable,
+    in_dims_t,
+    out_dims_t,
+    vmap_impl,
+)
+
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    import torch
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+# functools.wraps copies __dict__, but these attrs describe the original
+# compiled callable, not the transformed function wrapper.
+_DYNAMO_WRAPPER_ATTRS = (
+    "_torchdynamo_inline",
+    "_torchdynamo_orig_callable",
+    "_torchdynamo_wrapper_id",
+    "_isolate_recompiles_id",
+    "get_compiler_config",
+    "aot_compile",
+    "_is_torch_compile",
+)
+
+
+def _wraps_without_dynamo_attrs(
+    func: Callable[..., Any],
+) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]:
+    def inner(wrapper: Callable[_P, _R]) -> Callable[_P, _R]:
+        wrapper = functools.wraps(func)(wrapper)
+        for attr in _DYNAMO_WRAPPER_ATTRS:
+            wrapper.__dict__.pop(attr, None)
+        return wrapper
+
+    return inner
+
+
+# vmap(func)(inputs) wraps all Tensor inputs to be batched in BatchedTensors,
+# sends those into func, and then unwraps the output BatchedTensors. Operations
+# on BatchedTensors perform the batched operations that the user is asking for.
+#
+# vmap's randomness behavior differs from JAX's, which would require a PRNG key
+# to be passed everywhere.
+
+
+@exposed_in("torch.func")
+def vmap(
+    func: Callable[_P, _R],
+    in_dims: in_dims_t = 0,
+    out_dims: out_dims_t = 0,
+    randomness: str = "error",
+    *,
+    chunk_size: int | None = None,
+) -> Callable[_P, _R]:
+    """
+    vmap is the vectorizing map; ``vmap(func)`` returns a new function that
+    maps ``func`` over some dimension of the inputs. Semantically, vmap
+    pushes the map into PyTorch operations called by ``func``, effectively
+    vectorizing those operations.
+
+    vmap is useful for handling batch dimensions: one can write a function
+    ``func`` that runs on examples and then lift it to a function that can
+    take batches of examples with ``vmap(func)``. vmap can also be used to
+    compute batched gradients when composed with autograd.
+
+    .. note::
+        :func:`torch.vmap` is aliased to :func:`torch.func.vmap` for
+        convenience. Use whichever one you'd like.
+
+    Args:
+        func (function): A Python function that takes one or more arguments.
+            Must return one or more Tensors.
+        in_dims (int or nested structure): Specifies which dimension of the
+            inputs should be mapped over. ``in_dims`` should have a
+            structure like the inputs. If the ``in_dim`` for a particular
+            input is None, then that indicates there is no map dimension.
+            Default: 0.
+        out_dims (int or Tuple[int]): Specifies where the mapped dimension
+            should appear in the outputs. If ``out_dims`` is a Tuple, then
+            it should have one element per output. Default: 0.
+        randomness (str): Specifies whether the randomness in this
+            vmap should be the same or different across batches. If 'different',
+            the randomness for each batch will be different. If 'same', the
+            randomness will be the same across batches. If 'error', any calls to
+            random functions will error. Default: 'error'. WARNING: this flag
+            only applies to random PyTorch operations and does not apply to
+            Python's random module or numpy randomness.
+        chunk_size (None or int): If None (default), apply a single vmap over inputs.
+            If not None, then compute the vmap :attr:`chunk_size` samples at a time.
+            Note that :attr:`chunk_size=1` is equivalent to computing the vmap with a for-loop.
+            If you run into memory issues computing the vmap, please try a non-None chunk_size.
+
+    Returns:
+        Returns a new "batched" function. It takes the same inputs as
+        ``func``, except each input has an extra dimension at the index
+        specified by ``in_dims``. It takes returns the same outputs as
+        ``func``, except each output has an extra dimension at the index
+        specified by ``out_dims``.
+
+    .. warning:
+        :func:`vmap` works best with functional-style code. Please do not
+        perform any side-effects in ``func``, with the exception of
+        in-place PyTorch operations. Examples of side-effects include mutating
+        Python data structures and assigning values to variables not captured
+        in ``func``.
+
+    One example of using :func:`vmap` is to compute batched dot products. PyTorch
+    doesn't provide a batched ``torch.dot`` API; instead of unsuccessfully
+    rummaging through docs, use :func:`vmap` to construct a new function.
+
+        >>> torch.dot  # [D], [D] -> []
+        >>> batched_dot = torch.func.vmap(torch.dot)  # [N, D], [N, D] -> [N]
+        >>> x, y = torch.randn(2, 5), torch.randn(2, 5)
+        >>> batched_dot(x, y)
+
+    :func:`vmap` can be helpful in hiding batch dimensions, leading to a simpler
+    model authoring experience.
+
+        >>> batch_size, feature_size = 3, 5
+        >>> weights = torch.randn(feature_size, requires_grad=True)
+        >>>
+        >>> def model(feature_vec):
+        >>> # Very simple linear model with activation
+        >>>     return feature_vec.dot(weights).relu()
+        >>>
+        >>> examples = torch.randn(batch_size, feature_size)
+        >>> result = torch.vmap(model)(examples)
+
+    :func:`vmap` can also help vectorize computations that were previously difficult
+    or impossible to batch. One example is higher-order gradient computation.
+    The PyTorch autograd engine computes vjps (vector-Jacobian products).
+    Computing a full Jacobian matrix for some function f: R^N -> R^N usually
+    requires N calls to ``autograd.grad``, one per Jacobian row. Using :func:`vmap`,
+    we can vectorize the whole computation, computing the Jacobian in a single
+    call to ``autograd.grad``.
+
+        >>> # Setup
+        >>> N = 5
+        >>> f = lambda x: x**2
+        >>> x = torch.randn(N, requires_grad=True)
+        >>> y = f(x)
+        >>> I_N = torch.eye(N)
+        >>>
+        >>> # Sequential approach
+        >>> jacobian_rows = [torch.autograd.grad(y, x, v, retain_graph=True)[0]
+        >>>                  for v in I_N.unbind()]
+        >>> jacobian = torch.stack(jacobian_rows)
+        >>>
+        >>> # vectorized gradient computation
+        >>> def get_vjp(v):
+        >>>     return torch.autograd.grad(y, x, v)
+        >>> jacobian = torch.vmap(get_vjp)(I_N)
+
+    :func:`vmap` can also be nested, producing an output with multiple batched dimensions
+
+        >>> torch.dot  # [D], [D] -> []
+        >>> batched_dot = torch.vmap(
+        ...     torch.vmap(torch.dot)
+        ... )  # [N1, N0, D], [N1, N0, D] -> [N1, N0]
+        >>> x, y = torch.randn(2, 3, 5), torch.randn(2, 3, 5)
+        >>> batched_dot(x, y)  # tensor of size [2, 3]
+
+    If the inputs are not batched along the first dimension, ``in_dims`` specifies
+    the dimension that each inputs are batched along as
+
+        >>> torch.dot  # [N], [N] -> []
+        >>> batched_dot = torch.vmap(torch.dot, in_dims=1)  # [N, D], [N, D] -> [D]
+        >>> x, y = torch.randn(2, 5), torch.randn(2, 5)
+        >>> batched_dot(
+        ...     x, y
+        ... )  # output is [5] instead of [2] if batched along the 0th dimension
+
+    If there are multiple inputs each of which is batched along different dimensions,
+    ``in_dims`` must be a tuple with the batch dimension for each input as
+
+        >>> torch.dot  # [D], [D] -> []
+        >>> batched_dot = torch.vmap(torch.dot, in_dims=(0, None))  # [N, D], [D] -> [N]
+        >>> x, y = torch.randn(2, 5), torch.randn(5)
+        >>> batched_dot(
+        ...     x, y
+        ... )  # second arg doesn't have a batch dim because in_dim[1] was None
+
+    If the input is a Python struct, ``in_dims`` must be a tuple containing a struct
+    matching the shape of the input:
+
+        >>> f = lambda dict: torch.dot(dict["x"], dict["y"])
+        >>> x, y = torch.randn(2, 5), torch.randn(5)
+        >>> input = {"x": x, "y": y}
+        >>> batched_dot = torch.vmap(f, in_dims=({"x": 0, "y": None},))
+        >>> batched_dot(input)
+
+    By default, the output is batched along the first dimension. However, it can be batched
+    along any dimension by using ``out_dims``
+
+        >>> f = lambda x: x**2
+        >>> x = torch.randn(2, 5)
+        >>> batched_pow = torch.vmap(f, out_dims=1)
+        >>> batched_pow(x)  # [5, 2]
+
+    For any function that uses kwargs, the returned function will not batch the kwargs but will
+    accept kwargs
+
+        >>> x = torch.randn([2, 5])
+        >>> def fn(x, scale=4.):
+        >>>   return x * scale
+        >>>
+        >>> batched_pow = torch.vmap(fn)
+        >>> assert torch.allclose(batched_pow(x), x * 4)
+        >>> batched_pow(x, scale=x)  # scale is not batched, output has shape [2, 2, 5]
+
+    .. note::
+        vmap does not provide general autobatching or handle variable-length
+        sequences out of the box.
+    """
+    from torch.compiler import is_compiling
+
+    _check_randomness_arg(randomness)
+    if not (chunk_size is None or chunk_size > 0):
+        raise ValueError(
+            f"vmap: chunk_size should be None or greater than 0. (got {chunk_size})"
+        )
+
+    def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> _R:
+        # pyrefly: ignore[bad-argument-type]
+        return vmap_impl(
+            # pyrefly: ignore[bad-argument-type]
+            func,
+            in_dims,
+            out_dims,
+            randomness,
+            chunk_size,
+            *args,
+            **kwargs,
+        )
+
+    if not is_compiling():
+        wrapped = _wraps_without_dynamo_attrs(func)(wrapped)
+
+    return wrapped
+
+
+def chunk_vmap(
+    func: Callable[_P, _R],
+    in_dims: in_dims_t = 0,
+    out_dims: out_dims_t = 0,
+    randomness: str = "error",
+    chunks: int = 2,
+) -> Callable[_P, _R]:
+    """
+    chunk_vmap is the vectorizing map (vmap) using chunks of input data. It is a mix of vmap (which vectorizes
+    everything) and map (which executes things sequentially). ``chunk_vmap`` vectorizes the input with number of
+    chunks at a time. For more details about vectorizing map, see :func:`vmap`.
+
+    .. note::
+        Please use :func:`vmap` with ``chunk_size`` argument instead of this API.
+
+    Args:
+        func (function): A Python function that takes one or more arguments.
+            Must return one or more Tensors.
+        in_dims (int or nested structure): Specifies which dimension of the
+            inputs should be mapped over. ``in_dims`` should have a
+            structure like the inputs. If the ``in_dim`` for a particular
+            input is None, then that indicates there is no map dimension.
+            Default: 0.
+        out_dims (int or Tuple[int]): Specifies where the mapped dimension
+            should appear in the outputs. If ``out_dims`` is a Tuple, then
+            it should have one element per output. Default: 0.
+        randomness (str): Specifies whether the randomness in this
+            vmap should be the same or different across batches. If 'different',
+            the randomness for each batch will be different. If 'same', the
+            randomness will be the same across batches. If 'error', any calls to
+            random functions will error. Default: 'error'. WARNING: this flag
+            only applies to random PyTorch operations and does not apply to
+            Python's random module or numpy randomness.
+        chunks (int): Number of chunks to use to split the input data. Default is 2.
+            If equals to 1 then :func:`vmap` is called.
+
+    Returns:
+        Returns a new "batched" function. It takes the same inputs as
+        ``func``, except each input has an extra dimension at the index
+        specified by ``in_dims``. It takes returns the same outputs as
+        ``func``, except each output has an extra dimension at the index
+        specified by ``out_dims``.
+    """
+    _check_randomness_arg(randomness)
+
+    if chunks == 1:
+        return vmap(func, in_dims=in_dims, out_dims=out_dims, randomness=randomness)
+
+    def _get_chunk_flat_args(
+        flat_args_: Iterable[Any],
+        flat_in_dims_: Iterable[int | None],
+        chunks_: int,
+    ) -> Iterable[Any]:
+        flat_args_chunks = tuple(
+            t.chunk(chunks_, dim=in_dim)
+            if in_dim is not None
+            else [
+                t,
+            ]
+            * chunks_
+            for t, in_dim in zip(flat_args_, flat_in_dims_)
+        )
+        # transpose chunk dim and flatten structure
+        # chunks_flat_args is a list of flatten args
+        chunks_flat_args = zip(*flat_args_chunks)
+        return chunks_flat_args
+
+    @_wraps_without_dynamo_attrs(func)
+    def wrapped_with_chunks(*args: _P.args, **kwargs: _P.kwargs) -> _R:
+        _check_out_dims_is_int_or_int_pytree(out_dims, func)
+        _, flat_in_dims, flat_args, args_spec = _process_batched_inputs(
+            in_dims, args, func
+        )
+        # Chunk flat arguments
+        chunks_flat_args = _get_chunk_flat_args(flat_args, flat_in_dims, chunks)
+
+        # Apply vmap on chunks
+        return _chunked_vmap(
+            # pyrefly: ignore[bad-argument-type]
+            func,
+            flat_in_dims,
+            chunks_flat_args,
+            args_spec,
+            out_dims,
+            randomness,
+            **kwargs,
+        )
+
+    return wrapped_with_chunks
+
+
+# TODO: Improve the return type of this function
+@exposed_in("torch.func")
+def grad(
+    func: Callable[_P, Any], argnums: argnums_t = 0, has_aux: bool = False
+) -> Callable[_P, Any]:
+    """``grad`` operator helps computing gradients of ``func`` with respect to the
+    input(s) specified by ``argnums``. This operator can be nested to
+    compute higher-order gradients.
+
+    Args:
+        func (Callable): A Python function that takes one or more arguments.
+            Must return a single-element Tensor. If specified ``has_aux`` equals ``True``,
+            function can return a tuple of single-element Tensor and other auxiliary objects:
+            ``(output, aux)``.
+        argnums (int or Tuple[int]): Specifies arguments to compute gradients with respect to.
+            ``argnums`` can be single integer or tuple of integers. Default: 0.
+        has_aux (bool): Flag indicating that ``func`` returns a tensor and other
+            auxiliary objects: ``(output, aux)``. Default: False.
+
+    Returns:
+        Function to compute gradients with respect to its inputs. By default, the output of
+        the function is the gradient tensor(s) with respect to the first argument.
+        If specified ``has_aux`` equals ``True``, tuple of gradients and output auxiliary objects
+        is returned. If ``argnums`` is a tuple of integers, a tuple of output gradients with
+        respect to each ``argnums`` value is returned.
+
+    Example of using ``grad``:
+
+        >>> # xdoctest: +SKIP
+        >>> from torch.func import grad
+        >>> x = torch.randn([])
+        >>> cos_x = grad(lambda x: torch.sin(x))(x)
+        >>> assert torch.allclose(cos_x, x.cos())
+        >>>
+        >>> # Second-order gradients
+        >>> neg_sin_x = grad(grad(lambda x: torch.sin(x)))(x)
+        >>> assert torch.allclose(neg_sin_x, -x.sin())
+
+    When composed with ``vmap``, ``grad`` can be used to compute per-sample-gradients:
+
+        >>> # xdoctest: +SKIP
+        >>> from torch.func import grad, vmap
+        >>> batch_size, feature_size = 3, 5
+        >>>
+        >>> def model(weights, feature_vec):
+        >>> # Very simple linear model with activation
+        >>>     assert feature_vec.dim() == 1
+        >>>     return feature_vec.dot(weights).relu()
+        >>>
+        >>> def compute_loss(weights, example, target):
+        >>>     y = model(weights, example)
+        >>>     return ((y - target) ** 2).mean()  # MSELoss
+        >>>
+        >>> weights = torch.randn(feature_size, requires_grad=True)
+        >>> examples = torch.randn(batch_size, feature_size)
+        >>> targets = torch.randn(batch_size)
+        >>> inputs = (weights, examples, targets)
+        >>> grad_weight_per_example = vmap(grad(compute_loss), in_dims=(None, 0, 0))(
+        ...     *inputs
+        ... )
+
+    Example of using ``grad`` with ``has_aux`` and ``argnums``:
+
+        >>> # xdoctest: +SKIP
+        >>> from torch.func import grad
+        >>> def my_loss_func(y, y_pred):
+        >>>    loss_per_sample = (0.5 * y_pred - y) ** 2
+        >>>    loss = loss_per_sample.mean()
+        >>>    return loss, (y_pred, loss_per_sample)
+        >>>
+        >>> fn = grad(my_loss_func, argnums=(0, 1), has_aux=True)
+        >>> y_true = torch.rand(4)
+        >>> y_preds = torch.rand(4, requires_grad=True)
+        >>> out = fn(y_true, y_preds)
+        >>> # > output is ((grads w.r.t y_true, grads w.r.t y_preds), (y_pred, loss_per_sample))
+
+    .. note::
+        Using PyTorch ``torch.no_grad`` together with ``grad``.
+
+        Case 1: Using ``torch.no_grad`` inside a function:
+
+            >>> # xdoctest: +SKIP
+            >>> def f(x):
+            >>>     with torch.no_grad():
+            >>>         c = x ** 2
+            >>>     return x - c
+
+        In this case, ``grad(f)(x)`` will respect the inner ``torch.no_grad``.
+
+        Case 2: Using ``grad`` inside ``torch.no_grad`` context manager:
+
+            >>> # xdoctest: +SKIP
+            >>> with torch.no_grad():
+            >>>     grad(f)(x)
+
+        In this case, ``grad`` will respect the inner ``torch.no_grad``, but not the
+        outer one. This is because ``grad`` is a "function transform": its result
+        should not depend on the result of a context manager outside of ``f``.
+
+    """
+    # To avoid cyclical dependency.
+    import torch._functorch.eager_transforms as eager_transforms
+    from torch.compiler import is_compiling
+
+    def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> tuple[Any, torch.Tensor]:
+        return eager_transforms.grad_impl(func, argnums, has_aux, args, kwargs)
+
+    if not is_compiling():
+        wrapper = _wraps_without_dynamo_attrs(func)(wrapper)
+
+    return wrapper
+
+
+# TODO: Improve the return type of this function
+@exposed_in("torch.func")
+def grad_and_value(
+    func: Callable[_P, Any], argnums: argnums_t = 0, has_aux: bool = False
+) -> Callable[_P, tuple[Any, Any]]:
+    """
+    Returns a function to compute a tuple of the gradient and primal, or
+    forward, computation.
+
+    Args:
+        func (Callable): A Python function that takes one or more arguments.
+            Must return a single-element Tensor. If specified ``has_aux``
+            equals ``True``, function can return a tuple of single-element
+            Tensor and other auxiliary objects: ``(output, aux)``.
+        argnums (int or Tuple[int]): Specifies arguments to compute gradients
+            with respect to. ``argnums`` can be single integer or tuple of
+            integers. Default: 0.
+        has_aux (bool): Flag indicating that ``func`` returns a tensor and
+            other auxiliary objects: ``(output, aux)``. Default: False.
+
+    Returns:
+        Function to compute a tuple of gradients with respect to its inputs
+        and the forward computation. By default, the output of the function is
+        a tuple of the gradient tensor(s) with respect to the first argument
+        and the primal computation. If specified ``has_aux`` equals
+        ``True``, tuple of gradients and tuple of the forward computation with
+        output auxiliary objects is returned. If ``argnums`` is a tuple of
+        integers, a tuple of a tuple of the output gradients with respect to
+        each ``argnums`` value and the forward computation is returned.
+
+    See :func:`grad` for examples
+    """
+    from torch._functorch import eager_transforms
+    from torch.compiler import is_compiling
+
+    def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> tuple[Any, torch.Tensor]:
+        return eager_transforms.grad_and_value_impl(
+            func, argnums, has_aux, args, kwargs
+        )
+
+    if not is_compiling():
+        wrapper = _wraps_without_dynamo_attrs(func)(wrapper)
+
+    return wrapper

.venv/lib/python3.12/site-packages/torch/_functorch/autograd_function.py

@@ -0,0 +1,935 @@
+from __future__ import annotations
+
+from typing import Any, NamedTuple, TYPE_CHECKING
+from typing_extensions import ParamSpec, TypeVar
+
+import torch
+import torch.utils._pytree as pytree
+from torch._C._functorch import (
+    _unwrap_for_grad,
+    _wrap_for_grad,
+    current_level,
+    TransformType,
+)
+from torch._functorch.apis import vmap
+from torch._functorch.utils import enable_single_level_autograd_function
+from torch._functorch.vmap import (
+    _add_batch_dim,
+    _broadcast_to_and_flatten,
+    restore_vmap,
+    unwrap_batched,
+    wrap_batched,
+)
+from torch._ops import HigherOrderOperator
+from torch.autograd.forward_ad import _set_fwd_grad_enabled
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Sequence
+
+    from torch._functorch.pyfunctorch import FuncTorchInterpreter, VmapInterpreter
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+
+# autograd.Function technically runs before the regular PyTorch dispatcher.
+# This is how features like autocast and torch_dispatch (e.g. PythonTLSSnapshot)
+# work with it. One day we might decide to change this, but until then,
+# we need to give the illusion that autograd.Function runs before those things.
+#
+# We do this by using creating a custom HigherOrderOperator that only functorch
+# dispatches specially.
+class CustomFunctionHigherOrderOperator(HigherOrderOperator):
+    def __init__(self) -> None:
+        super().__init__("custom_function_call")
+
+    def __call__(
+        self,
+        autograd_function: type[torch.autograd.Function],
+        *args: _P.args,
+        **kwargs: _P.kwargs,
+    ) -> Any:
+        # When custom_function_call is done dispatching through functorch,
+        # it should just invoke the autograd.Function. This is consistent
+        # with the autograd.Function behavior of being invoked before the
+        # PyTorch dispatcher.
+        #
+        # This will lead us into trouble later down the line, but this is
+        # pre-existing. There is an invariant that a function traced by
+        # make_fx should have the same behavior when provided the same
+        # Tensor. However, make_fx sees autograd.Function as a composite
+        # (because autograd.Function happens before the Python dispatch key)
+        # and only traces the forward pass.
+        if torch._C._are_functorch_transforms_active():
+            # pyrefly: ignore [missing-attribute]
+            return super().__call__(autograd_function, *args, **kwargs)
+        return autograd_function.apply(*args, **kwargs)
+
+
+# "custom_function_call"
+# This is the mechanism for an autograd.Function that works with functorch transforms.
+# It wraps an autograd.Function; interactions with functorch transforms are defined
+# via PyDispatcher and HigherOrderOperator rather than through the traditional PyTorch
+# dispatcher.
+custom_function_call = CustomFunctionHigherOrderOperator()
+
+
+# The grad rule for custom_function_call is to construct a new _SingleLevelFunction
+# (autograd.Function that only works with a single layer (level) of functorch) that:
+# - unwraps the inputs
+# - redispatches to custom_function_call
+# - wraps the outputs
+# and whose backward pass calls the original autograd.Function's backward.
+#
+# Why do we need to redispatch to custom_function_call?
+# -----------------------------------------------------
+# This is consistent with how ATen operators work with functorch's grad transform:
+# they always redispatch to the original operator.
+# Consider torch.sin, and let's say we do grad0(grad1(torch.sin))(x)
+#
+# grad1 will:
+# - set up the autograd graph
+# - unwrap the inputs
+# - redispatch to at::sin (*)
+# - rewrap the outputs on the return
+#
+# On the redispatch in (*), grad0 will:
+# - set up the autograd graph
+# - unwrap the inputs
+# - redispatch to at::sin
+# - rewrap the outputs on the return
+#
+# To "set up the autograd graph", we generate a _SingleLevelFunction
+# and apply it.
+@custom_function_call.py_impl(TransformType.Grad)
+@custom_function_call.py_impl(TransformType.Jvp)
+def custom_function_call_grad(
+    interpreter: FuncTorchInterpreter,
+    autograd_function: type[torch.autograd.Function],
+    *operands: Any,
+) -> Any:
+    Generated = generate_single_level_function(interpreter, autograd_function)
+    with enable_single_level_autograd_function():
+        # pyrefly: ignore [missing-attribute]
+        flat_out = Generated.apply(*operands)
+    return flat_out
+
+
+def generate_single_level_function(
+    interpreter: FuncTorchInterpreter,
+    autograd_function: type[torch.autograd.Function],
+) -> type[torch.autograd.function._SingleLevelFunction]:
+    level = interpreter.level()
+
+    def forward(*operands: Any) -> Any:
+        unwrapped_operands = pytree.tree_map_only(
+            torch.Tensor, lambda x: _unwrap_for_grad(x, level), operands
+        )
+        # Both enable_grad() and _set_fwd_grad_enabled() are necessary no matter
+        # the transform. _SingleLevelFunction will turn off both fwd and bwd
+        # gradient computation and we need to turn it back on here.
+        with torch.enable_grad(), _set_fwd_grad_enabled(True), interpreter.lower():
+            unwrapped_output = custom_function_call(
+                autograd_function, *unwrapped_operands
+            )
+
+        # See NOTE [mark_dirty object identity check]
+        def wrap_fn(output: torch.Tensor) -> torch.Tensor:
+            return _wrap_for_grad(output, level)
+
+        return wrap_outputs_maintaining_identity(
+            unwrapped_output, unwrapped_operands, operands, wrap_fn
+        )
+
+    def setup_context(ctx: Any, inputs: Any, output: Any) -> Any:
+        return autograd_function.setup_context(ctx, inputs, output)
+
+    # backward is only used if the transform is TransformType.Grad
+    def backward(ctx: Any, *grads: Any) -> Any:
+        result = autograd_function.backward(ctx, *grads)
+        return result
+
+    # jvp is only used if the transform is TransformType.Jvp
+    def jvp(ctx: Any, *tangents: Any) -> Any:
+        result = autograd_function.jvp(ctx, *tangents)
+        return result
+
+    # This is the sequence of magic words to dynamically generate a Subclass with
+    # a given name. A Tensor's .grad_fn field has a class name that is the original
+    # autograd.Function's name + Backward, so we do this to generate some
+    # meaningful name.
+    name = f"{autograd_function.__name__}Generated"
+    Generated = type(
+        name,
+        (torch.autograd.function._SingleLevelFunction,),
+        {
+            "forward": staticmethod(forward),
+            "backward": staticmethod(backward),
+            "jvp": staticmethod(jvp),
+            "setup_context": staticmethod(setup_context),
+        },
+    )
+    return Generated
+
+
+# wrap_outputs_maintaining_identity handles outputs from the vmap,
+# backward (vjp), and jvp staticmethod. The way it distinguishes
+# between the vmap case and the {backward, jvp} case is if the out_dims
+# are specified or not.
+#
+# NB: we cannot use out_dims=None as the deciding factor. This because
+# out_dims=None can still happen in the vmap staticmethod! What the
+# user is saying in that case is that their output does not have a
+# dimension that is being vmapped over, which is valid.
+NO_OUT_DIMS = "not specified"
+
+
+# NOTE [mark_dirty object identity check]
+# autograd.Function's ctx.mark_dirty expect a returned input
+# to have the same object identity as the input.
+# Mode-only functorch will greatly simplify this logic.
+def wrap_outputs_maintaining_identity(
+    outputs: Any,
+    unwrapped_inputs: Any,
+    orig_inputs: Any,
+    wrap_fn: Callable[..., Any],
+    out_dims: Any = NO_OUT_DIMS,
+) -> Any:
+    flat_unwrapped_inputs = pytree.arg_tree_leaves(*unwrapped_inputs)
+    flat_orig_inputs = pytree.arg_tree_leaves(*orig_inputs)
+
+    unwrapped_input_to_orig_input = {
+        id(unwrapped): orig
+        for unwrapped, orig in zip(flat_unwrapped_inputs, flat_orig_inputs)
+    }
+
+    flat_outputs, spec = pytree.tree_flatten(outputs)
+    result = []
+
+    out_dims_specified = out_dims != NO_OUT_DIMS
+
+    flat_out_dims = None
+    if out_dims_specified:
+        flat_out_dims = _broadcast_to_and_flatten(out_dims, spec)
+        # _broadcast_to_and_flatten returns None if it is unable to broadcast.
+        # TODO: update following link from master to stable once that's out
+        if flat_out_dims is None:
+            raise RuntimeError(
+                f"The autograd.Function's vmap staticmethod returned an "
+                f"incompatible (output, out_dims) tuple. "
+                f"Expected out_dims={out_dims} "
+                f"to be compatible with the structure of `output`. "
+                f"out_dims has structure {pytree.tree_flatten(out_dims)[1]} "
+                f"but output has structure {spec}. "
+                f"For more details, please see "
+                f"https://pytorch.org/docs/main/notes/extending.func.html"
+            )
+
+    for i, output in enumerate(flat_outputs):
+        if not isinstance(output, torch.Tensor):
+            result.append(output)
+            continue
+        if id(output) in unwrapped_input_to_orig_input:
+            result.append(unwrapped_input_to_orig_input[id(output)])
+            continue
+        if out_dims_specified:
+            if flat_out_dims is None:
+                raise AssertionError(
+                    "flat_out_dims must not be None when out_dims is specified"
+                )
+            result.append(wrap_fn(output, flat_out_dims[i]))
+        else:
+            result.append(wrap_fn(output))
+
+    return pytree.tree_unflatten(result, spec)
+
+
+# NOTE: [functorch vjp and autograd interaction]
+# There's an edge case with the functorch vjp and autograd interaction
+# that will eventually be fixed by mode-only functorch.
+# The TL;DR is that there's no way to unwrap a dead GradTensorWrapper,
+# so we (the framework) need to do it manually. Regular PyTorch operators
+# automatically do so this is consistent.
+#
+# class MyExp(torch.autograd.Function):
+#     @staticmethod
+#     def forward(x):
+#         return x.exp()
+#
+#     @staticmethod
+#     def setup_context(ctx, inputs, output):
+#         y = output
+#         ctx.save_for_backward(y)
+#
+#     @staticmethod
+#     def backward(gy):
+#         y, = ctx.saved_tensors()
+#         return MyMul.apply(gy, y)
+#
+# x = torch.randn([], requires_grad=True)
+# gy = torch.randn([], requires_grad=True)
+# _, vjp_fn = vjp(MySin.apply, x)
+# result = vjp_fn(gy)
+#
+# MyMul is an autograd.Function that is not shown here.
+# It saves a `y` for backward (since gy requires grad).
+#
+# in vjp_fn(gy), we get:
+# > MyMul.apply(gy, GradTensorWrapper(y, level=dead))
+# Because the y that is saved for backward by MyExp is a GradTensorWrapper
+# but is now dead since we are outside the vjp context.
+#
+# PyTorch dispatcher operations, upon seeing a dead GradTensorWrapper,
+# will automatically unwrap the GradTensorWrapper when applied.
+# But since autograd.Function technically sits above the regular PyTorch
+# dispatcher, it doesn't get this treatment. So we manually do
+# the unwrapping to be consistent with regular PyTorch dispatcher operations.
+
+
+class VmapInfo(NamedTuple):
+    batch_size: int
+    randomness: str
+
+
+def has_overridden_vmap_rule(
+    autograd_function: type[torch.autograd.Function],
+) -> bool:
+    return autograd_function.vmap is not torch.autograd.Function.vmap
+
+
+def validate_vmap_returns_tuple_of_two_elements(result: Any) -> None:
+    base_error_msg = (
+        "Expected the vmap staticmethod to have two returns, an output "
+        "and out_dims with pytree structure compatible with the output. "
+    )
+    if not isinstance(result, tuple):
+        raise RuntimeError(base_error_msg + f"Got a {type(result)} instead")
+    if not len(result) == 2:
+        raise RuntimeError(base_error_msg + f"Got {len(result)} returns instead")
+
+
+@custom_function_call.py_impl(TransformType.Vmap)
+def custom_function_call_vmap(
+    interpreter: VmapInterpreter,
+    autograd_function: type[torch.autograd.Function],
+    *operands: Any,
+    **kwargs: Any,
+) -> Any:
+    if any(
+        isinstance(val, torch.Tensor)
+        for val in torch.utils._pytree.tree_flatten(kwargs)[0]
+    ):
+        raise NotImplementedError(
+            f"Run vmap on autograd.Function with kwarg-only Tensor args. "
+            f"Please do not pass kwarg-only Tensors to autograd.Function. "
+            f"Got: {kwargs}"
+        )
+
+    if autograd_function.generate_vmap_rule:
+        if has_overridden_vmap_rule(autograd_function):
+            # TODO: Update link to stable once that's out
+            # https://github.com/pytorch/pytorch/issues/92029
+            raise RuntimeError(
+                f"You tried to vmap over {autograd_function.__name__}, but "
+                f"it has both generate_vmap_rule=True and an overridden vmap "
+                f"staticmethod. Please set generate_vmap_rule=False or delete "
+                f"the overridden vmap staticmethod to avoid ambiguity. "
+                f"For more details, please see "
+                f"https://pytorch.org/docs/main/notes/extending.func.html"
+            )
+        return custom_function_call_vmap_generate_rule(
+            interpreter, autograd_function, *operands
+        )
+
+    if not has_overridden_vmap_rule(autograd_function):
+        # TODO: Update link to stable once that's out
+        # https://github.com/pytorch/pytorch/issues/92029
+        raise RuntimeError(
+            f"You tried to vmap over {autograd_function.__name__}, but "
+            f"it does not have vmap support. Please override and implement the "
+            f"vmap staticmethod or set generate_vmap_rule=True. "
+            f"For more details, please see "
+            f"https://pytorch.org/docs/main/notes/extending.func.html"
+        )
+
+    return custom_function_call_vmap_helper(
+        interpreter, autograd_function.vmap, autograd_function, *operands, **kwargs
+    )
+
+
+def custom_function_call_vmap_helper(
+    interpreter: VmapInterpreter,
+    vmap_function: Callable[..., Any],
+    op: Any,
+    *operands: Any,
+    **kwargs: Any,
+) -> Any:
+    current_level = interpreter.level()
+    info = VmapInfo(
+        batch_size=interpreter.batch_size(),
+        randomness=interpreter.randomness(),
+    )
+    # We're either in the autograd.Function case (vmap staticmethod)
+    # or the torch.library.register_vmap case.
+    autograd_function_case = isinstance(op, torch.autograd.function.FunctionMeta)
+
+    def lower_to_next() -> Any:
+        if autograd_function_case:
+            return interpreter.lower()
+        else:
+            return torch._C._ExcludeDispatchKeyGuard(
+                torch._C.DispatchKeySet(torch._C.DispatchKey.FuncTorchBatched)
+            )
+
+    unwrapped_operands, in_dims = unwrap_batched(operands, current_level)
+    # If none of the tensors are batched at the current level, then we skip the
+    # current level. This saves the user from needing to handle this case in
+    # their vmap staticmethod (and is consistent with our C++ batching rule API)
+    if pytree.tree_all(lambda dim: dim is None, in_dims):
+        with lower_to_next():
+            if autograd_function_case:
+                return custom_function_call(op, *operands)
+            else:
+                return op(*operands, **kwargs)
+
+    with lower_to_next():
+        result = vmap_function(info, in_dims, *unwrapped_operands, **kwargs)
+    validate_vmap_returns_tuple_of_two_elements(result)
+    unwrapped_output, out_dims = result
+
+    # See NOTE [mark_dirty object identity check]
+    def wrap_fn(output: torch.Tensor, out_dim: int | None) -> torch.Tensor:
+        return (
+            output
+            if out_dim is None
+            else _add_batch_dim(output, out_dim, current_level)
+        )
+
+    return wrap_outputs_maintaining_identity(
+        unwrapped_output, unwrapped_operands, operands, wrap_fn, out_dims=out_dims
+    )
+
+
+def unpack_outputs(outputs: tuple[Any, ...]) -> tuple[Any, Any]:
+    out_dims = outputs[-1]
+    if isinstance(out_dims, tuple):
+        outputs = outputs[:-1]
+    else:
+        outputs = outputs[0]
+    return outputs, out_dims
+
+
+def custom_function_call_vmap_generate_rule(
+    interpreter: VmapInterpreter,
+    autograd_function: type[torch.autograd.Function],
+    *operands: Any,
+) -> Any:
+    unwrapped_operands, in_dims = unwrap_batched(operands, interpreter.level())
+    vmapped_function = vmapify_autograd_function(
+        autograd_function,
+        in_dims,
+        interpreter.batch_size(),
+        interpreter.randomness(),
+    )
+    with interpreter.lower():
+        outputs = custom_function_call(vmapped_function, *unwrapped_operands)
+
+    if not isinstance(outputs, tuple):
+        raise AssertionError(f"expected outputs to be a tuple, got {type(outputs)}")
+    outputs, out_dims = unpack_outputs(outputs)
+    return wrap_batched(outputs, out_dims, interpreter.level())
+
+
+@custom_function_call.py_impl(TransformType.Functionalize)
+def custom_function_call_functionalize(
+    interpreter: FuncTorchInterpreter,
+    autograd_function: type[torch.autograd.Function],
+    generate_vmap_rule: bool,
+    *operands: Any,
+) -> Any:
+    raise RuntimeError("NYI: Functionalize rule for custom_function_call")
+
+
+def vmapify_autograd_function(
+    autograd_function: type[torch.autograd.Function],
+    in_dims: Any,
+    batch_size: int,
+    randomness: str,
+) -> type[torch.autograd.Function]:
+    def forward(*operands: Any) -> Any:
+        outputs, out_dims = restore_vmap(
+            autograd_function.forward, in_dims, batch_size, randomness
+        )(*operands)
+        if isinstance(outputs, torch.Tensor):
+            return outputs, out_dims
+        else:
+            return *outputs, out_dims
+
+    def setup_context(ctx: Any, inputs: Any, outputs: Any) -> None:
+        outputs, out_dims = unpack_outputs(outputs)
+        key = id(Generated)
+
+        def inner(inputs: Any, outputs: Any) -> None:
+            # wrapped_ctx.save_for_backward will:
+            # - unwrap batchedtensors into (tensor, bdim)
+            # - save_for_backward(*unwrapped_tensors)
+            # - assign the bdims to wrapped_ctx._pt_saved_tensors_bdims
+            wrapped_ctx = CtxCustomSave(ctx, current_level())
+            autograd_function.setup_context(wrapped_ctx, inputs, outputs)
+
+            # input_shapes are used for reductify later to reduce expanded gradients
+            # to the correct shape.
+            # See NOTE: [Why can't we rely on autograd to reduce expanded gradients?]
+            # for more details
+            input_shapes = tuple(
+                inp.shape if isinstance(inp, torch.Tensor) else None for inp in inputs
+            )
+            if not hasattr(ctx, "_pt_input_shapes"):
+                # pyrefly: ignore [implicit-any]
+                ctx._pt_input_shapes = {}
+            ctx._pt_input_shapes.update({key: input_shapes})
+
+            if not hasattr(ctx, "_pt_saved_tensors_bdims_stack"):
+                # pyrefly: ignore [implicit-any]
+                ctx._pt_saved_tensors_bdims_stack = {}
+            ctx._pt_saved_tensors_bdims_stack.update(
+                {key: (wrapped_ctx._pt_saved_tensors_bdims)}
+            )
+
+        # See NOTE: [Why do we need to run setup_context under a vmap?]
+        restore_vmap(
+            inner,
+            (in_dims, out_dims),
+            batch_size,
+            randomness,
+        )(inputs, outputs)
+
+        if not hasattr(ctx, "_pt_out_dims"):
+            # pyrefly: ignore [implicit-any]
+            ctx._pt_out_dims = {}
+        ctx._pt_out_dims.update({key: out_dims})
+
+    def jvp(ctx: Any, *tangents: Any) -> Any:
+        key = id(Generated)
+
+        def jvp_no_context(saved_tensors: Any, tangents: Any) -> Any:
+            wrapped_ctx = CtxWithSavedTensors(ctx, saved_tensors)
+            return autograd_function.jvp(wrapped_ctx, *tangents)
+
+        tangent_in_dims = get_tangents_in_dims(in_dims, tangents)
+        out_tangents, out_tangents_dims = restore_vmap(
+            jvp_no_context,
+            (ctx._pt_saved_tensors_bdims_stack[key], tangent_in_dims),
+            batch_size,
+            randomness,
+        )(ctx.saved_tensors, tangents)
+
+        result = reductify(
+            out_tangents, out_tangents_dims, ctx._pt_out_dims[key], batch_size
+        )
+        if isinstance(result, torch.Tensor):
+            return result, None
+        else:
+            return *result, None
+
+    def backward(ctx: Any, *grad_outputs: Any) -> Any:
+        key = id(Generated)
+        grad_outputs_ = grad_outputs[:-1]
+        grad_outputs_in_dims = ctx._pt_out_dims[key]
+
+        if not isinstance(grad_outputs_in_dims, tuple):
+            grad_outputs_in_dims = (grad_outputs_in_dims,)
+
+        grad_outputs_in_dims = tuple(
+            in_dim if grad_output is not None else None
+            for grad_output, in_dim in zip(grad_outputs_, grad_outputs_in_dims)
+        )
+
+        def backward_no_context(inputs: Any) -> Any:
+            saved_tensors, grad_outputs = inputs
+            wrapped_ctx = CtxWithSavedTensors(ctx, saved_tensors)
+            return autograd_function.backward(wrapped_ctx, *grad_outputs)
+
+        grad_ins, grad_ins_dims = restore_vmap(
+            backward_no_context,
+            ((ctx._pt_saved_tensors_bdims_stack[key], grad_outputs_in_dims),),
+            batch_size,
+            randomness,
+        )((ctx.saved_tensors, grad_outputs_))
+        result = reductify(
+            grad_ins, grad_ins_dims, in_dims, batch_size, ctx._pt_input_shapes[key]
+        )
+        return result
+
+    name = f"Vmapped{autograd_function.__name__}"
+    Generated = type(
+        name,
+        (torch.autograd.Function,),
+        {
+            "forward": staticmethod(forward),
+            "backward": staticmethod(backward),
+            "jvp": staticmethod(jvp),
+            "setup_context": staticmethod(setup_context),
+            "generate_vmap_rule": True,
+        },
+    )
+
+    return Generated
+
+
+# tangents might be None, so we need to replace
+# the corresponding in_dims with None.
+def get_tangents_in_dims(input_dims: Any, tangents: tuple[Any, ...]) -> Any:
+    flat_in_dims, spec = pytree.tree_flatten(input_dims)
+    flat_tangents = pytree.arg_tree_leaves(*tangents)
+    result = [
+        None if tangent is None else in_dim
+        for in_dim, tangent in zip(flat_in_dims, flat_tangents)
+    ]
+    return pytree.tree_unflatten(result, spec)
+
+
+# NOTE: [Why do we need to run setup_context under a vmap?]
+# Consider the following autograd.Function
+#
+# class Sum(torch.autograd.Function):
+#    @staticmethod
+#    def forward(x):
+#        return x.sum()
+#    @staticmethod
+#    def setup_context(ctx, inputs, outputs):
+#        ctx.x_shape = inputs[0]
+#    @staticmethod
+#    def backward(ctx, gy):
+#        return gy.expand(ctx.x_shape)
+#
+# x = torch.randn(B, 4)
+# in_dims = 0
+# vmap(Sum.apply, in_dims)(x)
+#
+# Let's assume for a moment that we didn't vmap setup_context in VmappedSum:
+#
+# class VmappedSum(torch.autograd.Function):
+#    @staticmethod
+#    def forward(x):
+#        return vmap(Sum.forward, in_dims)(x)
+#
+#    @staticmethod
+#    def setup_context(ctx, inputs, outputs):
+#        Sum.setup_context(ctx, inputs, outputs)
+#
+#    @staticmethod
+#    def backward(ctx, gy):
+#        def backward_no_context(gy):
+#            return gy.expand(ctx.x_shape)
+#
+#        dims = (0,)
+#        gx = vmap(backward_no_context, dims)(gy)
+#        return gx
+#
+# We end up saving [B, 4] as x_shape. In the backward, gy has shape [B],
+# and we're doing:
+#
+# def backward_no_context(gy):
+#     return gy.expand([B, 4])
+#
+# gx = vmap(backward_no_context, dims)(gy: "Tensor[B]")
+#
+# This gives us the wrong result (gx has shape [B, B, 4], but it should
+# have shape [4]). Performing vmap over setup_context means the shape
+# saved has shape [4] and leads to a correct result shape for gx.
+
+
+# Wraps a ctx object. Forwards all attr accesses to the underlying object
+# except for the attrs in _pt_attrs
+class WrappedCtx:
+    _pt_reserved_attrs: tuple[str, ...] = ("_pt_reserved_attrs", "_pt_inner_ctx")
+
+    def __init__(self, ctx: Any) -> None:
+        if not isinstance(ctx, WrappedCtx):
+            reserved_attrs = type(self)._pt_reserved_attrs
+            for name in reserved_attrs:
+                if not hasattr(ctx, name):
+                    continue
+                raise RuntimeError(
+                    f"PyTorch reserves the {reserved_attrs} field on ctx. "
+                    "Please name your fields on ctx something else to avoid name "
+                    "collision."
+                )
+        self._pt_inner_ctx = ctx
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._pt_inner_ctx, name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name in type(self)._pt_reserved_attrs:
+            self.__dict__[name] = value
+            return
+        return setattr(self._pt_inner_ctx, name, value)
+
+
+# Wraps ctx to create a new ctx object that overrides saved_tensors.
+class CtxWithSavedTensors(WrappedCtx):
+    _pt_reserved_attrs = ("_pt_new_saved_tensors", *WrappedCtx._pt_reserved_attrs)
+
+    def __init__(self, ctx: Any, new_saved_tensors: Sequence[torch.Tensor]) -> None:
+        super().__init__(ctx)
+        self._pt_new_saved_tensors = new_saved_tensors
+
+    @property
+    def saved_tensors(self) -> Sequence[torch.Tensor]:
+        return self._pt_new_saved_tensors
+
+
+class CtxCustomSave(WrappedCtx):
+    _pt_reserved_attrs = (
+        "_pt_saved_tensors_bdims",
+        "_pt_current_level",
+        *WrappedCtx._pt_reserved_attrs,
+    )
+
+    def __init__(self, ctx: Any, current_level: int) -> None:
+        super().__init__(ctx)
+        self._pt_saved_tensors_bdims: tuple[Any, ...] = ()
+        self._pt_current_level = current_level
+
+    def save_for_backward(self, *tensors: torch.Tensor) -> None:
+        unwrapped_tensors, bdims = unwrap_batched(tensors, self._pt_current_level)
+        self._pt_inner_ctx.save_for_backward(*unwrapped_tensors)
+        self._pt_saved_tensors_bdims = bdims
+
+    def save_for_forward(self, *tensors: torch.Tensor) -> None:
+        unwrapped_tensors, bdims = unwrap_batched(tensors, self._pt_current_level)
+        self._pt_inner_ctx.save_for_forward(*unwrapped_tensors)
+        self._pt_saved_tensors_bdims = bdims
+
+
+def reductify(
+    grad_input: torch.Tensor | tuple[torch.Tensor, ...],
+    grad_input_bdim: int | tuple[int, ...],
+    input_bdim: int | tuple[int, ...],
+    batch_size: int,
+    target_shape_without_bdim_to_reduce_to: Any = None,
+) -> tuple[Any, ...]:
+    if not isinstance(grad_input, tuple):
+        grad_input = (grad_input,)
+    if not isinstance(grad_input_bdim, tuple):
+        grad_input_bdim = (grad_input_bdim,)
+    if not isinstance(input_bdim, tuple):
+        input_bdim = (input_bdim,)
+
+    if target_shape_without_bdim_to_reduce_to is None:
+        target_shape_without_bdim_to_reduce_to = len(grad_input) * (None,)
+    result = tuple(
+        reductify_leaf(gi, gi_bdim, i_bdim, batch_size, maybe_ishape)
+        for gi, gi_bdim, i_bdim, maybe_ishape in zip(
+            grad_input,
+            grad_input_bdim,
+            input_bdim,
+            target_shape_without_bdim_to_reduce_to,
+        )
+    )
+    return result
+
+
+def reductify_leaf(
+    grad_input: torch.Tensor | None,
+    grad_input_bdim: int | None,
+    input_bdim: int | None,
+    batch_size: int,
+    target_shape_without_bdim_to_reduce_to: Any = None,
+) -> torch.Tensor | None:
+    if grad_input is None:
+        return None
+
+    if grad_input_bdim is None and input_bdim is None:
+        return grad_input
+
+    if grad_input_bdim is not None and input_bdim is None:
+        return grad_input.sum(grad_input_bdim)
+
+    # NOTE: [Why can't we rely on autograd to reduce expanded gradients?]
+    # For reverse-mode AD,
+    # given a grad_input and input, it is valid for the user to return a
+    # grad_input that has a broadcasted shape when compared to the input.
+    # In this situation, autograd automatically reduces the grad_input to
+    # the shape of the input.
+    #
+    # However, when input_bdim is not None, we have problems.
+    #
+    # [example 1]
+    # grad_input: Tensor[3, 4], input: Tensor[B, 4]
+    # We can expand grad_input to Tensor[B, 3, 4], but that isn't broadcastable
+    # from [B, 4].
+    #
+    # [example 2]
+    # grad_input: Tensor[3, B, 4], input: Tensor[B, 4]
+    # We can swizzle grad_input to Tensor[B, 3, 4], but that isn't broadcastable
+    # from [B, 4].
+    #
+    # This means that we need to also reduce the grad_input to the shape of the
+    # input. This behavior is controlled by the `target_shape_without_bdim_to_reduce_to` flag;
+    # if not-None then we do the reducing manually, otherwise, we do not do a reduction.
+    if input_bdim is None:
+        raise AssertionError("input_bdim must not be None")
+
+    if grad_input_bdim is None:
+        grad_input = grad_input.unsqueeze(input_bdim)
+        new_shape = list(grad_input.shape)
+        new_shape[input_bdim] = batch_size
+        grad_input = grad_input.expand(new_shape)
+        grad_input_bdim = input_bdim
+
+    if target_shape_without_bdim_to_reduce_to is not None:
+        return vmap(
+            torch.Tensor.sum_to_size,
+            in_dims=(grad_input_bdim, None),
+            out_dims=input_bdim,
+        )(grad_input, target_shape_without_bdim_to_reduce_to)
+
+    if input_bdim != grad_input_bdim:
+        grad_input = grad_input.movedim(grad_input_bdim, input_bdim)
+    return grad_input
+
+
+def autograd_function_forward_rewritten(
+    original_forward: Callable[_P, _R],
+    original_setup_context: Callable[..., Any],
+) -> Callable[..., _R]:
+    def new_forward(ctx: Any, *args: _P.args, **kwargs: _P.kwargs) -> _R:
+        output = original_forward(*args, **kwargs)
+        original_setup_context(ctx, args, output)
+        return output
+
+    return new_forward
+
+
+class AutogradFunctionApply(HigherOrderOperator):
+    def __init__(self) -> None:
+        super().__init__("autograd_function_apply")
+
+    def __call__(
+        self,
+        fwd: torch.fx.GraphModule,
+        bwd: torch.fx.GraphModule,
+        *fwd_args: Any,
+        **fwd_kwargs: Any,
+    ) -> Any:
+        saved_values: Iterable[Any] | None = None
+        dirty_idx = fwd_kwargs.get("dirty_idx", [])
+        dirty_idx_set = set(dirty_idx)
+        non_differentiable_idx = fwd_kwargs["non_differentiable_idx"]
+        saved_for_backward_idx = fwd_kwargs["saved_for_backward_idx"]
+
+        class ApplyTemplate(torch.autograd.Function):
+            @staticmethod
+            def forward(*args: Any, **kwargs: Any) -> Any:
+                nonlocal saved_values
+
+                # The Interpreter here is required to propagate metadata
+                # from the dynamo graph body to the local_map graph body.
+                # This is required for fx_traceback.annotate for work.
+                output, saved_values = torch.fx.Interpreter(fwd).run(*args)
+
+                # See Note [Activations with no version counter checks in eager]
+                # Mark tensors that came from ctx.save_for_backward with metadata.
+                # This allows AOT autograd to distinguish between tensors saved via
+                # save_for_backward vs those stashed directly on ctx (e.g., ctx.x = x).
+                from torch.fx.experimental.proxy_tensor import _get_proxies
+
+                for idx, t in enumerate(saved_values):
+                    if idx not in saved_for_backward_idx:
+                        for proxy in _get_proxies(t):
+                            proxy.node.meta["saved_tensor_with_no_vc_check"] = True
+
+                return output
+
+            @staticmethod
+            def setup_context(ctx: Any, inputs: tuple[Any, ...], output: Any) -> None:
+                def selected_outputs(idx: Iterable[int]) -> list[Any]:
+                    idx_set = set(idx)
+                    if isinstance(output, (tuple, list)):
+                        return [x for i, x in enumerate(output) if i in idx_set]
+                    return [output] if 0 in idx_set else []
+
+                # If users call ctx.mark_dirty() in the original fwd function.
+                if len(dirty_idx) > 0:
+                    ctx.mark_dirty(*selected_outputs(dirty_idx_set))
+
+                # If users call ctx.mark_non_differentiable() in the original fwd function.
+                if len(non_differentiable_idx) > 0:
+                    ctx.mark_non_differentiable(
+                        *selected_outputs(non_differentiable_idx)
+                    )
+
+            @staticmethod
+            def backward(ctx: Any, *grad: Any) -> Any:
+                # The Interpreter here is required to propagate metadata
+                # from the dynamo graph body to the local_map graph body.
+                # This is required for fx_traceback.annotate for work.
+
+                if saved_values is None:
+                    raise AssertionError("saved_values must not be None")
+                return torch.fx.Interpreter(bwd).run(*grad, *saved_values)
+
+        return ApplyTemplate.apply(*fwd_args)
+
+
+autograd_function_apply = AutogradFunctionApply()
+
+
+class DynamoAutogradFunctionTraceHelper:
+    @staticmethod
+    def fwd_trace_helper(orig_fwd: Callable[_P, Any]) -> Callable[_P, Any]:
+        # autograd.Function forward does more than just running the forward method. Most
+        # of this logic is in C++. Here, we rewrite that functionality in python and let
+        # Dynamo trace it.
+        def inner(*args: _P.args, **kwargs: _P.kwargs) -> Any:
+            with torch.no_grad():
+                outs = orig_fwd(*args, **kwargs)
+
+            ctx = args[0]
+            dirty_tensors = getattr(ctx, "dirty_tensors", None)
+
+            def is_dirty_tensor(tensor: torch.Tensor) -> bool:
+                if dirty_tensors is None:
+                    return False
+                return any(
+                    tensor is dirty_tensor
+                    for dirty_tensor in dirty_tensors
+                    if isinstance(dirty_tensor, torch.Tensor)
+                )
+
+            def is_tensor_arg(tensor: torch.Tensor) -> bool:
+                return any(
+                    arg is tensor for arg in args if isinstance(arg, torch.Tensor)
+                )
+
+            # Handle the case where if the input is passed on directly to the output, we call view_as
+            # Refer to https://github.com/pytorch/pytorch/blob/main/torch/csrc/autograd/custom_function.cpp#L254
+            if isinstance(outs, torch.Tensor):
+                if is_tensor_arg(outs) and not is_dirty_tensor(outs):
+                    return outs.view_as(outs)
+                else:
+                    return outs
+
+            new_outs = []
+            for out in outs:
+                if isinstance(out, torch.Tensor):
+                    if is_tensor_arg(out) and not is_dirty_tensor(out):
+                        new_outs.append(out.view_as(out))
+                    else:
+                        new_outs.append(out)
+                else:
+                    new_outs.append(out)
+            return tuple(new_outs)
+
+            # TODO - there is missing functionality here, where
+            # autograd.Function overwrites the requires_grad_ of the output
+            # tensors depending on the `mark_non_differentiable`. Currently,
+            # this is handled hackily in Dynamo, where we just overwrite the
+            # variable trackers requires_grad. Refer to the function -
+            # overwrite_tensor_vt_requires_grad
+
+        return inner

.venv/lib/python3.12/site-packages/torch/_functorch/batch_norm_replacement.py

@@ -0,0 +1,27 @@
+import torch.nn as nn
+from torch._functorch.utils import exposed_in
+
+
+def batch_norm_without_running_stats(module: nn.Module) -> None:
+    if (
+        isinstance(module, nn.modules.batchnorm._BatchNorm)
+        and module.track_running_stats
+    ):
+        module.running_mean = None
+        module.running_var = None
+        module.num_batches_tracked = None
+        module.track_running_stats = False
+
+
+@exposed_in("torch.func")
+def replace_all_batch_norm_modules_(root: nn.Module) -> nn.Module:
+    """
+    In place updates :attr:`root` by setting the ``running_mean`` and ``running_var`` to be None and
+    setting track_running_stats to be False for any nn.BatchNorm module in :attr:`root`
+    """
+    # base case
+    batch_norm_without_running_stats(root)
+
+    for obj in root.modules():
+        batch_norm_without_running_stats(obj)
+    return root

.venv/lib/python3.12/site-packages/torch/_functorch/benchmark_utils.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import contextlib
+import json
+import operator
+import os
+import time
+from contextlib import AbstractContextManager
+from typing import Any, TYPE_CHECKING
+from typing_extensions import TypeVar
+
+import torch
+from torch.profiler import profile, ProfilerActivity
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+
+_R = TypeVar("_R")
+
+
+def synchronize() -> None:
+    pass
+
+
+def dump_chrome_trace(
+    f: Callable[[tuple[Any, ...]], _R],
+    input_: tuple[Any, ...],
+    trace_filename: str,
+    optimize_ctx: AbstractContextManager[Any],
+    activities: Sequence[ProfilerActivity],
+    num_runs: int = 1,
+    devices: list[str] | None = None,
+    kwargs_for_f: dict[str, Any] | None = None,
+    kwargs_for_profiler: dict[str, Any] | None = None,
+) -> float:
+    """
+    Output the chrome trace of running f(input_, **kwargs_for_f) with [optimize_ctx]
+    [num_runs] times to [trace_filename].
+
+    [activities] are the activities that the profiler will record, e.g. ProfilerActivity.CUDA.
+    Return total runtime without the profiler
+
+    Outputs to trace_filename
+    """
+
+    if devices is None:
+        devices = ["cuda"]
+
+    global synchronize
+    if devices != ["cpu"] and torch.accelerator.is_available():
+        synchronize = torch.accelerator.synchronize
+
+    if kwargs_for_f is None:
+        kwargs_for_f = {}
+    if kwargs_for_profiler is None:
+        kwargs_for_profiler = {}
+
+    with optimize_ctx:
+        torch.manual_seed(1337)
+        for _ in range(5):  # warmup runs
+            f(input_, **kwargs_for_f)
+            synchronize()
+        torch.manual_seed(1337)
+        t0 = time.perf_counter()
+        for _ in range(num_runs):
+            f(input_, **kwargs_for_f)
+            synchronize()
+        t1 = time.perf_counter()
+    timing = t1 - t0
+
+    with profile(activities=activities, **kwargs_for_profiler) as prof:
+        with optimize_ctx:
+            synchronize()
+            torch.manual_seed(1337)
+            for _ in range(num_runs):
+                f(input_, **kwargs_for_f)
+                synchronize()
+    prof.export_chrome_trace(trace_filename)
+
+    return timing
+
+
+def get_chrome_trace_events(filename: str) -> list[dict[str, Any]]:
+    with open(filename) as f:
+        data = json.load(f)
+    events = data["traceEvents"]
+    return events
+
+
+def is_gpu_compute_event(event: dict[str, Any]) -> bool:
+    global gpu_pids
+    return (
+        "pid" in event
+        and event["pid"] in gpu_pids
+        and "ph" in event
+        and event["ph"] == "X"
+    )
+
+
+def get_sorted_gpu_events(events: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    sorted_gpu_events: list[dict[str, Any]] = []
+    for event in events:
+        if not is_gpu_compute_event(event):
+            continue
+        sorted_gpu_events.append(event)
+    return sorted(sorted_gpu_events, key=operator.itemgetter("ts"))
+
+
+def get_duration(sorted_gpu_events: list[dict[str, Any]]) -> int:
+    if len(sorted_gpu_events) == 0:
+        return 0
+    event = sorted_gpu_events[0]
+    current_end_time = event["ts"] + event["dur"]
+    total_duration = event["dur"]
+    for event in sorted_gpu_events[1:]:
+        start_time = max(event["ts"], current_end_time)
+        end_time = event["ts"] + event["dur"]
+        total_duration = total_duration + max(end_time - start_time, 0)
+        current_end_time = max(current_end_time, end_time)
+    return total_duration
+
+
+def get_sorted_gpu_mm_conv_events(events: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    def is_mm_conv_event(event: dict[str, Any]) -> bool:
+        return "name" in event and (
+            "gemm" in event["name"]
+            or "conv" in event["name"]
+            or "cutlass" in event["name"]
+            or "wgrad" in event["name"]
+        )
+
+    gpu_events = get_sorted_gpu_events(events)
+    sorted_events: list[dict[str, Any]] = []
+    for event in gpu_events:
+        if not is_mm_conv_event(event):
+            continue
+        sorted_events.append(event)
+    return sorted_events
+
+
+gpu_pids: list[Any] = []
+
+
+def compute_utilization(filename: str, total_length: float) -> tuple[float, float]:
+    """
+    Process the chrome traces outputs by the pytorch profiler to compute GPU Utilization
+    and percent of times spent on matmul and convolution
+
+    Args:
+        filename(str): Name of chrome traces file produced by pytorch profiler
+
+        total_length(float): total length of the process without profiler in second
+
+    Return:
+        tuple: (GPU Utilization, percent of time spent on matmul and convolution)
+    """
+    events = get_chrome_trace_events(filename)
+
+    # get pids of GPU events
+    global gpu_pids
+    gpu_pids = []
+    for event in events:
+        if "name" not in event:
+            continue
+        if event["name"] == "process_labels" and "GPU" in event["args"]["labels"]:
+            gpu_pids.append(event["pid"])
+
+    total_length = total_length * 1e6
+    sorted_gpu_events = get_sorted_gpu_events(events)
+    utilization = get_duration(sorted_gpu_events) / total_length
+
+    sorted_gpu_mm_conv_events = get_sorted_gpu_mm_conv_events(events)
+    mm_conv_utilization = get_duration(sorted_gpu_mm_conv_events) / total_length
+
+    return utilization, mm_conv_utilization
+
+
+def benchmark_utilization(
+    f: Callable[[tuple[Any, ...]], _R],
+    input_: tuple[Any, ...],
+    trace_folder: str,
+    optimize_ctx: AbstractContextManager[Any] | None = None,
+    trace_file_name: str = "tmp_chrome_trace",
+    num_runs: int = 1,
+) -> tuple[float, float]:
+    """
+    Benchmark the GPU Utilization and percent of time spent on matmul and convolution operations of
+    running f(input_, **kwargs_for_f) with [optimize_ctx] [num_runs] times.
+    It will produce a chrome trace file in trace_folder/trace_file_name.json
+
+    Example:
+
+    ```
+    def f(a):
+        return a.sum()
+
+
+    a = torch.rand(2**20, device="cuda")
+    utilization, mm_conv_utilization = benchmark_utilization(
+        f, a, "tmp", trace_file_name="tmp_chrome_trace"
+    )
+    ```
+
+    Args:
+        f: function to benchmark
+
+        input_: input to :attr:`f`
+
+        trace_folder: name of the folder to store the chrome trace
+
+        optimize_ctx: the context in which f will run
+
+        trace_file_name: name of the dumped chrome trace file, default to "tmp_chrome_trace"
+
+        num_runs: number of times to run f, excluding the warm-up runs, default to 1.
+
+    Return:
+        tuple: (GPU Utilization, percent of time spent on matmul and convolution)
+
+    """
+    isExist = os.path.exists(trace_folder)
+    if not isExist:
+        os.makedirs(trace_folder)
+        print("create folder " + trace_folder)
+
+    if optimize_ctx is None:
+        optimize_ctx = contextlib.nullcontext()
+
+    chrome_trace_file_name = os.path.join(trace_folder, trace_file_name + ".json")
+    total_length = dump_chrome_trace(
+        f,
+        input_,
+        chrome_trace_file_name,
+        optimize_ctx,
+        [ProfilerActivity.CUDA],
+        num_runs=num_runs,
+        devices=["cuda"],
+    )
+    utilization, mm_conv_utilization = compute_utilization(
+        chrome_trace_file_name, total_length
+    )
+
+    return utilization, mm_conv_utilization

.venv/lib/python3.12/site-packages/torch/_functorch/compile_utils.py

@@ -0,0 +1,306 @@
+from __future__ import annotations
+
+import dataclasses
+import operator
+import struct
+from typing import Any, TYPE_CHECKING
+
+import sympy
+
+import torch
+import torch.fx as fx
+from torch.fx.experimental.symbolic_shapes import free_unbacked_symbols
+from torch.multiprocessing.reductions import StorageWeakRef
+from torch.utils import _pytree as pytree
+from torch.utils._pytree import tree_flatten
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Hashable
+
+    from torch._ops import OpOverloadPacket
+    from torch.utils._pytree import TreeSpec
+
+aten = torch.ops.aten
+
+
+@dataclasses.dataclass(frozen=True)
+class _ScalarKey:
+    tag: str
+    bits: bytes
+
+
+def _normalize_cse_arg(val: Any) -> Any:
+    # Python float hash/eq is not value-identity: nan != nan (hash(nan) is
+    # id-based) while -0.0 == 0.0 and hashes equal. Key by bit pattern instead.
+    if type(val) is float:
+        return _ScalarKey("float", struct.pack(">d", val))
+    if type(val) is complex:
+        return _ScalarKey("complex", struct.pack(">dd", val.real, val.imag))
+    return val
+
+
+def get_aten_target(node: fx.Node) -> OpOverloadPacket | Callable[..., Any] | str:
+    if hasattr(node.target, "overloadpacket"):
+        return node.target.overloadpacket
+    return node.target
+
+
+rand_ops = [
+    aten.dropout,
+    aten._fused_dropout,
+    aten._standard_gamma,
+    aten.bernoulli,
+    aten.multinomial,
+    aten.native_dropout,
+    aten.normal,
+    aten.poisson,
+    aten.binomial,
+    aten.rrelu,
+    aten.rand_like,
+    aten.rand,
+    aten.randint,
+    aten.randn,
+    aten.randperm,
+]
+
+
+# return a new copy of torch.fx.graph.Graph with CSE applied to the input graph
+def fx_graph_cse(
+    fx_g: torch.fx.graph.Graph,
+    extra_node_key: Callable[[fx.Node], Hashable] | None = None,
+) -> fx.Graph:
+    new_graph = fx.Graph()
+    env: dict[
+        fx.Node, fx.Node
+    ] = {}  # map from node in the old graph to node in the new graph
+    hash_env: dict[
+        tuple[Any, Hashable | None, int], fx.Node
+    ] = {}  # map from hash to a node in the new graph
+    token_map: dict[
+        tuple[Any, Hashable | None, int], dict[str, Any]
+    ] = {}  # map from hash to token
+
+    from torch._inductor.pattern_matcher import (
+        compute_mutation_region_ids,
+        same_mutation_regions,
+    )
+
+    compute_mutation_region_ids(fx_g)  # type: ignore[arg-type]
+
+    # Make a set of separate storages returned from the output, which will be preserved
+    # when pruning.  This prevents us from deduplicating returned tensors which have
+    # experienced identical operations, but are separate data structures in eager mode.
+    output_node: fx.Node = list(fx_g.nodes)[-1]
+    if output_node.op != "output":
+        raise AssertionError(
+            f"expected output_node.op to be 'output', got '{output_node.op}'"
+        )
+
+    def checkable_node(node: fx.Node) -> bool:
+        """We can evaluate only nodes that represent tensors with defined storage."""
+        if "val" not in node.meta or not isinstance(node.meta["val"], torch.Tensor):
+            return False
+
+        try:
+            node.meta["val"].untyped_storage()
+        except NotImplementedError:
+            return False
+
+        return True
+
+    def custom_context_key(node: fx.Node) -> tuple[int, int | None, int | None]:
+        custom = node.meta.get("custom", {})
+        return (
+            custom.get("stream", 0),
+            custom.get("mempool"),
+            custom.get("mempool_device"),
+        )
+
+    output_storages = {
+        StorageWeakRef(n.meta["val"].untyped_storage())
+        for n in output_node.all_input_nodes
+        if checkable_node(n)
+    }
+    nodes_that_alias_outputs = {
+        n
+        for n in fx_g.nodes
+        if checkable_node(n)
+        and StorageWeakRef(n.meta["val"].untyped_storage()) in output_storages
+    }
+
+    # A node used as the mutable base of a functional-wrapper op is a distinct
+    # mutable buffer. Two identical factory ops feeding distinct bases (e.g. the
+    # forward and backward ``aten.full`` from a pair of ``ones_like`` calls) must
+    # not be CSE-merged, or the later mutation aliases a buffer that still has a
+    # live downstream view and reinplacing fails (mirrors the aten.empty
+    # exclusion below). See pytorch/pytorch#170160.
+    from torch._higher_order_ops.auto_functionalize import get_mutable_args
+    from torch._higher_order_ops.triton_kernel_wrap import (
+        triton_kernel_wrapper_functional,
+    )
+
+    def _add_base(node: Any, bases: set[fx.Node]) -> None:
+        for b in node if isinstance(node, (list, tuple)) else (node,):
+            if isinstance(b, fx.Node):
+                bases.add(b)
+
+    nodes_used_as_mutation_base: set[fx.Node] = set()
+    for n in fx_g.find_nodes(
+        op="call_function", target=torch.ops.higher_order.auto_functionalized_v2
+    ):
+        # v2 lists its mutable buffers explicitly in ``_all_bases``.
+        for base in n.kwargs.get("_all_bases", ()):
+            _add_base(base, nodes_used_as_mutation_base)
+    for n in fx_g.find_nodes(
+        op="call_function", target=torch.ops.higher_order.auto_functionalized
+    ):
+        # v1 has no ``_all_bases``; the mutated tensors are the args named by the
+        # wrapped op's schema (``_mutable_op`` is the first positional).
+        mutable_op = n.args[0]
+        mutable_args_names, _ = get_mutable_args(mutable_op)
+        for name in mutable_args_names:
+            _add_base(n.kwargs.get(name), nodes_used_as_mutation_base)
+    for n in fx_g.find_nodes(
+        op="call_function", target=triton_kernel_wrapper_functional
+    ):
+        inner_kwargs = n.kwargs.get("kwargs", {})
+        for name in n.kwargs.get("tensors_to_clone", ()):
+            _add_base(inner_kwargs.get(name), nodes_used_as_mutation_base)
+
+    for n in fx_g.nodes:
+        # The placeholder, output, and get_attr nodes are copied to the new graph without change
+        # do not CSE away random operations
+        if (
+            n.op == "placeholder"
+            or n.op == "output"
+            or n.op == "get_attr"
+            or n.is_impure()
+            or get_aten_target(n) in rand_ops
+            # aten.empty is non-deterministic, so don't CSE it.
+            # Also, aten.empty is almost always fusible into its consumer,
+            # so it's not worth CSEing.
+            or get_aten_target(n) is aten.empty
+            or n in nodes_that_alias_outputs
+            # Keep distinct functional-wrapper mutation bases independent.
+            or n in nodes_used_as_mutation_base
+            # This CSE pass currently doesn't handle re-propagation of unbacked
+            # meta where it'll sometimes eliminate a _local_scalar_dense but not
+            # replace the meta of downstream users. eg. one bug we've seen is:
+            #
+            # _local_scalar_dense_11: "Sym(u14)" = torch.ops.aten._local_scalar_dense.default(select_10);
+            # sym_sum_2: "Sym(u19 + u20 + u21)" = torch.sym_sum((_local_scalar_dense_11, _local_scalar_dense_12, _local_scalar_dense_13))
+            #
+            # Notice how _local_scalar_dense_11 is u14 but sym_sum_2's meta is incorrectly the old
+            # pre-cse value of u19.
+            or (
+                "val" in n.meta
+                and isinstance(n.meta["val"], sympy.Symbol)
+                and free_unbacked_symbols(n.meta["val"])
+            )
+        ):
+            new_node = new_graph.node_copy(n, lambda x: env[x])
+            env[n] = new_node
+        else:  # n.op == 'call_function', should never see n.op == 'call_module' or 'call_method'
+            # substitute args and kwargs members to their mapping in env if exists
+            # specs can be used to reconstruct nested list/dictionaries
+            def substitute(
+                arg_list: list[Any] | tuple[Any, ...],
+            ) -> tuple[tuple[Any, ...], TreeSpec]:
+                arg_list, spec = tree_flatten(arg_list)
+                for i in range(len(arg_list)):
+                    v = arg_list[i]
+                    if isinstance(v, torch.fx.node.Node) and v in env:
+                        arg_list[i] = env[v]
+                    if isinstance(v, (torch.SymBool, torch.SymInt, torch.SymFloat)):
+                        arg_list[i] = v.node
+                    arg_list[i] = _normalize_cse_arg(arg_list[i])
+                return tuple(arg_list), spec
+
+            args, args_spec = substitute(n.args)
+            kwargs, kwargs_spec = substitute(n.kwargs)
+
+            # each token corresponds to a unique node
+            # nodes with the same token can be substituted
+            extra_key = extra_node_key(n) if extra_node_key is not None else None
+            token = {
+                "target": n.target,
+                "extra_key": extra_key,
+                "args": args,
+                "args_spec": args_spec,
+                "kwargs": kwargs,
+                "kwargs_spec": kwargs_spec,
+                "custom_context": custom_context_key(n),
+            }
+
+            # hash substituted args to a number, do not hash specs because specs are not hashable
+            # We need to add type into hash to avoid situations like:
+            # hash((primals_2, 1.0)) == hash((primals_2, 1))
+            hash_arg = hash(
+                (tuple((a, type(a)) for a in args), tuple((a, type(a)) for a in kwargs))
+            )
+            hash_val = (n.target, extra_key, hash_arg)
+
+            # check if a node has a substitute and can be eliminated
+            hash_val_in_hash_env = hash_val in hash_env
+            overwrite_due_to_mutation = False
+            if hash_val_in_hash_env and token_map[hash_val] == token:
+                duplicate_n_prev = hash_env[hash_val]
+                if same_mutation_regions(n, duplicate_n_prev):
+                    env[n] = duplicate_n_prev
+                    continue
+                else:
+                    # any futures duplicates should replace with n, not duplicate_n_prev
+                    overwrite_due_to_mutation = True
+
+            new_node = new_graph.node_copy(n, lambda x: env[x])
+            env[n] = new_node
+            if overwrite_due_to_mutation or not hash_val_in_hash_env:
+                hash_env[hash_val] = new_node
+                token_map[hash_val] = token
+
+    return new_graph
+
+
+def raise_getitems(gm: fx.GraphModule) -> fx.GraphModule:
+    # Pre-create a list of nodes to iterate over, as modifying the node order
+    # during the loop can lead to infinite loops if not handled properly.
+    getitem_nodes = list(
+        gm.graph.find_nodes(op="call_function", target=operator.getitem)
+    )
+
+    # loop through getitem nodes in the graph and raise them to the parent node
+    # in reverse order to preserve their original relative order
+    for node in reversed(getitem_nodes):
+        if len(node.all_input_nodes) != 1:
+            raise AssertionError(
+                f"expected node {node.name} to have 1 input node, got {len(node.all_input_nodes)}"
+            )
+        parent = node.all_input_nodes[0]
+        parent.append(node)
+
+    gm.recompile()
+    return gm
+
+
+def strip_overloads(gm: fx.GraphModule) -> None:
+    """
+    Modifies the target of graph nodes in :attr:`gm` to strip overloads.
+
+    Args:
+        gm(fx.GraphModule): The input Fx graph module to be modified
+    """
+    for node in gm.graph.nodes:
+        if isinstance(node.target, torch._ops.OpOverload):
+            node.target = node.target.overloadpacket
+    gm.recompile()
+
+
+def get_placeholders(graph: fx.Graph) -> list[Any]:
+    return graph.find_nodes(op="placeholder")
+
+
+def get_outputs(graph: fx.Graph) -> list[fx.Node]:
+    for node in graph.find_nodes(op="output"):
+        return pytree.tree_leaves(node.args[0])
+    raise AssertionError("No output node found")

.venv/lib/python3.12/site-packages/torch/_functorch/compilers.py

@@ -0,0 +1,505 @@
+from __future__ import annotations
+
+import copy
+import logging
+import os
+import pickle
+import random
+from contextlib import contextmanager
+from functools import partial
+from typing import Any, TYPE_CHECKING
+from typing_extensions import ParamSpec, TypeVar
+
+import sympy
+
+import torch
+import torch.fx as fx
+import torch.nn as nn
+import torch.utils._pytree as pytree
+from torch import SymInt
+from torch._decomp import get_decompositions
+from torch.fx.experimental.symbolic_shapes import bind_symbols
+
+from .aot_autograd import aot_function, aot_module, make_boxed_compiler
+from .compile_utils import strip_overloads
+from .partitioners import (
+    default_partition,
+    draw_graph,
+    min_cut_rematerialization_partition,
+)
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator, Sequence
+
+    from torch.fx.node import Node
+    from torch.types import IntLikeType
+
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+log = logging.getLogger(__name__)
+
+
+# These canonicalizations are needed here (and not decompositions), as the ops
+# we're trying to canonicalize to CompositeImplicitAutograd.
+def _canonicalize(fx_g: fx.GraphModule) -> fx.GraphModule:
+    for node in fx_g.graph.find_nodes(
+        op="call_function", target=torch.ops.aten._to_copy
+    ):
+        node.target = torch.ops.aten.to
+    fx_g.recompile()
+    return fx_g
+
+
+@contextmanager
+def _disable_jit_autocast() -> Generator[None, None, None]:
+    # pyrefly: ignore [missing-attribute]
+    old_jit_autocast_flag = torch._C._jit_set_autocast_mode(False)
+    try:
+        yield
+    finally:
+        # pyrefly: ignore [missing-attribute]
+        torch._C._jit_set_autocast_mode(old_jit_autocast_flag)
+
+
+@make_boxed_compiler
+def ts_compile(fx_g: fx.GraphModule, inps: Sequence[Any]) -> torch.jit.ScriptModule:
+    """
+    Compiles the :attr:`fx_g` with Torchscript compiler.
+
+    .. warning::
+        This API is experimental and likely to change.
+
+    Args:
+        fx_g(fx.GraphModule): The input Fx graph module to be compiled.
+
+    Returns:
+        Torch scripted model.
+    """
+
+    from torch.fx._lazy_graph_module import _unwrap_lazy_graph_module
+
+    fx_g = _unwrap_lazy_graph_module(fx_g)
+
+    with _disable_jit_autocast():
+        strip_overloads(fx_g)
+
+        for node in fx_g.graph.find_nodes(
+            op="call_function", target=torch.ops.aten._to_copy
+        ):
+            if len(node.args) == 1 and len(node.kwargs) == 1 and "dtype" in node.kwargs:
+                node.target = torch.ops.aten.to
+
+        for node in fx_g.graph.nodes:
+            new_kwargs = {}
+            for k, v in node.kwargs.items():
+                if isinstance(v, torch.device):
+                    v = v.type
+                new_kwargs[k] = v
+            node.kwargs = new_kwargs
+
+        fx_g.graph.lint()
+
+        fx_g.recompile()
+
+        f = torch.jit.script(fx_g)
+
+        # pyrefly: ignore [missing-attribute]
+        torch._C._jit_pass_remove_mutation(f.graph)
+
+        f = torch.jit.freeze(f.eval())
+        f = torch.jit.optimize_for_inference(f)
+        if not any(torch._subclasses.fake_tensor.is_fake_tensor(t) for t in inps):
+            f(*inps)
+    return f
+
+
+def _draw_graph_compile(
+    fx_g: fx.GraphModule, _: Any, name: str, clear_meta: bool = True
+) -> fx.GraphModule:
+    print(fx_g.code)
+    draw_graph(fx_g, name, clear_meta=clear_meta)
+    return fx_g
+
+
+def draw_graph_compile(
+    name: str,
+) -> Callable[[fx.GraphModule, list[Any]], fx.GraphModule]:
+    return make_boxed_compiler(partial(_draw_graph_compile, name=name))
+
+
+@make_boxed_compiler
+def nop(fx_g: fx.GraphModule, _: Any) -> fx.GraphModule:
+    """
+    Returns the :attr:`fx_g` Fx graph module as it is. This is a no-op compiler
+    and can be used to check accuracy.
+
+    .. warning::
+        This API is experimental and likely to change.
+
+    """
+    return fx_g
+
+
+class DebugInterpreter(fx.Interpreter):
+    def run(
+        self,
+        *args: Any,
+        initial_env: dict[Node, Any] | None = None,
+        enable_io_processing: bool = True,
+    ) -> Any:
+        self.symbol_mapping = bind_symbols(
+            # pyrefly: ignore[bad-argument-type]
+            self.module,
+            *args,
+        )
+        return super().run(
+            *args, initial_env=initial_env, enable_io_processing=enable_io_processing
+        )
+
+    def run_node(self, n: Node) -> Any:
+        def subst_symint(ni: IntLikeType) -> int:
+            if not isinstance(ni, SymInt):
+                return ni
+            r = sympy.expand(ni.node.expr.xreplace(self.symbol_mapping))
+            if not r.is_number:
+                raise AssertionError(f"expected r to be a number, got {r}")
+            return int(r)
+
+        def subst_symint_tuple(nis: tuple[IntLikeType, ...]) -> tuple[int, ...]:
+            return tuple(subst_symint(ni) for ni in nis)
+
+        def check_significant_strides(a: torch.Tensor, b: torch.Tensor) -> bool:
+            if subst_symint(a.numel()) > 0:
+                for idx in range(a.ndim):
+                    if (
+                        subst_symint(a.stride(idx)) != b.stride(idx)
+                        and subst_symint(a.size(idx)) > 1
+                    ):
+                        return False
+            return True
+
+        def check(nv: torch.Tensor, rv: torch.Tensor, desc: Callable[[], str]) -> None:
+            if not callable(desc):
+                raise AssertionError(f"expected desc to be callable, got {type(desc)}")
+            if nv.dtype != rv.dtype:
+                raise AssertionError(f"{desc()}: {nv.dtype} != {rv.dtype}")
+            if subst_symint_tuple(nv.size()) != rv.size():
+                raise AssertionError(
+                    f"{desc()}: {nv.size()} aka {subst_symint_tuple(nv.size())} != {rv.size()}"
+                )
+            same_strides = check_significant_strides(nv, rv)
+            if not same_strides:
+                raise AssertionError(
+                    f"{desc()}: {nv.stride()} aka {subst_symint_tuple(nv.stride())} != {rv.stride()}"
+                )
+
+        r = super().run_node(n)
+        if "val" in n.meta:
+            n_vals, _n_spec = pytree.tree_flatten(n.meta["val"])
+            r_vals, _r_spec = pytree.tree_flatten(r)
+            # TODO: There is some sort of problem where we record that an
+            # operator returned a tuple/list, and then later it turns out the
+            # real version of the operator returned a list/tuple. Need to
+            # figure out what's actually going on here, the error itself is
+            # harmless enough as we only getitem out the outputs.
+            # assert n_spec == r_spec, f"{n_spec} != {r_spec}"
+            if len(n_vals) != len(r_vals):
+                raise AssertionError(f"{len(n_vals)} != {len(r_vals)}")
+            for i, nv, rv in zip(range(len(n_vals)), n_vals, r_vals):
+                if not isinstance(rv, torch.Tensor):
+                    continue
+                check(nv, rv, lambda: f"output {i} where {self.symbol_mapping}")
+        return r
+
+
+@make_boxed_compiler
+def debug_nop(
+    fx_g: fx.GraphModule, _: Any
+) -> Callable[[DebugInterpreter, Any, dict[Node, Any] | None, bool], Any]:
+    """
+    Returns a (slow) interpreter over the FX graph module that also checks
+    various debugging properties (e.g., that tracing strides matched real
+    strides.)
+    """
+    return DebugInterpreter(fx_g).run
+
+
+@make_boxed_compiler
+def simple_ts_compile(fx_g: fx.GraphModule, _: Any) -> torch.jit.ScriptModule:
+    strip_overloads(fx_g)
+    f = torch.jit.script(fx_g)
+    f = torch.jit.freeze(f.eval())
+    return f
+
+
+def nnc_jit(f: Callable[..., Any]) -> Callable[..., Any]:
+    return aot_function(f, simple_ts_compile)
+
+
+aten = torch.ops.aten
+default_decompositions = {
+    aten.detach,
+    aten.gelu_backward,
+    aten.leaky_relu_backward,
+    aten.sigmoid_backward,
+    aten.threshold_backward,
+    aten.hardtanh_backward,
+    aten.hardsigmoid_backward,
+    aten.hardswish_backward,
+    aten.tanh_backward,
+    aten.silu_backward,
+    aten.elu_backward,
+    aten.cudnn_batch_norm,
+    aten.cudnn_batch_norm_backward,
+    aten.masked_fill.Scalar,
+    aten.masked_fill.Tensor,
+    aten.elu,
+    aten.leaky_relu,
+    aten.hardtanh,
+    aten.hardswish,
+    aten.hardsigmoid,
+    aten.conj_physical,
+    aten.is_same_size,
+}
+
+# pyrefly: ignore[bad-argument-type]
+default_decompositions = get_decompositions(default_decompositions)
+
+
+@make_boxed_compiler
+def print_compile(fx_g: fx.GraphModule, _: Any) -> fx.GraphModule:
+    print(fx_g.code)
+    return fx_g
+
+
+def memory_efficient_fusion(
+    fn: Callable[_P, _R] | nn.Module,
+    **kwargs: Any,
+) -> Callable[_P, _R] | nn.Module:
+    """
+    Wrapper function over :func:`aot_function` and :func:`aot_module` to perform
+    memory efficient fusion. It uses the
+    :func:`min_cut_rematerialization_partition` partitioner to perform efficient
+    recomputation. It uses NVFuser to compile the generated forward and backward
+    graphs.
+
+    .. warning::
+        This API is experimental and likely to change.
+
+    Args:
+        fn (Union[Callable, nn.Module]): A Python function or a ``nn.Module``
+            that takes one or more arguments. Must return one or more Tensors.
+        **kwargs: Any other overrides you want to make to the settings
+
+    Returns:
+        Returns a ``Callable``  or ``nn.Module`` that retains the eager behavior
+        of the original :attr:`fn`, but whose forward and backward graphs have
+        gone through recomputation optimizations, and the graphs have been
+        compiled with nvfuser.
+
+    """
+    config = {
+        "fw_compiler": ts_compile,
+        "bw_compiler": ts_compile,
+        "partition_fn": min_cut_rematerialization_partition,
+        "decompositions": default_decompositions,
+    }
+    config.update(kwargs)
+    if isinstance(fn, torch.nn.Module):
+        return aot_module(fn, **config)  # pyrefly: ignore[bad-argument-type]
+    else:
+        return aot_function(fn, **config)  # pyrefly: ignore[bad-argument-type]
+
+
+def debug_compile(
+    fx_g: fx.GraphModule, inps: Sequence[torch.Tensor]
+) -> torch.jit.ScriptModule:
+    fx_g.to_folder("foo")
+    print(
+        f"""
+##############################################################
+# To minimize FX graph, copy and paste the below and run it  #
+##############################################################
+
+import torch
+import torch.fx as fx
+from functorch.compile import minifier, check_nvfuser_subprocess, check_nvfuser_correctness_subprocess
+
+inps = {[(i.shape, i.dtype) for i in inps]}
+inps = [torch.ones(shape, dtype=dtype, device='cuda') for (shape, dtype) in inps]
+from foo import FxModule
+mod = FxModule().cuda()
+
+with torch.jit.fuser("fuser2"):
+  # check_nvfuser_subprocess can be replaced with check_nvfuser_correctness_subprocess
+  minifier(fx.symbolic_trace(mod), inps, check_nvfuser_subprocess)
+"""
+    )
+    # pyrefly: ignore[missing-import, missing-module-attribute]
+    from foo import FxModule
+
+    FxModule().cuda()(*inps)
+
+    return ts_compile(fx_g, inps)
+
+
+graph_index: int = 0
+
+
+def get_inputs(input_data_path: str) -> list[torch.Tensor]:
+    """
+    Return a random input for the given inputs meta generated from _save_fx_default.
+    """
+    inputs: list[torch.Tensor] = []
+    with open(input_data_path, "rb") as f:
+        inputs_meta = pickle.load(f)
+        inputs = []
+        for meta in inputs_meta:
+            if len(meta) == 1:
+                type = meta
+                input_ = type(random.random())
+            else:
+                type, shape, _stride, dtype, device = meta
+                if dtype in {
+                    torch.int,
+                    torch.int32,
+                    torch.int64,
+                    torch.bool,
+                    torch.int,
+                    torch.uint8,
+                    int,
+                    float,
+                }:
+                    input_ = torch.randint(0, 1, shape, dtype=dtype, device=device)
+                else:
+                    input_ = torch.rand(shape, dtype=dtype, device=device)
+            inputs.append(input_)
+    return inputs
+
+
+def _save_fx_default(
+    current_name: str,
+    folder_name: str,
+    dump_example_input: bool,
+    gm: torch.fx.GraphModule,
+    example_inputs: list[torch.Tensor],
+) -> nn.Module:
+    """
+    The forward, backward, and joint computation graph will be stored in
+    {folder_name}/{current_name}/{current_name}_forward_{graph_index},
+    {folder_name}/{current_name}/{current_name}_backward_{graph_index}, and
+    {folder_name}/{current_name}/{current_name}_joint_{graph_index} respectively.
+    The input shape of the graphs will be stored in the .input files.
+    These files can be loaded with pickle,
+    and is a list of format (type, shape, stride, dtype, device).
+    In the case of type = int or float, it is just (type,).
+    For joint graph input, it is a nested list [[],[]]
+    where the two inner lists have the same format.
+    If dump_example_input is True, example_inputs will be stored in .pt file.
+    Since each function might produce multiple graphs,
+    the graph_index is used to distinguish different graphs
+    """
+    from functorch.compile import aot_module_simplified
+
+    def get_input_meta(args: Any) -> list[Any]:
+        input_meta = []
+        if len(args) > 0 and isinstance(args[0], tuple):  # joint input
+            input_meta += get_input_meta(args[0])
+            input_meta += get_input_meta(args[1])
+            return input_meta
+        for arg in args:
+            if type(arg) is int or type(arg) is float:
+                input_meta.append((type(arg),))
+            else:
+                input_meta.append(
+                    (type(arg), arg.shape, arg.stride(), arg.dtype, arg.device)
+                )
+        return input_meta
+
+    def graph_saver_helper(
+        gm_to_save: fx.GraphModule, args: Any, type_name: str
+    ) -> None:
+        global graph_index
+        if len(gm_to_save.graph.nodes) == 0:
+            log.log(
+                logging.WARNING,
+                "No nodes in graph {%s}_{%s}_{%s}.",
+                current_name,
+                type_name,
+                graph_index,
+            )
+            return
+
+        gm = copy.deepcopy(gm_to_save)
+        gm.graph.set_codegen(torch.fx.graph.CodeGen())  # remove codegen
+        gm.recompile()
+
+        input_meta = get_input_meta(args)
+
+        os.makedirs(f"{folder_name}/{current_name}", exist_ok=True)
+        gm.to_folder(
+            f"{folder_name}/{current_name}/{current_name}_{type_name}_{graph_index}"
+        )
+        with open(
+            f"{folder_name}/{current_name}/{current_name}_{type_name}_{graph_index}/{current_name}_{type_name}_{graph_index}.input",
+            "wb",
+        ) as f:
+            pickle.dump(input_meta, f)
+        if dump_example_input:
+            torch.save(
+                args,
+                f"{folder_name}/{current_name}/{current_name}_{type_name}_{graph_index}/{current_name}_{type_name}_{graph_index}.pt",
+            )
+
+    def graph_saver_forward(
+        gm: fx.GraphModule, example_inputs: list[torch.Tensor]
+    ) -> fx.GraphModule:
+        graph_saver_helper(gm, example_inputs, "forward")
+        return gm
+
+    def graph_saver_backward(
+        gm: fx.GraphModule, example_inputs: list[torch.Tensor]
+    ) -> fx.GraphModule:
+        graph_saver_helper(gm, example_inputs, "backward")
+        global graph_index
+        graph_index += 1
+        return gm
+
+    def graph_saver_joint(
+        gm: fx.GraphModule, joint_args: list[torch.Tensor]
+    ) -> tuple[fx.GraphModule, fx.GraphModule]:
+        graph_saver_helper(gm, joint_args, "joint")
+        return default_partition(gm, joint_args)  # pyrefly: ignore[missing-argument]
+
+    # pyrefly: ignore[bad-return]
+    return aot_module_simplified(
+        gm,
+        example_inputs,
+        fw_compiler=graph_saver_forward,  # pyrefly: ignore[bad-argument-type]
+        bw_compiler=graph_saver_backward,  # pyrefly: ignore[bad-argument-type]
+        partition_fn=graph_saver_joint,
+        decompositions=default_decompositions,  # pyrefly: ignore[bad-argument-type]
+    )
+
+
+# WARNING: This isn't tested anywhere!!
+def graph_dumper_aot(
+    current_name: str, folder_name: str, dump_example_input: bool = False
+) -> Callable[[bool, nn.Module], Any]:
+    """
+    Dump the forward, backward, and joint computation graph.
+    Example Usage:
+    save_fx_func = graph_dumper_aot(current_name, folder_name, dump_example_input = False)
+    optimize_ctx = torchdynamo.optimize(
+        save_fx_func
+    )
+    with torch.enable_grad():
+        with optimize_ctx:
+            result = forward_and_backward_pass(model, example_inputs)
+    """
+    global graph_index
+    graph_index = 0
+    return partial(_save_fx_default, current_name, folder_name, dump_example_input)

.venv/lib/python3.12/site-packages/torch/_functorch/config.py

@@ -0,0 +1,464 @@
+# 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.
+
+from collections.abc import Callable
+
+
+"""
+Global flags for aot autograd
+"""
+
+import os
+import sys
+from typing import Literal, TYPE_CHECKING
+
+from torch.utils._config_module import Config, install_config_module
+
+
+# [@compile_ignored: debug]
+_save_config_ignore = [
+    # callable not serializable
+    "joint_custom_pass",
+    # callable configs with uuid() for caching, or raw callables
+    "activation_memory_budget_runtime_estimator",
+    "activation_memory_budget_solver",
+]
+
+
+# Converts torch rng ops to their functional philox rng equivalents. Note that
+# we functionalize only CUDA rng ops today.
+functionalize_rng_ops = False
+
+# can be useful for debugging if we are incorrectly creating meta fake tensors
+fake_tensor_allow_meta = os.environ.get("FAKE_ALLOW_META", "1") != "0"
+
+# Enables optional asserts in hotpath code to check for errors. If
+# you are seeing weird accuracy problems, try turning this on.
+# This is currently off by default as it will harm tracing time,
+# but it is on by default for aot_eager.
+debug_assert = False
+
+debug_partitioner = os.environ.get("AOT_PARTITIONER_DEBUG", "0") != "0"
+
+# See # NOTE [Export custom triton op]
+decompose_custom_triton_ops = True
+
+static_weight_shapes = True
+
+# See https://github.com/pytorch/pytorch/issues/141881
+# Tells partitioner that parameters are free to save for backward.
+treat_parameters_as_free_to_save = True
+
+# Applies CSE to the graph before partitioning
+cse = True
+
+# When the partitioner's _size_of encounters a (Fake)ScriptObject in node
+# metadata, it has no general way to know the object's true memory footprint:
+# a ScriptObject may hold tensors internally. By default we raise rather than
+# guess. Enabling this flag makes _size_of assume such objects are zero size,
+# which unblocks dynamic-shapes compilation of models containing ScriptObject
+# parameters (e.g. embedding-table configs from FBGEMM) at the cost of
+# soundness. This is a temporary escape hatch until we have a principled way to
+# probe the size of a (Fake)ScriptObject.
+unsafe_treat_script_objects_as_zero_size = False
+
+from torch._environment import is_fbcode
+
+
+enable_autograd_cache: bool = Config(
+    justknob="pytorch/remote_cache:enable_local_autograd_cache",
+    env_name_force="TORCHINDUCTOR_AUTOGRAD_CACHE",
+    default=True,
+)
+
+autograd_cache_allow_custom_autograd_functions: bool = Config(
+    env_name_force="TORCHINDUCTOR_AUTOGRAD_CACHE_ALLOW_CUSTOM_AUTOGRAD", default=False
+)
+
+# For now, this is just for enabling unit testing in test_aot_autograd_cache.py
+# We will either make this the default with AOTAutogradCache, or
+# we'll just use it in the precompile flow. So there's no
+# need to add env vars or make it configurable
+bundled_autograd_cache: bool = False
+
+bypass_autograd_cache_key: bool = False
+
+# Whether or not to normalize placeholder names in graphs
+# from dynamo in AOTAutogradCache
+autograd_cache_normalize_inputs = not is_fbcode()
+
+# Enable debug mode at first invocation to check if custom ops are valid.
+# When enabled, this checks that custom operators don't violate aliasing constraints.
+#
+# check_custom_op_aliasing: Controls whether to run the custom op aliasing check at all.
+#   - When True: The check runs on first invocation of compiled functions.
+#   - When False: The check is skipped entirely.
+#
+# error_on_custom_op_aliasing: Controls behavior when a violation is detected.
+#   Only has effect when check_custom_op_aliasing is True.
+#   - When True: Raises RuntimeError on aliasing violations.
+#   - When False: Emits UserWarning on aliasing violations.
+#
+# Deprecated: Custom ops returning aliased outputs is deprecated and will
+# become an error in a future version of PyTorch. Currently error_on_custom_op_aliasing
+# is True in CI unless explicitly overridden.
+check_custom_op_aliasing = True
+error_on_custom_op_aliasing: bool = Config(
+    env_name_force="TORCHINDUCTOR_ERROR_ON_CUSTOM_OP_ALIASING",
+    default=bool(os.getenv("CI")),
+)
+
+
+def remote_autograd_cache_default() -> bool | None:
+    if os.environ.get("TORCHINDUCTOR_AUTOGRAD_REMOTE_CACHE") == "1":
+        return True
+    if os.environ.get("TORCHINDUCTOR_AUTOGRAD_REMOTE_CACHE") == "0":
+        return False
+    return None
+
+
+enable_remote_autograd_cache = remote_autograd_cache_default()
+
+
+# When AOTAutograd regenerates aliased graph outputs,
+# attempt to use functionalization's view-replay logic
+# before falling back to the autograd engine's view replay or as_strided.
+# This can have some perf implications
+# (although for many models this will not matter).
+# (1) If you have many view ops chained together, replaying all of them
+#     at runtime can have more overhead compared to a single as_strided call
+# (2) If you are doing training, AsStridedBackward is quite slow,
+#     and the individual view op backward formulas will likely be faster.
+# (3) Some backends like XLA do not support as_strided
+
+# Temporary hack: disable this flag for internal
+# (needed to fix an internal issue while avoiding bumping XLA pin)
+# eventually: either default this config to false completely
+# once XLA pin update works,
+# or default config to true and fix relevant bugs
+
+
+# View replay is currently not compatible with AOTAutogradCache, since
+# FunctionalTensors are not serializable. We'll need to make them
+# serializable before enabling warm cache with this config turned on.
+view_replay_for_aliased_outputs = not is_fbcode()
+
+# Restricts the amount of computation AOTAutograd can do.
+# NB: We have essentially disabled this heuristic now. However, this is kept
+# here for now in case it's useful. Setting it low can artificially reduce the
+# amount of recomputation AOTAutograd performs, although not in any kind of
+# principled way.
+max_dist_from_bw = 1000
+
+
+# Bans recomputation of nodes that are reading from nodes that are far before
+# the current node
+ban_recompute_used_far_apart = True
+# Breaks up long chain of fusible ops, as otherwise we can have an arbitrarily
+# long chain of recomputation in the backwards pass.
+ban_recompute_long_fusible_chains = True
+# Bans recomputation of nodes that must be materialized in the backwards pass
+# (used by a non-fusible node)
+ban_recompute_materialized_backward = True
+# Chooses to ban recomputation of nodes based off an allowlist. Setting it to
+# False changes it to use a denylist. Main change is on operators like
+# sort/pool/stuff that isn't cheap enough to be fusible for free but also isn't
+# that expensive
+ban_recompute_not_in_allowlist = True
+# Chooses to ban recomputation of reductions. This is generally a good idea, as
+# the result of reductions is generally very small but recomputing reductions in
+# a fusion can be expensive.
+ban_recompute_reductions = True
+# Prevents the partitioner from ever saving views (i.e. always recompute them).
+# Generally a good idea since views are free to recompute.
+recompute_views = False
+# Set this flag to enable considering non-built-in ops, including triton and custom
+# ops, for recomputation during the knapsack optimization solver.
+is_non_builtin_to_include = False
+
+# Rematerialize AC nodes for graphs with forward+loss+backward in one graph.
+# This optimization minimizes activation checkpoint node lifetimes by computing them
+# just-in-time. For AC nodes only used in backward, they are deferred to backward region
+# instead of being computed and saved in forward. This reduces peak memory usage.
+# Note: This only applies to forward+loss+backward graphs where torch.autograd.grad is allowed
+# in the graph. Joint graphs (standard AOTAutograd) use the partitioner instead.
+remat_using_tags_for_fwd_loss_bwd_graph = True
+
+# By default, the partitioner is purely trying to optimize for runtime (although
+# it should always use less memory than eager)
+# This knob controls the partitioner to make that tradeoff for you, choosing the
+# fastest option that saves less activations than the memory budget.
+# Specifically, 0.0 corresponds to the activation memory from applying
+# activation checkpointing to the full compiled region, and 1.0 corresponds to
+# the activation memory from the default runtime-optimized strategy.  So, 0.4
+# would result in a strategy that saves 40% of the activations compared to the
+# default strategy.
+# It solves a 0-1 knapsack to find the minimum recompute necessary to stay below
+# the activation memory budget.
+# NOTE: This *cannot* be treated as
+activation_memory_budget = 1.0
+
+# This controls how we estimate the runtime when deciding what the cheapest
+# operators to recompute are. The 3 options are
+# "flops": Bases it off of the flop count provided by torch.utils.flop_counter
+# "profile": Benchmarks each operator to come up with a runtime
+# "testing": Returns 1 for everything
+activation_memory_budget_runtime_estimator = "flops"
+
+# This controls the solver used for the 0-1 knapsack. By default we use a
+# quantized DP solution ("dp"). The other approaches are a "greedy", an "ilp"
+# (which has a scipy dependency) and "dp_knapsack_sliding_hirschberg", which
+# used memory-efficient quantized DP solution
+activation_memory_budget_solver = "dp"
+
+# This dumps out an SVG visualization of the expected runtime vs. activation
+# memory tradeoffs for all memory budget values from 0 to 1 in increments of
+# 0.5. See an example here:
+# https://github.com/pytorch/pytorch/pull/126320#discussion_r1625104015
+visualize_memory_budget_pareto = (
+    os.environ.get("PARTITIONER_MEMORY_BUDGET_PARETO", "0") == "1"
+)
+
+# This controls the directory in which to dump the SVG plot with the pareto
+# frontier of the activation checkpointing memory-vs-runtime tradeoffs.
+memory_budget_pareto_dir = os.environ.get("PARTITIONER_MEMORY_BUDGET_PARETO_DIR")
+
+# Sets all of the ban_recompute heuristics to False except ban_recompute_reductions
+# Generally, this will probably result in some memory improvement, but at the
+# cost of some performance
+aggressive_recomputation = False
+
+# activation offloading enablement (testing purpose)
+enable_activation_offloading = False
+
+# activation offloading with separate CUDA stream
+activation_offload_separate_stream = False
+
+# activation offloading wait sinking when using separate stream (fwd graph)
+activation_offload_sink_wait = False
+
+# activation reloading with prefetching when using separate streams (bwd graph)
+activation_reload_prefetch = False
+
+# CPU ↔ GPU bandwidth in GB/s, used to estimate transfer times for prefetch
+# scheduling. This is hardware-specific and should be set by the user.
+activation_offload_cpu_gpu_bw: float = 50.0
+
+# If FakeTensor.data_ptr() should error.
+# This option is independent of AOTAutograd and torch.compile, but our policy
+# is to turn it off during torch.compile.
+fake_tensor_allow_unsafe_data_ptr_access = True
+
+# Unlifts effect tokens from the inputs/outputs in the traced graph and instead
+# inserts make_token/sink_token calls in the graph to create tokens and then
+# sink them at the end. Note that this means the graph is no longer functional
+# which may lead to silent errors unless the backend knows how to handle the
+# tokens.
+unlift_effect_tokens = False
+
+# NOTE: [The default layout constraint for custom operators.]
+# This must be the name of one of the layout constraint tags
+# (that is, one of {"needs_fixed_stride_order", "flexible_layout"}),
+# If the custom op does not have a layout constraint tag already
+# then we assume the following applies.
+#
+# This config is respected by Inductor and we recommend other backends also
+# respect it.
+# This config is in torch._functorch and not torch._inductor because it affects
+# ProxyTensor tracing.
+custom_op_default_layout_constraint: Literal[
+    "needs_exact_strides", "needs_fixed_stride_order", "flexible_layout"
+] = "needs_exact_strides"
+
+
+# Run aot eager decomp partition with CrossRefFakeMode
+# options = False, "all", "custom_ops"
+fake_tensor_crossref = False
+
+# This mode specifies that we should also keep track of the real
+# tensor along with the fake tensor, and do real compute.  While
+# seemingly this eliminates the whole point of fake tensors, there are
+# two obvious use cases for it:
+#
+#   1. When users call item()/other data dependent operations,
+#      if we propagate_real_tensors we are able to determine what
+#      the true value is and keep going.
+#
+#   2. It can be useful for testing, when you want to see if the fake
+#      and real tensors agree with each other.  (Note that there are
+#      currently known inaccuracies in how we clone real tensors, that
+#      would have to be tightened up for this to be useful in this
+#      case.)
+#
+# Note that fake tensors are typically understood to be cheap to store
+# indefinitely, so we tend to hold on to them longer than we would
+# hold onto the real tensors.  So we also support you explicitly
+# deallocating the real tensor associated with a fake tensor, at which
+# point we will stop propagating real tensors.
+#
+# One more thing: when you provide a real tensor to fakeify, we will
+# clone it, so that we can safely perform mutations on it if necessary.
+# This will increase live memory usage.  This could potentially be
+# optimized by using COW.  We also currently do not faithfully
+# maintain autograd metadata on the real tensor; this is fine because
+# AOTAutograd will only use the fake tensor to determine leafness/etc
+# of tensors in question.
+fake_tensor_propagate_real_tensors = False
+
+# AOTDispatcher traces out a backward graph at the time of the forward pass.
+# This flag controls whether or not that backward graph gets autocast behavior
+# applied to it.
+#
+# The options are either:
+# - "same_as_forward". We assume that the backward of the torch.compile'ed region
+#   will be run under the same autocast context manager that the region was run
+#   under. This is equivalent to running the following code in eager:
+#
+#   with torch.amp.autocast(...):
+#       y = region(x)
+#       ...
+#       z.backward()
+#
+# - "off". We assume that the backward of the torch.compile'd region will
+#   not be run under any autocast context managers.
+#   This is equivalent to running the following code in eager:
+#
+#   with torch.amp.autocast(...):
+#       y = region(x)
+#       ...
+#   z.backward()
+#
+# - or a list of kwargs dicts that represent an autocast context manager to turn
+#   on during the backward pass.
+#
+#   e.g. [{"device_type": "cuda"}] is equivalent to running the following code in eager:
+#
+#   y = region(x)
+#   ...
+#   with torch.amp.autocast(device="cuda"):
+#       z.backward()
+backward_pass_autocast = "same_as_forward"
+
+# This controls whether we collect donated buffers. This flag must be set
+# False if a user wants to retain_graph=True for backward.
+donated_buffer = not is_fbcode()
+
+# Controls the default graph output format used by draw_graph.
+# Most supported formats are defined here https://graphviz.org/docs/outputs/.
+# The "dot" and "raw" formats write raw DOT text without invoking Graphviz.
+torch_compile_graph_format = os.environ.get("TORCH_COMPILE_GRAPH_FORMAT", "svg")
+
+# Valid only if fake_tensor_propagate_real_tensors = True; if a fake-real
+# kernel mismatch is detected, bypasses by making a fake kernel from the
+# real tensor outputs.
+generate_fake_kernels_from_real_mismatches = False
+
+# When there are device mismatches in FakeTensor device propagation,
+# prefer a specific device type over others. This is particularly useful
+# in full compiled mode where intermediate tensors with device mismatches
+# represent only logical differences during compilation - these intermediate
+# tensors will never physically materialize in the binary execution, so the
+# device mismatch is not a real runtime concern. Enabling this allows the
+# compiler to proceed with compilation by choosing the preferred device type
+# for consistency. For example, set to "mtia" to prefer MTIA devices over
+# CPU, or "cuda" to prefer CUDA devices over CPU.
+fake_tensor_prefer_device_type: str | None = None
+
+# CUDAGraph safe run_with_rng functionalization.
+graphsafe_rng_functionalization = True
+
+# Whether or not to eagerly compile the backward
+# used by AOT compile and other settings
+# TODO: once AOT compile calls aot autograd directly instead of
+# through compile_fx, we can remove this
+force_non_lazy_backward_lowering = False
+
+# only for testing, used to turn functionalization off in AOTDispatcher
+_test_disable_functionalization = True
+
+# Error on BypassAOTAutogradCache instead of just a warning
+# Used for tests
+strict_autograd_cache = False
+
+# Note [Recomputing collectives in the partitioner]
+# The purpose of this config is as follows:
+# - We have many passes in the compiler (min-cut partitioning, DCE, etc)
+#   which can reorder or delete duplicate nodes in the graph
+# - If any of these passes reorder/delete/duplicate a collective
+#   in a setting where the compiler is being run independently on multiple
+#   ranks, we run the risk that the compiler will make a different decision on
+#   different ranks, resulting in a NCCL hang when using torch.compile
+# To handle this, we will (by default) ensure that collectives are not modified
+# by the compiler.
+#
+# A few examples:
+# - don't dead-code-eliminate collectives
+#   (in case they are dead on rank i but not rank j)
+# - don't recompute collectives in partitioning
+#   (in case we recompute on rank i but not rank j)
+#
+# Today this flag **must** be set to false, but eventually
+# we want the option to set it to true.
+# In order to potentially optimize collectives, we'll need the compiler
+# to broadcast information across ranks at compile time to ensure
+# that any decisions on collectives are made consistently.
+unsafe_allow_optimization_of_collectives = False
+
+# See Note [AOTAutograd Tangent Subclassness for mutated inputs]
+# TODO(ivankobzarev): Remove this config, being able to deduce it compile time.
+disable_guess_zero_tangent_for_mutated_input_subclass = False
+
+# See Note [Tangents memory format]
+# By default tangents strideness is guessed to be contiguous,
+# At runtime non contiguous tangents will be coerced to be contiguous.
+# This config changes this guess for tangents strides to be the same as outputs.
+# TODO(ivankobzarev): Remove this config once extra memory usage is investigated.
+guess_tangent_strides_as_outputs = not is_fbcode()
+
+
+# This is a temporary config to ensure all ranks take the same decision in the partitioner
+# it will ultimately be removed once we share size_hints across ranks through compiler collectives
+_sync_decision_cross_ranks = False
+
+# By default apply inlined saved_tensors_hooks only for "donated" buffers.
+# "donated" buffers are invisible to the user, they are intermediates of the forward graph.
+# Applying saved tensors hooks for memory optimizations only for intermediates
+# guarantees that original saved tensors could be deallocated.
+# This config enables saved_tensors_hooks are applied for **all** saved tensors,
+# that could include inputs, parameters, outputs.
+# "donated" - applied only to saved intermediates of the graph
+# "no_static" - applied to all saved but not "static"
+# (this includes parameters and user marked as static)
+# "all" - no filtering, everything saved for backward.
+saved_tensors_hooks_filtering_mode = "donated"
+
+
+# This callback is invoked on the joint graph before partitioning
+joint_custom_pass: Callable = None  # type: ignore[assignment]
+
+force_autograd_cache = False
+
+# Note [Selective Decomposition]
+# This config allows selective decomposition of certain operators in the graph.
+# When True, it does NOT decompose any nodes, except those nodes that users explicitly
+# annotated with regional inductor compile. Please read torch.fx.passes.regional_inductor
+# on to explicitly annotate. This is currently only used by inductor lite mode.
+selective_decompose: bool = False
+
+# Complex Support
+# This config disallows decomposition of complex-valued Tensors using
+# `torch._subclasses.complex_tensor.ComplexTensor` by decomposing everything into
+# real-valued operations, passing through the regular pipeline as necessary,
+# then converting back to a regular tensor.
+enable_complex_wrapper: bool = False
+
+
+if TYPE_CHECKING:
+    from torch.utils._config_typing import *  # noqa: F403
+
+
+# adds patch, save_config, invalid config checks, etc
+install_config_module(sys.modules[__name__])

.venv/lib/python3.12/site-packages/torch/_functorch/deprecated.py

@@ -0,0 +1,188 @@
+"""
+The APIs in this file are exposed as `functorch.*`. They are thin wrappers
+around the torch.func.* APIs that have deprecation warnings -- we're trying
+to move people to the torch.func.* equivalents.
+
+NB: We don't use *args, **kwargs in the signatures because that changes the
+documentation.
+"""
+
+from __future__ import annotations
+
+import textwrap
+import warnings
+from typing import Any, TYPE_CHECKING
+
+import torch._functorch.apis as apis
+import torch._functorch.eager_transforms as _impl
+import torch._functorch.make_functional as _nn_impl
+import torch.nn as nn
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from torch._functorch.eager_transforms import argnums_t
+    from torch._functorch.vmap import in_dims_t, out_dims_t
+
+
+def get_warning(
+    api: str, new_api: str | None = None, replace_newlines: bool = False
+) -> str:
+    if new_api is None:
+        new_api = f"torch.func.{api}"
+    warning = (
+        f"We've integrated functorch into PyTorch. As the final step of the \n"
+        f"integration, `functorch.{api}` is deprecated as of PyTorch \n"
+        f"2.0 and will be deleted in a future version of PyTorch >= 2.3. \n"
+        f"Please use `{new_api}` instead; see the PyTorch 2.0 release notes \n"
+        f"and/or the `torch.func` migration guide for more details \n"
+        f"https://pytorch.org/docs/main/func.migrating.html"
+    )
+    if replace_newlines:
+        warning = warning.replace("\n", "")
+    return warning
+
+
+def warn_deprecated(api: str, new_api: str | None = None) -> None:
+    warning = get_warning(api, new_api, replace_newlines=True)
+    warnings.warn(warning, FutureWarning, stacklevel=3)
+
+
+def setup_docs(
+    functorch_api: Callable[..., Any],
+    torch_func_api: Callable[..., Any] | None = None,
+    new_api_name: str | None = None,
+) -> None:
+    api_name = functorch_api.__name__
+    if torch_func_api is None:
+        torch_func_api = getattr(_impl, api_name)
+    # See https://docs.python.org/3/using/cmdline.html#cmdoption-OO
+    if torch_func_api.__doc__ is None:
+        return
+
+    warning = get_warning(api_name, new_api_name)
+    warning_note = "\n.. warning::\n\n" + textwrap.indent(warning, "    ")
+    warning_note = textwrap.indent(warning_note, "    ")
+    functorch_api.__doc__ = torch_func_api.__doc__ + warning_note
+
+
+def vmap(
+    func: Callable[..., Any],
+    in_dims: in_dims_t = 0,
+    out_dims: out_dims_t = 0,
+    randomness: str = "error",
+    *,
+    chunk_size: int | None = None,
+) -> Callable[..., Any]:
+    warn_deprecated("vmap", "torch.vmap")
+    return apis.vmap(func, in_dims, out_dims, randomness, chunk_size=chunk_size)
+
+
+def grad(
+    func: Callable[..., Any], argnums: argnums_t = 0, has_aux: bool = False
+) -> Callable[..., Any]:
+    warn_deprecated("grad")
+    return apis.grad(func, argnums, has_aux)
+
+
+def grad_and_value(
+    func: Callable[..., Any], argnums: argnums_t = 0, has_aux: bool = False
+) -> Callable[..., Any]:
+    warn_deprecated("grad_and_value")
+    return apis.grad_and_value(func, argnums, has_aux)
+
+
+def vjp(func: Callable[..., Any], *primals: Any, has_aux: bool = False) -> Any:
+    warn_deprecated("vjp")
+    return _impl.vjp(func, *primals, has_aux=has_aux)
+
+
+def jvp(
+    func: Callable[..., Any],
+    primals: Any,
+    tangents: Any,
+    *,
+    strict: bool = False,
+    has_aux: bool = False,
+) -> Any:
+    warn_deprecated("jvp")
+    return _impl.jvp(func, primals, tangents, strict=strict, has_aux=has_aux)
+
+
+def jacrev(
+    func: Callable[..., Any],
+    argnums: int | tuple[int, ...] = 0,
+    *,
+    has_aux: bool = False,
+    chunk_size: int | None = None,
+    _preallocate_and_copy: bool = False,
+) -> Callable[..., Any]:
+    warn_deprecated("jacrev")
+    return _impl.jacrev(
+        func,
+        argnums,
+        has_aux=has_aux,
+        chunk_size=chunk_size,
+        _preallocate_and_copy=_preallocate_and_copy,
+    )
+
+
+def jacfwd(
+    func: Callable[..., Any],
+    argnums: argnums_t = 0,
+    has_aux: bool = False,
+    *,
+    randomness: str = "error",
+) -> Callable[..., Any]:
+    warn_deprecated("jacfwd")
+    return _impl.jacfwd(func, argnums, has_aux, randomness=randomness)
+
+
+def hessian(func: Callable[..., Any], argnums: int = 0) -> Callable[..., Any]:
+    warn_deprecated("hessian")
+    return _impl.hessian(func, argnums=argnums)
+
+
+def functionalize(
+    func: Callable[..., Any], *, remove: str = "mutations"
+) -> Callable[..., Any]:
+    warn_deprecated("functionalize")
+    return _impl.functionalize(func, remove=remove)
+
+
+def make_functional(model: nn.Module, disable_autograd_tracking: bool = False) -> Any:
+    warn_deprecated("make_functional", "torch.func.functional_call")
+    return _nn_impl.make_functional(model, disable_autograd_tracking)
+
+
+def make_functional_with_buffers(
+    model: nn.Module, disable_autograd_tracking: bool = False
+) -> Any:
+    warn_deprecated("make_functional_with_buffers", "torch.func.functional_call")
+    return _nn_impl.make_functional_with_buffers(model, disable_autograd_tracking)
+
+
+def combine_state_for_ensemble(models: list[nn.Module]) -> Any:
+    warn_deprecated("combine_state_for_ensemble", "torch.func.stack_module_state")
+    return _nn_impl.combine_state_for_ensemble(models)
+
+
+setup_docs(vmap, apis.vmap, "torch.vmap")
+setup_docs(grad, apis.grad)
+setup_docs(grad_and_value, apis.grad_and_value)
+setup_docs(vjp)
+setup_docs(jvp)
+setup_docs(jacrev)
+setup_docs(jacfwd)
+setup_docs(hessian)
+setup_docs(functionalize)
+setup_docs(make_functional, _nn_impl.make_functional, "torch.func.functional_call")
+setup_docs(
+    make_functional_with_buffers, _nn_impl.make_functional, "torch.func.functional_call"
+)
+setup_docs(
+    combine_state_for_ensemble,
+    _nn_impl.combine_state_for_ensemble,
+    "torch.func.stack_module_state",
+)

.venv/lib/python3.12/site-packages/torch/_functorch/eager_transforms.py

@@ -0,0 +1,1960 @@
+# 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.
+
+from __future__ import annotations
+
+import contextlib
+from functools import partial
+from typing import Any, overload, TYPE_CHECKING
+from typing_extensions import ParamSpec, TypeVar
+
+import torch
+import torch.autograd.forward_ad as fwAD
+from torch._C._functorch import (
+    _assert_wrapped_functional,  # type: ignore[attr-defined]
+    _func_decrement_nesting,  # type: ignore[attr-defined]
+    _func_increment_nesting,  # type: ignore[attr-defined]
+    _grad_decrement_nesting,
+    _grad_increment_nesting,
+    _propagate_functional_input_mutation,  # type: ignore[attr-defined]
+    _unwrap_functional_tensor,
+    _wrap_for_grad,
+    _wrap_functional_tensor,
+    get_inplace_requires_grad_allowed,
+    get_unwrapped,
+    is_functorch_wrapped_tensor,
+    set_inplace_requires_grad_allowed,
+)
+from torch._functorch.predispatch import (
+    _jvp_decrement_nesting,
+    _jvp_increment_nesting,
+    _unwrap_for_grad,
+)
+from torch._functorch.utils import argnums_t, exposed_in
+from torch._subclasses.functional_tensor import FunctionalTensor
+from torch.fx.experimental import const_fold
+from torch.fx.experimental.proxy_tensor import make_fx
+from torch.utils import _pytree as pytree
+from torch.utils._pytree import (
+    tree_flatten,
+    tree_map,
+    tree_map_,
+    tree_map_only,
+    tree_unflatten,
+    treespec_pprint,
+)
+
+from .apis import _wraps_without_dynamo_attrs, vmap
+from .vmap import doesnt_support_saved_tensors_hooks, get_chunk_sizes
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator, Sequence
+
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+_T = TypeVar("_T")
+
+
+def lazy_dynamo_disallow(func: Callable[_P, _R]) -> Callable[_P, _R]:
+    import torch._dynamo
+
+    return torch._dynamo.disallow_in_graph(func)
+
+
+@contextlib.contextmanager
+def enable_inplace_requires_grad(enabled: bool) -> Generator[None, None, None]:
+    prev_state = get_inplace_requires_grad_allowed()
+    set_inplace_requires_grad_allowed(enabled)
+    try:
+        yield
+    finally:
+        set_inplace_requires_grad_allowed(prev_state)
+
+
+def _set_tensor_requires_grad(x: torch.Tensor) -> torch.Tensor:
+    # avoid graph-break on x.requires_grad_()
+    # https://github.com/pytorch/pytorch/pull/110053
+    return x.requires_grad_()
+
+
+def _create_differentiable(inps: Any, level: int | None = None) -> Any:
+    def create_differentiable(x: torch.Tensor | Any) -> torch.Tensor:
+        if isinstance(x, torch.Tensor):
+            with enable_inplace_requires_grad(True):
+                return _set_tensor_requires_grad(x)
+        raise ValueError(f"Thing passed to transform API must be Tensor, got {type(x)}")
+
+    return tree_map(create_differentiable, inps)
+
+
+_Tensors = torch.Tensor | tuple[torch.Tensor, ...]
+_TensorsT = TypeVar("_TensorsT", bound=_Tensors)
+_TensorsU = TypeVar("_TensorsU", bound=_Tensors)
+
+
+def _undo_create_differentiable(inps: _TensorsT, level: int | None = None) -> _TensorsT:
+    def unwrap_tensors(x: _TensorsU) -> _TensorsU:
+        if isinstance(x, torch.Tensor):
+            if level is None:
+                raise AssertionError("level must not be None when unwrapping tensors")
+            # pyrefly: ignore[bad-return]
+            return _unwrap_for_grad(x, level)
+        # TODO: Remove the following hack for namedtuples
+        if isinstance(x, tuple):
+            return tree_map(unwrap_tensors, tuple(x))
+
+        raise RuntimeError(f"Expected tensors, got unsupported type {type(x)}")
+
+    return tree_map(unwrap_tensors, inps)
+
+
+def _is_differentiable(maybe_tensor: object) -> bool:
+    if not isinstance(maybe_tensor, torch.Tensor):
+        return False
+    return maybe_tensor.requires_grad
+
+
+def _any_differentiable(
+    tensor_or_tuple_of_tensors: _Tensors,
+) -> bool:
+    flat_args, _ = tree_flatten(tensor_or_tuple_of_tensors)
+    return any(tuple(map(_is_differentiable, flat_args)))
+
+
+def _wrap_tensor_for_grad(maybe_tensor: _T, level: int) -> _T:
+    if not isinstance(maybe_tensor, torch.Tensor):
+        return maybe_tensor
+    # pyrefly: ignore[bad-return]
+    return _wrap_for_grad(maybe_tensor, level)
+
+
+def _wrap_all_tensors(tensor_pytree: _T, level: int) -> _T:
+    return tree_map(partial(_wrap_tensor_for_grad, level=level), tensor_pytree)
+
+
+# TODO: this is more accurate - enable in 3.11
+# _Ts = TypeVarTuple("_Ts")
+# @overload
+# def _as_tuple(val: tuple[*_Ts]) -> tuple[*_Ts]: ...
+@overload
+def _as_tuple(val: tuple[_R, ...]) -> tuple[_R]: ...
+@overload
+def _as_tuple(val: _R) -> tuple[_R]: ...
+def _as_tuple(val: object) -> object:
+    if isinstance(val, tuple):
+        return val
+    return (val,)
+
+
+# Version of autograd.grad that handles outputs that don't depend on inputs
+
+
+def _autograd_grad(
+    outputs: Sequence[torch.Tensor],
+    inputs: Sequence[torch.Tensor],
+    grad_outputs: Sequence[torch.Tensor] | None = None,
+    retain_graph: bool = False,
+    create_graph: bool = True,
+) -> tuple[torch.Tensor, ...]:
+    if grad_outputs is None:
+        diff_outputs = tuple(out for out in outputs if out.requires_grad)
+    else:
+        result = tuple(
+            (out, go) for out, go in zip(outputs, grad_outputs) if out.requires_grad
+        )
+        if len(result) == 0:
+            diff_outputs, grad_outputs = (), ()
+        else:
+            diff_outputs, grad_outputs = zip(*result)
+    if len(diff_outputs) == 0:
+        return tuple(torch.zeros_like(inp) for inp in inputs)
+    with torch._dynamo.compiled_autograd._disable():
+        grad_inputs = torch.autograd.grad(
+            diff_outputs,
+            inputs,
+            grad_outputs,
+            retain_graph=retain_graph,
+            create_graph=create_graph,
+            allow_unused=True,
+        )
+    grad_inputs = tuple(
+        torch.zeros_like(inp) if gi is None else gi
+        for gi, inp in zip(grad_inputs, inputs)
+    )
+    return grad_inputs
+
+
+# NOTE [grad and vjp interaction with no_grad]
+#
+# def f(x):
+#   with torch.no_grad():
+#     c = x ** 2
+#   return x - c
+#
+# The thing to consider is if enable_grad is on/off before grad gets called.
+#
+# Case 1: enable_grad is on.
+# grad(f)(x)
+# In this case, `grad` should respect the inner torch.no_grad.
+#
+# Case 2: enable_grad is off
+# with torch.no_grad():
+#   grad(f)(x)
+# In this case, `grad` should respect the inner torch.no_grad, but not the
+# outer one. This is because `grad` is a "function transform": its result
+# should not depend on the result of a context manager outside of `f`.
+#
+# This gives us the following desired behavior:
+# - (nested) grad transforms must obey torch.no_grad inside them
+# - (nested) grad transforms should not obey torch.no_grad outside them
+#
+# To achieve this behavior, upon entering grad/vjp:
+# - we save the current ("previous") is_grad_enabled (*)
+# - we unconditionally enable grad.
+#
+# Inside DynamicLayerBackFallback, when we're temporarily popping `grad` layer
+# off the stack:
+# - if grad_mode is disabled, then we do nothing. (there is a torch.no_grad
+#   active, all subsequent grad transforms must obey it).
+# - if grad_mode is enabled, and the previous is_grad_enabled (*) is False,
+#   then we temporarily restore the previous `is_grad_enabled`. This is
+#   because we're crossing the boundary from a `grad` outside the
+#   no_grad to a `grad` inside the no_grad.
+#
+# NB: vjp has some interesting behavior because the vjp's Callable[..., Any] can be called
+# under a different grad_mode than the forward computation...
+#
+# NB: forward-mode AD: forward-mode AD doesn't respect torch.no_grad, but
+# it respects c10::AutoFwGradMode. We've implemented the same logic for
+# our jvp transform (it will have special handling if FwGradMode is disabled).
+
+
+# How do we increment and decrement the nesting? I don't think we can.
+@exposed_in("torch.func")
+def vjp(
+    func: Callable[..., Any], *primals: Any, has_aux: bool = False
+) -> tuple[Any, Callable[..., Any]] | tuple[Any, Callable[..., Any], Any]:
+    """
+    Standing for the vector-Jacobian product, returns a tuple containing the
+    results of ``func`` applied to ``primals`` and a function that, when
+    given ``cotangents``, computes the reverse-mode Jacobian of ``func`` with
+    respect to ``primals`` times ``cotangents``.
+
+    Args:
+        func (Callable[..., Any]): A Python function that takes one or more arguments. Must
+            return one or more Tensors.
+        primals (Tensors): Positional arguments to ``func`` that must all be
+            Tensors. The returned function will also be computing the
+            derivative with respect to these arguments
+        has_aux (bool): Flag indicating that ``func`` returns a
+            ``(output, aux)`` tuple where the first element is the output of
+            the function to be differentiated and the second element is
+            other auxiliary objects that will not be differentiated.
+            Default: False.
+
+    Returns:
+        Returns a ``(output, vjp_fn)`` tuple containing the output of ``func``
+        applied to ``primals`` and a function that computes the vjp of
+        ``func`` with respect to all ``primals`` using the cotangents passed
+        to the returned function. If ``has_aux is True``, then instead returns a
+        ``(output, vjp_fn, aux)`` tuple.
+        The returned ``vjp_fn`` function will return a tuple of each VJP.
+
+    When used in simple cases, :func:`vjp` behaves the same as :func:`grad`
+
+        >>> x = torch.randn([5])
+        >>> f = lambda x: x.sin().sum()
+        >>> (_, vjpfunc) = torch.func.vjp(f, x)
+        >>> grad = vjpfunc(torch.tensor(1.0))[0]
+        >>> assert torch.allclose(grad, torch.func.grad(f)(x))
+
+    However, :func:`vjp` can support functions with multiple outputs by
+    passing in the cotangents for each of the outputs
+
+        >>> x = torch.randn([5])
+        >>> f = lambda x: (x.sin(), x.cos())
+        >>> (_, vjpfunc) = torch.func.vjp(f, x)
+        >>> vjps = vjpfunc((torch.ones([5]), torch.ones([5])))
+        >>> assert torch.allclose(vjps[0], x.cos() + -x.sin())
+
+    :func:`vjp` can even support outputs being Python structs
+
+        >>> x = torch.randn([5])
+        >>> f = lambda x: {"first": x.sin(), "second": x.cos()}
+        >>> (_, vjpfunc) = torch.func.vjp(f, x)
+        >>> cotangents = {"first": torch.ones([5]), "second": torch.ones([5])}
+        >>> vjps = vjpfunc(cotangents)
+        >>> assert torch.allclose(vjps[0], x.cos() + -x.sin())
+
+    The function returned by :func:`vjp` will compute the partials with
+    respect to each of the ``primals``
+
+        >>> x, y = torch.randn([5, 4]), torch.randn([4, 5])
+        >>> (_, vjpfunc) = torch.func.vjp(torch.matmul, x, y)
+        >>> cotangents = torch.randn([5, 5])
+        >>> vjps = vjpfunc(cotangents)
+        >>> assert len(vjps) == 2
+        >>> assert torch.allclose(vjps[0], torch.matmul(cotangents, y.transpose(0, 1)))
+        >>> assert torch.allclose(vjps[1], torch.matmul(x.transpose(0, 1), cotangents))
+
+    ``primals`` are the positional arguments for ``f``. All kwargs use their
+    default value
+
+        >>> x = torch.randn([5])
+        >>> def f(x, scale=4.):
+        >>>   return x * scale
+        >>>
+        >>> (_, vjpfunc) = torch.func.vjp(f, x)
+        >>> vjps = vjpfunc(torch.ones_like(x))
+        >>> assert torch.allclose(vjps[0], torch.full(x.shape, 4.0))
+
+    .. note::
+        Using PyTorch ``torch.no_grad`` together with ``vjp``.
+        Case 1: Using ``torch.no_grad`` inside a function:
+
+            >>> def f(x):
+            >>>     with torch.no_grad():
+            >>>         c = x ** 2
+            >>>     return x - c
+
+        In this case, ``vjp(f)(x)`` will respect the inner ``torch.no_grad``.
+
+        Case 2: Using ``vjp`` inside ``torch.no_grad`` context manager:
+
+            >>> # xdoctest: +SKIP(failing)
+            >>> with torch.no_grad():
+            >>>     vjp(f)(x)
+
+        In this case, ``vjp`` will respect the inner ``torch.no_grad``, but not the
+        outer one. This is because ``vjp`` is a "function transform": its result
+        should not depend on the result of a context manager outside of ``f``.
+    """
+    return _vjp_with_argnums(func, *primals, has_aux=has_aux)
+
+
+@contextlib.contextmanager
+def _disable_inference_mode() -> Generator[None, None, None]:
+    # Disable inference_mode without clobbering grad_mode / fw_grad_mode.
+    # torch.inference_mode(False) unconditionally sets grad_mode=True and
+    # fw_grad_mode=True; we save and restore those to avoid that.
+    # No-op when inference_mode is already off.
+    if not torch.is_inference_mode_enabled():
+        yield
+        return
+    prev_grad = torch.is_grad_enabled()
+    prev_fw_grad = torch._C._is_fwd_grad_enabled()
+    with torch.inference_mode(False):
+        torch._C._set_grad_enabled(prev_grad)
+        torch._C._set_fwd_grad_enabled(prev_fw_grad)
+        yield
+
+
+@contextlib.contextmanager
+def grad_increment_nesting() -> Generator[int, None, None]:
+    try:
+        grad_level = _grad_increment_nesting()
+        yield grad_level
+    finally:
+        _grad_decrement_nesting()
+
+
+def enter_jvp_nesting() -> int:
+    global JVP_NESTING
+    jvp_level = _jvp_increment_nesting()
+    JVP_NESTING += 1
+    return jvp_level
+
+
+def exit_jvp_nesting() -> None:
+    global JVP_NESTING
+    _jvp_decrement_nesting()
+    JVP_NESTING -= 1
+
+
+@contextlib.contextmanager
+def jvp_increment_nesting() -> Generator[int, None, None]:
+    try:
+        yield enter_jvp_nesting()
+    finally:
+        exit_jvp_nesting()
+
+
+@doesnt_support_saved_tensors_hooks
+def _vjp_with_argnums(
+    func: Callable[..., Any],
+    *primals: Any,
+    argnums: argnums_t | None = None,
+    has_aux: bool = False,
+) -> tuple[Any, Callable[..., Any]] | tuple[Any, Callable[..., Any], Any]:
+    # This is the same function as vjp but also accepts an argnums argument
+    # All args are the same as vjp except for the added argument
+    # argnums (int or tuple[int,...] | None): Optional, specifies the argument(s) to compute gradients with respect to.
+    #         If None, computes the gradients with respect to all inputs (used for vjp). Default: None
+    #
+    # WARN: Users should NOT call this function directly and should just be calling vjp.
+    # It is only separated so that inputs passed to jacrev but not differentiated get the correct wrappers.
+    #
+    # NOTE: All error messages are produced as if vjp was being called, even if this was called by jacrev
+    #
+    # Returns the same two elements as :func:`vjp` but the function returned, vjp_fn, returns a tuple of VJPs
+    # for only the primal elements given by argnums.
+    with grad_increment_nesting() as level:
+        # See NOTE [grad and vjp interaction with no_grad]
+        with torch.enable_grad():
+            primals = _wrap_all_tensors(primals, level)
+            if argnums is None:
+                diff_primals = _create_differentiable(primals, level)
+            else:
+                diff_primals = _slice_argnums(primals, argnums, as_tuple=False)
+                tree_map_(partial(_create_differentiable, level=level), diff_primals)
+            primals_out = func(*primals)
+
+            aux: Any = None
+            if has_aux:
+                if not (isinstance(primals_out, tuple) and len(primals_out) == 2):
+                    raise RuntimeError(
+                        "vjp(f, *primals): output of function f should be a tuple: (output, aux) "
+                        "if has_aux is True"
+                    )
+                primals_out, aux = primals_out
+                aux = _undo_create_differentiable(aux, level)
+
+            flat_primals_out, primals_out_spec = tree_flatten(primals_out)
+            assert_non_empty_tensor_output(flat_primals_out, "vjp(f, *primals)")
+            flat_diff_primals, primals_spec = tree_flatten(diff_primals)
+            results = _undo_create_differentiable(primals_out, level)
+
+            for primal_out in flat_primals_out:
+                if not isinstance(primal_out, torch.Tensor):
+                    raise AssertionError(
+                        f"expected primal_out to be a Tensor, got {type(primal_out)}"
+                    )
+                if primal_out.is_floating_point() or primal_out.is_complex():
+                    continue
+                raise RuntimeError(
+                    "vjp(f, ...): All outputs of f must be "
+                    "floating-point or complex Tensors, got Tensor "
+                    f"with dtype {primal_out.dtype}"
+                )
+
+        def wrapper(
+            cotangents: Any,
+            retain_graph: bool = True,
+            create_graph: bool | None = None,
+        ) -> Any:
+            if create_graph is None:
+                create_graph = torch.is_grad_enabled()
+            flat_cotangents, cotangents_spec = tree_flatten(cotangents)
+            if primals_out_spec != cotangents_spec:
+                raise RuntimeError(
+                    f"Expected pytree structure of cotangents to be the same "
+                    f"as pytree structure of outputs to the function. "
+                    f"cotangents: {treespec_pprint(cotangents_spec)}, "
+                    f"primal output: {treespec_pprint(primals_out_spec)}"
+                )
+            # This closure runs after grad_increment_nesting exits, so
+            # inference_mode may have been restored. Disable it for autograd.
+            # Skip under Dynamo — tracing through the generator CM emits
+            # spurious _enter_inference_mode nodes.
+            ctx = (
+                contextlib.nullcontext()
+                if torch.compiler.is_compiling()
+                else _disable_inference_mode()
+            )
+            with ctx:
+                result = _autograd_grad(
+                    flat_primals_out,
+                    flat_diff_primals,
+                    flat_cotangents,
+                    retain_graph=retain_graph,
+                    create_graph=create_graph,
+                )
+            return tree_unflatten(result, primals_spec)
+
+    if has_aux:
+        return results, wrapper, aux  # type: ignore[possibly-unbound]
+    else:
+        return results, wrapper
+
+
+def _safe_zero_index(x: tuple[_R, ...]) -> _R:
+    if len(x) != 1:
+        raise AssertionError(f"expected tuple of length 1, got length {len(x)}")
+    return x[0]
+
+
+# jacrev and jacfwd don't support complex functions
+# Helper function to throw appropriate error.
+def error_if_complex(func_name: str, args: Any, is_input: bool) -> None:
+    flat_args = pytree.tree_leaves(args)
+    for idx, arg in enumerate(flat_args):
+        if isinstance(arg, torch.Tensor) and arg.dtype.is_complex:
+            input_or_output = "inputs" if is_input else "outputs"
+            err_msg = (
+                f"{func_name}: Expected all {input_or_output} "
+                f"to be real but received complex tensor at flattened input idx: {idx}"
+            )
+            raise RuntimeError(err_msg)
+
+
+@exposed_in("torch.func")
+def jacrev(
+    func: Callable[..., Any],
+    argnums: int | tuple[int, ...] = 0,
+    *,
+    has_aux: bool = False,
+    chunk_size: int | None = None,
+    _preallocate_and_copy: bool = False,
+) -> Callable[..., Any]:
+    """
+    Computes the Jacobian of ``func`` with respect to the arg(s) at index
+    ``argnum`` using reverse mode autodiff
+
+    .. note::
+        Using :attr:`chunk_size=1` is equivalent to computing the jacobian
+        row-by-row with a for-loop i.e. the constraints of :func:`vmap` are
+        not applicable.
+
+    Args:
+        func (function): A Python function that takes one or more arguments,
+            one of which must be a Tensor, and returns one or more Tensors
+        argnums (int or tuple[int, ...]): Optional, integer or tuple of integers,
+            saying which arguments to get the Jacobian with respect to.
+            Default: 0.
+        has_aux (bool): Flag indicating that ``func`` returns a
+            ``(output, aux)`` tuple where the first element is the output of
+            the function to be differentiated and the second element is
+            auxiliary objects that will not be differentiated.
+            Default: False.
+        chunk_size (None or int): If None (default), use the maximum chunk size
+            (equivalent to doing a single vmap over vjp to compute the jacobian).
+            If 1, then compute the jacobian row-by-row with a for-loop.
+            If not None, then compute the jacobian :attr:`chunk_size` rows at a time
+            (equivalent to doing multiple vmap over vjp). If you run into memory issues computing
+            the jacobian, please try to specify a non-None chunk_size.
+
+    Returns:
+        Returns a function that takes in the same inputs as ``func`` and
+        returns the Jacobian of ``func`` with respect to the arg(s) at
+        ``argnums``. If ``has_aux is True``, then the returned function
+        instead returns a ``(jacobian, aux)`` tuple where ``jacobian``
+        is the Jacobian and ``aux`` is auxiliary objects returned by ``func``.
+
+    A basic usage with a pointwise, unary operation will give a diagonal array
+    as the Jacobian
+
+        >>> from torch.func import jacrev
+        >>> x = torch.randn(5)
+        >>> jacobian = jacrev(torch.sin)(x)
+        >>> expected = torch.diag(torch.cos(x))
+        >>> assert torch.allclose(jacobian, expected)
+
+    If you would like to compute the output of the function as well as the
+    jacobian of the function, use the ``has_aux`` flag to return the output
+    as an auxiliary object:
+
+        >>> from torch.func import jacrev
+        >>> x = torch.randn(5)
+        >>>
+        >>> def f(x):
+        >>>   return x.sin()
+        >>>
+        >>> def g(x):
+        >>>   result = f(x)
+        >>>   return result, result
+        >>>
+        >>> jacobian_f, f_x = jacrev(g, has_aux=True)(x)
+        >>> assert torch.allclose(f_x, f(x))
+
+    :func:`jacrev` can be composed with vmap to produce batched
+    Jacobians:
+
+        >>> from torch.func import jacrev, vmap
+        >>> x = torch.randn(64, 5)
+        >>> jacobian = vmap(jacrev(torch.sin))(x)
+        >>> assert jacobian.shape == (64, 5, 5)
+
+    Additionally, :func:`jacrev` can be composed with itself to produce
+    Hessians
+
+        >>> from torch.func import jacrev
+        >>> def f(x):
+        >>>   return x.sin().sum()
+        >>>
+        >>> x = torch.randn(5)
+        >>> hessian = jacrev(jacrev(f))(x)
+        >>> assert torch.allclose(hessian, torch.diag(-x.sin()))
+
+    By default, :func:`jacrev` computes the Jacobian with respect to the first
+    input. However, it can compute the Jacobian with respect to a different
+    argument by using ``argnums``:
+
+        >>> from torch.func import jacrev
+        >>> def f(x, y):
+        >>>   return x + y ** 2
+        >>>
+        >>> x, y = torch.randn(5), torch.randn(5)
+        >>> jacobian = jacrev(f, argnums=1)(x, y)
+        >>> expected = torch.diag(2 * y)
+        >>> assert torch.allclose(jacobian, expected)
+
+    Additionally, passing a tuple to ``argnums`` will compute the Jacobian
+    with respect to multiple arguments
+
+        >>> from torch.func import jacrev
+        >>> def f(x, y):
+        >>>   return x + y ** 2
+        >>>
+        >>> x, y = torch.randn(5), torch.randn(5)
+        >>> jacobian = jacrev(f, argnums=(0, 1))(x, y)
+        >>> expectedX = torch.diag(torch.ones_like(x))
+        >>> expectedY = torch.diag(2 * y)
+        >>> assert torch.allclose(jacobian[0], expectedX)
+        >>> assert torch.allclose(jacobian[1], expectedY)
+
+    .. note::
+        Using PyTorch ``torch.no_grad`` together with ``jacrev``.
+        Case 1: Using ``torch.no_grad`` inside a function:
+
+            >>> def f(x):
+            >>>     with torch.no_grad():
+            >>>         c = x ** 2
+            >>>     return x - c
+
+        In this case, ``jacrev(f)(x)`` will respect the inner ``torch.no_grad``.
+
+        Case 2: Using ``jacrev`` inside ``torch.no_grad`` context manager:
+
+            >>> with torch.no_grad():
+            >>>     jacrev(f)(x)
+
+        In this case, ``jacrev`` will respect the inner ``torch.no_grad``, but not the
+        outer one. This is because ``jacrev`` is a "function transform": its result
+        should not depend on the result of a context manager outside of ``f``.
+    """
+    if not (chunk_size is None or chunk_size > 0):
+        raise ValueError("jacrev: `chunk_size` should be greater than 0.")
+
+    @_wraps_without_dynamo_attrs(func)
+    def wrapper_fn(*args: Any) -> Any:
+        error_if_complex("jacrev", args, is_input=True)
+        vjp_out = _vjp_with_argnums(func, *args, argnums=argnums, has_aux=has_aux)
+        aux: Any = None
+        if has_aux:
+            # pyrefly: ignore[bad-unpacking]
+            output, vjp_fn, aux = vjp_out
+        else:
+            # pyrefly: ignore[bad-unpacking]
+            output, vjp_fn = vjp_out
+
+        # See NOTE: [Computing jacobian with vmap and vjp for multiple outputs]
+        flat_output, output_spec = tree_flatten(output)
+
+        error_if_complex("jacrev", flat_output, is_input=False)
+
+        # NB: vjp already checks that all outputs are tensors
+        # Step 1: Construct grad_outputs by splitting the standard basis
+        flat_output_numels = tuple(out.numel() for out in flat_output)
+
+        primals = _slice_argnums(args, argnums)
+        flat_primals, primals_spec = tree_flatten(primals)
+
+        def compute_jacobian_stacked() -> list[Any]:
+            # Helper function to compute chunked Jacobian
+            # The intermediate chunked calculation are only
+            # scoped at this function level.
+            chunked_results: list[list[Any]] = []
+            for flat_basis_chunk in _chunked_standard_basis_for_(
+                flat_output, flat_output_numels, chunk_size=chunk_size
+            ):
+                if chunk_size == 1:
+                    # sanity check.
+                    for t in flat_basis_chunk:
+                        if t.size(0) != 1:
+                            raise AssertionError(
+                                f"expected t.size(0) to be 1, got {t.size(0)}"
+                            )
+
+                    flat_basis_chunk = tree_map(
+                        lambda t: torch.squeeze(t, 0), flat_basis_chunk
+                    )
+
+                basis = tree_unflatten(flat_basis_chunk, output_spec)
+
+                if chunk_size == 1:
+                    # Behaviour with `chunk_size=1` is same as `for-loop`
+                    # i.e. user shouldn't deal with the limitations of vmap.
+                    chunked_result = vjp_fn(basis)
+                else:  # chunk_size is None or chunk_size != 1
+                    chunked_result = vmap(vjp_fn)(basis)
+
+                flat_results = pytree.tree_leaves(chunked_result)
+
+                if chunk_size == 1:
+                    flat_results = tree_map(
+                        lambda t: torch.unsqueeze(t, 0), flat_results
+                    )
+
+                chunked_results.append(flat_results)
+
+            if len(chunked_results) == 1:
+                # Short-circuit if we used a single chunk
+                return chunked_results[0]
+
+            # Concatenate chunks.
+            flat_results = []
+            # Iterate and concat the jacobians of different
+            # inputs.
+            for idx in range(len(flat_primals)):
+                r = tuple(r_[idx] for r_ in chunked_results)
+                flat_results.append(torch.cat(r, 0))
+
+            return flat_results
+
+        def compute_jacobian_preallocate_and_copy() -> list[Any]:
+            # Helper function to compute chunked Jacobian
+            # The intermediate chunked calculation are only
+            # scoped at this function level.
+            out_vec_size = sum(flat_output_numels)
+
+            # Don't pre-allocate if we have a single chunk.
+            stacked_results: list[torch.Tensor] = []
+            if not (chunk_size is None or chunk_size >= out_vec_size):
+                stacked_results = [
+                    primal.new_zeros(out_vec_size, *primal.shape)
+                    for primal in flat_primals
+                ]
+
+            for idx, flat_basis_chunk in enumerate(
+                _chunked_standard_basis_for_(
+                    flat_output, flat_output_numels, chunk_size=chunk_size
+                )
+            ):
+                if chunk_size == 1:
+                    # sanity check.
+                    for t in flat_basis_chunk:
+                        if t.size(0) != 1:
+                            raise AssertionError(
+                                f"expected t.size(0) to be 1, got {t.size(0)}"
+                            )
+
+                    flat_basis_chunk = [torch.squeeze(t, 0) for t in flat_basis_chunk]
+
+                basis = tree_unflatten(flat_basis_chunk, output_spec)
+
+                if chunk_size == 1:
+                    # Behaviour with `chunk_size=1` is same as `for-loop`
+                    # i.e. user shouldn't deal with the limitations of vmap.
+                    chunked_result = vjp_fn(basis)
+                else:  # chunk_size is None or chunk_size != 1
+                    chunked_result = vmap(vjp_fn)(basis)
+
+                flat_results = pytree.tree_leaves(chunked_result)
+
+                # Short-circuit if we have a single chunk.
+                if chunk_size is None or chunk_size >= out_vec_size:
+                    if chunk_size == 1:  # and out_vec_size == 1
+                        # Since we squeezed the output dim
+                        flat_results = tree_map(
+                            lambda t: torch.unsqueeze(t, 0), flat_results
+                        )
+                    return flat_results
+
+                for r, sr in zip(flat_results, stacked_results):  # type: ignore[possibly-unbound]
+                    sr[idx * chunk_size : (idx + 1) * chunk_size].copy_(r)
+
+            return stacked_results  # type: ignore[possibly-unbound]
+
+        if _preallocate_and_copy:
+            flat_jacobians_per_input = compute_jacobian_preallocate_and_copy()
+        else:
+            flat_jacobians_per_input = compute_jacobian_stacked()
+
+        # Step 2: The returned jacobian is one big tensor per input. In this step,
+        # we split each Tensor by output.
+        flat_jacobians_per_input = [
+            torch.split(result, list(flat_output_numels), dim=0)
+            for result in flat_jacobians_per_input
+        ]
+        flat_input_flat_output = [
+            tuple(
+                split.view(out.shape + primal.shape)
+                for split, out in zip(splits, flat_output)
+            )
+            for splits, primal in zip(flat_jacobians_per_input, flat_primals)
+        ]
+
+        # Step 3: Right now, `jacobian` is a List[List[Tensor]].
+        # The outer List corresponds to the number of primals,
+        # the inner List corresponds to the number of outputs.
+        # We need to:
+        # a. Exchange the order of the outer List and inner List
+        # b. tree_unflatten the inner Lists (which correspond to the primals)
+        # c. handle the argnums=int case
+        # d. tree_unflatten the outer List (which corresponds to the outputs)
+        flat_output_flat_input = tuple(zip(*flat_input_flat_output))
+
+        flat_output_input = tuple(
+            tree_unflatten(flat_input, primals_spec)
+            for flat_input in flat_output_flat_input
+        )
+
+        if isinstance(argnums, int):
+            flat_output_input = tuple(
+                _safe_zero_index(flat_input) for flat_input in flat_output_input
+            )
+        output_input = tree_unflatten(flat_output_input, output_spec)
+        if has_aux:
+            return output_input, aux  # type: ignore[possibly-unbound]
+        return output_input
+
+    return wrapper_fn
+
+
+# NOTE: [Computing jacobian with vmap and vjp for multiple outputs]
+#
+# Let's consider f(x) = (x**2, x.sum()) and let x = torch.randn(3).
+# It turns out we can compute the jacobian of this function with a single
+# call to autograd.grad by using vmap over the correct grad_outputs.
+#
+# Firstly, one way to compute the jacobian is to stack x**2 and x.sum()
+# into a 4D vector. E.g., use g(x) = torch.stack([x**2, x.sum()])
+#
+# To get the first row of the jacobian, we call
+# >>> autograd.grad(g(x), x, grad_outputs=torch.tensor([1, 0, 0, 0]))
+# To get the 2nd row of the jacobian, we call
+# >>> autograd.grad(g(x), x, grad_outputs=torch.tensor([0, 1, 0, 0]))
+# and so on.
+#
+# Using vmap, we can vectorize all 4 of these computations into one by
+# passing the standard basis for R^4 as the grad_output.
+# vmap(partial(autograd.grad, g(x), x))(torch.eye(4)).
+#
+# Now, how do we compute the jacobian *without stacking the output*?
+# We can just split the standard basis across the outputs. So to
+# compute the jacobian of f(x), we'd use
+# >>> autograd.grad(f(x), x, grad_outputs=_construct_standard_basis_for(...))
+# The grad_outputs looks like the following:
+# ( torch.tensor([[1, 0, 0],
+#                 [0, 1, 0],
+#                 [0, 0, 1],
+#                 [0, 0, 0]]),
+#   torch.tensor([[0],
+#                 [0],
+#                 [0],
+#                 [1]]) )
+#
+# But we're not done yet!
+# >>> vmap(partial(autograd.grad(f(x), x, grad_outputs=...)))
+# returns a Tensor of shape [4, 3]. We have to remember to split the
+# jacobian of shape [4, 3] into two:
+# - one of shape [3, 3] for the first output
+# - one of shape [   3] for the second output
+
+
+def _chunked_standard_basis_for_(
+    tensors: Sequence[torch.Tensor],
+    tensor_numels: Sequence[int],
+    chunk_size: int | None = None,
+) -> Generator[tuple[torch.Tensor, ...], None, None]:
+    # This function:
+    # - constructs a N=sum(tensor_numels) standard basis. i.e. an NxN identity matrix.
+    # - Splits the identity matrix into chunks with each chunk size determined by `tensor_numels`.
+    # - Each chunk corresponds to one tensor. The chunk has the same dtype and
+    #   device as the tensor
+    #
+    # For example, with tensor_numels = [1, 2, 1], this function returns:
+    # ( tensor([[1],     tensor([[0, 0],      tensor([[0],
+    #           [0],             [1, 0],              [0],
+    #           [0],             [0, 1],              [0],
+    #           [0]])  ,         [0, 0]])  ,          [1]])  )
+    #
+    # Precondition: tensor_numels == tuple(tensor.numel() for tensor in tensors)
+    # Precondition: tensors always has at least one element.
+    #
+    # See NOTE: [Computing jacobian with vmap and grad for multiple tensors]
+    # for context behind this function.
+    # NOTE: Argument `chunk_size` is used to generate chunked basis instead of
+    #       one huge basis matrix. `chunk_size` dictates the maximum size of the
+    #       basis matrix along dim=0.
+    if len(tensors) != len(tensor_numels):
+        raise AssertionError(
+            f"len(tensors)={len(tensors)} != len(tensor_numels)={len(tensor_numels)}"
+        )
+    if len(tensors) == 0:
+        raise AssertionError("tensors must have at least one element")
+    if chunk_size is not None and chunk_size <= 0:
+        raise AssertionError(f"chunk_size must be > 0 or None, got {chunk_size}")
+    total_numel = sum(tensor_numels)
+    if chunk_size and chunk_size < total_numel:
+        chunk_numels = get_chunk_sizes(total_numel, chunk_size)
+    else:  # chunk_size is None or chunk_size >= total_numel
+        chunk_size = total_numel
+        chunk_numels = [total_numel]
+
+    diag_start_indices = []
+    diag_start_idx = 0
+    for tensor_numel in tensor_numels:
+        diag_start_indices.append(diag_start_idx)
+        diag_start_idx -= tensor_numel
+
+    for chunk_idx, total_numel in enumerate(chunk_numels):
+        chunks = tuple(
+            tensor.new_zeros(total_numel, tensor_numel)
+            for tensor, tensor_numel in zip(tensors, tensor_numels)
+        )
+
+        for chunk, diag_start_idx in zip(chunks, diag_start_indices):
+            offset = int(diag_start_idx) + chunk_idx * chunk_size
+            chunk.diagonal(offset).fill_(1)
+        chunks = tuple(
+            chunk.view(total_numel, *tensor.shape)
+            for chunk, tensor in zip(chunks, tensors)
+        )
+        yield chunks
+
+
+def _construct_standard_basis_for(
+    tensors: Sequence[torch.Tensor], tensor_numels: Sequence[int]
+) -> tuple[torch.Tensor, ...] | None:
+    for basis in _chunked_standard_basis_for_(tensors, tensor_numels, chunk_size=None):
+        return basis
+    return None
+
+
+def _validate_and_wrap_argnum(argnum: int, num_args: int) -> int:
+    if not isinstance(argnum, int):
+        raise RuntimeError(f"argnum must be int, got: {type(argnum)}")
+    if argnum >= 0 and argnum < num_args:
+        return argnum
+    if argnum < 0 and argnum >= -num_args:
+        return argnum + num_args
+    raise RuntimeError(f"Got argnum={argnum}, but only {num_args} positional inputs")
+
+
+def _check_unique_non_empty(argnums: argnums_t) -> None:
+    if isinstance(argnums, tuple):
+        if len(argnums) == 0:
+            raise RuntimeError("argnums must be non-empty")
+        if len(set(argnums)) != len(argnums):
+            raise RuntimeError(f"argnums elements must be unique, got {argnums}")
+
+
+def _replace_args(
+    old_args: tuple[Any, ...], new_args: tuple[Any, ...], argnums: argnums_t
+) -> tuple[Any, ...]:
+    if isinstance(argnums, int):
+        if len(new_args) != 1:
+            raise RuntimeError(
+                f"new_args should be of size 1, was of size {len(new_args)}"
+            )
+        return tuple(
+            new_args[0] if i == argnums else old_args[i] for i in range(len(old_args))
+        )
+    if isinstance(argnums, tuple):
+        if len(new_args) != len(argnums):
+            raise RuntimeError(
+                "new_args should have the same size as argnums. "
+                f"Argnums size {len(argnums)}, new_args size {len(new_args)}"
+            )
+
+        argnums_tuple = argnums
+
+        def get_right_elem(i: int) -> Any:
+            return (
+                new_args[argnums_tuple.index(i)] if i in argnums_tuple else old_args[i]
+            )
+
+        return tuple(get_right_elem(i) for i in range(len(old_args)))
+    raise RuntimeError(f"argnums must be int or Tuple[int, ...], got: {type(argnums)}")
+
+
+def _validate_and_wrap_argnums(argnums: argnums_t, num_args: int) -> argnums_t:
+    if isinstance(argnums, int):
+        return _validate_and_wrap_argnum(argnums, num_args)
+    if isinstance(argnums, tuple):
+        return tuple(_validate_and_wrap_argnum(argnum, num_args) for argnum in argnums)
+    raise AssertionError("Should never get here")
+
+
+def _slice_argnums(
+    args: tuple[Any, ...], argnums: argnums_t, as_tuple: bool = True
+) -> Any:
+    if not isinstance(argnums, int) and not isinstance(argnums, tuple):
+        raise RuntimeError(
+            f"argnums must be int or Tuple[int, ...], got: {type(argnums)}"
+        )
+    argnums = _validate_and_wrap_argnums(argnums, len(args))
+    _check_unique_non_empty(argnums)
+    if isinstance(argnums, int):
+        if as_tuple:
+            return (args[argnums],)
+        else:
+            return args[argnums]
+    return tuple(args[i] for i in argnums)
+
+
+JVP_NESTING = 0
+
+
+def assert_flat_tuple_of_tensors(elts: Any, api: str, argname: str) -> None:
+    if not isinstance(elts, tuple):
+        raise RuntimeError(
+            f"{api}: Expected {argname} to be a tuple of Tensors, got {type(elts)}"
+        )
+    for elt in elts:
+        if isinstance(elt, torch.Tensor):
+            continue
+        raise RuntimeError(
+            f"{api}: Expected {argname} to be a tuple of Tensors, got "
+            f"a tuple with an element of type {type(elt)}"
+        )
+    if len(elts) == 0:
+        raise RuntimeError(
+            f"{api}: Expected {argname} to be a non-empty tuple of Tensors."
+        )
+
+
+def assert_non_empty_tensor_output(output: list[Any], api: str) -> None:
+    if (len(output) == 1 and output[0] is None) or len(output) < 1:
+        raise RuntimeError(
+            f"{api}: Expected f to be a function that has non-empty output (got output = {output})"
+        )
+    for o in output:
+        if not isinstance(o, torch.Tensor):
+            raise RuntimeError(
+                f"{api}: expected f(*primals) to return only tensors"
+                f", got unsupported type {type(o)}"
+            )
+
+
+def assert_output_is_tensor_or_tensors(output: Any, api: str) -> None:
+    if isinstance(output, torch.Tensor):
+        return
+    if not isinstance(output, tuple):
+        raise RuntimeError(
+            f"{api}: Expected output of f to be a Tensor or Tensors, got {type(output)}"
+        )
+    if len(output) == 0:
+        raise RuntimeError(
+            f"{api}: Expected output of f to be a non-empty tuple of Tensors."
+        )
+    for out in output:
+        if isinstance(out, torch.Tensor):
+            continue
+        raise RuntimeError(
+            f"{api}: Expected output of f to be a Tensor or Tensors, got "
+            f"{type(out)} as an output"
+        )
+
+
+def assert_non_empty_list_of_tensors(
+    output: list[torch.Tensor], api: str, argname: str
+) -> None:
+    if len(output) == 0:
+        raise RuntimeError(f"{api}: Expected {argname} to contain at least one Tensor.")
+    for out in output:
+        if isinstance(out, torch.Tensor):
+            continue
+        raise RuntimeError(
+            f"{api}: Expected {argname} to only contain Tensors, got {type(out)}"
+        )
+
+
+jvp_str = "jvp(f, primals, tangents)"
+
+
+def safe_unpack_dual(
+    dual: torch.Tensor, strict: bool
+) -> tuple[torch.Tensor, torch.Tensor]:
+    if not isinstance(dual, torch.Tensor):
+        raise RuntimeError(
+            f"{jvp_str}: expected f(*args) to return only tensors"
+            f", got unsupported type {type(dual)}"
+        )
+
+    primal, tangent = fwAD.unpack_dual(dual)
+    if tangent is None:
+        if strict:
+            raise RuntimeError(
+                "jvp(f, primals, tangents, strict=True): "
+                "The output of f is independent of "
+                "the inputs. This is not allowed with strict=True."
+            )
+        tangent = torch.zeros_like(primal)
+    return primal, tangent
+
+
+@exposed_in("torch.func")
+def jvp(
+    func: Callable[..., Any],
+    primals: Any,
+    tangents: Any,
+    *,
+    strict: bool = False,
+    has_aux: bool = False,
+) -> tuple[Any, Any] | tuple[Any, Any, Any]:
+    """
+    Standing for the Jacobian-vector product, returns a tuple containing
+    the output of `func(*primals)` and the "Jacobian of ``func`` evaluated at
+    ``primals``" times ``tangents``. This is also known as forward-mode autodiff.
+
+    Args:
+        func (function): A Python function that takes one or more arguments,
+            one of which must be a Tensor, and returns one or more Tensors
+        primals (Tensors): Positional arguments to ``func`` that must all be
+            Tensors. The returned function will also be computing the
+            derivative with respect to these arguments
+        tangents (Tensors): The "vector" for which Jacobian-vector-product is
+            computed. Must be the same structure and sizes as the inputs to
+            ``func``.
+        has_aux (bool): Flag indicating that ``func`` returns a
+            ``(output, aux)`` tuple where the first element is the output of
+            the function to be differentiated and the second element is
+            other auxiliary objects that will not be differentiated.
+            Default: False.
+
+    Returns:
+        Returns a ``(output, jvp_out)`` tuple containing the output of ``func``
+        evaluated at ``primals`` and the Jacobian-vector product.
+        If ``has_aux is True``, then instead returns a ``(output, jvp_out, aux)`` tuple.
+
+    .. note::
+        You may see this API error out with "forward-mode AD not implemented
+        for operator X". If so, please file a bug report and we will prioritize it.
+
+    jvp is useful when you wish to compute gradients of a function R^1 -> R^N
+
+        >>> from torch.func import jvp
+        >>> x = torch.randn([])
+        >>> f = lambda x: x * torch.tensor([1.0, 2.0, 3])
+        >>> warnings.filterwarnings(
+        ...     "ignore", message=".*torch.jit.script"
+        ... )  # docs: hide
+        >>> value, grad = jvp(f, (x,), (torch.tensor(1.0),))
+        >>> assert torch.allclose(value, f(x))
+        >>> assert torch.allclose(grad, torch.tensor([1.0, 2, 3]))
+
+    :func:`jvp` can support functions with multiple inputs by passing in the
+    tangents for each of the inputs
+
+         >>> from torch.func import jvp
+         >>> x = torch.randn(5)
+         >>> y = torch.randn(5)
+         >>> f = lambda x, y: (x * y)
+         >>> _, output = jvp(f, (x, y), (torch.ones(5), torch.ones(5)))
+         >>> assert torch.allclose(output, x + y)
+
+    """
+
+    return _jvp_with_argnums(
+        func, primals, tangents, argnums=None, strict=strict, has_aux=has_aux
+    )
+
+
+def _jvp_with_argnums(
+    func: Callable[..., Any],
+    primals: Any,
+    tangents: Any,
+    argnums: argnums_t | None,
+    *,
+    strict: bool = False,
+    has_aux: bool,
+) -> tuple[Any, Any] | tuple[Any, Any, Any]:
+    # This is the same function as jvp but also accepts an argnums argument
+    # Most args are the same as jvp except for the added argument
+    # argnums (int or tuple[int, ...]): Optional, specifies the argument(s) to compute gradients with respect to.
+    #         If None, computes the gradients with respect to all inputs (used for jvp). Default: None
+    # Because of this, tangents must be of length argnums and matches up to the corresponding primal whose index is
+    # given by argnums
+    #
+    # WARN: Users should NOT call this function directly and should just be calling jvp.
+    # It is only separated so that inputs passed to jacfwd but not differentiated get the correct wrappers.
+    #
+    # NOTE: All error messages are produced as if jvp was being called, even if this was called by jacfwd
+    #
+    # Returns the same two elements as :func:`jvp` but the returned tuple, ``jvp_out``, only has JVPs with respect to
+    # the primals given by argnums
+    if not isinstance(primals, tuple):
+        raise RuntimeError(
+            f"{jvp_str}: Expected primals to be a tuple. "
+            f"E.g. it should be valid to call f(*primals)."
+        )
+    diff_args = primals if argnums is None else _slice_argnums(primals, argnums)
+    flat_primals, primals_spec = tree_flatten(diff_args)
+    flat_tangents, tangents_spec = tree_flatten(tangents)
+    if primals_spec != tangents_spec:
+        raise RuntimeError(
+            f"{jvp_str}: Expected primals and tangents to have the same python "
+            f"structure. For example, if primals is a tuple of 3 tensors, "
+            f"tangents also must be. Got primals with structure {primals_spec} "
+            f"and tangents with structure {tangents_spec}"
+        )
+    assert_non_empty_list_of_tensors(flat_primals, jvp_str, "primals")
+    assert_non_empty_list_of_tensors(flat_tangents, jvp_str, "tangents")
+
+    global JVP_NESTING
+
+    with jvp_increment_nesting() as level:
+        with fwAD._set_fwd_grad_enabled(True):
+            ctx = fwAD.dual_level if JVP_NESTING == 1 else contextlib.nullcontext
+            with ctx():
+                flat_duals = tuple(
+                    fwAD.make_dual(p, t) for p, t in zip(flat_primals, flat_tangents)
+                )
+                duals = tree_unflatten(flat_duals, primals_spec)
+                if argnums is not None:
+                    primals = _wrap_all_tensors(primals, level)
+                    duals = _replace_args(primals, duals, argnums)
+                result_duals = func(*duals)
+                aux: Any = None
+                if has_aux:
+                    if not (isinstance(result_duals, tuple) and len(result_duals) == 2):
+                        raise RuntimeError(
+                            f"{jvp_str}: output of function f should be a tuple: (output, aux) "
+                            "if has_aux is True"
+                        )
+                    result_duals, aux = result_duals
+                    aux = _undo_create_differentiable(aux, level)
+
+                result_duals, spec = tree_flatten(result_duals)
+                assert_non_empty_tensor_output(result_duals, jvp_str)
+
+                primals_out, tangents_out = zip(
+                    *[safe_unpack_dual(dual, strict) for dual in result_duals]
+                )
+                primals_out = tree_map(
+                    partial(_undo_create_differentiable, level=level), primals_out
+                )
+                tangents_out = tree_map(
+                    partial(_undo_create_differentiable, level=level), tangents_out
+                )
+
+                primals_out_unflatten = tree_unflatten(primals_out, spec)
+                tangents_out_unflatten = tree_unflatten(tangents_out, spec)
+                if has_aux:
+                    return primals_out_unflatten, tangents_out_unflatten, aux  # type: ignore[possibly-unbound]
+
+                return primals_out_unflatten, tangents_out_unflatten
+
+
+def safe_unflatten(tensor: torch.Tensor, dim: int, shape: torch.Size) -> torch.Tensor:
+    if len(shape) == 0:
+        if tensor.shape[dim] != 1:
+            raise AssertionError(
+                f"expected tensor.shape[{dim}] to be 1, got {tensor.shape[dim]}"
+            )
+        return tensor.squeeze(dim)
+    return tensor.unflatten(dim, shape)
+
+
+@exposed_in("torch.func")
+def jacfwd(
+    func: Callable[..., Any],
+    argnums: argnums_t = 0,
+    has_aux: bool = False,
+    *,
+    randomness: str = "error",
+) -> Callable[..., Any]:
+    """
+    Computes the Jacobian of ``func`` with respect to the arg(s) at index
+    ``argnum`` using forward-mode autodiff
+
+    Args:
+        func (function): A Python function that takes one or more arguments,
+            one of which must be a Tensor, and returns one or more Tensors
+        argnums (int or tuple[int, ...]): Optional, integer or tuple of integers,
+            saying which arguments to get the Jacobian with respect to.
+            Default: 0.
+        has_aux (bool): Flag indicating that ``func`` returns a
+            ``(output, aux)`` tuple where the first element is the output of
+            the function to be differentiated and the second element is
+            auxiliary objects that will not be differentiated.
+            Default: False.
+        randomness(str): Flag indicating what type of randomness to use.
+            See :func:`vmap` for more detail. Allowed: "different", "same", "error".
+            Default: "error"
+
+    Returns:
+        Returns a function that takes in the same inputs as ``func`` and
+        returns the Jacobian of ``func`` with respect to the arg(s) at
+        ``argnums``. If ``has_aux is True``, then the returned function
+        instead returns a ``(jacobian, aux)`` tuple where ``jacobian``
+        is the Jacobian and ``aux`` is auxiliary objects returned by ``func``.
+
+    .. note::
+        You may see this API error out with "forward-mode AD not implemented
+        for operator X". If so, please file a bug report and we will prioritize it.
+        An alternative is to use :func:`jacrev`, which has better operator coverage.
+
+    A basic usage with a pointwise, unary operation will give a diagonal array
+    as the Jacobian
+
+        >>> from torch.func import jacfwd
+        >>> x = torch.randn(5)
+        >>> jacobian = jacfwd(torch.sin)(x)
+        >>> expected = torch.diag(torch.cos(x))
+        >>> assert torch.allclose(jacobian, expected)
+
+    :func:`jacfwd` can be composed with vmap to produce batched
+    Jacobians:
+
+        >>> from torch.func import jacfwd, vmap
+        >>> x = torch.randn(64, 5)
+        >>> jacobian = vmap(jacfwd(torch.sin))(x)
+        >>> assert jacobian.shape == (64, 5, 5)
+
+    If you would like to compute the output of the function as well as the
+    jacobian of the function, use the ``has_aux`` flag to return the output
+    as an auxiliary object:
+
+        >>> from torch.func import jacfwd
+        >>> x = torch.randn(5)
+        >>>
+        >>> def f(x):
+        >>>   return x.sin()
+        >>>
+        >>> def g(x):
+        >>>   result = f(x)
+        >>>   return result, result
+        >>>
+        >>> jacobian_f, f_x = jacfwd(g, has_aux=True)(x)
+        >>> assert torch.allclose(f_x, f(x))
+
+    Additionally, :func:`jacrev` can be composed with itself or :func:`jacrev`
+    to produce Hessians
+
+        >>> from torch.func import jacfwd, jacrev
+        >>> def f(x):
+        >>>   return x.sin().sum()
+        >>>
+        >>> x = torch.randn(5)
+        >>> hessian = jacfwd(jacrev(f))(x)
+        >>> assert torch.allclose(hessian, torch.diag(-x.sin()))
+
+    By default, :func:`jacfwd` computes the Jacobian with respect to the first
+    input. However, it can compute the Jacobian with respect to a different
+    argument by using ``argnums``:
+
+        >>> from torch.func import jacfwd
+        >>> def f(x, y):
+        >>>   return x + y ** 2
+        >>>
+        >>> x, y = torch.randn(5), torch.randn(5)
+        >>> jacobian = jacfwd(f, argnums=1)(x, y)
+        >>> expected = torch.diag(2 * y)
+        >>> assert torch.allclose(jacobian, expected)
+
+    Additionally, passing a tuple to ``argnums`` will compute the Jacobian
+    with respect to multiple arguments
+
+        >>> from torch.func import jacfwd
+        >>> def f(x, y):
+        >>>   return x + y ** 2
+        >>>
+        >>> x, y = torch.randn(5), torch.randn(5)
+        >>> jacobian = jacfwd(f, argnums=(0, 1))(x, y)
+        >>> expectedX = torch.diag(torch.ones_like(x))
+        >>> expectedY = torch.diag(2 * y)
+        >>> assert torch.allclose(jacobian[0], expectedX)
+        >>> assert torch.allclose(jacobian[1], expectedY)
+
+    """
+
+    @_wraps_without_dynamo_attrs(func)
+    def wrapper_fn(*args: Any) -> Any:
+        error_if_complex("jacfwd", args, is_input=True)
+        primals = args if argnums is None else _slice_argnums(args, argnums)
+        flat_primals, primals_spec = tree_flatten(primals)
+        flat_primals_numels = tuple(p.numel() for p in flat_primals)
+        flat_basis = _construct_standard_basis_for(flat_primals, flat_primals_numels)
+        if flat_basis is None:
+            raise AssertionError("flat_basis must not be None")
+        basis = tree_unflatten(flat_basis, primals_spec)
+
+        def push_jvp(basis: Any) -> Any:
+            output = _jvp_with_argnums(
+                func, args, basis, argnums=argnums, has_aux=has_aux
+            )
+            # output[0] is the output of `func(*args)`
+            error_if_complex("jacfwd", output[0], is_input=False)
+            if has_aux:
+                _, jvp_out, aux = output  # pyrefly: ignore[bad-unpacking]
+                return jvp_out, aux
+            _, jvp_out = output  # pyrefly: ignore[bad-unpacking]
+            return jvp_out
+
+        results = vmap(push_jvp, randomness=randomness)(basis)
+        aux: Any = None
+        if has_aux:
+            results, aux = results
+            # aux is in the standard basis format, e.g. NxN matrix
+            # We need to fetch the first element as original `func` output
+            flat_aux, aux_spec = tree_flatten(aux)
+            flat_aux = [value[0] for value in flat_aux]
+            aux = tree_unflatten(flat_aux, aux_spec)
+
+        jac_outs, spec = tree_flatten(results)
+        # Most probably below output check can never raise an error
+        # as jvp should test the output before
+        # assert_non_empty_output(jac_outs, 'jacfwd(f, ...)(*args)')
+
+        jac_outs_ins = tuple(
+            tuple(
+                safe_unflatten(jac_out_in, -1, primal.shape)
+                for primal, jac_out_in in zip(
+                    flat_primals,
+                    torch.split(
+                        jac_out.movedim(0, -1), list(flat_primals_numels), dim=-1
+                    ),
+                )
+            )
+            for jac_out in jac_outs
+        )
+        jac_outs_ins = tuple(
+            tree_unflatten(jac_ins, primals_spec) for jac_ins in jac_outs_ins
+        )
+
+        if isinstance(argnums, int):
+            jac_outs_ins = tuple(jac_ins[0] for jac_ins in jac_outs_ins)
+        if has_aux:
+            return tree_unflatten(jac_outs_ins, spec), aux  # type: ignore[possibly-unbound]
+        return tree_unflatten(jac_outs_ins, spec)
+
+    return wrapper_fn
+
+
+@exposed_in("torch.func")
+def hessian(func: Callable[..., Any], argnums: argnums_t = 0) -> Callable[..., Any]:
+    """
+    Computes the Hessian of ``func`` with respect to the arg(s) at index
+    ``argnum`` via a forward-over-reverse strategy.
+
+    The forward-over-reverse strategy (composing ``jacfwd(jacrev(func))``) is
+    a good default for good performance. It is possible to compute Hessians
+    through other compositions of :func:`jacfwd` and :func:`jacrev` like
+    ``jacfwd(jacfwd(func))`` or ``jacrev(jacrev(func))``.
+
+    Args:
+        func (function): A Python function that takes one or more arguments,
+            one of which must be a Tensor, and returns one or more Tensors
+        argnums (int or tuple[int, ...]): Optional, integer or tuple of integers,
+            saying which arguments to get the Hessian with respect to.
+            Default: 0.
+
+    Returns:
+        Returns a function that takes in the same inputs as ``func`` and
+        returns the Hessian of ``func`` with respect to the arg(s) at
+        ``argnums``.
+
+    .. note::
+        You may see this API error out with "forward-mode AD not implemented
+        for operator X". If so, please file a bug report and we will prioritize it.
+        An alternative is to use ``jacrev(jacrev(func))``, which has better
+        operator coverage.
+
+    A basic usage with a R^N -> R^1 function gives a N x N Hessian:
+
+        >>> from torch.func import hessian
+        >>> def f(x):
+        >>>   return x.sin().sum()
+        >>>
+        >>> x = torch.randn(5)
+        >>> hess = hessian(f)(x)  # equivalent to jacfwd(jacrev(f))(x)
+        >>> assert torch.allclose(hess, torch.diag(-x.sin()))
+
+    """
+    return jacfwd(jacrev(func, argnums), argnums)
+
+
+@doesnt_support_saved_tensors_hooks
+def grad_and_value_impl(
+    func: Callable[..., Any],
+    argnums: argnums_t,
+    has_aux: bool,
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+) -> tuple[Any, Any]:
+    with grad_increment_nesting() as level:
+        output, aux, grad_input = None, None, None
+        # See NOTE [grad and vjp interaction with no_grad]
+        with torch.enable_grad():
+            args = _wrap_all_tensors(args, level)
+            kwargs = _wrap_all_tensors(kwargs, level)
+            diff_args = _slice_argnums(args, argnums, as_tuple=False)
+            tree_map_(partial(_create_differentiable, level=level), diff_args)
+
+            output = func(*args, **kwargs)
+            if has_aux:
+                if not (isinstance(output, tuple) and len(output) == 2):
+                    raise RuntimeError(
+                        "grad_and_value(f)(*args): output of function f should be a tuple: (output, aux) "
+                        "if has_aux is True"
+                    )
+                output, aux = output
+
+            if not isinstance(output, torch.Tensor):
+                raise RuntimeError(
+                    "grad_and_value(f)(*args): Expected f(*args) "
+                    f"to return a Tensor, got {type(output)}"
+                )
+            if output.dim() != 0:
+                raise RuntimeError(
+                    "grad_and_value(f)(*args): Expected f(*args) "
+                    "to return a scalar Tensor, got tensor with "
+                    f"{output.dim()} dims. Maybe you wanted to "
+                    "use the vjp or jacrev APIs instead?"
+                )
+
+            flat_diff_args, spec = tree_flatten(diff_args)
+
+            # NB: need create_graph so that backward pass isn't run in no_grad mode
+            flat_outputs = _as_tuple(output)
+            flat_grad_input = _autograd_grad(
+                flat_outputs, flat_diff_args, create_graph=True
+            )
+            grad_input = tree_unflatten(flat_grad_input, spec)
+
+            grad_input = _undo_create_differentiable(grad_input, level)
+            output = _undo_create_differentiable(output, level)
+            if has_aux:
+                # pyrefly: ignore[bad-specialization]
+                aux = _undo_create_differentiable(aux, level)
+
+        if has_aux:
+            return grad_input, (output, aux)
+        return grad_input, output
+
+
+def grad_impl(
+    func: Callable[..., Any],
+    argnums: argnums_t,
+    has_aux: bool,
+    args: tuple[Any, ...],
+    kwargs: dict[str, Any],
+) -> Any:
+    results = grad_and_value_impl(func, argnums, has_aux, args, kwargs)
+    if has_aux:
+        grad, (_, aux) = results
+        return grad, aux
+    grad, _ = results
+    return grad
+
+
+def _maybe_wrap_functional_tensor(
+    maybe_tensor: Any, level: int, *, _python_functionalize: bool = False
+) -> Any:
+    if not isinstance(maybe_tensor, torch.Tensor):
+        return maybe_tensor
+    wrapped = _wrap_functional_tensor(maybe_tensor, level)
+    _assert_wrapped_functional(maybe_tensor, wrapped)
+    if _python_functionalize:
+        # pyrefly: ignore[missing-argument]
+        out = FunctionalTensor(wrapped)
+        # pyrefly: ignore[missing-attribute]
+        torch._mirror_autograd_meta_to(maybe_tensor, out)
+        return out
+    return wrapped
+
+
+def _wrap_all_tensors_to_functional(
+    tensor_pytree: Any, level: int, *, _python_functionalize: bool = False
+) -> Any:
+    return tree_map(
+        partial(
+            lambda x: _maybe_wrap_functional_tensor(
+                x, level, _python_functionalize=_python_functionalize
+            )
+        ),
+        tensor_pytree,
+    )
+
+
+def _maybe_unwrap_functional_tensor(maybe_tensor: Any, *, reapply_views: bool) -> Any:
+    if not isinstance(maybe_tensor, torch.Tensor):
+        return maybe_tensor
+    if isinstance(maybe_tensor, FunctionalTensor):
+        maybe_tensor = maybe_tensor.elem
+
+    if not torch._is_functional_tensor(maybe_tensor):
+        # If it's not a functional tensor, just return it.
+        # This can happen if we functionalize a fn that returns a global,
+        # which was never wrapped properly.
+        return maybe_tensor
+    # Sync any pending updates on the output tensor
+    torch._sync(maybe_tensor)
+    return _unwrap_functional_tensor(maybe_tensor, reapply_views)
+
+
+def _unwrap_all_tensors_from_functional(
+    tensor_pytree: Any, *, reapply_views: bool
+) -> Any:
+    return tree_map(
+        lambda t: _maybe_unwrap_functional_tensor(t, reapply_views=reapply_views),
+        tensor_pytree,
+    )
+
+
+@exposed_in("torch.func")
+def functionalize(
+    func: Callable[..., Any], *, remove: str = "mutations"
+) -> Callable[..., Any]:
+    """
+    functionalize is a transform that can be used to remove (intermediate)
+    mutations and aliasing from a function, while preserving the function's
+    semantics.
+
+    ``functionalize(func)`` returns a new function with the same semantics
+    as ``func``, but with all intermediate mutations removed.
+    Every inplace operation performed on an intermediate tensor:
+    ``intermediate.foo_()``
+    gets replaced by its out-of-place equivalent:
+    ``intermediate_updated = intermediate.foo()``.
+
+    functionalize is useful for shipping a pytorch program off to
+    backends or compilers that aren't able to easily represent
+    mutations or aliasing operators.
+
+    Args:
+        func (Callable[..., Any]): A Python function that takes one or more arguments.
+        remove (str): An optional string argument, that takes on either
+            the value 'mutations' or 'mutations_and_views'.
+            If 'mutations' is passed in then all mutating operators
+            will be replaced with their non-mutating equivalents.
+            If 'mutations_and_views' is passed in, then additionally, all aliasing
+            operators will be replaced with their non-aliasing equivalents.
+            Default: 'mutations'.
+
+    Returns:
+        Returns a new "functionalized" function. It takes the same inputs as
+        ``func``, and has the same behavior, but any mutations
+        (and optionally aliasing) performed on intermediate tensors
+        in the function will be removed.
+
+    functionalize will also remove mutations (and views) that were performed on function inputs.
+    However to preserve semantics, functionalize will "fix up" the mutations after
+    the transform has finished running, by detecting if any tensor inputs "should have"
+    been mutated, and copying the new data back to the inputs if necessary.
+
+
+    Example::
+
+        >>> # xdoctest: +SKIP
+        >>> import torch
+        >>> from torch.fx.experimental.proxy_tensor import make_fx
+        >>> from torch.func import functionalize
+        >>>
+        >>> # A function that uses mutations and views, but only on intermediate tensors.
+        >>> def f(a):
+        ...     b = a + 1
+        ...     c = b.view(-1)
+        ...     c.add_(1)
+        ...     return b
+        ...
+        >>> inpt = torch.randn(2)
+        >>>
+        >>> out1 = f(inpt)
+        >>> out2 = functionalize(f)(inpt)
+        >>>
+        >>> # semantics are the same (outputs are equivalent)
+        >>> print(torch.allclose(out1, out2))
+        True
+        >>>
+        >>> f_traced = make_fx(f)(inpt)
+        >>> f_no_mutations_traced = make_fx(functionalize(f))(inpt)
+        >>> f_no_mutations_and_views_traced = make_fx(functionalize(f, remove='mutations_and_views'))(inpt)
+        >>>
+        >>> print(f_traced.code)
+
+
+
+        def forward(self, a_1):
+            add = torch.ops.aten.add(a_1, 1);  a_1 = None
+            view = torch.ops.aten.view(add, [-1])
+            add_ = torch.ops.aten.add_(view, 1);  view = None
+            return add
+
+        >>> print(f_no_mutations_traced.code)
+
+
+
+        def forward(self, a_1):
+            add = torch.ops.aten.add(a_1, 1);  a_1 = None
+            view = torch.ops.aten.view(add, [-1]);  add = None
+            add_1 = torch.ops.aten.add(view, 1);  view = None
+            view_1 = torch.ops.aten.view(add_1, [2]);  add_1 = None
+            return view_1
+
+        >>> print(f_no_mutations_and_views_traced.code)
+
+
+
+        def forward(self, a_1):
+            add = torch.ops.aten.add(a_1, 1);  a_1 = None
+            view_copy = torch.ops.aten.view_copy(add, [-1]);  add = None
+            add_1 = torch.ops.aten.add(view_copy, 1);  view_copy = None
+            view_copy_1 = torch.ops.aten.view_copy(add_1, [2]);  add_1 = None
+            return view_copy_1
+
+
+        >>> # A function that mutates its input tensor
+        >>> def f(a):
+        ...     b = a.view(-1)
+        ...     b.add_(1)
+        ...     return a
+        ...
+        >>> f_no_mutations_and_views_traced = make_fx(functionalize(f, remove='mutations_and_views'))(inpt)
+        >>> #
+        >>> # All mutations and views have been removed,
+        >>> # but there is an extra copy_ in the graph to correctly apply the mutation to the input
+        >>> # after the function has completed.
+        >>> print(f_no_mutations_and_views_traced.code)
+
+
+
+        def forward(self, a_1):
+            view_copy = torch.ops.aten.view_copy(a_1, [-1])
+            add = torch.ops.aten.add(view_copy, 1);  view_copy = None
+            view_copy_1 = torch.ops.aten.view_copy(add, [2]);  add = None
+            copy_ = torch.ops.aten.copy_(a_1, view_copy_1);  a_1 = None
+            return view_copy_1
+
+
+    There are a few "failure modes" for functionalize that are worth calling out:
+      (1) Like other torch.func transforms, `functionalize()` doesn't work with functions
+          that directly use `.backward()`. The same is true for torch.autograd.grad.
+          If you want to use autograd, you can compute gradients directly
+          with `functionalize(grad(f))`.
+      (2) Like other torch.func transforms, `functionalize()` doesn't work with global state.
+          If you call `functionalize(f)` on a function that takes views / mutations of
+          non-local state, functionalization will simply no-op and pass the view/mutation
+          calls directly to the backend.
+          One way to work around this is to ensure that any non-local state creation
+          is wrapped into a larger function, which you then call functionalize on.
+      (3) `resize_()` has some limitations: functionalize will only work on programs
+          that use resize_()` as long as the tensor being resized is not a view.
+      (4) `as_strided()` has some limitations: functionalize will not work on
+          `as_strided()` calls that result in tensors with overlapping memory.
+
+
+    Finally, a helpful mental model for understanding functionalization is that
+    most user pytorch programs are writing with the public torch API.
+    When executed, torch operators are generally decomposed into
+    our internal C++ "ATen" API.
+    The logic for functionalization happens entirely at the level of ATen.
+    Functionalization knows how to take every aliasing operator in ATen,
+    and map it to its non-aliasing equivalent
+    (e.g. ``tensor.view({-1})`` -> ``at::view_copy(tensor, {-1})``),
+    and how to take every mutating operator in ATen,
+    and map it to its non-mutating equivalent
+    (e.g. ``tensor.add_(1)`` -> ``at::add(tensor, -1)``),
+    while tracking aliases and mutations out-of-line to know when to fix things up.
+    Information about which ATen operators are aliasing or mutating all comes from
+    https://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/native_functions.yaml.
+    """
+    if remove == "mutations":
+        reapply_views = True
+    elif remove == "mutations_and_views":
+        reapply_views = False
+    else:
+        raise RuntimeError(
+            f"functionalize(f, remove='mutations'): received invalid argument for remove={remove}."
+            " Valid options are:\n"
+            "     remove='mutations': all inplace and out= operators will be removed from the program, and replaced"
+            " with their out-of-place equivalents.\n"
+            "     remove='mutations_and_views': In addition to the above, all aliasing operators {view} will be"
+            " replaced with their non-aliasing counterparts, {view}_copy.\n"
+        )
+
+    @_wraps_without_dynamo_attrs(func)
+    def wrapped(*args: Any, **kwargs: Any) -> Any:
+        try:
+            func_level = _func_increment_nesting(reapply_views)
+            func_args = _wrap_all_tensors_to_functional(args, func_level)
+            func_kwargs = _wrap_all_tensors_to_functional(kwargs, func_level)
+
+            flattened_unwrapped_args = pytree.arg_tree_leaves(*args)
+            flattened_wrapped_args = pytree.arg_tree_leaves(*func_args)
+            flattened_unwrapped_kwargs = pytree.arg_tree_leaves(**kwargs)
+            flattened_wrapped_kwargs = pytree.arg_tree_leaves(**func_kwargs)
+
+            func_outputs = func(*func_args, **func_kwargs)
+            outputs = _unwrap_all_tensors_from_functional(
+                func_outputs, reapply_views=reapply_views
+            )
+
+            for a in flattened_wrapped_args + flattened_wrapped_kwargs:
+                if isinstance(a, torch.Tensor):
+                    # Call sync_() on the inputs, to ensure that any pending mutations have been applied.
+                    torch._sync(a)
+
+            # And if any mutations were applied to the inputs, we need to propagate them back to the user.
+            for unwrapped, wrapped in zip(
+                flattened_unwrapped_args, flattened_wrapped_args
+            ):
+                if isinstance(unwrapped, torch.Tensor) and isinstance(
+                    wrapped, torch.Tensor
+                ):
+                    _propagate_functional_input_mutation(unwrapped, wrapped)
+            for unwrapped, wrapped in zip(
+                flattened_unwrapped_kwargs, flattened_wrapped_kwargs
+            ):
+                if isinstance(unwrapped, torch.Tensor) and isinstance(
+                    wrapped, torch.Tensor
+                ):
+                    _propagate_functional_input_mutation(unwrapped, wrapped)
+
+            return outputs
+        finally:
+            _func_decrement_nesting()
+
+    return wrapped
+
+
+@exposed_in("torch.func")
+def linearize(
+    func: Callable[..., Any], *primals: Any
+) -> tuple[Any, Callable[..., Any]]:
+    """
+    Returns the value of ``func`` at ``primals`` and linear approximation
+    at ``primals``.
+
+    Args:
+        func (Callable[..., Any]): A Python function that takes one or more arguments.
+        primals (Tensors): Positional arguments to ``func`` that must all be
+            Tensors. These are the values at which the function is linearly approximated.
+
+    Returns:
+        Returns a ``(output, jvp_fn)`` tuple containing the output of ``func``
+        applied to ``primals`` and a function that computes the jvp of
+        ``func`` evaluated at ``primals``.
+
+    linearize is useful if jvp is to be computed multiple times at ``primals``. However,
+    to achieve this, linearize saves intermediate computation and has higher memory requirements
+    than directly applying `jvp`. So, if all the ``tangents`` are known, it maybe more efficient
+    to compute vmap(jvp) instead of using linearize.
+
+    .. note::
+        linearize evaluates ``func`` twice. Please file an issue for an implementation
+        with a single evaluation.
+
+    Example::
+
+        >>> import torch
+        >>> from torch.func import linearize
+        >>> def fn(x):
+        ...     return x.sin()
+        ...
+        >>> warnings.filterwarnings("ignore", message=".*Attempted to insert a get_attr Node with no underlying reference")  # docs: hide
+        >>> output, jvp_fn = linearize(fn, torch.zeros(3, 3))
+        >>> jvp_fn(torch.ones(3, 3))
+        tensor([[1., 1., 1.],
+                [1., 1., 1.],
+                [1., 1., 1.]])
+        >>>
+
+    """
+    # Note: We evaluate `fn` twice.
+    # Once for returning the output and other while
+    # tracing the graph.
+    # If this becomes a bottle-neck, we should update
+    # make_fx such that it also returns the output.
+
+    output = func(*primals)
+    _, output_spec = tree_flatten(output)
+
+    flat_primals, primals_argspec = tree_flatten(primals)
+
+    # tangents for tracing
+    flat_tangents = tuple(p.new_empty(()).expand_as(p) for p in flat_primals)
+
+    # function to trace
+    def trace_fn(flat_tangents: tuple[torch.Tensor, ...]) -> Any:
+        with fwAD.dual_level():
+            flat_duals = tuple(
+                fwAD.make_dual(p, t) for p, t in zip(flat_primals, flat_tangents)
+            )
+            duals = tree_unflatten(flat_duals, primals_argspec)
+            output = func(*duals)
+            tangents = tree_map_only(
+                torch.Tensor, lambda dual: safe_unpack_dual(dual, False)[1], output
+            )
+
+        return tangents
+
+    jvp_graph = lazy_dynamo_disallow(make_fx)(trace_fn)(flat_tangents)
+    const_folded_jvp_graph = lazy_dynamo_disallow(const_fold.split_const_subgraphs)(
+        jvp_graph
+    )
+
+    # Hold only the meta-data regarding the primals.
+    flat_primals_shape = tuple(p.shape for p in flat_primals)
+    flat_primals_device = tuple(p.device for p in flat_primals)
+    flat_primals_dtype = tuple(p.dtype for p in flat_primals)
+
+    def forward_ad_checks(flat_tangents: Sequence[torch.Tensor]) -> None:
+        for idx, t in enumerate(flat_tangents):
+            if t.shape != flat_primals_shape[idx]:
+                msg = (
+                    f"tangent:{idx} with shape {t.shape} in flattened "
+                    f"pytree doesn't match the shape {flat_primals_shape[idx]} "
+                    "of the corresponding primal."
+                )
+                raise RuntimeError(msg)
+
+            if t.device != flat_primals_device[idx]:
+                msg = (
+                    f"tangent:{idx} with device {t.device} in flattened "
+                    f"pytree doesn't match the device {flat_primals_device[idx]} "
+                    "of the corresponding primal."
+                )
+                raise RuntimeError(msg)
+
+            if t.dtype != flat_primals_dtype[idx]:
+                msg = (
+                    f"tangent:{idx} with dtype {t.dtype} in flattened "
+                    f"pytree doesn't match the dtype {flat_primals_dtype[idx]} "
+                    "of the corresponding primal."
+                )
+                raise RuntimeError(msg)
+
+    # jvp_fn : Callable[..., Any] to return
+    #   It takes care of checking the argspec of tangents,
+    #   calling the folded fx graph and unflattening fx graph output
+    def jvp_fn(*tangents: Any) -> Any:
+        flat_tangents, tangent_argspec = tree_flatten(tangents)
+        if tangent_argspec != primals_argspec:
+            raise RuntimeError(
+                f"Expected the tangents {tangent_argspec} to have "
+                f"the same argspec as the primals {primals_argspec}"
+            )
+
+        forward_ad_checks(flat_tangents)  # type: ignore[arg-type]
+
+        flat_output = const_folded_jvp_graph(*flat_tangents)
+        # const folded graph can return flat output,
+        # so transform output.
+        return tree_unflatten(flat_output, output_spec)
+
+    return output, jvp_fn
+
+
+@exposed_in("torch.func")
+def debug_unwrap(tensor: torch.Tensor, *, recurse: bool = True) -> torch.Tensor:
+    """Unwraps a functorch tensor (e.g. BatchedTensor, GradTrackingTensor) to its underlying tensor.
+
+    This function should only be used in a debug setting (e.g. trying to print the
+    value of a Tensor in a debugger). Otherwise, using the result of function
+    inside of a function being transformed will lead to undefined behavior.
+    """
+    if not is_functorch_wrapped_tensor(tensor):
+        return tensor
+    result = get_unwrapped(tensor)
+    if recurse:
+        return debug_unwrap(result)
+    return result

.venv/lib/python3.12/site-packages/torch/_functorch/einops.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import torch
+from torch._functorch.utils import exposed_in
+
+
+__all__ = ["rearrange"]
+
+
+@exposed_in("torch.func")
+def rearrange(
+    tensor: torch.Tensor | list[torch.Tensor] | tuple[torch.Tensor, ...],
+    pattern: str,
+    **axes_lengths: int,
+) -> torch.Tensor:
+    r"""A native implementation of `einops.rearrange`, a reader-friendly smart element reordering for multidimensional
+    tensors. This operation includes functionality of transpose (axes permutation), reshape (view), squeeze, unsqueeze,
+    stack, concatenate and other operations.
+
+    See: https://einops.rocks/api/rearrange/
+
+    Args:
+        tensor (Tensor or sequence of Tensor): the tensor(s) to rearrange
+        pattern (str): the rearrangement pattern
+        axes_lengths (int): any additional length specifications for dimensions
+
+    Returns:
+        Tensor: the rearranged tensor
+
+    Examples:
+        >>> from torch.func import rearrange
+        >>> # suppose we have a set of 32 images in "h w c" format (height-width-channel)
+        >>> images = torch.randn((32, 30, 40, 3))
+
+        >>> # stack along first (batch) axis, output is a single array
+        >>> rearrange(images, "b h w c -> b h w c").shape
+        torch.Size([32, 30, 40, 3])
+
+        >>> # concatenate images along height (vertical axis), 960 = 32 * 30
+        >>> rearrange(images, "b h w c -> (b h) w c").shape
+        torch.Size([960, 40, 3])
+
+        >>> # concatenated images along horizontal axis, 1280 = 32 * 40
+        >>> rearrange(images, "b h w c -> h (b w) c").shape
+        torch.Size([30, 1280, 3])
+
+        >>> # reordered axes to "b c h w" format for deep learning
+        >>> rearrange(images, "b h w c -> b c h w").shape
+        torch.Size([32, 3, 30, 40])
+
+        >>> # flattened each image into a vector, 3600 = 30 * 40 * 3
+        >>> rearrange(images, "b h w c -> b (c h w)").shape
+        torch.Size([32, 3600])
+
+        >>> # split each image into 4 smaller (top-left, top-right, bottom-left, bottom-right), 128 = 32 * 2 * 2
+        >>> rearrange(images, "b (h1 h) (w1 w) c -> (b h1 w1) h w c", h1=2, w1=2).shape
+        torch.Size([128, 15, 20, 3])
+
+        >>> # space-to-depth operation
+        >>> rearrange(images, "b (h h1) (w w1) c -> b h w (c h1 w1)", h1=2, w1=2).shape
+        torch.Size([32, 15, 20, 12])
+    """
+    if not isinstance(tensor, torch.Tensor):
+        tensor = torch.stack(tensor)
+
+    # Lazy import to avoid circular import:
+    # torch._functorch.einops -> functorch.einops (package __init__) -> torch._functorch.einops
+    from functorch.einops.rearrange import _create_rearrange_callable
+
+    rearrange_callable = _create_rearrange_callable(
+        tensor.ndim, pattern, **axes_lengths
+    )
+
+    return rearrange_callable(tensor)

.venv/lib/python3.12/site-packages/torch/_functorch/functional_call.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+from torch._functorch.utils import exposed_in
+
+
+@exposed_in("torch.func")
+def functional_call(
+    module: torch.nn.Module,
+    parameter_and_buffer_dicts: dict[str, Tensor] | Sequence[dict[str, Tensor]],
+    args: Any = None,
+    kwargs: dict[str, Any] | None = None,
+    *,
+    tie_weights: bool = True,
+    strict: bool = False,
+) -> Any:
+    r"""Performs a functional call on the module by replacing the module parameters
+    and buffers with the provided ones.
+
+    .. note:: If the module has active parametrizations, passing a value in the
+        :attr:`parameter_and_buffer_dicts` argument with the name set to the regular parameter
+        name will completely disable the parametrization.
+        If you want to apply the parametrization function to the value passed
+        please set the key as ``{submodule_name}.parametrizations.{parameter_name}.original``.
+
+    .. note:: If the module performs in-place operations on parameters/buffers, these will be reflected
+        in the ``parameter_and_buffer_dicts`` input.
+
+
+         Example::
+
+            >>> a = {'foo': torch.zeros(())}
+            >>> # xdoctest: +SKIP
+            >>> mod = Foo()  # does self.foo = self.foo + 1
+            >>> print(mod.foo)  # tensor(0.)
+            >>> functional_call(mod, a, torch.ones(()))
+            >>> print(mod.foo)  # tensor(0.)
+            >>> print(a['foo'])  # tensor(1.)
+
+    .. note:: If the module has tied weights, whether or not functional_call respects the tying is determined by the
+        tie_weights flag.
+
+        Example::
+
+            >>> a = {'foo': torch.zeros(())}
+            >>> # xdoctest: +SKIP
+            >>> mod = Foo()  # has both self.foo and self.foo_tied which are tied. Returns x + self.foo + self.foo_tied
+            >>> print(mod.foo)  # tensor(1.)
+            >>> mod(torch.zeros(()))  # tensor(2.)
+            >>> functional_call(mod, a, torch.zeros(()))  # tensor(0.) since it will change self.foo_tied too
+            >>> functional_call(mod, a, torch.zeros(()), tie_weights=False)  # tensor(1.)--self.foo_tied is not updated
+            >>> new_a = {'foo': torch.zeros(()), 'foo_tied': torch.zeros(())}
+            >>> functional_call(mod, new_a, torch.zeros()) # tensor(0.)
+
+    An example of passing multiple dictionaries
+
+    .. code-block:: python
+
+            a = (
+                {"weight": torch.ones(1, 1)},
+                {"buffer": torch.zeros(1)},
+            )  # two separate dictionaries
+            mod = nn.Bar(1, 1)  # return self.weight @ x + self.buffer
+            print(mod.weight)  # tensor(...)
+            print(mod.buffer)  # tensor(...)
+            x = torch.randn((1, 1))
+            print(x)
+            functional_call(mod, a, x)  # same as x
+            print(mod.weight)  # same as before functional_call
+
+
+    And here is an example of applying the grad transform over the parameters
+    of a model.
+
+    .. code-block:: python
+
+        import torch
+        import torch.nn as nn
+        from torch.func import functional_call, grad
+
+        x = torch.randn(4, 3)
+        t = torch.randn(4, 3)
+        model = nn.Linear(3, 3)
+
+
+        def compute_loss(params, x, t):
+            y = functional_call(model, params, x)
+            return nn.functional.mse_loss(y, t)
+
+
+        grad_weights = grad(compute_loss)(dict(model.named_parameters()), x, t)
+
+    .. note:: If the user does not need grad tracking outside of grad transforms, they can detach all of the
+        parameters for better performance and memory usage
+
+        Example::
+
+            >>> detached_params = {k: v.detach() for k, v in model.named_parameters()}
+            >>> grad_weights = grad(compute_loss)(detached_params, x, t)
+            >>> grad_weights.grad_fn  # None--it's not tracking gradients outside of grad
+
+        This means that the user cannot call ``grad_weight.backward()``. However, if they don't need autograd tracking
+        outside of the transforms, this will result in less memory usage and faster speeds.
+
+    Args:
+        module (torch.nn.Module): the module to call
+        parameters_and_buffer_dicts (Dict[str, Tensor] or tuple of Dict[str, Tensor]): the parameters that will be used in
+            the module call. If given a tuple of dictionaries, they must have distinct keys so that all dictionaries can
+            be used together
+        args (Any or tuple): arguments to be passed to the module call. If not a tuple, considered a single argument.
+        kwargs (dict): keyword arguments to be passed to the module call
+        tie_weights (bool, optional): If True, then parameters and buffers tied in the original model will be treated as
+            tied in the reparameterized version. Therefore, if True and different values are passed for the tied
+            parameters and buffers, it will error. If False, it will not respect the originally tied parameters and
+            buffers unless the values passed for both weights are the same. Default: True.
+        strict (bool, optional): If True, then the parameters and buffers passed in must match the parameters and
+            buffers in the original module. Therefore, if True and there are any missing or unexpected keys, it will
+            error. Default: False.
+
+    Returns:
+        Any: the result of calling ``module``.
+    """
+    if isinstance(parameter_and_buffer_dicts, dict):
+        parameters_and_buffers = parameter_and_buffer_dicts
+    elif isinstance(parameter_and_buffer_dicts, Sequence):
+        if not all(isinstance(d, dict) for d in parameter_and_buffer_dicts):
+            raise ValueError(
+                "Expected all elements of parameter_and_buffer_dicts to be dictionaries"
+            )
+        all_keys = [k for d in parameter_and_buffer_dicts for k in d]
+        all_keys_counter: dict[str, int] = {}
+        for k in all_keys:
+            v = all_keys_counter.get(k, 0)
+            all_keys_counter[k] = v + 1
+        repeated_keys = [key for key, n in all_keys_counter.items() if n > 1]
+        if len(repeated_keys) > 0:
+            raise ValueError(
+                f"{repeated_keys} appeared in multiple dictionaries; behavior of functional call is ambiguous"
+            )
+        parameters_and_buffers = {
+            k: v for d in parameter_and_buffer_dicts for k, v in d.items()
+        }
+    else:
+        raise ValueError(
+            f"Expected parameter_and_buffer_dicts to be a dict, or a list/tuple of dicts, "
+            f"but got {type(parameter_and_buffer_dicts)}"
+        )
+
+    return nn.utils.stateless._functional_call(
+        module,
+        parameters_and_buffers,
+        args,
+        kwargs,
+        tie_weights=tie_weights,
+        strict=strict,
+    )
+
+
+@exposed_in("torch.func")
+def stack_module_state(
+    models: Sequence[nn.Module] | nn.ModuleList,
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    """stack_module_state(models) -> params, buffers
+
+    Prepares a list of torch.nn.Modules for ensembling with :func:`vmap`.
+
+    Given a list of ``M`` ``nn.Modules`` of the same class, returns two dictionaries
+    that stack all of their parameters and buffers together, indexed by name.
+    The stacked parameters are optimizable (i.e. they are new leaf nodes in the
+    autograd history that are unrelated to the original parameters and can be
+    passed directly to an optimizer).
+
+    Here's an example of how to ensemble over a very simple model:
+
+    .. code-block:: python
+
+        num_models = 5
+        batch_size = 64
+        in_features, out_features = 3, 3
+        models = [torch.nn.Linear(in_features, out_features) for i in range(num_models)]
+        data = torch.randn(batch_size, 3)
+
+
+        def wrapper(params, buffers, data):
+            return torch.func.functional_call(models[0], (params, buffers), data)
+
+
+        params, buffers = stack_module_state(models)
+        output = vmap(wrapper, (0, 0, None))(params, buffers, data)
+
+        assert output.shape == (num_models, batch_size, out_features)
+
+    When there's submodules, this follows state dict naming conventions
+
+    .. code-block:: python
+
+        import torch.nn as nn
+
+
+        class Foo(nn.Module):
+            def __init__(self, in_features, out_features):
+                super().__init__()
+                hidden = 4
+                self.l1 = nn.Linear(in_features, hidden)
+                self.l2 = nn.Linear(hidden, out_features)
+
+            def forward(self, x):
+                return self.l2(self.l1(x))
+
+
+        num_models = 5
+        in_features, out_features = 3, 3
+        models = [Foo(in_features, out_features) for i in range(num_models)]
+        params, buffers = stack_module_state(models)
+        print(list(params.keys()))  # "l1.weight", "l1.bias", "l2.weight", "l2.bias"
+
+    .. warning::
+        All of the modules being stacked together must be the same (except for
+        the values of their parameters/buffers). For example, they should be in the
+        same mode (training vs eval).
+    """
+    if len(models) == 0:
+        raise RuntimeError("stack_module_state: Expected at least one model, got 0.")
+    if not (all(m.training for m in models) or all(not m.training for m in models)):
+        raise RuntimeError(
+            "stack_module_state: Expected all models to have the same training/eval mode."
+        )
+    model0_typ = type(models[0])
+    if not all(type(m) is model0_typ for m in models):
+        raise RuntimeError(
+            "stack_module_state: Expected all models to be of the same class."
+        )
+    all_params = [dict(model.named_parameters()) for model in models]
+    params = {
+        k: construct_stacked_leaf(tuple(params[k] for params in all_params), k)
+        for k in all_params[0]
+    }
+    all_buffers = [dict(model.named_buffers()) for model in models]
+    buffers = {
+        k: construct_stacked_leaf(tuple(buffers[k] for buffers in all_buffers), k)
+        for k in all_buffers[0]
+    }
+
+    return params, buffers
+
+
+def construct_stacked_leaf(
+    tensors: tuple[Tensor, ...] | list[Tensor], name: str
+) -> Tensor:
+    all_requires_grad = all(t.requires_grad for t in tensors)
+    none_requires_grad = all(not t.requires_grad for t in tensors)
+    if not all_requires_grad and not none_requires_grad:
+        raise RuntimeError(
+            f"Expected {name} from each model to have the same .requires_grad"
+        )
+    result = torch.stack(tensors)
+    if all_requires_grad:
+        result = result.detach().requires_grad_()
+    return result

.venv/lib/python3.12/site-packages/torch/_functorch/fx_minifier.py

@@ -0,0 +1,562 @@
+from __future__ import annotations
+
+import copy
+import math
+import os
+import sys
+from dataclasses import dataclass
+from functools import partial, wraps
+from typing import Any, TYPE_CHECKING
+
+import torch
+import torch.fx as fx
+from torch.hub import tqdm
+from torch.multiprocessing.reductions import StorageWeakRef
+from torch.utils._content_store import ContentStoreWriter
+
+from .compile_utils import get_outputs, get_placeholders
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+
+is_tuple = object()
+
+
+@dataclass
+class LoadTensorMeta:
+    size: tuple[int, ...]
+    stride: tuple[int, ...]
+    dtype: torch.dtype
+    device: torch.device
+
+
+class ConcreteProp(torch.fx.Interpreter):
+    def __init__(
+        self,
+        mod: fx.GraphModule,
+        *,
+        writer: ContentStoreWriter | None = None,
+        skip_offload: bool = False,
+    ) -> None:
+        super().__init__(mod)
+        self.writer = writer
+        self.skip_offload = skip_offload
+        self.seen_storages: set[StorageWeakRef] = set()
+        self.pbar: Any = None
+
+    def run_node(self, n: fx.Node) -> Any:
+        self.pbar.update(1)
+        r = super().run_node(n)
+        name = n.name
+
+        if isinstance(r, torch.Tensor):
+            if self.writer is None:
+                n.meta["concrete_value"] = r
+            else:
+                if StorageWeakRef(r.untyped_storage()) in self.seen_storages:
+                    # Refuse to offload tensors which alias other live
+                    # tensors, because this will violate operator contracts
+                    n.meta["concrete_value"] = None
+                else:
+                    if not self.skip_offload:
+                        self.writer.write_tensor(os.path.join("eager", name), r)
+                    n.meta["concrete_value"] = LoadTensorMeta(
+                        r.size(), r.stride(), r.dtype, r.device
+                    )
+                    self.seen_storages.add(StorageWeakRef(r.untyped_storage()))
+        else:
+            n.meta["concrete_value"] = is_tuple
+
+        return r
+
+    def propagate(self, *args: Any) -> Any:
+        mod = self.module
+        if not isinstance(mod, fx.GraphModule):
+            raise AssertionError(f"expected fx.GraphModule, got {type(mod)}")
+        with tqdm(
+            desc="Saving intermediates for delta debugging",
+            total=len(mod.graph.nodes),
+            disable=self.writer is None,
+        ) as pbar:
+            self.pbar = pbar
+            r = super().run(*args)
+            if not self.skip_offload:
+                pbar.set_description(
+                    "Saved!  To skip next time, run with --skip-saving-eager-intermediates"
+                )
+            return r
+
+
+def is_load_tensor_node(node: fx.Node) -> bool:
+    return (
+        node.op == "call_function"
+        and node.target is torch.ops.debugprims.load_tensor.default
+    )
+
+
+# inplace modifies node/inps
+def _convert_node_to_placeholder(
+    graph: fx.Graph, node: fx.Node, inps: list[torch.Tensor]
+) -> bool:
+    if node.op == "output" or node.op == "placeholder":
+        return False
+
+    if is_load_tensor_node(node):
+        return False
+
+    concrete_val = node.meta.get("concrete_value", None)
+
+    if isinstance(concrete_val, torch.Tensor):
+        node.op = "placeholder"
+        node.target = node.name
+        node.args = ()
+        node.kwargs = {}
+
+        inps.append(concrete_val)
+        return True
+
+    elif concrete_val is None:
+        return False
+
+    elif concrete_val is is_tuple:
+        r = False
+        for tuple_user in list(node.users):
+            r = _convert_node_to_placeholder(graph, tuple_user, inps) or r
+        # NB: We must not erase the node at this point, because
+        # we are iterating over the nodes and this would change
+        # the iteration order
+        # graph.erase_node(node)
+        return r
+
+    elif isinstance(concrete_val, LoadTensorMeta):
+        node.op = "call_function"
+        node.target = torch.ops.debugprims.load_tensor.default
+        node.args = (
+            os.path.join("eager", node.name),
+            concrete_val.size,
+            concrete_val.stride,
+        )
+        node.kwargs = {
+            "device": concrete_val.device,
+            "dtype": concrete_val.dtype,
+        }
+        return True
+
+    return False
+
+
+def create_minified_hlo_graph(
+    minified_fx_graph: fx.GraphModule, inputs: Sequence[torch.Tensor]
+) -> None:
+    """
+    Takes minified FX graph as primary input, and ports it to HLO via StableHLO
+    Provides minified HLO graph as output, and archive them to local directory
+    """
+    hlo_dir = f"{os.getcwd()}/hlo_files"
+    os.makedirs(hlo_dir, exist_ok=True)
+
+    from torch_xla.stablehlo import save_torch_model_as_stablehlo
+
+    save_torch_model_as_stablehlo(minified_fx_graph, inputs, hlo_dir)
+
+
+def dump_state(fx_g: fx.GraphModule, inps: Sequence[torch.Tensor]) -> None:
+    print(
+        f"""
+# Working Repro with {len(fx_g.graph.nodes)} nodes
+inps = {[(i.shape, i.dtype, str(i.device)) for i in inps]}
+inps = [torch.zeros(())] + [torch.ones(shape, dtype=dtype, device=device) for (shape, dtype, device) in inps]
+{fx_g.code}
+"""
+    )
+
+
+def is_power_of_two(n: int) -> bool:
+    if n == 0:
+        return False
+    return (n & (n - 1)) == 0
+
+
+@dataclass
+class ReproState:
+    graph: fx.Graph
+    inps: Sequence[torch.Tensor]
+
+    def __post_init__(self) -> None:
+        ph_nodes = get_placeholders(self.graph)
+        if len(ph_nodes) != len(self.inps):
+            raise AssertionError(
+                f"len(ph_nodes)={len(ph_nodes)} != len(self.inps)={len(self.inps)}"
+            )
+
+
+def minifier(
+    fail_f: fx.GraphModule,
+    inps: Sequence[torch.Tensor],
+    module_fails: Callable[[fx.GraphModule, Sequence[torch.Tensor]], bool],
+    dump_state: Callable[[fx.GraphModule, Sequence[torch.Tensor]], None] = dump_state,
+    *,
+    save_dir: str | None = None,
+    offload_to_disk: bool = False,
+    skip_offload: bool = False,
+    skip_sanity: bool = False,
+    max_granularity: int | None = None,
+) -> tuple[fx.GraphModule, Sequence[torch.Tensor]]:
+    """
+    Minimizes a FX graph with given inputs, such that the resulting FX graph still returns True for module_fails.
+
+    Does 2 main strategies:
+    1. Truncates suffix: Removes some suffix from the graph and sets a new output.
+    2. Delta Debugging: Tries replacing half of the graph with inputs. If fails,
+        tries replacing quarter of the graph, etc.
+
+    >>> # xdoctest: +SKIP(failing)
+    >>> failing_function = fx.symbolic_trace(f)
+    >>> minimize(failing_function, [torch.randn(5)], lambda fx_g, inps: fx_g(*inps))
+
+    note: module_fails returns True if it fails.
+    """
+
+    failing_graph = fail_f.graph
+    cur_size = len(failing_graph.nodes)
+
+    if max_granularity is not None and not is_power_of_two(max_granularity):
+        raise RuntimeError(f"max_granularity {max_granularity} not power of two")
+
+    num_queries = 0
+
+    def deepcopy_fx_graph(fx_graph: fx.Graph) -> fx.Graph:
+        return fx.GraphModule(fail_f, copy.deepcopy(fx_graph)).graph
+
+    def graph_fails(graph: fx.Graph, inps: Sequence[torch.Tensor]) -> bool:
+        nonlocal num_queries
+        graph = copy.deepcopy(graph)
+        num_queries += 1
+        mod = fx.GraphModule(fail_f, graph)
+        mod.graph.lint()
+        return module_fails(mod, inps)
+
+    writer = None
+    if offload_to_disk:
+        if save_dir is None:
+            raise AssertionError("save_dir must not be None when offload_to_disk=True")
+        writer = ContentStoreWriter(save_dir)
+
+    ConcreteProp(fail_f, writer=writer, skip_offload=skip_offload).propagate(*inps)
+    if not skip_sanity and not graph_fails(failing_graph, inps):
+        raise RuntimeError("Input graph did not fail the tester")
+    print(f"Started off with {cur_size} nodes", file=sys.stderr)
+
+    def _register_strategy(
+        strategy: Callable[[fx.Graph, Sequence[torch.Tensor], int], ReproState | None],
+        name: str,
+    ) -> Callable[[ReproState, int], ReproState | None]:
+        @wraps(strategy)
+        def new_func(old_state: ReproState, granularity: int = 1) -> ReproState | None:
+            print(file=sys.stderr)
+            print(
+                f"Strategy: {name} (G: {granularity}) "
+                f"({len(old_state.graph.nodes)} nodes, {len(old_state.inps)} inputs)",
+                file=sys.stderr,
+            )
+            new_state = strategy(
+                deepcopy_fx_graph(old_state.graph), list(old_state.inps), granularity
+            )
+            if new_state is not None:
+                new_nodes = len(new_state.graph.nodes)
+                old_nodes = len(old_state.graph.nodes)
+                new_inps = len(new_state.inps)
+                old_inps = len(old_state.inps)
+                new_outs = len(get_outputs(new_state.graph))
+                old_outs = len(get_outputs(old_state.graph))
+                progress_made = False
+                if new_nodes < old_nodes:
+                    progress_made = True
+                    print(
+                        f"SUCCESS: Went from {old_nodes} to {new_nodes} nodes",
+                        file=sys.stderr,
+                    )
+                if new_inps > old_inps:
+                    progress_made = True
+                    print(
+                        f"SUCCESS: Went from {old_inps} to {new_inps} inputs",
+                        file=sys.stderr,
+                    )
+                if new_outs < old_outs:
+                    progress_made = True
+                    print(
+                        f"SUCCESS: Went from {old_outs} to {new_outs} outputs",
+                        file=sys.stderr,
+                    )
+
+                if not progress_made:
+                    raise RuntimeError("Success raised but no progress made?")
+
+                if not graph_fails(new_state.graph, new_state.inps):
+                    print(
+                        "WARNING: Something went wrong, not applying this minification",
+                        file=sys.stderr,
+                    )
+                    return None
+                return new_state
+            else:
+                print(f"FAIL: {name}", file=sys.stderr)
+            return None
+
+        return new_func
+
+    def register_strategy(
+        name: str,
+    ) -> Callable[
+        [Callable[[fx.Graph, Sequence[torch.Tensor], int], ReproState | None]],
+        Callable[[ReproState, int], ReproState | None],
+    ]:
+        return partial(_register_strategy, name=name)
+
+    @register_strategy("Truncate suffix")
+    def remove_suffix(
+        cur_graph: fx.Graph, cur_inps: Sequence[torch.Tensor], granularity: int
+    ) -> ReproState | None:
+        tested: set[int] = set()
+        new_graph = fx.Graph()
+        env: dict[fx.Node, fx.Node] = {}
+        for idx, node in enumerate(cur_graph.nodes):
+            new_node = new_graph.node_copy(node, lambda x: env[x])
+            if node.op not in ["placeholder", "output"]:
+                # If idx is divisible by (granularity * 2), it would have been checked already.
+                if (
+                    idx % granularity == 0
+                    and (idx % (granularity * 2) != 0)
+                    and idx not in tested
+                ):
+                    output_node = new_graph.output((new_node,))
+                    if len(new_graph.nodes) < len(cur_graph.nodes) and graph_fails(
+                        new_graph, cur_inps
+                    ):
+                        return ReproState(new_graph, cur_inps)
+                    else:
+                        tested.add(idx)
+                        new_graph.erase_node(output_node)
+            env[node] = new_node
+        return None
+
+    @register_strategy("Remove outputs")
+    def remove_outputs(
+        cur_graph: fx.Graph, cur_inps: Sequence[torch.Tensor], granularity: int
+    ) -> ReproState | None:
+        granularity = max(1, granularity // 2)
+        output: fx.Node | None = None
+        for idx, node in enumerate(cur_graph.nodes):
+            node.idx = idx  # type: ignore[attr-defined]
+            if node.op == "output":
+                output = node
+                break
+
+        if output is None:
+            return None
+
+        if isinstance(output.args[0], fx.Node):
+            return None
+
+        # output.args[0] is a tuple/list of nodes when returning multiple outputs
+        output_args_raw = output.args[0]
+        if not isinstance(output_args_raw, (list, tuple)):
+            raise AssertionError(
+                f"expected output_args_raw to be list or tuple, got {type(output_args_raw)}"
+            )
+        output_args = sorted(
+            output_args_raw,
+            key=lambda x: x.idx if isinstance(x, fx.Node) else int(1e9),  # type: ignore[attr-defined]
+        )
+        if len(output_args) == 1:
+            return None
+
+        for idx in range(0, len(output_args), granularity):
+            output.args = (output_args[:idx] + output_args[idx + granularity :],)
+            if graph_fails(cur_graph, cur_inps):
+                return ReproState(cur_graph, cur_inps)
+        return None
+
+    def remove_unused_inputs_unchecked(cur_state: ReproState) -> ReproState | None:
+        cur_graph = cur_state.graph
+        cur_inps = cur_state.inps
+        ph_nodes = list(get_placeholders(cur_graph))
+        if len(ph_nodes) != len(cur_inps):
+            raise AssertionError(
+                f"len(ph_nodes)={len(ph_nodes)} != len(cur_inps)={len(cur_inps)}"
+            )
+
+        new_inps: list[torch.Tensor] = []
+        for idx in range(len(ph_nodes)):
+            if len(ph_nodes[idx].users) == 0:
+                cur_graph.erase_node(ph_nodes[idx])
+            else:
+                new_inps.append(cur_inps[idx])
+        if len(new_inps) < len(cur_inps):
+            return ReproState(cur_graph, new_inps)
+        return None
+
+    def remove_unused_inputs_checked(cur_state: ReproState) -> ReproState | None:
+        new_state = remove_unused_inputs_unchecked(cur_state)
+        if new_state is not None and graph_fails(new_state.graph, new_state.inps):
+            return new_state
+        return None
+
+    def _remove_unused_wrapper(
+        cur_graph: fx.Graph, cur_inps: Sequence[torch.Tensor], granularity: int
+    ) -> ReproState | None:
+        return remove_unused_inputs_checked(ReproState(cur_graph, cur_inps))
+
+    remove_unused_inputs = register_strategy("Remove unused inputs")(
+        _remove_unused_wrapper
+    )
+
+    @register_strategy("Eliminate dead code")
+    def eliminate_dead_code(
+        cur_graph: fx.Graph, cur_inps: Sequence[torch.Tensor], granularity: int
+    ) -> ReproState | None:
+        if cur_graph.eliminate_dead_code() and graph_fails(cur_graph, cur_inps):
+            return ReproState(cur_graph, cur_inps)
+        return None
+
+    def _consolidate_placeholders(
+        cur_graph: fx.Graph, inps: list[torch.Tensor]
+    ) -> fx.Graph:
+        new_graph = fx.Graph()
+        env = {}
+        seen_non_placeholder = False
+
+        # Move all placeholders to the front; also, if any load_tensor
+        # is at the front, convert it into an input (because it can be live
+        # all the time)
+        for node in cur_graph.nodes:
+            if node.op == "placeholder":
+                new_node = new_graph.node_copy(node, lambda x: env[x])
+                env[node] = new_node
+            elif not seen_non_placeholder and is_load_tensor_node(node):
+                new_node = new_graph.placeholder(node.name)
+                env[node] = new_node
+                inps.append(
+                    torch.ops.debugprims.load_tensor.default(*node.args, **node.kwargs)
+                )
+            else:
+                seen_non_placeholder = True
+
+        # Move everyone else
+        for node in cur_graph.nodes:
+            if node not in env:
+                new_node = new_graph.node_copy(node, lambda x: env[x])
+                env[node] = new_node
+        return new_graph
+
+    @register_strategy("Delta Debugging")
+    def delta_debugging(
+        cur_graph: fx.Graph, cur_inps: Sequence[torch.Tensor], granularity: int
+    ) -> ReproState | None:
+        num_nodes = len(cur_graph.nodes)
+        for start_range in range(0, num_nodes, granularity):
+            is_removing = False
+            new_graph = deepcopy_fx_graph(cur_graph)
+            new_inps = list(cur_inps[:])
+            end_range = min(num_nodes, start_range + granularity)
+            for idx in range(start_range, end_range):
+                new_node = list(new_graph.nodes)[idx]
+                if _convert_node_to_placeholder(new_graph, new_node, new_inps):
+                    is_removing = True
+            if not is_removing:
+                continue
+            new_graph.eliminate_dead_code()
+            new_graph = _consolidate_placeholders(new_graph, new_inps)
+            new_state = remove_unused_inputs_unchecked(ReproState(new_graph, new_inps))
+            if new_state is None:
+                new_state = ReproState(new_graph, new_inps)
+            if graph_fails(new_state.graph, new_state.inps):
+                return ReproState(new_state.graph, new_state.inps)
+
+        return None
+
+    @register_strategy("Consolidate Inputs")
+    def consolidate_inputs(
+        cur_graph: fx.Graph, cur_inps: Sequence[torch.Tensor], granularity: int
+    ) -> ReproState | None:
+        old_len = len(cur_inps)
+        new_inps = list(cur_inps[:])
+        cur_graph = _consolidate_placeholders(cur_graph, new_inps)
+        if len(cur_inps) > old_len and graph_fails(cur_graph, new_inps):
+            return ReproState(cur_graph, new_inps)
+        return None
+
+    failing_state = ReproState(failing_graph, inps)
+
+    def try_granularity(
+        failing_state: ReproState, granularity: int, use_non_granular: bool
+    ) -> ReproState | None:
+        print(f"Trying granularity {granularity}", file=sys.stderr)
+
+        strategies = []
+        num_nodes = len(failing_state.graph.nodes)
+        num_outputs = len(get_outputs(failing_state.graph))
+        if num_outputs > num_nodes // 2:
+            strategies += [remove_outputs]
+
+        if use_non_granular:
+            strategies += [
+                eliminate_dead_code,
+                remove_unused_inputs,
+                consolidate_inputs,
+            ]
+
+        strategies += [remove_suffix, delta_debugging]
+
+        for strategy in strategies:
+            new_state = strategy(failing_state, granularity)
+            if new_state is not None:
+                return new_state
+        return None
+
+    while True:
+        dump_state(fx.GraphModule(fail_f, failing_state.graph), failing_state.inps)
+        granularity = int(2 ** (math.floor(math.log2(len(failing_state.graph.nodes)))))
+        if max_granularity is not None:
+            granularity = min(max_granularity, granularity)
+        new_state = try_granularity(failing_state, granularity, use_non_granular=True)
+        if new_state is not None:
+            failing_state = new_state
+            continue
+
+        granularity //= 2
+        has_progress = False
+        while granularity >= 1:
+            new_state = try_granularity(
+                failing_state, granularity, use_non_granular=False
+            )
+            if new_state is not None:
+                failing_state = new_state
+                has_progress = True
+                break
+            granularity //= 2
+        if has_progress:
+            continue
+
+        new_state = remove_outputs(failing_state, 1)
+        if new_state is not None:
+            failing_state = new_state
+            continue
+
+        break
+
+    if not graph_fails(failing_state.graph, failing_state.inps):
+        raise RuntimeError("Uh oh, something went wrong :( Final graph is not failing")
+
+    print(f"Made {num_queries} queries", file=sys.stderr)
+    failing_fx = fx.GraphModule(fail_f, failing_state.graph)
+
+    # If XLA debugging environment is enabled, create minified HLO graph as well
+    if "XLA_HLO_DEBUG" in os.environ:
+        create_minified_hlo_graph(failing_fx, failing_state.inps)
+
+    dump_state(failing_fx, failing_state.inps)
+    print("Wrote minimal repro out to repro.py", file=sys.stderr)
+    return failing_fx, failing_state.inps

.venv/lib/python3.12/site-packages/torch/_functorch/make_functional.py

@@ -0,0 +1,669 @@
+# 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.
+
+from __future__ import annotations
+
+import copy
+from typing import Any, NoReturn, TYPE_CHECKING
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+from torch.nn.utils._named_member_accessor import NamedMemberAccessor
+
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Sequence
+
+# Utilities to make nn.Module "functional"
+# In particular the goal is to be able to provide a function that takes as input
+# the parameters and evaluate the nn.Module using fixed inputs.
+
+
+def raise_parameter_tying_error() -> NoReturn:
+    raise RuntimeError(
+        "make_functional(module): we don't yet support models that "
+        "do parameter tying (also sometimes known as weight sharing). "
+        "Please try to rewrite your model by replacing all instances of the "
+        "tied parameter with another and/or comment your support in "
+        "https://github.com/pytorch/functorch/issues/446"
+    )
+
+
+def create_names_map(
+    named_params: dict[str, Tensor] | Iterable[tuple[str, Tensor]],
+    tied_named_params: dict[str, Tensor] | Iterable[tuple[str, Tensor]],
+) -> dict[str, list[str]]:
+    """
+    named_params is a dictionary of tensors: {'A': A, 'B': B}
+    tied_named_params is another dictionary of tensors {'A': A, 'B': B, 'B_tied': B}
+    with potentially tied (or 'duplicated') tensors
+
+    This function creates a mapping from the names in named_params to the
+    names in tied_named_params: {'A': ['A'], 'B': ['B', 'B_tied']}.
+    """
+    named_params_dict = dict(named_params)
+    tied_named_params_dict = dict(tied_named_params)
+
+    tensors_dict_keys = set(named_params_dict.keys())
+    tied_tensors_dict_keys = set(tied_named_params_dict.keys())
+    if not tensors_dict_keys.issubset(tied_tensors_dict_keys):
+        raise AssertionError(
+            f"tensors_dict_keys {tensors_dict_keys} is not a subset of "
+            f"tied_tensors_dict_keys {tied_tensors_dict_keys}"
+        )
+
+    tensor_to_mapping: dict[Tensor, tuple[str, list[str]]] = {}
+    for key, tensor in named_params_dict.items():
+        tensor_to_mapping[tensor] = (key, [])
+    for key, tensor in tied_named_params_dict.items():
+        if tensor not in tensor_to_mapping:
+            raise AssertionError(
+                f"tensor for key '{key}' not found in tensor_to_mapping"
+            )
+        tensor_to_mapping[tensor][1].append(key)
+    return dict(tensor_to_mapping.values())
+
+
+def _extract_members(
+    mod: nn.Module,
+    named_members: Callable[..., Iterable[tuple[str, Tensor]]],
+    subclass: Callable[[Tensor], Tensor],
+) -> tuple[tuple[Tensor, ...], tuple[str, ...], dict[str, list[str]]]:
+    all_named_members = tuple(named_members(remove_duplicate=False))
+    unique_named_members = tuple(named_members(remove_duplicate=True))
+    names_map = create_names_map(unique_named_members, all_named_members)
+
+    # Remove all the members in the model
+    # pyrefly: ignore [implicit-any]
+    memo = {}
+    accessor = NamedMemberAccessor(mod)
+    for name, p in all_named_members:
+        if p not in memo:
+            memo[p] = subclass(torch.empty_like(p, device="meta"))
+        replacement = memo[p]
+        accessor.set_tensor(name, replacement)
+
+    if len(unique_named_members) == 0:
+        names, params = (), ()
+    else:
+        names, params = zip(*unique_named_members)  # type: ignore[assignment]
+    return params, names, names_map
+
+
+def extract_weights(
+    mod: nn.Module,
+) -> tuple[tuple[Tensor, ...], tuple[str, ...], dict[str, list[str]]]:
+    """
+    This function removes all the Parameters from the model and
+    return them as a tuple as well as their original attribute names.
+    The weights must be re-loaded with `load_weights` before the model
+    can be used again.
+    Note that this function modifies the model in place and after this
+    call, mod.parameters() will be empty.
+    """
+    return _extract_members(mod, mod.named_parameters, nn.Parameter)
+
+
+def extract_buffers(
+    mod: nn.Module,
+) -> tuple[tuple[Tensor, ...], tuple[str, ...], dict[str, list[str]]]:
+    return _extract_members(mod, mod.named_buffers, lambda x: x)
+
+
+def load_weights(
+    mod: nn.Module,
+    names: Sequence[str],
+    params: Sequence[Tensor],
+    as_params: bool = False,
+) -> None:
+    """
+    Reload a set of weights so that `mod` can be used again to perform a forward pass.
+    Note that the `params` are regular Tensors (that can have history) and so are left
+    as Tensors. This means that mod.parameters() will still be empty after this call.
+    """
+    accessor = NamedMemberAccessor(mod)
+    if as_params:
+        params = [nn.Parameter(p) for p in params]
+    accessor.set_tensors(names, params)
+
+
+def _swap_state(
+    mod: nn.Module, names_map: dict[str, list[str]], elems: Iterable[Tensor]
+) -> list[Tensor]:
+    result: list[Tensor] = []
+    accessor = NamedMemberAccessor(mod)
+    for (_, attr_names), elem in zip(names_map.items(), elems):
+        for i, attr_name in enumerate(attr_names):
+            if i == 0:
+                result.append(accessor.swap_tensor(attr_name, elem))
+            else:
+                accessor.set_tensor(attr_name, elem)
+    return result
+
+
+def load_buffers(
+    mod: nn.Module,
+    names: Sequence[str],
+    buffers: Sequence[Tensor],
+    as_params: bool = False,
+) -> None:
+    accessor = NamedMemberAccessor(mod)
+    accessor.set_tensors(names, buffers)
+
+
+def load_state(
+    model: nn.Module,
+    weights: Sequence[Tensor],
+    weight_names: Sequence[str],
+    buffers: Sequence[Tensor] = (),
+    buffer_names: Sequence[str] = (),
+) -> nn.Module:
+    """load_state(model, weights, weight_names, buffers=(), buffer_names=()) -> model
+
+    load_state takes `weights` and `buffers` and assigns them to the model.
+    This is the inverse operation of `make_functional_deprecated_v1`.
+    """
+    if len(weight_names) != len(weights):
+        raise AssertionError(
+            f"len(weight_names)={len(weight_names)} != len(weights)={len(weights)}"
+        )
+    load_weights(model, weight_names, weights)
+    if len(buffers) > 0:
+        if len(buffer_names) != len(buffers):
+            raise AssertionError(
+                f"len(buffer_names)={len(buffer_names)} != len(buffers)={len(buffers)}"
+            )
+        load_buffers(model, buffer_names, buffers)
+    return model
+
+
+def make_functional_deprecated_v1(
+    model: nn.Module,
+) -> tuple[tuple[Tensor, ...], Callable[..., Any], tuple[str, ...]]:
+    """make_functional_deprecated_v1(model) -> weights, func, weight_names
+
+    Given an nn.Module, make_functional_deprecated_v1 extracts the state (weights)
+    and returns a functional version of the model, `func`. This makes
+    it so that it is possible use transforms over the parameters of
+    `model`.
+
+    `func` can be invoked as follows:
+    ```
+    x = torch.randn(4, 3)
+    model = nn.Linear(3, 3)
+    weights, func, _ = make_functional_deprecated_v1(model)
+    func(weights, (x,))
+    ```
+
+    And here is an example of applying the grad transform:
+    ```
+    x = torch.randn(4, 3)
+    model = nn.Linear(3, 3)
+    weights, _, func = make_functional_deprecated_v1(model)
+    grad_weights = grad(func)(weights, (x,))
+    ```
+
+    To put the state back into a model, use `load_state`.
+    """
+    buffers = list(model.buffers())
+    if len(buffers) > 0:
+        raise RuntimeError(
+            "make_functional_deprecated_v1(model): `model` has buffers. Please use "
+            "make_functional_with_buffers_deprecated_v1(model) instead."
+        )
+    weights, descriptors, _ = extract_weights(model)
+
+    def fun(weights: tuple[Tensor, ...], data: tuple[Any, ...]) -> Any:
+        mutable_model = copy.deepcopy(model)
+        load_weights(mutable_model, descriptors, weights)
+        return mutable_model(*data)
+
+    return weights, fun, descriptors
+
+
+def make_functional_with_buffers_deprecated_v1(
+    model: nn.Module,
+) -> tuple[
+    tuple[Tensor, ...],
+    tuple[Tensor, ...],
+    Callable[..., Any],
+    tuple[str, ...],
+    tuple[str, ...],
+]:
+    """make_functional_with_buffers_deprecated_v1(model) -> weights, buffers, func, weight_names, buffer_names
+
+    Given an nn.Module, make_functional_with_buffers_deprecated_v1 extracts the state (weights and buffers)
+    and returns a functional version of the model, `func`.
+
+    `func` can be invoked as follows:
+    ```
+    x = torch.randn(4, 3)
+    model = nn.Linear(3, 3)
+    weights, buffers, func, _, _ = make_functional_with_buffers_deprecated_v1(model)
+    func(weights, buffers, (x,))
+    ```
+
+    And here is an example of applying the grad transform:
+    ```
+    x = torch.randn(4, 3)
+    model = nn.Linear(3, 3)
+    weights, buffers, func, _, _ = make_functional_with_buffers_deprecated_v1(model)
+    func(weights, buffers, (x,))
+    grad_weights = grad(func)(weights, buffers, (x,))
+    ```
+
+    To put the state back into a model, use `load_state`.
+    """
+    weights, weight_descriptors, _ = extract_weights(model)
+    buffers, buf_descriptors, _ = extract_buffers(model)
+
+    def fun(
+        weights: tuple[Tensor, ...],
+        buffers: tuple[Tensor, ...],
+        data: tuple[Any, ...],
+    ) -> Any:
+        mutable_model = copy.deepcopy(model)
+        load_weights(mutable_model, weight_descriptors, weights)
+        load_buffers(mutable_model, buf_descriptors, buffers)
+        return mutable_model(*data)
+
+    return weights, buffers, fun, weight_descriptors, buf_descriptors
+
+
+class FunctionalModuleWithBuffers(nn.Module):
+    """
+    This is the callable object returned by :func:`make_functional_with_buffers`.
+    """
+
+    def __init__(
+        self,
+        stateless_model: nn.Module,
+        param_names: tuple[str, ...],
+        buffer_names: tuple[str, ...],
+        param_names_map: dict[str, list[str]],
+        buffer_names_map: dict[str, list[str]],
+    ) -> None:
+        super().__init__()
+        self.stateless_model = stateless_model
+        self.param_names = param_names
+        self.buffer_names = buffer_names
+
+        self.all_names_map = dict(param_names_map)
+        self.all_names_map.update(buffer_names_map)
+
+    @staticmethod
+    def _create_from(
+        model: nn.Module, disable_autograd_tracking: bool = False
+    ) -> tuple[FunctionalModuleWithBuffers, tuple[Tensor, ...], tuple[Tensor, ...]]:
+        # TODO: We don't need to copy the model to create a stateless copy
+        model_copy = copy.deepcopy(model)
+        params, param_names, param_names_map = extract_weights(model_copy)
+        buffers, buffer_names, buffer_names_map = extract_buffers(model_copy)
+        if disable_autograd_tracking:
+            for param in params:
+                param.requires_grad_(False)
+        return (
+            FunctionalModuleWithBuffers(
+                model_copy, param_names, buffer_names, param_names_map, buffer_names_map
+            ),
+            params,
+            buffers,
+        )
+
+    def forward(
+        self,
+        params: Iterable[Tensor],
+        buffers: Iterable[Tensor],
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        # Temporarily load the state back onto self.stateless_model
+        old_state = _swap_state(
+            self.stateless_model,
+            self.all_names_map,
+            tuple(params) + tuple(buffers),
+        )
+        try:
+            return self.stateless_model(*args, **kwargs)
+        finally:
+            # Remove the loaded state on self.stateless_model
+            _swap_state(self.stateless_model, self.all_names_map, old_state)
+
+
+class FunctionalModule(nn.Module):
+    """
+    This is the callable object returned by :func:`make_functional`.
+    """
+
+    def __init__(
+        self,
+        stateless_model: nn.Module,
+        param_names: tuple[str, ...],
+        names_map: dict[str, list[str]],
+    ) -> None:
+        super().__init__()
+        self.stateless_model = stateless_model
+        self.param_names = param_names
+        self.names_map = names_map
+
+    @staticmethod
+    def _create_from(
+        model: nn.Module, disable_autograd_tracking: bool = False
+    ) -> tuple[FunctionalModule, tuple[Tensor, ...]]:
+        # TODO: We don't need to copy the model to create a stateless copy
+        model_copy = copy.deepcopy(model)
+        params, param_names, names_map = extract_weights(model_copy)
+        if disable_autograd_tracking:
+            for param in params:
+                param.requires_grad_(False)
+        return FunctionalModule(model_copy, param_names, names_map), params
+
+    def forward(self, params: Iterable[Tensor], *args: Any, **kwargs: Any) -> Any:
+        # Temporarily load the state back onto self.stateless_model
+        old_state = _swap_state(self.stateless_model, self.names_map, params)
+        try:
+            return self.stateless_model(*args, **kwargs)
+        finally:
+            # Remove the loaded state on self.stateless_model
+            _swap_state(self.stateless_model, self.names_map, old_state)
+
+
+def make_functional(
+    model: nn.Module, disable_autograd_tracking: bool = False
+) -> tuple[FunctionalModule, tuple[Tensor, ...]]:
+    """make_functional(model, disable_autograd_tracking=False) -> func, params
+
+    Given a ``torch.nn.Module``, :func:`make_functional` extracts the state
+    (params) and returns a functional version of the model, ``func``. This
+    makes it so that it is possible use transforms over the parameters of
+    ``model``.
+
+    ``func`` can be invoked as follows:
+
+    .. code-block:: python
+
+        import torch
+        import torch.nn as nn
+        from functorch import make_functional
+
+        x = torch.randn(4, 3)
+        model = nn.Linear(3, 3)
+        func, params = make_functional(model)
+        func(params, x)
+
+    And here is an example of applying the grad transform over the parameters
+    of a model.
+
+    .. code-block:: python
+
+        import torch
+        import torch.nn as nn
+        from functorch import make_functional, grad
+
+        x = torch.randn(4, 3)
+        t = torch.randn(4, 3)
+        model = nn.Linear(3, 3)
+        func, params = make_functional(model)
+
+
+        def compute_loss(params, x, t):
+            y = func(params, x)
+            return nn.functional.mse_loss(y, t)
+
+
+        grad_weights = grad(compute_loss)(params, x, t)
+
+    If the model has any buffers, please use :func:`make_functional_with_buffers` instead.
+
+    Args:
+        model (torch.nn.Module): Input model.
+        disable_autograd_tracking (bool): Flag to disable gradients tracking for output parameters.
+            The returned params are unrelated to the set of params from the original model. If False (default),
+            the params will have ``requires_grad=True`` on them (aka they will be trackable with regular
+            PyTorch autograd), matching the requires_grad-ness of the params from the original model.
+            Otherwise, the returned params will have ``requires_grad=False``. Default, False.
+            If you plan on using regular PyTorch autograd (e.g., if you want to call ``.backward()`` or
+            ``torch.autograd.grad()``, then set ``disable_autograd_tracking=False``.
+            Otherwise, if you're only planning on using functorch's gradient transforms,
+            then please set ``disable_autograd_tracking=True`` to avoid unnecessarily tracking
+            history with PyTorch autograd.
+
+    """
+    buffers = list(model.buffers())
+    if len(buffers) > 0:
+        raise RuntimeError(
+            "make_functional(model): `model` has buffers. Please use "
+            "make_functional_with_buffers(model) instead."
+        )
+    return FunctionalModule._create_from(
+        model, disable_autograd_tracking=disable_autograd_tracking
+    )
+
+
+def make_functional_with_buffers(
+    model: nn.Module, disable_autograd_tracking: bool = False
+) -> tuple[FunctionalModuleWithBuffers, tuple[Tensor, ...], tuple[Tensor, ...]]:
+    """make_functional_with_buffers(model, disable_autograd_tracking=False) -> func, params, buffers
+
+    Given a ``torch.nn.Module``, make_functional_with_buffers extracts the
+    state (params and buffers) and returns a functional version of the model
+    ``func`` that can be invoked like a function.
+
+    ``func`` can be invoked as follows:
+
+    .. code-block:: python
+
+        import torch
+        import torch.nn as nn
+        from functorch import make_functional_with_buffers
+
+        x = torch.randn(4, 3)
+        model = nn.Linear(3, 3)
+        func, params, buffers = make_functional_with_buffers(model)
+        func(params, buffers, x)
+
+    And here is an example of applying the grad transform over the parameters
+    of a model:
+
+    .. code-block:: python
+
+        import torch
+        import torch.nn as nn
+        from functorch import make_functional_with_buffers, grad
+
+        x = torch.randn(4, 3)
+        t = torch.randn(4, 3)
+        model = nn.Linear(3, 3)
+        func, params, buffers = make_functional_with_buffers(model)
+
+
+        def compute_loss(params, buffers, x, t):
+            y = func(params, buffers, x)
+            return nn.functional.mse_loss(y, t)
+
+
+        grad_weights = grad(compute_loss)(params, buffers, x, t)
+
+    Args:
+        model (torch.nn.Module): Input model.
+        disable_autograd_tracking (bool): Flag to disable gradients tracking for output parameters.
+            The returned params are unrelated to the set of params from the original model. If False (default),
+            the params will have ``requires_grad=True`` on them (aka they will be trackable with regular
+            PyTorch autograd), matching the requires_grad-ness of the params from the original model.
+            Otherwise, the returned params will have ``requires_grad=False``. Default, False.
+            If you plan on using regular PyTorch autograd (e.g., if you want to call ``.backward()`` or
+            ``torch.autograd.grad()``, then set ``disable_autograd_tracking=False``.
+            Otherwise, if you're only planning on using functorch's gradient transforms,
+            then please set ``disable_autograd_tracking=True`` to avoid unnecessarily tracking
+            history with PyTorch autograd.
+
+    """
+    return FunctionalModuleWithBuffers._create_from(
+        model, disable_autograd_tracking=disable_autograd_tracking
+    )
+
+
+def transpose_stack(
+    tuple_of_tuple_of_tensors: tuple[tuple[Tensor, ...], ...],
+) -> tuple[Tensor, ...]:
+    tuple_of_tuple_of_tensors = tuple(zip(*tuple_of_tuple_of_tensors))
+    results = tuple(
+        torch.stack(shards).detach() for shards in tuple_of_tuple_of_tensors
+    )
+    return results
+
+
+def combine_state_for_ensemble(
+    models: Sequence[nn.Module],
+) -> tuple[FunctionalModuleWithBuffers, tuple[Tensor, ...], tuple[Tensor, ...]]:
+    """combine_state_for_ensemble(models) -> func, params, buffers
+
+    Prepares a list of torch.nn.Modules for ensembling with :func:`vmap`.
+
+    Given a list of ``M`` ``nn.Modules`` of the same class, stacks all of their
+    parameters and buffers together to make ``params`` and ``buffers``.
+    Each parameter and buffer in the result will have an additional dimension
+    of size ``M``.
+
+    :func:`combine_state_for_ensemble` also returns ``func``, a functional
+    version of one of the models in :attr:`models`. One cannot directly run
+    ``func(params, buffers, *args, **kwargs)`` directly, you probably want to
+    use ``vmap(func, ...)(params, buffers, *args, **kwargs)``
+
+    Here's an example of how to ensemble over a very simple model:
+
+    .. code-block:: python
+
+        num_models = 5
+        batch_size = 64
+        in_features, out_features = 3, 3
+        models = [torch.nn.Linear(in_features, out_features) for i in range(num_models)]
+        data = torch.randn(batch_size, 3)
+
+        fmodel, params, buffers = combine_state_for_ensemble(models)
+        output = vmap(fmodel, (0, 0, None))(params, buffers, data)
+
+        assert output.shape == (num_models, batch_size, out_features)
+
+    .. warning::
+        All of the modules being stacked together must be the same (except for
+        the values of their parameters/buffers). For example, they should be in the
+        same mode (training vs eval).
+
+        This API is subject to change -- we're investigating better ways to
+        create ensembles and would love your feedback how to improve this.
+    """
+    if len(models) == 0:
+        raise RuntimeError(
+            "combine_state_for_ensemble: Expected at least one model, got 0."
+        )
+    if not (all(m.training for m in models) or all(not m.training for m in models)):
+        raise RuntimeError(
+            "combine_state_for_ensemble: Expected all models to "
+            "have the same training/eval mode."
+        )
+    model0_typ = type(models[0])
+    if not all(type(m) is model0_typ for m in models):
+        raise RuntimeError(
+            "combine_state_for_ensemble: Expected all models to be of the same class."
+        )
+    funcs, params, buffers = zip(
+        *[make_functional_with_buffers(model) for model in models]
+    )
+    params = transpose_stack(params)
+    buffers = transpose_stack(buffers)
+    return funcs[0], params, buffers
+
+
+def functional_init(
+    model_class: type[nn.Module],
+    ensemble_shape: tuple[()] | tuple[int, ...] = (),
+    device: torch.types.Device = "cpu",
+) -> Callable[..., tuple[tuple[Tensor, ...], Callable[..., Any], tuple[str, ...]]]:
+    def wrapped(
+        *args: Any, **kwargs: Any
+    ) -> tuple[tuple[Tensor, ...], Callable[..., Any], tuple[str, ...]]:
+        if len(ensemble_shape) >= 2:
+            raise ValueError("NYI: ensemble_shape with more than 1 element")
+        if len(ensemble_shape) == 0:
+            model = model_class(*args, **kwargs).to(device)
+            return make_functional_deprecated_v1(model)
+        num_models = ensemble_shape[0]  # type: ignore[misc]
+        if num_models <= 0:
+            raise ValueError(f"num_models {num_models} should be > 0")
+        # NB: Not very efficient, more of a POC
+        models = tuple(
+            model_class(*args, **kwargs).to(device) for _ in range(num_models)
+        )
+        _, fn, names = make_functional_deprecated_v1(model_class(*args, **kwargs))
+        weights = tuple(make_functional_deprecated_v1(model)[0] for model in models)
+        weights = tuple(zip(*weights))
+        weights = tuple(torch.stack(shards).detach() for shards in weights)
+        return weights, fn, names
+
+    return wrapped
+
+
+def functional_init_with_buffers(
+    model_class: type[nn.Module],
+    ensemble_shape: tuple[()] | tuple[int, ...] = (),
+    device: torch.types.Device = "cpu",
+) -> Callable[
+    ...,
+    tuple[
+        tuple[Tensor, ...],
+        tuple[Tensor, ...],
+        Callable[..., Any],
+        tuple[str, ...],
+        tuple[str, ...],
+    ]
+    | tuple[tuple[Tensor, ...], Callable[..., Any], tuple[str, ...]],
+]:
+    def wrapped(
+        *args: Any, **kwargs: Any
+    ) -> (
+        tuple[
+            tuple[Tensor, ...],
+            tuple[Tensor, ...],
+            Callable[..., Any],
+            tuple[str, ...],
+            tuple[str, ...],
+        ]
+        | tuple[tuple[Tensor, ...], Callable[..., Any], tuple[str, ...]]
+    ):
+        if len(ensemble_shape) >= 2:
+            raise ValueError("NYI: ensemble_shape with more than 1 element")
+        if len(ensemble_shape) == 0:
+            model = model_class(*args, **kwargs).to(device)
+            return make_functional_deprecated_v1(model)
+        num_models = ensemble_shape[0]  # type: ignore[misc]
+        if num_models <= 0:
+            raise ValueError(f"num_models {num_models} should be > 0")
+        # NB: Not very efficient, more of a POC
+        models = tuple(
+            model_class(*args, **kwargs).to(device) for _ in range(num_models)
+        )
+        (
+            _,
+            _,
+            fn,
+            weight_names,
+            buffer_names,
+        ) = make_functional_with_buffers_deprecated_v1(model_class(*args, **kwargs))
+        weights, buffers = zip(
+            *tuple(
+                make_functional_with_buffers_deprecated_v1(model)[:2]
+                for model in models
+            )
+        )
+        weights = tuple(zip(*weights))
+        weights = tuple(torch.stack(shards).detach() for shards in weights)
+        buffers = tuple(zip(*buffers))
+        buffers = tuple(torch.stack(shards).detach() for shards in buffers)
+        return weights, buffers, fn, weight_names, buffer_names
+
+    return wrapped

.venv/lib/python3.12/site-packages/torch/_functorch/predispatch.py

@@ -0,0 +1,297 @@
+# 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.
+
+"""
+This module contains pre-dispatch wrappers for functorch operations
+that enable proper tracing in PT2 non-strict export/compile fx graph.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import torch
+from torch._C import (
+    _enter_dual_level as _enter_dual_level_impl,
+    _exit_dual_level as _exit_dual_level_impl,
+)
+from torch._C._functorch import (
+    _add_batch_dim as _add_batch_dim_impl,
+    _jvp_decrement_nesting as _jvp_decrement_nesting_impl,
+    _jvp_increment_nesting as _jvp_increment_nesting_impl,
+    _remove_batch_dim as _remove_batch_dim_impl,
+    _unwrap_for_grad as _unwrap_for_grad_impl,
+    _vmap_decrement_nesting as _vmap_decrement_nesting_impl,
+    _vmap_increment_nesting as _vmap_increment_nesting_impl,
+)
+from torch._VF import (  # type: ignore[attr-defined]
+    _make_dual as _make_dual_impl,
+    _unpack_dual as _unpack_dual_impl,
+)
+
+
+if TYPE_CHECKING:
+    import threading
+
+
+def _add_batch_dim(self: torch.Tensor, batch_dim: int, level: int) -> torch.Tensor:
+    """
+    Thin wrapper around torch._C._add_batch_dim that is used to proxy in
+    PT2 export/compile fx graph
+    """
+    from torch._export.utils import _maybe_find_pre_dispatch_tf_mode_for_export
+
+    mode = _maybe_find_pre_dispatch_tf_mode_for_export()
+    batch_dim = self.ndim + batch_dim if batch_dim < 0 else batch_dim
+
+    if mode:
+        return torch.overrides.handle_torch_function(
+            _add_batch_dim, (self,), self, batch_dim, level
+        )
+
+    res = _add_batch_dim_impl(self, batch_dim, level)
+    return res
+
+
+def _remove_batch_dim(
+    self: torch.Tensor, level: int, batch_size: int, out_dim: int
+) -> torch.Tensor:
+    """
+    Thin wrapper around torch._C._remove_batch_dim that is used to proxy in
+    PT2 export/compile fx graph
+    """
+    from torch._export.utils import _maybe_find_pre_dispatch_tf_mode_for_export
+
+    mode = _maybe_find_pre_dispatch_tf_mode_for_export()
+
+    if mode:
+        return torch.overrides.handle_torch_function(
+            _remove_batch_dim, (self,), self, level, batch_size, out_dim
+        )
+
+    res = _remove_batch_dim_impl(self, level, batch_size, out_dim)
+    return res
+
+
+def _vmap_increment_nesting(batch_size: int, randomness: str) -> int:
+    """
+    Thin wrapper around torch._C._vmap_increment_nesting that is used
+    to proxy in export/compile graph
+    """
+    from torch._export.utils import _maybe_find_pre_dispatch_tf_mode_for_export
+
+    mode = _maybe_find_pre_dispatch_tf_mode_for_export()
+
+    if mode:
+        return torch.overrides.handle_torch_function(
+            _vmap_increment_nesting, (batch_size,), batch_size, randomness
+        )
+    res = _vmap_increment_nesting_impl(batch_size, randomness)
+    return res
+
+
+def _vmap_decrement_nesting() -> int:
+    """
+    Thin wrapper around torch._C._vmap_increment_nesting that is used
+    to proxy in export/compile graph
+    """
+    from torch._export.utils import _maybe_find_pre_dispatch_tf_mode_for_export
+
+    mode = _maybe_find_pre_dispatch_tf_mode_for_export()
+
+    if mode:
+        return torch.overrides.handle_torch_function(
+            _vmap_decrement_nesting,
+            (),
+        )
+    return _vmap_decrement_nesting_impl()
+
+
+# Global variables for lazy_load_decompositions
+DECOMPOSITIONS_LOADED: bool = False
+DECOMPOSITIONS_LOCK: threading.Lock | None = None
+VMAP_DECOMPOSITIONS_LIB: torch.library.Library | None = None
+
+
+def lazy_load_decompositions() -> None:
+    """
+    Lazy loading of vmap decompositions with pre-dispatch support.
+    """
+    from torch._export.utils import _maybe_find_pre_dispatch_tf_mode_for_export
+
+    mode = _maybe_find_pre_dispatch_tf_mode_for_export()
+
+    if mode:
+        return torch.overrides.handle_torch_function(lazy_load_decompositions, ())
+
+    global DECOMPOSITIONS_LOADED, DECOMPOSITIONS_LOCK, VMAP_DECOMPOSITIONS_LIB
+
+    if DECOMPOSITIONS_LOADED:
+        return
+
+    # Initialize lock if needed
+    if DECOMPOSITIONS_LOCK is None:
+        import threading
+
+        DECOMPOSITIONS_LOCK = threading.Lock()
+
+    with DECOMPOSITIONS_LOCK:
+        if DECOMPOSITIONS_LOADED:
+            return
+
+        import os
+
+        if not (os.environ.get("PYTORCH_JIT", "1") == "1" and __debug__):
+            DECOMPOSITIONS_LOADED = True
+            return
+
+        # use an alternate way to register an operator into the decomposition table
+        # _register_jit_decomposition doesn't work for some operators, e.g. addr,
+        #  because the Tensor types generated cannot be unioned by torchscript
+        # decomp should be type OpOverload
+        VMAP_DECOMPOSITIONS_LIB = torch.library.Library(
+            "aten", "IMPL", "FuncTorchBatched"
+        )
+
+        from torch._decomp import decomposition_table
+
+        def _register_python_decomposition_vmap(decomp: torch._ops.OpOverload) -> None:
+            if VMAP_DECOMPOSITIONS_LIB is None:
+                raise AssertionError("VMAP_DECOMPOSITIONS_LIB must not be None")
+            if decomp in decomposition_table:
+                VMAP_DECOMPOSITIONS_LIB.impl(decomp, decomposition_table[decomp])
+            else:
+                raise RuntimeError(f"could not find decomposition for {decomp}")
+
+        _register_python_decomposition_vmap(torch.ops.aten.mse_loss_backward.default)
+        _register_python_decomposition_vmap(
+            torch.ops.aten.smooth_l1_loss_backward.default
+        )
+        _register_python_decomposition_vmap(torch.ops.aten.huber_loss_backward.default)
+        _register_python_decomposition_vmap(torch.ops.aten.nll_loss_forward.default)
+        _register_python_decomposition_vmap(torch.ops.aten.nll_loss2d_forward.default)
+        _register_python_decomposition_vmap(torch.ops.aten.nll_loss_backward.default)
+        _register_python_decomposition_vmap(torch.ops.aten.nll_loss2d_backward.default)
+        _register_python_decomposition_vmap(torch.ops.aten.addr.default)
+
+        DECOMPOSITIONS_LOADED = True
+
+
+def _make_dual(
+    tensor: torch.Tensor, tangent: torch.Tensor, *, level: int = 0
+) -> torch.Tensor:
+    """
+    Thin wrapper around torch._VF._make_dual that is used to proxy in
+    PT2 export/compile fx graph for forward-mode AD.
+    """
+    from torch._export.utils import _maybe_find_pre_dispatch_tf_mode_for_export
+
+    mode = _maybe_find_pre_dispatch_tf_mode_for_export()
+
+    if mode:
+        return torch.overrides.handle_torch_function(
+            _make_dual, (tensor, tangent), tensor, tangent, level=level
+        )
+
+    return _make_dual_impl(tensor, tangent, level=level)
+
+
+def _unpack_dual(
+    tensor: torch.Tensor, *, level: int = 0
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """
+    Thin wrapper around torch._VF._unpack_dual that is used to proxy in
+    PT2 export/compile fx graph for forward-mode AD.
+    """
+    from torch._export.utils import _maybe_find_pre_dispatch_tf_mode_for_export
+
+    mode = _maybe_find_pre_dispatch_tf_mode_for_export()
+
+    if mode:
+        return torch.overrides.handle_torch_function(
+            _unpack_dual, (tensor,), tensor, level=level
+        )
+
+    return _unpack_dual_impl(tensor, level=level)
+
+
+def _jvp_increment_nesting() -> int:
+    """
+    Thin wrapper around torch._C._functorch._jvp_increment_nesting that is
+    used to proxy in export/compile graph for forward-mode AD.
+    """
+    from torch._export.utils import _maybe_find_pre_dispatch_tf_mode_for_export
+
+    mode = _maybe_find_pre_dispatch_tf_mode_for_export()
+
+    if mode:
+        return torch.overrides.handle_torch_function(
+            _jvp_increment_nesting,
+            (),
+        )
+    return _jvp_increment_nesting_impl()
+
+
+def _jvp_decrement_nesting() -> int:
+    """
+    Thin wrapper around torch._C._functorch._jvp_decrement_nesting that is
+    used to proxy in export/compile graph for forward-mode AD.
+    """
+    from torch._export.utils import _maybe_find_pre_dispatch_tf_mode_for_export
+
+    mode = _maybe_find_pre_dispatch_tf_mode_for_export()
+
+    if mode:
+        return torch.overrides.handle_torch_function(
+            _jvp_decrement_nesting,
+            (),
+        )
+    return _jvp_decrement_nesting_impl()
+
+
+def _unwrap_for_grad(tensor: torch.Tensor, level: int) -> torch.Tensor:
+    """
+    Thin wrapper around torch._C._functorch._unwrap_for_grad that is used
+    to proxy in PT2 export/compile fx graph for functorch transforms (grad, vjp, jvp).
+    """
+    from torch._export.utils import _maybe_find_pre_dispatch_tf_mode_for_export
+
+    mode = _maybe_find_pre_dispatch_tf_mode_for_export()
+
+    if mode:
+        return torch.overrides.handle_torch_function(
+            _unwrap_for_grad, (tensor,), tensor, level
+        )
+
+    return _unwrap_for_grad_impl(tensor, level)
+
+
+def _enter_dual_level() -> int:
+    """
+    Thin wrapper around torch._C._enter_dual_level that is used to proxy in
+    PT2 export/compile fx graph for forward-mode AD.
+    """
+    from torch._export.utils import _maybe_find_pre_dispatch_tf_mode_for_export
+
+    mode = _maybe_find_pre_dispatch_tf_mode_for_export()
+
+    if mode:
+        return torch.overrides.handle_torch_function(_enter_dual_level, ())
+    return _enter_dual_level_impl()
+
+
+def _exit_dual_level(*, level: int) -> None:
+    """
+    Thin wrapper around torch._C._exit_dual_level that is used to proxy in
+    PT2 export/compile fx graph for forward-mode AD.
+    """
+    from torch._export.utils import _maybe_find_pre_dispatch_tf_mode_for_export
+
+    mode = _maybe_find_pre_dispatch_tf_mode_for_export()
+
+    if mode:
+        return torch.overrides.handle_torch_function(_exit_dual_level, (), level=level)
+    return _exit_dual_level_impl(level=level)

.venv/lib/python3.12/site-packages/torch/_functorch/pyfunctorch.py

@@ -0,0 +1,338 @@
+from __future__ import annotations
+
+import contextlib
+from abc import ABC, abstractmethod
+from functools import cached_property
+from typing import Any, TYPE_CHECKING
+
+import torch
+import torch.utils._pytree as pytree
+from torch._C._functorch import (
+    CFunctionalizeInterpreterPtr,
+    CGradInterpreterPtr,
+    CInterpreter,
+    CJvpInterpreterPtr,
+    CVmapInterpreterPtr,
+    pop_dynamic_layer_stack,
+    push_dynamic_layer_stack,
+    RandomnessType,
+    TransformType,
+)
+from torch.autograd.forward_ad import _set_fwd_grad_enabled
+
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+
+"""
+This file contains the functorch integration with PyDispatcher.
+
+PyDispatcher does not understand functorch's DynamicLayerStack dispatching
+logic because it is entirely implemented in C++ in the fallbacks for two
+dispatch keys, FuncTorchDynamicLayer{Front, Back}Mode (PyDispatcher is unable
+to directly reuse C++ boxed fallbacks).
+
+Instead of trying to hammer PyDispatcher into understanding those fallbacks,
+we re-implement the logic of peeking the top of the stack for an interpreter,
+selecting the interpreter to dispatch on, etc, in Python. This leads to a
+simpler design.
+
+The main difference between C++ functorch and PyDispatcher's functorch logic
+is that:
+- C++ functorch needs to manually tweak dispatch keys to ping-pong between
+  DynamicLayerFrontMode and DynamicLayerBackMode.
+- PyDispatcher's functorch logic pops an Interpreter from the top of the stack
+  and asks it to execute the rule associated with the Interpreter.
+
+In C++ we do the ping-pong because e.g. vmap rules are associated with the
+batched DispatchKey, but in PyDispatcher we are able to avoid this by asking
+the user to register a batching rule directly to a transform that an
+interpreter then invokes.
+"""
+
+
+# FuncTorchInterpreter is the Python version of Interpreter (recall that
+# the DynamicLayerStack is a stack of interpreters).
+# It is a wrapper around the actual C++ Interpreter object.
+#
+# Keep the methods in sync with aten/src/ATen/functorch/Interpreter.h
+class FuncTorchInterpreter(ABC):
+    def __init__(self, cptr: Any) -> None:
+        self._cptr = cptr
+
+    # Process an operation. eg for vmap, this is invoking a batching rule.
+    # Conceptually this is analogous to Interpreter::process in C++
+    @abstractmethod
+    def process(self, op: Any, args: tuple[Any, ...], kwargs: dict[str, Any]) -> Any:
+        pass
+
+    # lower an operation from this Interpreter to the next Interpreter on the stack.
+    # Concretely, this involves temporarily popping the current Interpreter.
+    # Conceptually this is analogous to Interpreter::sendToNextInterpreter in C++
+    def lower(self) -> contextlib.AbstractContextManager[Any]:
+        return temporarily_pop_interpreter_stack()
+
+    def level(self) -> int:
+        return self._cptr.level()
+
+    def key(self) -> TransformType:
+        return self._cptr.key()
+
+    def get_state(self) -> tuple[Any, ...]:
+        raise NotImplementedError
+
+    def check_state(self, state: tuple[Any, ...]) -> bool:
+        return state == self.get_state()
+
+    def __getstate__(self) -> dict[str, Any]:
+        state = self.__dict__.copy()
+        state.pop("_cptr", None)
+        return state
+
+
+@contextlib.contextmanager
+def temporarily_pop_interpreter_stack() -> Generator[None, None, None]:
+    try:
+        saved = pop_dynamic_layer_stack()
+        yield
+    finally:
+        push_dynamic_layer_stack(saved)
+
+
+@contextlib.contextmanager
+def temporarily_clear_interpreter_stack() -> Generator[list[Any], None, None]:
+    stack: list[Any] = []
+    try:
+        while torch._C._functorch.peek_interpreter_stack() is not None:
+            stack.append(pop_dynamic_layer_stack())
+        yield list(stack)
+    finally:
+        while stack:
+            push_dynamic_layer_stack(stack.pop())
+
+
+@contextlib.contextmanager
+def temporarily_restore_interpreter_stack(
+    stack: list[Any] | None,
+) -> Generator[None, None, None]:
+    pushed: list[Any] = []
+    if stack is None:
+        return
+    try:
+        for s in reversed(stack):
+            push_dynamic_layer_stack(s)
+            pushed.append(s)
+        yield
+    finally:
+        for _ in reversed(pushed):
+            # TODO: would be nice to assert that the layers are the same, but
+            # Python object identity is not preserved
+            pop_dynamic_layer_stack()
+
+
+class VmapInterpreter(FuncTorchInterpreter):
+    def __init__(self, cdata: CInterpreter) -> None:
+        if cdata.key() != TransformType.Vmap:
+            raise AssertionError(f"expected TransformType.Vmap, got {cdata.key()}")
+        # NOTE: [Interpreter cdata vs cptr]
+        # cdata is a generic CInterpreter. We wrap it in a CVmapInterpreterPtr
+        # so that we can access methods specific to the vmap interpreter
+        self._cdata = cdata
+
+    @cached_property
+    # pyrefly: ignore [bad-override]
+    def _cptr(self) -> CVmapInterpreterPtr:
+        return CVmapInterpreterPtr(self._cdata)
+
+    def process(self, op: Any, args: tuple[Any, ...], kwargs: dict[str, Any]) -> Any:
+        kernel = op.functorch_table[TransformType.Vmap]
+        return kernel(self, *args, **kwargs)
+
+    def batch_size(self) -> int:
+        return self._cptr.batchSize()
+
+    def randomness(self) -> str:
+        typ = self._cptr.randomness()
+        if typ == RandomnessType.Error:
+            return "error"
+        elif typ == RandomnessType.Same:
+            return "same"
+        elif typ == RandomnessType.Different:
+            return "different"
+        raise RuntimeError(f"Unknown RandomnessType: {typ}")
+
+    def get_state(self) -> tuple[Any, ...]:
+        return (self.key().name, self.level(), self.randomness())
+
+
+@contextlib.contextmanager
+def nested(
+    *contexts: contextlib.AbstractContextManager[Any],
+) -> Generator[tuple[contextlib.AbstractContextManager[Any], ...], None, None]:
+    with contextlib.ExitStack() as stack:
+        for ctx in contexts:
+            stack.enter_context(ctx)
+        yield contexts
+
+
+class GradInterpreter(FuncTorchInterpreter):
+    def __init__(self, cdata: CInterpreter) -> None:
+        if cdata.key() != TransformType.Grad:
+            raise AssertionError(f"expected TransformType.Grad, got {cdata.key()}")
+        # See NOTE: [Interpreter cdata vs cptr]
+        self._cdata = cdata
+
+    @cached_property
+    # pyrefly: ignore [bad-override]
+    def _cptr(self) -> CGradInterpreterPtr:
+        return CGradInterpreterPtr(self._cdata)
+
+    def lift(
+        self, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> tuple[tuple[Any, ...], dict[str, Any]]:
+        args, kwargs = pytree.tree_map_only(
+            torch.Tensor, self._cptr.lift, [args, kwargs]
+        )
+        return args, kwargs
+
+    def process(self, op: Any, args: tuple[Any, ...], kwargs: dict[str, Any]) -> Any:
+        kernel = op.functorch_table[TransformType.Grad]
+        args, kwargs = self.lift(args, kwargs)
+        return kernel(self, *args, **kwargs)
+
+    # GradInterpreter has custom lower because of the no_grad interaction
+    # See NOTE [grad and vjp interaction with no_grad]
+    # This logic is mirrored from C++ GradInterpreterPtr::sendToNextInterpreter
+    def lower(self) -> contextlib.AbstractContextManager[Any]:
+        prev_grad_mode = self.prev_grad_mode()
+        if not prev_grad_mode:
+            return nested(torch.no_grad(), super().lower())
+        return super().lower()
+
+    def prev_grad_mode(self) -> bool:
+        return self._cptr.prevGradMode()
+
+    def get_state(self) -> tuple[Any, ...]:
+        return (self.key().name, self.level(), self.prev_grad_mode())
+
+
+class JvpInterpreter(FuncTorchInterpreter):
+    def __init__(self, cdata: CInterpreter) -> None:
+        if cdata.key() != TransformType.Jvp:
+            raise AssertionError(f"expected TransformType.Jvp, got {cdata.key()}")
+        # See NOTE: [Interpreter cdata vs cptr]
+        self._cdata = cdata
+
+    @cached_property
+    # pyrefly: ignore [bad-override]
+    def _cptr(self) -> CJvpInterpreterPtr:
+        return CJvpInterpreterPtr(self._cdata)
+
+    def lift(
+        self, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> tuple[tuple[Any, ...], dict[str, Any]]:
+        args, kwargs = pytree.tree_map_only(
+            torch.Tensor, self._cptr.lift, [args, kwargs]
+        )
+        return args, kwargs
+
+    def process(self, op: Any, args: tuple[Any, ...], kwargs: dict[str, Any]) -> Any:
+        kernel = op.functorch_table[TransformType.Jvp]
+        args, kwargs = self.lift(args, kwargs)
+        return kernel(self, *args, **kwargs)
+
+    # Jvp has custom lower because of the no_fwd_grad interaction
+    # See NOTE [grad and vjp interaction with no_grad] for related info.
+    # This logic is mirrored from C++ JvpInterpreterPtr::sendToNextInterpreter
+    def lower(self) -> contextlib.AbstractContextManager[Any]:
+        prev_fwd_grad_mode = self.prev_fwd_grad_mode()
+        if not prev_fwd_grad_mode:
+            return nested(_set_fwd_grad_enabled(False), super().lower())
+        return super().lower()
+
+    def prev_fwd_grad_mode(self) -> bool:
+        return self._cptr.prevFwdGradMode()
+
+    def get_state(self) -> tuple[Any, ...]:
+        return (self.key().name, self.level(), self.prev_fwd_grad_mode())
+
+
+class FunctionalizeInterpreter(FuncTorchInterpreter):
+    def __init__(self, cdata: CInterpreter) -> None:
+        if cdata.key() != TransformType.Functionalize:
+            raise AssertionError(
+                f"expected TransformType.Functionalize, got {cdata.key()}"
+            )
+        self._cdata = cdata
+
+    @cached_property
+    # pyrefly: ignore [bad-override]
+    def _cptr(self) -> CFunctionalizeInterpreterPtr:
+        return CFunctionalizeInterpreterPtr(self._cdata)
+
+    def process(self, op: Any, args: tuple[Any, ...], kwargs: dict[str, Any]) -> Any:
+        kernel = op.functorch_table[TransformType.Functionalize]
+        return kernel(self, *args, **kwargs)
+
+    def functionalize_add_back_views(self) -> bool:
+        return self._cptr.functionalizeAddBackViews()
+
+    def get_state(self) -> tuple[Any, ...]:
+        return (self.key().name, self.level())
+
+
+def coerce_cinterpreter(cinterpreter: CInterpreter) -> FuncTorchInterpreter:
+    key = cinterpreter.key()
+    if key == TransformType.Grad:
+        return GradInterpreter(cinterpreter)
+    if key == TransformType.Vmap:
+        return VmapInterpreter(cinterpreter)
+    if key == TransformType.Jvp:
+        return JvpInterpreter(cinterpreter)
+    if key == TransformType.Functionalize:
+        return FunctionalizeInterpreter(cinterpreter)
+    raise RuntimeError(f"NYI: PyDispatcher has not implemented support for {key}")
+
+
+def retrieve_current_functorch_interpreter() -> FuncTorchInterpreter:
+    interpreter = torch._C._functorch.peek_interpreter_stack()
+    if interpreter is None:
+        raise AssertionError("interpreter must not be None")
+    return coerce_cinterpreter(interpreter)
+
+
+def retrieve_all_functorch_interpreters() -> list[FuncTorchInterpreter]:
+    cis = torch._C._functorch.get_interpreter_stack()
+    if cis is None:
+        return []
+    return [coerce_cinterpreter(ci) for ci in cis]
+
+
+def compare_functorch_state(states: list[tuple[Any, ...]]) -> bool:
+    # There are four possible cases covered here:
+    # 1. Current stack empty AND stack when generated not empty -> Invalidate
+    # 2. Current stack not empty AND stack when generated empty -> Invalidate
+    # 3. Current stack and generated stack empty -> Valid FX graph
+    # 4. Current stack and generated stack not empty -> Valid if both states match
+    peek = torch._C._functorch.peek_interpreter_stack()
+    if (peek is None and len(states) != 0) or (peek is not None and len(states) == 0):
+        return False
+
+    cis = retrieve_all_functorch_interpreters()
+    return len(cis) == len(states) and all(
+        ci.check_state(state) for ci, state in zip(cis, states)
+    )
+
+
+def dispatch_functorch(op: Any, args: tuple[Any, ...], kwargs: dict[str, Any]) -> Any:
+    interpreter = retrieve_current_functorch_interpreter()
+    # In traditional PyTorch operators, DispatchKey::FuncTorchTensorWrapper's
+    # unwrap_dead_tensors fallback handles unwrapping dead tensor wrappers.
+    # PyDispatcher sidesteps the PyTorch dispatcher when dealing with functorch
+    # transforms, so we manually unwrap the dead tensors here.
+    # This logic won't need to exist when we have mode-only functorch.
+    args, kwargs = pytree.tree_map_only(
+        torch.Tensor, torch._C._functorch.unwrap_if_dead, (args, kwargs)
+    )
+    return interpreter.process(op, args, kwargs)

.venv/lib/python3.12/site-packages/torch/_functorch/python_key.py

@@ -0,0 +1,15 @@
+# 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.
+__all__ = ["make_fx", "dispatch_trace", "PythonKeyTracer", "pythonkey_decompose"]
+from torch.fx.experimental.proxy_tensor import (
+    decompose,
+    dispatch_trace,
+    make_fx,
+    PythonKeyTracer,
+)
+
+
+pythonkey_decompose = decompose

.venv/lib/python3.12/site-packages/torch/_functorch/pytree_hacks.py

@@ -0,0 +1,23 @@
+# 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.
+
+import warnings
+
+# TODO: remove this file when the migration of the pytree utility is done
+from torch.utils._pytree import tree_map_, treespec_pprint
+
+
+__all__ = ["tree_map_", "treespec_pprint"]
+
+
+with warnings.catch_warnings():
+    warnings.simplefilter("always")
+    warnings.warn(
+        "`torch._functorch.pytree_hacks` is deprecated and will be removed in a future release. "
+        "Please `use torch.utils._pytree` instead.",
+        DeprecationWarning,
+        stacklevel=2,
+    )

.venv/lib/python3.12/site-packages/torch/_functorch/top_operators_github_usage.py

@@ -0,0 +1,630 @@
+from __future__ import annotations
+
+
+"""
+From https://docs.google.com/spreadsheets/d/12R3nCOLskxPYjjiNkdqy4OdQ65eQp_htebXGODsjSeA/edit#gid=0
+Try to keep this list in sync with that.
+"""
+
+import operator
+
+
+top_torch: list[tuple[str, int]] = [
+    ("t", 6837449),
+    ("tensor", 585786),
+    ("mode", 462182),
+    ("cat", 394818),
+    ("max", 368038),
+    ("zeros", 329495),
+    ("load", 327756),
+    ("no_grad", 294694),
+    ("save", 265130),
+    ("from_numpy", 243063),
+    ("manual_seed", 165044),
+    ("ones", 153696),
+    ("randn", 150796),
+    ("stack", 133358),
+    ("sum", 130772),
+    ("arange", 98087),
+    ("rand", 94715),
+    ("mean", 88546),
+    ("exp", 73883),
+    ("zeros_like", 72831),
+    ("min", 72248),
+    ("sigmoid", 66798),
+    ("log", 62135),
+    ("matmul", 47811),
+    ("clamp", 45304),
+    ("sqrt", 44911),
+    ("abs", 43535),
+    ("tanh", 42793),
+    ("empty", 40311),
+    ("argmax", 38435),
+    ("bmm", 33984),
+    ("pow", 33571),
+    ("norm", 31125),
+    ("mm", 30995),
+    ("is_tensor", 29546),
+    ("ones_like", 29512),
+    ("nonzero", 28681),
+    ("full", 28373),
+    ("unsqueeze", 27911),
+    ("where", 26585),
+    ("randperm", 26450),
+    ("eye", 24342),
+    ("mul", 23236),
+    ("topk", 22537),
+    ("as_tensor", 21967),
+    ("sort", 21412),
+    ("squeeze", 20863),
+    ("randint", 20771),
+    ("linspace", 20041),
+    ("add", 19201),
+    ("transpose", 18663),
+    ("split", 18325),
+    ("gather", 17904),
+    ("set_grad_enabled", 16013),
+    ("sin", 15669),
+    ("cos", 15562),
+    ("div", 15513),
+    ("index_select", 14866),
+    ("multinomial", 14331),
+    ("flatten", 14267),
+    ("isnan", 14170),
+    ("randn_like", 13096),
+    ("eq", 12680),
+    ("einsum", 12480),
+    ("round", 12367),
+    ("floor", 11628),
+    ("allclose", 11000),
+    ("reshape", 10605),
+    ("diag", 10167),
+    ("chunk", 9581),
+    ("std", 9379),
+    ("set_default_tensor_type", 9281),
+    ("triu", 8559),
+    ("meshgrid", 8292),
+    ("set_num_threads", 8126),
+    ("unique", 7964),
+    ("full_like", 7780),
+    ("tril", 7538),
+    ("dot", 7275),
+    ("sign", 6943),
+    ("equal", 6916),
+    ("normal", 6750),
+    ("cumsum", 6556),
+    ("dist", 6058),
+    ("isfinite", 6030),
+    ("gt", 5935),
+    ("set_printoptions", 5888),
+    ("range", 5491),
+    ("empty_like", 5351),
+    ("flip", 5342),
+    ("masked_select", 5341),
+    ("bernoulli", 5262),
+    ("atan", 5253),
+    ("var", 5247),
+    ("prod", 5200),
+    ("erf", 5088),
+    ("inverse", 5072),
+    ("addmm", 4854),
+    ("logsumexp", 4582),
+    ("fft", 4436),
+    ("lt", 4421),
+    ("log2", 4316),
+    ("enable_grad", 4238),
+    ("rand_like", 4187),
+    ("argsort", 3972),
+    ("seed", 3932),
+    ("mv", 3547),
+    ("ger", 3309),
+    ("ge", 3248),
+    ("atan2", 3210),
+    ("ceil", 3202),
+    ("ne", 3075),
+    ("bincount", 3063),
+    ("acos", 3055),
+    ("rsqrt", 3031),
+    ("svd", 3029),
+    ("numel", 3003),
+    ("log1p", 2840),
+    ("unbind", 2808),
+    ("le", 2714),
+    ("isinf", 2707),
+    ("cross", 2646),
+    ("set_default_dtype", 2536),
+    ("argmin", 2535),
+    ("sparse_coo_tensor", 2489),
+    ("log10", 2304),
+    ("kthvalue", 2192),
+    ("set_rng_state", 2158),
+    ("get_rng_state", 1996),
+    ("get_default_dtype", 1879),
+    ("det", 1868),
+    ("qr", 1864),
+    ("histc", 1852),
+    ("symeig", 1832),
+    ("trace", 1801),
+    ("median", 1795),
+    ("addcmul", 1751),
+    ("remainder", 1717),
+    ("baddbmm", 1693),
+    ("lgamma", 1665),
+    ("repeat_interleave", 1598),
+    ("fmod", 1576),
+    ("reciprocal", 1575),
+    ("tan", 1560),
+    ("initial_seed", 1532),
+    ("take", 1529),
+    ("stft", 1487),
+    ("get_num_threads", 1477),
+    ("real", 1459),
+    ("quantize_per_tensor", 1392),
+    ("diag_embed", 1364),
+    ("lerp", 1363),
+    ("asin", 1345),
+    ("eig", 1333),
+    ("trunc", 1290),
+    ("diagonal", 1287),
+    ("cosh", 1279),
+    ("rfft", 1269),
+    ("cumprod", 1260),
+    ("addr", 1211),
+    ("roll", 1198),
+    ("narrow", 1188),
+    ("digamma", 1172),
+    ("square", 1163),
+    ("sinh", 1131),
+    ("logspace", 1084),
+    ("broadcast_tensors", 1070),
+    ("irfft", 1013),
+    ("frac", 997),
+    ("hann_window", 994),
+    ("solve", 989),
+    ("logdet", 977),
+    ("expm1", 968),
+    ("cdist", 946),
+    ("addmv", 903),
+    ("randint_like", 888),
+    ("tensordot", 888),
+    ("ifft", 877),
+    ("true_divide", 854),
+    ("erfinv", 830),
+    ("addcdiv", 819),
+    ("addbmm", 813),
+    ("renorm", 781),
+    ("pinverse", 753),
+    ("isclose", 740),
+    ("erfc", 729),
+    ("is_storage", 725),
+    ("triangular_solve", 723),
+    ("rot90", 709),
+    ("logical_not", 686),
+    ("geqrf", 681),
+    ("slogdet", 677),
+    ("lu", 665),
+    ("hamming_window", 659),
+    ("orgqr", 651),
+    ("ormqr", 622),
+    ("is_floating_point", 602),
+    ("diagflat", 562),
+    ("cholesky_solve", 559),
+    ("tril_indices", 552),
+    ("chain_matmul", 551),
+    ("triu_indices", 548),
+    ("angle", 522),
+    ("poisson", 505),
+    ("matrix_power", 485),
+    ("unique_consecutive", 471),
+    ("quantize_per_channel", 465),
+    ("std_mean", 458),
+    ("bartlett_window", 447),
+    ("var_mean", 428),
+    ("lstsq", 421),
+    ("logical_and", 419),
+    ("mvlgamma", 411),
+    ("blackman_window", 400),
+    ("bitwise_not", 395),
+    ("cholesky_inverse", 388),
+    ("as_strided", 384),
+    ("floor_divide", 353),
+    ("cartesian_prod", 321),
+    ("lu_solve", 317),
+    ("set_flush_denormal", 310),
+    ("empty_strided", 283),
+    ("logical_xor", 282),
+    ("polygamma", 282),
+    ("logical_or", 280),
+    ("set_num_interop_threads", 278),
+    ("combinations", 274),
+    ("trapz", 270),
+    ("matrix_rank", 260),
+    ("lu_unpack", 255),
+    ("result_type", 244),
+    ("conj", 231),
+    ("cummax", 230),
+    ("lobpcg", 229),
+    ("bitwise_xor", 217),
+    ("promote_types", 213),
+    ("get_num_interop_threads", 211),
+    ("cummin", 205),
+    ("bitwise_and", 198),
+    ("dequantize", 192),
+    ("bitwise_or", 191),
+    ("imag", 191),
+    ("can_cast", 184),
+    ("istft", 180),
+    ("compiled_with_cxx11_abi", 159),
+    ("is_complex", 151),
+    ("block_diag", 136),
+    ("pca_lowrank", 124),
+    ("absolute", 122),
+    ("svd_lowrank", 108),
+    ("neg", 2),
+]
+
+top_nn_functional: list[tuple[str, int]] = [
+    ("nn.functional.softmax", 10522),
+    ("nn.functional.relu", 8572),
+    ("nn.functional.interpolate", 7277),
+    ("nn.functional.pad", 5207),
+    ("nn.functional.log_softmax", 4699),
+    ("nn.functional.normalize", 2338),
+    ("nn.functional.cross_entropy", 2083),
+    ("nn.functional.grid_sample", 1970),
+    ("nn.functional.one_hot", 1967),
+    ("nn.functional.mse_loss", 1920),
+    ("nn.functional.conv2d", 1593),
+    ("nn.functional.dropout", 1516),
+    ("nn.functional.softplus", 1385),
+    ("nn.functional.sigmoid", 1128),
+    ("nn.functional.linear", 1036),
+    ("nn.functional.gelu", 930),
+    ("nn.functional.avg_pool2d", 899),
+    ("nn.functional.max_pool2d", 876),
+    ("nn.functional.nll_loss", 863),
+    ("nn.functional.embedding", 737),
+    ("nn.functional.tanh", 664),
+    ("nn.functional.leaky_relu", 640),
+    ("nn.functional.adaptive_avg_pool2d", 633),
+    ("nn.functional.cosine_similarity", 627),
+    ("nn.functional.unfold", 609),
+    ("nn.functional.conv1d", 596),
+    ("nn.functional.binary_cross_entropy_with_logits", 591),
+    ("nn.functional.l1_loss", 571),
+    ("nn.functional.binary_cross_entropy", 492),
+    ("nn.functional.elu", 416),
+    ("nn.functional.batch_norm", 413),
+    ("nn.functional.upsample", 413),
+    ("nn.functional.fold", 305),
+    ("nn.functional.affine_grid", 298),
+    ("nn.functional.max_pool1d", 297),
+    ("nn.functional.torch", 294),
+    ("nn.functional.threshold", 263),
+    ("nn.functional.smooth_l1_loss", 262),
+    ("nn.functional.pairwise_distance", 253),
+    ("nn.functional.logsigmoid", 243),
+    ("nn.functional.adaptive_max_pool2d", 235),
+    ("nn.functional.relu6", 213),
+    ("nn.functional.pixel_shuffle", 209),
+    ("nn.functional.avg_pool3d", 203),
+    ("nn.functional.bilinear", 203),
+    ("nn.functional.conv_transpose2d", 201),
+    ("nn.functional.gumbel_softmax", 197),
+    ("nn.functional.max_unpool2d", 196),
+    ("nn.functional.kl_div", 191),
+    ("nn.functional.hardtanh", 189),
+    ("nn.functional.ctc_loss", 185),
+    ("nn.functional.layer_norm", 178),
+    ("nn.functional.conv3d", 172),
+    ("nn.functional.max_unpool3d", 167),
+    ("nn.functional.hardshrink", 165),
+    ("nn.functional.hardswish", 156),
+    ("nn.functional.selu", 156),
+    ("nn.functional.glu", 155),
+    ("nn.functional.assert_int_or_pair", 150),
+    ("nn.functional.hardsigmoid", 146),
+    ("nn.functional.upsample_bilinear", 146),
+    ("nn.functional.max_pool3d", 140),
+    ("nn.functional.adaptive_avg_pool3d", 139),
+    ("nn.functional.instance_norm", 124),
+    ("nn.functional.embedding_bag", 122),
+    ("nn.functional.upsample_nearest", 110),
+    ("nn.functional.avg_pool1d", 105),
+    ("nn.functional.prelu", 102),
+    ("nn.functional.celu", 92),
+    ("nn.functional.dropout2d", 86),
+    ("nn.functional.hinge_embedding_loss", 82),
+    ("nn.functional.softsign", 81),
+    ("nn.functional.max_unpool1d", 74),
+    ("nn.functional.silu", 74),
+    ("nn.functional.softshrink", 70),
+    ("nn.functional.leaky_relu_", 68),
+    ("nn.functional.softmin", 67),
+    ("nn.functional.channel_shuffle", 66),
+    ("nn.functional.multilabel_margin_loss", 66),
+    ("nn.functional.dropout3d", 65),
+    ("nn.functional.multi_margin_loss", 65),
+    ("nn.functional.lp_pool2d", 64),
+    ("nn.functional.conv_transpose1d", 62),
+    ("nn.functional.triplet_margin_loss", 62),
+    ("nn.functional.tanhshrink", 61),
+    ("nn.functional.adaptive_max_pool1d", 59),
+    ("nn.functional.cosine_embedding_loss", 58),
+    ("nn.functional.multi_head_attention_forward", 58),
+    ("nn.functional.max_pool1d_with_indices", 53),
+    ("nn.functional.poisson_nll_loss", 53),
+    ("nn.functional.margin_ranking_loss", 52),
+    ("nn.functional.soft_margin_loss", 52),
+    ("nn.functional.adaptive_max_pool3d", 51),
+    ("nn.functional.group_norm", 51),
+    ("nn.functional.local_response_norm", 51),
+    ("nn.functional.multilabel_soft_margin_loss", 51),
+    ("nn.functional.relu_", 50),
+    ("nn.functional.alpha_dropout", 49),
+    ("nn.functional.feature_alpha_dropout", 49),
+    ("nn.functional.lp_pool1d", 49),
+    ("nn.functional.adaptive_max_pool1d_with_indices", 48),
+    ("nn.functional.adaptive_max_pool2d_with_indices", 48),
+    ("nn.functional.adaptive_max_pool3d_with_indices", 48),
+    ("nn.functional.fractional_max_pool2d", 48),
+    ("nn.functional.fractional_max_pool2d_with_indices", 48),
+    ("nn.functional.fractional_max_pool3d", 48),
+    ("nn.functional.fractional_max_pool3d_with_indices", 48),
+    ("nn.functional.max_pool2d_with_indices", 48),
+    ("nn.functional.max_pool3d_with_indices", 48),
+    ("nn.functional.handle_torch_function", 47),
+    ("nn.functional.has_torch_function", 47),
+    ("nn.functional.adaptive_avg_pool1d", 43),
+    ("nn.functional.pdist", 43),
+    ("nn.functional.rrelu_", 37),
+    ("nn.functional.elu_", 34),
+    ("nn.functional.boolean_dispatch", 33),
+    ("nn.functional.hardtanh_", 26),
+    ("nn.functional.triplet_margin_with_distance_loss", 23),
+    ("nn.functional.selu_", 20),
+    ("nn.functional.pixel_unshuffle", 19),
+    ("nn.functional.conv_transpose3d", 18),
+    ("nn.functional.gaussian_nll_loss", 15),
+    ("nn.functional.has_torch_function_unary", 15),
+    ("nn.functional.has_torch_function_variadic", 15),
+    ("nn.functional.celu_", 13),
+    ("nn.functional.huber_loss", 7),
+    ("nn.functional.mish", 4),
+    ("nn.functional.threshold_", 3),
+    ("nn.functional.grad", 2),
+    ("nn.functional.conv_tbc", 1),
+    ("nn.functional.math", 1),
+]
+
+top_nn_module: list[tuple[str, int, str | None]] = [
+    ("nn.Module", 927129, None),
+    ("nn.Linear", 530688, "nn.functional.linear"),
+    ("nn.Sequential", 384968, None),
+    ("nn.Conv2d", 383320, "nn.functional.conv2d"),
+    ("nn.ReLU", 318877, "nn.functional.relu"),
+    ("nn.BatchNorm2d", 233265, "nn.functional.batch_norm"),
+    ("nn.Dropout", 179268, "nn.functional.dropout"),
+    ("nn.ModuleList", 171225, None),
+    ("nn.Parameter", 153291, None),
+    ("nn.CrossEntropyLoss", 152696, "nn.functional.cross_entropy"),
+    ("nn.MaxPool2d", 138619, "nn.functional.max_pool2d"),
+    ("nn.Embedding", 111844, "nn.functional.embedding"),
+    ("nn.DataParallel", 104238, None),
+    ("nn.MSELoss", 82954, "nn.functional.mse_loss"),
+    ("nn.Sigmoid", 75810, "nn.functional.sigmoid"),
+    ("nn.LeakyReLU", 65632, "nn.functional.leaky_relu"),
+    ("nn.BatchNorm1d", 65374, "nn.functional.batch_norm"),
+    ("nn.Softmax", 65114, "nn.functional.softmax"),
+    ("nn.Tanh", 59445, "nn.functional.tanh"),
+    ("nn.AdaptiveAvgPool2d", 59071, "nn.functional.adaptive_avg_pool2d"),
+    ("nn.AvgPool2d", 58377, "nn.functional.avg_pool2d"),
+    ("nn.ConvTranspose2d", 57524, "nn.functional.conv_transpose2d"),
+    ("nn.LSTM", 57411, None),
+    ("nn.Conv1d", 41108, "nn.functional.conv1d"),
+    ("nn.LayerNorm", 36089, "nn.functional.layer_norm"),
+    ("nn.BCELoss", 34005, "nn.functional.binary_cross_entropy"),
+    ("nn.Upsample", 32527, "nn.functional.interpolate"),
+    ("nn.BCEWithLogitsLoss", 29944, "nn.functional.binary_cross_entropy_with_logits"),
+    ("nn.GRU", 25421, None),
+    ("nn.Dropout2d", 23512, "nn.functional.dropout2d"),
+    ("nn.LogSoftmax", 22897, "nn.functional.log_softmax"),
+    ("nn.L1Loss", 22778, "nn.functional.l1_loss"),
+    ("nn.GroupNorm", 22183, "nn.functional.group_norm"),
+    ("nn.NLLLoss", 21751, "nn.functional.nll_loss"),
+    ("nn.Conv3d", 20874, "nn.functional.conv3d"),
+    ("nn.Identity", 17911, None),
+    ("nn.InstanceNorm2d", 16426, "nn.functional.instance_norm"),
+    ("nn.BatchNorm3d", 16378, "nn.functional.batch_norm"),
+    ("nn.PReLU", 13472, "nn.functional.prelu"),
+    ("nn.ReLU6", 12622, "nn.functional.relu6"),
+    ("nn.ELU", 12508, "nn.functional.elu"),
+    ("nn.LSTMCell", 10885, None),
+    ("nn.Flatten", 10384, "torch.flatten"),
+    ("nn.ModuleDict", 10255, None),
+    ("nn.ReflectionPad2d", 9954, "nn.functional.pad"),
+    ("nn.MaxPool3d", 9526, "nn.functional.max_pool3d"),
+    ("nn.MaxPool1d", 9154, "nn.functional.max_pool1d"),
+    ("nn.RNN", 9154, None),
+    ("nn.ZeroPad2d", 8847, "nn.functional.pad"),
+    ("nn.ParameterList", 7702, None),
+    ("nn.SyncBatchNorm", 6814, None),
+    ("nn.PixelShuffle", 6571, "nn.functional.pixel_shuffle"),
+    ("nn.SmoothL1Loss", 6517, "nn.functional.smooth_l1_loss"),
+    ("nn.Hardswish", 6458, "nn.functional.hardswish"),
+    ("nn.AdaptiveMaxPool2d", 6071, "nn.functional.adaptive_max_pool2d"),
+    ("nn.SELU", 6043, "nn.functional.selu"),
+    ("nn.ConvTranspose3d", 6039, "nn.functional.conv_transpose3d"),
+    ("nn.GRUCell", 5840, None),
+    ("nn.ReplicationPad2d", 5600, "nn.functional.pad"),
+    ("nn.KLDivLoss", 5541, "nn.functional.kl_div"),
+    ("nn.ConvTranspose1d", 5183, "nn.functional.conv_transpose1d"),
+    ("nn.Softplus", 5120, "nn.functional.softplus"),
+    ("nn.SiLU", 4895, "nn.functional.silu"),
+    ("nn.AvgPool3d", 4523, "nn.functional.avg_pool3d"),
+    ("nn.CosineSimilarity", 4058, "nn.functional.cosine_similarity"),
+    ("nn.GELU", 3932, "nn.functional.gelu"),
+    ("nn.UpsamplingBilinear2d", 3673, "nn.functional.interpolate"),
+    ("nn.InstanceNorm1d", 3658, "nn.functional.instance_norm"),
+    ("nn.Transformer", 3604, None),
+    ("nn.MultiheadAttention", 3435, "nn.functional.multi_head_attention_forward"),
+    ("nn.AvgPool1d", 3195, "nn.functional.avg_pool1d"),
+    ("nn.Dropout3d", 2964, "nn.functional.dropout3d"),
+    ("nn.AdaptiveAvgPool3d", 2915, "nn.functional.adaptive_avg_pool3d"),
+    ("nn.InstanceNorm3d", 2893, "nn.functional.instance_norm"),
+    ("nn.Hardtanh", 2613, "nn.functional.hardtanh"),
+    ("nn.MarginRankingLoss", 2568, "nn.functional.margin_ranking_loss"),
+    ("nn.GLU", 2526, "nn.functional.glu"),
+    ("nn.AdaptiveAvgPool1d", 2481, "nn.functional.adaptive_avg_pool1d"),
+    ("nn.EmbeddingBag", 2344, "nn.functional.embedding_bag"),
+    ("nn.TransformerEncoderLayer", 2292, None),
+    ("nn.TransformerEncoder", 2091, None),
+    ("nn.MaxUnpool2d", 2031, "nn.functional.max_unpool2d"),
+    ("nn.UpsamplingNearest2d", 2004, "nn.functional.interpolate"),
+    ("nn.ConstantPad1d", 1904, "nn.functional.pad"),
+    ("nn.ConstantPad2d", 1791, "nn.functional.pad"),
+    ("nn.CTCLoss", 1789, "nn.functional.ctc_loss"),
+    ("nn.AdaptiveMaxPool1d", 1713, "nn.functional.adaptive_max_pool1d"),
+    ("nn.AdaptiveLogSoftmaxWithLoss", 1665, None),
+    ("nn.Bilinear", 1664, "nn.functional.bilinear"),
+    ("nn.RNNCell", 1653, None),
+    ("nn.MultiLabelSoftMarginLoss", 1624, "nn.functional.multilabel_soft_margin_loss"),
+    ("nn.Unfold", 1452, "nn.functional.unfold"),
+    ("nn.RReLU", 1431, "nn.functional.rrelu"),
+    ("nn.CosineEmbeddingLoss", 1357, "nn.functional.cosine_embedding_loss"),
+    ("nn.LocalResponseNorm", 1331, "nn.functional.local_response_norm"),
+    ("nn.Softmax2d", 1300, "nn.functional.softmax"),
+    ("nn.PairwiseDistance", 1241, "nn.functional.pairwise_distance"),
+    ("nn.LogSigmoid", 1235, "nn.functional.logsigmoid"),
+    ("nn.TripletMarginLoss", 1230, "nn.functional.triplet_margin_loss"),
+    ("nn.RNNBase", 1133, None),
+    ("nn.Threshold", 1043, "nn.functional.threshold"),
+    ("nn.AdaptiveMaxPool3d", 1025, "nn.functional.adaptive_max_pool3d"),
+    ("nn.CELU", 1018, "nn.functional.celu"),
+    ("nn.NLLLoss2d", 966, "nn.functional.nll_loss"),
+    ("nn.Softsign", 877, "nn.functional.softsign"),
+    ("nn.ReplicationPad1d", 862, "nn.functional.pad"),
+    ("nn.SoftMarginLoss", 856, "nn.functional.soft_margin_loss"),
+    ("nn.ParameterDict", 742, None),
+    ("nn.ReflectionPad1d", 731, "nn.functional.pad"),
+    ("nn.Softshrink", 713, "nn.functional.softshrink"),
+    ("nn.AlphaDropout", 710, "nn.functional.alpha_dropout"),
+    ("nn.Tanhshrink", 681, "nn.functional.tanhshrink"),
+    ("nn.PoissonNLLLoss", 676, "nn.functional.poisson_nll_loss"),
+    ("nn.MaxUnpool3d", 660, "nn.functional.max_unpool3d"),
+    ("nn.Fold", 630, "nn.functional.fold"),
+    ("nn.MultiMarginLoss", 622, "nn.functional.multi_margin_loss"),
+    ("nn.TransformerDecoderLayer", 614, None),
+    ("nn.TransformerDecoder", 607, None),
+    ("nn.Hardshrink", 592, "nn.functional.hardshrink"),
+    ("nn.ConstantPad3d", 582, "nn.functional.pad"),
+    ("nn.MultiLabelMarginLoss", 580, "nn.functional.multilabel_margin_loss"),
+    ("nn.LPPool2d", 550, "nn.functional.lp_pool2d"),
+    ("nn.Softmin", 537, "nn.functional.softmin"),
+    ("nn.MaxUnpool1d", 518, "nn.functional.max_unpool1d"),
+    ("nn.FractionalMaxPool2d", 484, "nn.functional.fractional_max_pool2d"),
+    ("nn.Hardsigmoid", 477, "nn.functional.hardsigmoid"),
+    ("nn.ReplicationPad3d", 470, "nn.functional.pad"),
+    ("nn.HingeEmbeddingLoss", 442, "nn.functional.hinge_embedding_loss"),
+    ("nn.LPPool1d", 386, "nn.functional.lp_pool1d"),
+    ("nn.FractionalMaxPool3d", 252, "nn.functional.fractional_max_pool3d"),
+    ("nn.Container", 217, None),
+    ("nn.Unflatten", 206, "nn.functional.unflatten"),
+    ("nn.FeatureAlphaDropout", 136, "nn.functional.feature_alpha_dropout"),
+    (
+        "nn.TripletMarginWithDistanceLoss",
+        107,
+        "nn.functional.triplet_margin_with_distance_loss",
+    ),
+    ("nn.ChannelShuffle", 90, "nn.functional.channel_shuffle"),
+    ("nn.RNNCellBase", 88, None),
+    ("nn.LazyLinear", 81, "nn.functional.linear"),
+    ("nn.UninitializedParameter", 60, None),
+    ("nn.CrossMapLRN2d", 59, None),
+    ("nn.GaussianNLLLoss", 55, "nn.functional.gaussian_nll_loss"),
+    ("nn.PixelUnshuffle", 45, "nn.functional.pixel_unshuffle"),
+    ("nn.Mish", 31, "nn.functional.mish"),
+    ("nn.ReflectionPad3d", 22, "nn.functional.pad"),
+    ("nn.HuberLoss", 18, "nn.functional.huber_loss"),
+    ("nn.LazyConv2d", 15, None),
+    ("nn.LazyConv1d", 9, None),
+    ("nn.LazyConv3d", 8, None),
+    ("nn.LazyConvTranspose1d", 8, None),
+    ("nn.LazyConvTranspose2d", 8, None),
+    ("nn.LazyConvTranspose3d", 8, None),
+    ("nn.LazyBatchNorm1d", 3, None),
+    ("nn.LazyBatchNorm2d", 3, None),
+    ("nn.LazyBatchNorm3d", 3, None),
+    ("nn.UninitializedBuffer", 3, None),
+]
+
+# No rankings because these are a little hard to get rankings for
+method_only_ops: list[str] = [
+    "bfloat16",
+    "bool",
+    "byte",
+    "char",
+    "contiguous",
+    "cpu",
+    "cuda",
+    "detach",
+    "double",
+    "expand",
+    "expand_as",
+    "float",
+    "get_device",
+    "half",
+    "hardshrink",
+    "index_add",
+    "index_copy",
+    "index_fill",
+    "index_put",
+    "int",
+    "is_contiguous",
+    "is_pinned",
+    "is_set_to",
+    "is_shared",
+    "is_signed",
+    "item",
+    "long",
+    "masked_scatter",
+    "masked_fill",
+    "narrow_copy",
+    "numpy",
+    "pin_memory",
+    "repeat",
+    "reshape_as",
+    "select",
+    "short",
+    "storage_offset",
+    "sum_to_size",
+    "to",
+    "to_mkldnn",
+    "tolist",
+    "type",
+    "type_as",
+    "unfold",
+    "view",
+    "view_as",
+]
+
+
+def get_nn_functional_top_list() -> list[tuple[str, int]]:
+    top_nn_functional_: dict[str, int] = dict(top_nn_functional)
+    for _, count, functional_name in top_nn_module:
+        if functional_name is None:
+            continue
+        if functional_name == "torch.flatten":
+            continue
+        if functional_name not in top_nn_functional_:
+            top_nn_functional_[functional_name] = count
+        else:
+            top_nn_functional_[functional_name] += count
+
+    top_nn_functional_list = list(top_nn_functional_.items())
+    top_nn_functional_list.sort(key=operator.itemgetter(1), reverse=True)
+    return top_nn_functional_list
+
+
+usage_count: dict[str, int] = dict(get_nn_functional_top_list())
+usage_count.update(top_torch)

.venv/lib/python3.12/site-packages/torch/_functorch/utils.py

@@ -0,0 +1,30 @@
+import contextlib
+from collections.abc import Generator
+
+from torch._C._functorch import (
+    get_single_level_autograd_function_allowed,
+    set_single_level_autograd_function_allowed,
+    unwrap_dead_wrappers,
+)
+from torch.utils._exposed_in import exposed_in
+
+
+__all__ = [
+    "exposed_in",
+    "argnums_t",
+    "enable_single_level_autograd_function",
+    "unwrap_dead_wrappers",
+]
+
+
+@contextlib.contextmanager
+def enable_single_level_autograd_function() -> Generator[None, None, None]:
+    try:
+        prev_state = get_single_level_autograd_function_allowed()
+        set_single_level_autograd_function_allowed(True)
+        yield
+    finally:
+        set_single_level_autograd_function_allowed(prev_state)
+
+
+argnums_t = int | tuple[int, ...]

.venv/lib/python3.12/site-packages/torch/_functorch/vmap.py

@@ -0,0 +1,567 @@
+# 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.
+
+from __future__ import annotations
+
+import contextlib
+import functools
+import itertools
+from collections.abc import Callable  # noqa: TC003
+from functools import partial
+from typing import Any, cast, NoReturn, TYPE_CHECKING
+from typing_extensions import ParamSpec, TypeVar
+
+import torch
+from torch import Tensor
+from torch._C._functorch import is_batchedtensor
+from torch._functorch.predispatch import (
+    _add_batch_dim,
+    _remove_batch_dim,
+    _vmap_decrement_nesting,
+    _vmap_increment_nesting,
+    lazy_load_decompositions,
+)
+from torch.utils._pytree import (
+    _broadcast_to_and_flatten,
+    tree_flatten,
+    tree_map_,
+    tree_unflatten,
+    TreeSpec,
+)
+
+
+if TYPE_CHECKING:
+    from collections.abc import Generator, Iterable
+
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+in_dims_t = int | tuple[Any, ...]
+out_dims_t = int | tuple[int, ...] | None
+
+
+def doesnt_support_saved_tensors_hooks(f: Callable[_P, _R]) -> Callable[_P, _R]:
+    message = (
+        "torch.func.{grad, vjp, jacrev, hessian} don't yet support saved tensor hooks. "
+        "Please open an issue with your use case."
+    )
+
+    @functools.wraps(f)
+    def fn(*args: _P.args, **kwargs: _P.kwargs) -> _R:
+        with torch.autograd.graph.disable_saved_tensors_hooks(message):
+            return f(*args, **kwargs)
+
+    return fn
+
+
+# Checks that all args-to-be-batched have the same batch dim size
+def _validate_and_get_batch_size(
+    flat_in_dims: list[int | None], flat_args: list[Any]
+) -> int:
+    batch_sizes = [
+        arg.size(in_dim)
+        for in_dim, arg in zip(flat_in_dims, flat_args)
+        if in_dim is not None
+    ]
+    if len(batch_sizes) == 0:
+        raise ValueError("vmap: Expected at least one Tensor to vmap over")
+    if batch_sizes and any(size != batch_sizes[0] for size in batch_sizes):
+        raise ValueError(
+            f"vmap: Expected all tensors to have the same size in the mapped "
+            f"dimension, got sizes {batch_sizes} for the mapped dimension"
+        )
+    return batch_sizes[0]
+
+
+def _num_outputs(batched_outputs: Tensor | tuple[Tensor, ...]) -> int:
+    if isinstance(batched_outputs, tuple):
+        return len(batched_outputs)
+    return 1
+
+
+# If value is a tuple, check it has length `num_elements`.
+# If value is not a tuple, make a tuple with `value` repeated `num_elements` times
+
+
+def _as_tuple(
+    value: tuple[_R, ...] | _R,
+    num_elements: int,
+    error_message_lambda: Callable[[], str],
+) -> tuple[_R, ...]:
+    if not isinstance(value, tuple):
+        return (value,) * num_elements
+    if len(value) != num_elements:
+        raise ValueError(error_message_lambda())
+    return value
+
+
+def _process_batched_inputs(
+    in_dims: in_dims_t, args: tuple[Any, ...], func: Callable[..., Any]
+) -> tuple[int, list[int | None], list[Any], TreeSpec]:
+    if not isinstance(in_dims, int) and not isinstance(in_dims, tuple):
+        raise ValueError(
+            f"vmap({_get_name(func)}, in_dims={in_dims}, ...)(<inputs>): "
+            f"expected `in_dims` to be int or a (potentially nested) tuple "
+            f"matching the structure of inputs, got: {type(in_dims)}."
+        )
+    if len(args) == 0:
+        raise ValueError(
+            f"vmap({_get_name(func)})(<inputs>): got no inputs. Maybe you forgot to add "
+            f"inputs, or you are trying to vmap over a function with no inputs. "
+            f"The latter is unsupported."
+        )
+
+    flat_args, args_spec = tree_flatten(args)
+    flat_in_dims = _broadcast_to_and_flatten(in_dims, args_spec)
+    if flat_in_dims is None:
+        raise ValueError(
+            f"vmap({_get_name(func)}, in_dims={in_dims}, ...)(<inputs>): "
+            f"in_dims is not compatible with the structure of `inputs`. "
+            f"in_dims has structure {tree_flatten(in_dims)[1]} but inputs "
+            f"has structure {args_spec}."
+        )
+
+    for i, (arg, in_dim) in enumerate(zip(flat_args, flat_in_dims)):
+        if not isinstance(in_dim, int) and in_dim is not None:
+            raise ValueError(
+                f"vmap({_get_name(func)}, in_dims={in_dims}, ...)(<inputs>): "
+                f"Got in_dim={in_dim} for an input but in_dim must be either "
+                f"an integer dimension or None."
+            )
+        if isinstance(in_dim, int) and not isinstance(arg, Tensor):
+            raise ValueError(
+                f"vmap({_get_name(func)}, in_dims={in_dims}, ...)(<inputs>): "
+                f"Got in_dim={in_dim} for an input but the input is of type "
+                f"{type(arg)}. We cannot vmap over non-Tensor arguments, "
+                f"please use None as the respective in_dim"
+            )
+        if in_dim is not None and (in_dim < -arg.dim() or in_dim >= arg.dim()):
+            raise ValueError(
+                f"vmap({_get_name(func)}, in_dims={in_dims}, ...)(<inputs>): "
+                f"Got in_dim={in_dim} for some input, but that input is a Tensor "
+                f"of dimensionality {arg.dim()} so expected in_dim to satisfy "
+                f"-{arg.dim()} <= in_dim < {arg.dim()}."
+            )
+        if in_dim is not None and in_dim < 0:
+            flat_in_dims[i] = in_dim % arg.dim()
+
+    return (
+        _validate_and_get_batch_size(flat_in_dims, flat_args),
+        flat_in_dims,
+        flat_args,
+        args_spec,
+    )
+
+
+# Creates BatchedTensors for every Tensor in arg that should be batched.
+# Returns the (potentially) batched arguments and the batch_size.
+
+
+# TODO: See if we can explain how flat works to the type checker
+def _create_batched_inputs(
+    flat_in_dims: list[int | None],
+    flat_args: list[Any],
+    vmap_level: int,
+    args_spec: TreeSpec,
+) -> tuple[Any, ...]:
+    # See NOTE [Ignored _remove_batch_dim, _add_batch_dim]
+    batched_inputs = [
+        arg if in_dim is None else _add_batch_dim(arg, in_dim, vmap_level)
+        for in_dim, arg in zip(flat_in_dims, flat_args)
+    ]
+    return tree_unflatten(batched_inputs, args_spec)
+
+
+def _maybe_remove_batch_dim(
+    name: str,
+    batched_output: Any,
+    vmap_level: int,
+    batch_size: int,
+    out_dim: int | None,
+) -> torch.Tensor:
+    if out_dim is None:
+        if isinstance(batched_output, torch.Tensor) and is_batchedtensor(
+            batched_output
+        ):
+            raise ValueError(
+                f"vmap({name}, ...): `{name}` can not return a "
+                f"BatchedTensor when out_dim is None"
+            )
+        return batched_output
+
+    # out_dim is non None
+    if not isinstance(batched_output, torch.Tensor):
+        raise ValueError(
+            f"vmap({name}, ...): `{name}` must only return "
+            f"Tensors, got type {type(batched_output)}. "
+            "Did you mean to set out_dims= to None for output?"
+        )
+
+    return _remove_batch_dim(batched_output, vmap_level, batch_size, out_dim)
+
+
+# Undoes the batching (and any batch dimensions) associated with the `vmap_level`.
+def _unwrap_batched(
+    batched_outputs: Tensor | tuple[Tensor, ...],
+    out_dims: out_dims_t,
+    vmap_level: int,
+    batch_size: int,
+    func: Callable[..., Any],
+) -> tuple[Any, ...]:
+    flat_batched_outputs, output_spec = tree_flatten(batched_outputs)
+
+    def incompatible_error() -> NoReturn:
+        raise ValueError(
+            f"vmap({_get_name(func)}, ..., out_dims={out_dims})(<inputs>): "
+            f"out_dims is not compatible with the structure of `outputs`. "
+            f"out_dims has structure {tree_flatten(out_dims)[1]} but outputs "
+            f"has structure {output_spec}."
+        )
+
+    flat_out_dims: list[int | None] = []
+    if isinstance(batched_outputs, torch.Tensor):
+        # Some weird edge case requires us to spell out the following
+        # see test_out_dims_edge_case
+        if isinstance(out_dims, int):
+            flat_out_dims = [out_dims]
+        elif isinstance(out_dims, tuple) and len(out_dims) == 1:
+            flat_out_dims = list(out_dims)
+        elif out_dims is None:
+            flat_out_dims = [out_dims]
+        else:
+            incompatible_error()
+    else:
+        broadcast_result = _broadcast_to_and_flatten(out_dims, output_spec)
+        if broadcast_result is None:
+            incompatible_error()
+        else:
+            flat_out_dims = broadcast_result
+
+    flat_outputs = [
+        _maybe_remove_batch_dim(
+            _get_name(func), batched_output, vmap_level, batch_size, out_dim
+        )
+        for batched_output, out_dim in zip(flat_batched_outputs, flat_out_dims)
+    ]
+    return tree_unflatten(flat_outputs, output_spec)
+
+
+def _check_int_or_none(x: Any, func: Callable[..., Any], out_dims: out_dims_t) -> None:
+    if isinstance(x, int):
+        return
+    if x is None:
+        return
+    raise ValueError(
+        f"vmap({_get_name(func)}, ..., out_dims={out_dims}): `out_dims` must be "
+        f"an int, None or a python collection of ints representing where in the outputs the "
+        f"vmapped dimension should appear."
+    )
+
+
+def _check_out_dims_is_int_or_int_pytree(
+    out_dims: out_dims_t, func: Callable[..., Any]
+) -> None:
+    if isinstance(out_dims, int):
+        return
+    tree_map_(partial(_check_int_or_none, func=func, out_dims=out_dims), out_dims)
+
+
+def _get_name(func: Callable[..., Any]) -> str:
+    if hasattr(func, "__name__"):
+        return func.__name__
+
+    if isinstance(func, functools.partial):
+        return f"functools.partial({_get_name(func.func)}, ...)"
+
+    # Not all callables have __name__, in fact, only static functions/methods
+    # do.  A callable created via nn.Module, to name one example, doesn't have a
+    # __name__.
+    return repr(func)
+
+
+def vmap_impl(
+    func: Callable[_P, Tensor | tuple[Tensor, ...]],
+    in_dims: in_dims_t,
+    out_dims: out_dims_t,
+    randomness: str,
+    chunk_size: int | None,
+    *args: _P.args,
+    **kwargs: _P.kwargs,
+) -> Any:
+    lazy_load_decompositions()
+    _check_out_dims_is_int_or_int_pytree(out_dims, func)
+    batch_size, flat_in_dims, flat_args, args_spec = _process_batched_inputs(
+        in_dims, args, func
+    )
+
+    if chunk_size is not None:
+        chunks_flat_args = _get_chunked_inputs(
+            flat_args, flat_in_dims, batch_size, chunk_size
+        )
+        return _chunked_vmap(
+            func,
+            flat_in_dims,
+            chunks_flat_args,
+            args_spec,
+            out_dims,
+            randomness,
+            **kwargs,
+        )
+
+    # If chunk_size is not specified.
+    return _flat_vmap(
+        func,
+        batch_size,
+        flat_in_dims,
+        flat_args,
+        args_spec,
+        out_dims,
+        randomness,
+        **kwargs,
+    )
+
+
+def get_chunk_sizes(total_elems: int, chunk_size: int) -> list[int]:
+    n_chunks = total_elems // chunk_size
+    chunk_sizes = [chunk_size] * n_chunks
+    # remainder chunk
+    remainder = total_elems % chunk_size
+    if remainder != 0:
+        chunk_sizes.append(remainder)
+    return chunk_sizes
+
+
+def _get_chunked_inputs(
+    flat_args: list[Any],
+    flat_in_dims: list[int | None],
+    batch_size: int,
+    chunk_size: int | None,
+) -> Iterable[tuple[Any, ...]]:
+    split_idxs = (batch_size,)
+    if chunk_size is not None:
+        chunk_sizes = get_chunk_sizes(batch_size, chunk_size)
+        split_idxs = tuple(itertools.accumulate(chunk_sizes))
+
+    flat_args_chunks = tuple(
+        (
+            t.tensor_split(split_idxs, dim=in_dim)
+            if in_dim is not None
+            else [
+                t,
+            ]
+            * len(split_idxs)
+        )
+        for t, in_dim in zip(flat_args, flat_in_dims)
+    )
+
+    # transpose chunk dim and flatten structure
+    # chunks_flat_args is a list of flatten args
+    chunks_flat_args = zip(*flat_args_chunks)
+    return chunks_flat_args
+
+
+def _flatten_chunks_output(
+    chunks_output_: list[Any],
+) -> tuple[list[tuple[Any, ...]], TreeSpec]:
+    # chunks_output is a list of chunked outputs
+    # flatten chunked outputs:
+    flat_chunks_output: list[list[Any]] = []
+    arg_spec: TreeSpec | None = None
+    for output in chunks_output_:
+        flat_output, arg_specs = tree_flatten(output)
+        flat_chunks_output.append(flat_output)
+        if arg_spec is None:
+            arg_spec = arg_specs
+
+    # transpose chunk dim and flatten structure
+    # flat_output_chunks is flat list of chunks
+    flat_output_chunks = list(zip(*flat_chunks_output))
+    if arg_spec is None:
+        raise AssertionError("arg_spec must not be None")
+    return flat_output_chunks, arg_spec
+
+
+def _concat_chunked_outputs(
+    out_dims: out_dims_t,
+    arg_spec: TreeSpec,
+    flat_output_chunks: list[tuple[Any, ...] | None],
+) -> list[Tensor]:
+    # concat chunks on out_dim
+    flat_out_dims = _broadcast_to_and_flatten(out_dims, arg_spec)
+    if flat_out_dims is None:
+        raise AssertionError("flat_out_dims must not be None")
+    if len(flat_out_dims) != len(flat_output_chunks):
+        raise AssertionError(
+            f"len(flat_out_dims)={len(flat_out_dims)} != len(flat_output_chunks)={len(flat_output_chunks)}"
+        )
+    flat_output: list[Tensor] = []
+    for idx, out_dim in enumerate(flat_out_dims):
+        chunk = flat_output_chunks[idx]
+        if chunk is None:
+            raise AssertionError(f"chunk at index {idx} must not be None")
+        flat_output.append(torch.cat(chunk, dim=out_dim))
+        # release tensors
+        flat_output_chunks[idx] = None
+
+    return flat_output
+
+
+# Applies vmap on chunked_input and returns concatenated output over the chunks.
+def _chunked_vmap(
+    func: Callable[_P, Tensor | tuple[Tensor, ...]],
+    flat_in_dims: list[int | None],
+    chunks_flat_args: Iterable[tuple[Any, ...]],
+    args_spec: TreeSpec,
+    out_dims: out_dims_t,
+    randomness: str,
+    **kwargs: Any,
+) -> Any:
+    chunks_output: list[Any] = []
+    rs = torch.get_rng_state() if randomness == "same" else None
+    for flat_args_tuple in chunks_flat_args:
+        flat_args = list(flat_args_tuple)
+        batch_size = _validate_and_get_batch_size(flat_in_dims, flat_args)
+
+        # The way we compute split the input in `_get_chunked_inputs`,
+        # we may get a tensor with `0` batch-size. We skip any computation
+        # in that case.
+        # Eg.
+        # >>> chunk_size = 1
+        # >>> batch_size = 6
+        # >>> t = torch.zeros(batch_size, 1)
+        # >>> t.tensor_split([1, 2, 3, 4, 5, 6])
+        # (tensor([[0.]]), tensor([[0.]]), tensor([[0.]]), tensor([[0.]]),
+        #  tensor([[0.]]), tensor([[0.]]), tensor([], size=(0, 1)))
+        if batch_size == 0:
+            continue
+
+        if rs is not None:
+            torch.set_rng_state(rs)
+        chunks_output.append(
+            _flat_vmap(
+                func,
+                batch_size,
+                flat_in_dims,
+                flat_args,
+                args_spec,
+                out_dims,
+                randomness,
+                **kwargs,
+            )
+        )
+
+    flat_output_chunks, arg_spec = _flatten_chunks_output(chunks_output)
+
+    # chunked output tensors are held by both `flat_output_chunks` and `chunks_output`.
+    # eagerly remove the reference from `chunks_output`.
+    del chunks_output
+
+    # concat chunks on out_dim
+    # Note: We use cast since flat_output_chunks is modified in _concat_chunked_outputs
+    # to set elements to None after processing
+    flat_output = _concat_chunked_outputs(
+        out_dims, arg_spec, cast(list[tuple[Any, ...] | None], flat_output_chunks)
+    )
+
+    # finally unflatten the output
+    return tree_unflatten(flat_output, arg_spec)
+
+
+# Vmap refactored helper functions:
+def _check_randomness_arg(randomness: str) -> None:
+    if randomness not in ["error", "different", "same"]:
+        raise RuntimeError(
+            f"Only allowed values for randomness are 'error', 'different', or 'same'. Got {randomness}"
+        )
+
+
+@contextlib.contextmanager
+def vmap_increment_nesting(
+    batch_size: int, randomness: str
+) -> Generator[int, None, None]:
+    try:
+        vmap_level = _vmap_increment_nesting(batch_size, randomness)
+        yield vmap_level
+    finally:
+        _vmap_decrement_nesting()
+
+
+def _flat_vmap(
+    func: Callable[..., Tensor | tuple[Tensor, ...]],
+    batch_size: int,
+    flat_in_dims: list[int | None],
+    flat_args: list[Any],
+    args_spec: TreeSpec,
+    out_dims: out_dims_t,
+    randomness: str,
+    **kwargs: Any,
+) -> Any:
+    with vmap_increment_nesting(batch_size, randomness) as vmap_level:
+        batched_inputs = _create_batched_inputs(
+            flat_in_dims, flat_args, vmap_level, args_spec
+        )
+        batched_outputs = func(*batched_inputs, **kwargs)
+        return _unwrap_batched(batched_outputs, out_dims, vmap_level, batch_size, func)
+
+
+# `restore_vmap` is a private helper function. It is vmap but has the following
+# differences:
+# - instead of returning outputs, it returns an (outputs, out_dims) tuple.
+#   out_dims is a pytree of same shape as outputs and contains Optional[int]
+#   specifying where the vmapped dimension, if it exists, is in the corresponding output.
+# - does no validation on in_dims or inputs (vmap expects at least one Tensor to be vmapped).
+#   restore_vmap allows for no inputs to have the vmap dimension
+# - does no validation on outputs (vmap expects only Tensor outputs)
+#   restore_vmap allows for return of arbitrary outputs (not just Tensors)
+#
+# The TL;DR is that restore_vmap is more general than vmap and has a slightly
+# different API. The relaxations are so that we can "pause" vmap in the middle
+# of its execution and then "restore" it later (this is what we do in
+# the generate_vmap_rule=True implementation of autograd.Function).
+#
+# restore_vmap can be technically used in the implementation of vmap, but doing
+# that refactor is a bit technically challenging because:
+# - vmap couples the tensor-wrapping code with error checking
+# - vmap's tensor unwrapping code is in C++; we would need to rewrite part of it
+#   in python because it overlaps with unwrap_batched
+def restore_vmap(
+    func: Callable[..., _R], in_dims: in_dims_t, batch_size: int, randomness: str
+) -> Callable[..., tuple[Any, Any]]:
+    def inner(*args: Any, **kwargs: Any) -> tuple[Any, Any]:
+        with vmap_increment_nesting(batch_size, randomness) as vmap_level:
+            batched_inputs = wrap_batched(args, in_dims, vmap_level)
+            batched_outputs = func(*batched_inputs, **kwargs)
+            return unwrap_batched(batched_outputs, vmap_level)
+
+    return inner
+
+
+def wrap_batched(
+    args: tuple[Any, ...], bdims: in_dims_t, level: int
+) -> tuple[Any, ...]:
+    flat_args, spec = tree_flatten(args)
+    flat_bdims = _broadcast_to_and_flatten(bdims, spec)
+    if flat_bdims is None:
+        raise AssertionError("flat_bdims must not be None")
+    result = _create_batched_inputs(flat_bdims, flat_args, level, spec)
+    return result
+
+
+def unwrap_batched(args: Any, level: int) -> tuple[Any, Any]:
+    flat_args, spec = tree_flatten(args)
+    if len(flat_args) == 0:
+        return args, ()
+    result = [
+        (
+            torch._C._functorch._unwrap_batched(arg, level)
+            if isinstance(arg, torch.Tensor)
+            else (arg, None)
+        )
+        for arg in flat_args
+    ]
+    output, bdims = zip(*result)
+    return tree_unflatten(output, spec), tree_unflatten(bdims, spec)

.venv/lib/python3.12/site-packages/torch/_guards.py

@@ -0,0 +1,1610 @@
+from __future__ import annotations
+
+import contextlib
+import dataclasses
+import enum
+import functools
+import logging
+import re
+import sys
+import threading
+import traceback
+import unittest.mock
+import weakref
+from abc import abstractmethod
+from collections import defaultdict
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Any, Generic, NamedTuple, overload, TYPE_CHECKING, TypeVar
+from typing_extensions import dataclass_transform
+
+import torch
+from torch.utils import _pytree as pytree
+from torch.utils._ordered_set import OrderedSet
+from torch.utils._python_dispatch import is_traceable_wrapper_subclass
+from torch.utils._traceback import CapturedTraceback, format_frame
+from torch.utils.weak import WeakTensorKeyDictionary
+
+
+log = logging.getLogger(__name__)
+
+
+if TYPE_CHECKING:
+    import dis
+    from collections.abc import Callable, Generator, Iterator
+    from types import CodeType
+
+    import sympy
+
+    from torch._dynamo.backends.distributed import DDPOptimizerContext
+    from torch._dynamo.codegen import PyCodegen
+    from torch._dynamo.guards import GuardCheckSpec
+    from torch._dynamo.output_graph import CodeOptions
+    from torch._functorch._aot_autograd.schemas import ViewAndMutationMeta
+    from torch._higher_order_ops.invoke_subgraph import NestedCompileRegionOptions
+    from torch._subclasses.fake_tensor import FakeTensorMode
+
+
+"""
+torch._guards is the definitional source of truth for general purpose guard structures.
+
+An important thing to keep in mind here is the preservation of layering. There should be no dynamo notions,
+and no guard installation notions here.
+"""
+
+COMPILE_ID_PATTERN = re.compile(r"^(?P<frame_id>\d+)/(?P<frame_compile_id>\d+)$")
+CA_COMPILE_ID_PATTERN = re.compile(
+    r"^!(?P<compiled_autograd_id>\d+)(?:/(?P<frame_id>\d+)/(?P<frame_compile_id>\d+))?$"
+)
+
+# [Note: Updating CompiledId]
+#
+# CompiledId represents a unique program-level identifier, and we want to keep that
+# property as the codebase evolves. This property is relied on even outside of the pytorch
+# repo, e.g. tlparse or other internal tooling. The in-memory format can be freely changed,
+# as those dependencies only consume the string serialization.
+#
+# The string form should be:
+# 1. Program-level uid: CompileId can uniquely identify a compiled graph.
+# 2. Storage efficient: This object is logged in nearly every entry. We should elide symbols when possible.
+# 3. Compact: The string form is directly displayed by some tools. Special symbols are okay.
+
+
+@dataclass(frozen=True, kw_only=True, slots=True)
+class CompileId:
+    frame_id: int | None
+    # This id is per-frame, and counts how many times we've compiled this
+    # frame.  This could have been a global id but having this be per-frame
+    # gives you a better intuitive sense for how many recompiles have occurred
+    # so far.
+    frame_compile_id: int | None
+
+    # torch.compiling a compiled autograd graph
+    compiled_autograd_id: int | None = None
+
+    # TODO: consider also tracking the recompilation count
+    # See Note: Updating CompileId
+
+    def __str__(self) -> str:
+        # NOTE: Keep this in sync with both from_string and the tlparse repo
+        if self.compiled_autograd_id is not None:
+            if (self.frame_id is None) != (self.frame_compile_id is None):
+                raise AssertionError(
+                    f"frame_id and frame_compile_id must both be None or both be set, "
+                    f"got frame_id={self.frame_id}, frame_compile_id={self.frame_compile_id}"
+                )
+            frame_str = ""
+            if self.frame_id is not None:
+                frame_str = f"/{self.frame_id}/{self.frame_compile_id}"
+
+            return f"!{self.compiled_autograd_id}{frame_str}"
+        else:
+            if self.frame_id is None or self.frame_compile_id is None:
+                raise AssertionError(
+                    f"frame_id and frame_compile_id must not be None, "
+                    f"got frame_id={self.frame_id}, frame_compile_id={self.frame_compile_id}"
+                )
+            return f"{self.frame_id}/{self.frame_compile_id}"
+
+    @classmethod
+    def from_string(cls, compile_id: str | None) -> CompileId | None:
+        """
+        Factory method that creates a CompileId from its string representation.
+        Keep this in sync with the __str__ method.
+        """
+        if compile_id is None:
+            return None
+        try:
+            for pattern in (COMPILE_ID_PATTERN, CA_COMPILE_ID_PATTERN):
+                if match := pattern.match(compile_id):
+                    groups = match.groupdict()
+                    for k, v in groups.items():
+                        if v is not None:
+                            groups[k] = int(v)
+                    return cls(**groups)  # type: ignore[arg-type]
+            else:
+                raise ValueError
+
+        except Exception as e:
+            raise ValueError(f"Invalid compile_id '{compile_id}'") from e
+
+
+class TraceId(NamedTuple):
+    compile_id: CompileId
+    # This starts off as 0, and every time we restart analysis it goes
+    # up by one
+    attempt: int
+
+    def __str__(self) -> str:
+        # Keep this in sync with tlparse repo
+        if self.attempt == 0:
+            return str(self.compile_id)
+        else:
+            return f"{self.compile_id}_{self.attempt}"
+
+
+class GuardSource(enum.Enum):
+    LOCAL = 0
+    GLOBAL = 1
+    LOCAL_SPECIALIZED_NN_MODULE = 2
+    GLOBAL_SPECIALIZED_NN_MODULE = 3
+    CONSTANT = 4
+    RANDOM_VALUE = 5
+    SHAPE_ENV = 6
+    LOCAL_FSDP_MODULE = 7
+    GLOBAL_FSDP_MODULE = 8
+    BACKWARD_STATE = 9
+    EPHEMERAL = 10
+    SYNTHETIC_LOCAL = 11
+    LOCAL_UNSPECIALIZED_NN_MODULE = 12
+    GLOBAL_UNSPECIALIZED_NN_MODULE = 13
+    LOCAL_UNSPECIALIZED_BUILTIN_NN_MODULE = 14
+    GLOBAL_UNSPECIALIZED_BUILTIN_NN_MODULE = 15
+    TEMP_LOCAL = 16
+
+    def is_fsdp_module(self) -> bool:
+        return self in (GuardSource.GLOBAL_FSDP_MODULE, GuardSource.LOCAL_FSDP_MODULE)
+
+    def is_specialized_nn_module(self) -> bool:
+        import torch._dynamo.config as config
+
+        if config._unsafe_skip_fsdp_module_guards:
+            return (
+                self
+                in (
+                    GuardSource.GLOBAL_SPECIALIZED_NN_MODULE,
+                    GuardSource.LOCAL_SPECIALIZED_NN_MODULE,
+                )
+                or self.is_fsdp_module()
+            )
+        return self in (
+            GuardSource.GLOBAL_SPECIALIZED_NN_MODULE,
+            GuardSource.LOCAL_SPECIALIZED_NN_MODULE,
+        )
+
+    def is_unspecialized_nn_module(self) -> bool:
+        return self in (
+            GuardSource.GLOBAL_UNSPECIALIZED_NN_MODULE,
+            GuardSource.LOCAL_UNSPECIALIZED_NN_MODULE,
+            GuardSource.GLOBAL_UNSPECIALIZED_BUILTIN_NN_MODULE,
+            GuardSource.LOCAL_UNSPECIALIZED_BUILTIN_NN_MODULE,
+        )
+
+    def is_unspecialized_builtin_nn_module(self) -> bool:
+        return self in (
+            GuardSource.GLOBAL_UNSPECIALIZED_BUILTIN_NN_MODULE,
+            GuardSource.LOCAL_UNSPECIALIZED_BUILTIN_NN_MODULE,
+        )
+
+    def is_local(self) -> bool:
+        return self in (
+            GuardSource.LOCAL,
+            GuardSource.LOCAL_SPECIALIZED_NN_MODULE,
+            GuardSource.LOCAL_FSDP_MODULE,
+            GuardSource.LOCAL_UNSPECIALIZED_NN_MODULE,
+            GuardSource.LOCAL_UNSPECIALIZED_BUILTIN_NN_MODULE,
+        )
+
+
+"""
+Base class for a "GuardBuilder" role.
+
+The GuardBuilderBase role is to represent a scope within which to build a guard. The name is a little
+confusing, as it's not a builder, but for the sake of avoiding a lot of renames and keeping the original reference
+to torchdynamo's GuardBuilder.
+
+Note: create_fn is invoked with a GuardBuilderBase and a Guard. A GuardBuilder is chosen based
+on GuardSource's select function.
+
+There is value in keeping this GuardBuilderBase empty to keep layering clean.
+"""
+
+
+class GuardBuilderBase:
+    pass
+
+
+@dataclasses.dataclass(frozen=True)
+class SLoc:
+    framework_loc: traceback.FrameSummary | str | None
+    maybe_user_loc: str | None
+
+    def __str__(self) -> str:
+        floc = (
+            self.framework_loc
+            if isinstance(self.framework_loc, str)
+            else ""
+            if self.framework_loc is None
+            else format_frame(self.framework_loc)
+        )
+        if self.maybe_user_loc is not None:
+            return f"{self.maybe_user_loc} ({floc})"
+        else:
+            return f"({floc})"
+
+
+class ShapeGuard(NamedTuple):
+    expr: sympy.logic.boolalg.Boolean
+    sloc: SLoc
+    size_oblivious: bool
+
+
+@dataclasses.dataclass(slots=True)
+class Guard:
+    # originating_source is the source that called the make_guard method to
+    # construct this guard object. The property name specifies what exactly it
+    # is the guard is guarding on.  The meaning of the name is dependent on the
+    # create_fn; you must look at the use-site inside create_fn to know what
+    # name means.
+    #
+    # That being said, although you might think this is just a "name", name is
+    # usually an arbitrary Python expression that will be evaluated with all
+    # globals (and locals, if you create a LOCAL guard) to extract the Python
+    # object that we want to perform guard tests on.  This evaluation
+    # typically happens in GuardBuilder.eval.  In these cases, name is
+    # typically produced by originating_source.name (not to be confused with
+    # GuardSource - the property source).
+    #
+    # Occasionally, name is not a valid Python expression; sometimes
+    # it is meaningless.  Example create_fns that are like this include
+    # GRAD_MODE and SHAPE_ENV.
+    originating_source: Source
+    create_fn: Callable[[GuardBuilderBase, Guard], None]
+
+    # Export only. These values are written to at time of guard check_fn creation.
+    guard_types: list[str] | None = None
+    code_list: list[str] | None = None
+    obj_weakref: object | None = None
+    guarded_class_weakref: weakref.ReferenceType[Any] | None = None
+
+    stack: CapturedTraceback | None = None
+    user_stack: traceback.StackSummary | None = None
+    _hash: int | None = None
+    _unserializable: bool = False
+    _force_dict_keys_match: bool = False
+
+    def __hash__(self) -> int:
+        if self._hash is None:
+            self._hash = hash((self.name, self.source, id(self.create_fn)))
+        return self._hash
+
+    def sort_key(self) -> tuple[bool, int, int, str, int]:
+        # Put the duplicate input guards at the end. The duplicate guards have
+        # two sources while guard.name only considers one source.
+
+        is_duplicate_input = (
+            isinstance(self.create_fn, functools.partial)
+            and self.create_fn.func is torch._dynamo.guards.GuardBuilder.DUPLICATE_INPUT
+        )
+        return (
+            is_duplicate_input,
+            self.source.value if self.source else -1,
+            len(self.name),
+            self.name,
+            self.inner_create_fn().__code__.co_firstlineno,
+        )
+
+    def __lt__(self, other: Guard) -> bool:
+        return self.sort_key() < other.sort_key()
+
+    def inner_create_fn(self) -> Callable[[GuardBuilderBase, Guard], Any]:
+        if isinstance(self.create_fn, functools.partial):
+            return self.create_fn.func
+        else:
+            return self.create_fn
+
+    @property
+    def name(self) -> str:
+        return self.originating_source.name
+
+    @property
+    def source(self) -> GuardSource:
+        return self.originating_source.guard_source
+
+    @staticmethod
+    def weakref_to_str(obj_weakref: object) -> str:
+        """
+        This is a workaround of a Python weakref bug.
+
+        `obj_weakref` is instance returned by `weakref.ref`,
+        `str(obj_weakref)` is buggy if the original obj overrides __getattr__, e.g:
+
+            class MyConfig(dict):
+                def __getattr__(self, x):
+                    return self[x]
+
+            obj = MyConfig(offset=5)
+            obj_weakref = weakref.ref(obj)
+            str(obj_weakref)  # raise error: KeyError: '__name__'
+        """
+        if isinstance(obj_weakref, weakref.ReferenceType):
+            obj = obj_weakref()
+            if obj is not None:
+                return f"<weakref at {hex(id(obj_weakref))}; to '{obj.__class__.__name__}' at {hex(id(obj))}>"
+            else:
+                return f"<weakref at {hex(id(obj_weakref))}; dead>"
+        else:
+            return str(obj_weakref)
+
+    def __repr__(self) -> str:
+        s = f"""
+        {self.source.name.lower() if self.source else ""} {repr(self.name)} {self.inner_create_fn().__name__}
+        {{
+            'guard_types': {self.guard_types},
+            'code': {self.code_list},
+            'obj_weakref': {self.weakref_to_str(self.obj_weakref)}
+            'guarded_class': {self.guarded_class_weakref}
+        }}
+        """
+        return s
+
+    def __str__(self) -> str:
+        output = f"Name: {repr(self.name)}\n"
+        source = self.source.name.lower() if self.source else ""
+        output += f"    Source: {source}\n"
+        output += f"    Create Function: {self.inner_create_fn().__name__}\n"
+        output += f"    Guard Types: {self.guard_types}\n"
+        output += f"    Code List: {self.code_list}\n"
+        output += f"    Object Weakref: {self.weakref_to_str(self.obj_weakref)}\n"
+        output += f"    Guarded Class Weakref: {self.guarded_class_weakref}\n"
+        return output
+
+    def create(self, builder: GuardBuilderBase) -> Any:
+        try:
+            return self.create_fn(builder, self)
+        except Exception:
+            log.exception("Error while creating guard:\n%s", str(self).rstrip())
+            if self.stack:
+                log.error("Created at:\n%s", "".join(self.stack.format()[-4:]).rstrip())
+            raise
+
+    def is_specialized_nn_module(self) -> bool:
+        return self.source.is_specialized_nn_module()
+
+    def is_fsdp_module(self) -> bool:
+        return self.source.is_fsdp_module()
+
+    def is_local(self) -> bool:
+        return self.source.is_local()
+
+    def create_fn_name(self) -> str:
+        if isinstance(self.create_fn, functools.partial):
+            create_fn = self.create_fn.func  # type: ignore[attr-defined]
+        else:
+            create_fn = self.create_fn
+        return create_fn.__name__
+
+    def set_export_info(
+        self,
+        guard_type: str,
+        guarded_class: weakref.ReferenceType[Any] | None,
+        code_list: list[str],
+        obj_weakref: object,
+    ) -> None:
+        if not self.guard_types:
+            self.guard_types = []
+
+        self.guard_types.append(guard_type)
+
+        if self.guarded_class_weakref not in (guarded_class, None):
+            raise AssertionError(
+                f"Guarded class id must be identical, or None, "
+                f"got {self.guarded_class_weakref} vs {guarded_class}"
+            )
+        self.guarded_class_weakref = guarded_class
+
+        if not self.code_list:
+            self.code_list = code_list
+        else:
+            self.code_list.extend(code_list)
+
+        # Some objects are ephemeral, e.g., list[slice(1, 2)]. If we have
+        # multiple guards on the same object, the weakref can die between the
+        # invocation of set_export_info calls. So a dead weakref is also
+        # acceptable.
+        is_valid = (
+            self.obj_weakref in (obj_weakref, None)
+            or callable(self.obj_weakref)
+            and self.obj_weakref() is None
+        )
+        if not is_valid:
+            raise AssertionError(
+                f"Guarded object must be identical, None or ephemeral (dead weakref), "
+                f"got {self.obj_weakref} vs {obj_weakref}"
+            )
+        self.obj_weakref = obj_weakref
+
+
+T = TypeVar("T")
+
+"""
+Parent structure for guard env expressions.
+A GuardEnvExpr can have any subtype.
+Note: All subtypes must be handled exhaustively in
+torch._dynamo.guards._parse_guard_env_guards to avoid a RuntimeError.
+"""
+
+
+@dataclasses.dataclass(frozen=True)
+class GuardEnvExpr:
+    pass
+
+
+"""
+A class representing a pair of duplicate inputs.
+input_pos_a and input_pos_b are input positions we have deduped.
+"""
+
+
+@dataclasses.dataclass(frozen=True)
+class DuplicateInputs(GuardEnvExpr):
+    input_source_a: Source
+    input_source_b: Source
+
+    def __post_init__(self) -> None:
+        if self.input_source_a == self.input_source_b:
+            raise AssertionError(
+                f"input_source_a and input_source_b must be different, "
+                f"got {self.input_source_a}"
+            )
+
+
+"""
+A class representing storage overlap relations among inputs that aliases the same storage.
+
+Given that a set of tensors alias the same storage, this guard checks whether they actually
+have overlapping storages.
+
+While non_overlapping_sources represent input tensors that definitely don't have any storage
+overlapping with any other input, overlapping_sources represent tensors that either:
+
+1. Do overlap some other input tensor
+2. Might not overlap some other input tensor, but we are not sure
+"""
+
+
+@dataclasses.dataclass(frozen=True)
+class StorageOverlap(GuardEnvExpr):
+    overlapping_sources: list[Source]
+    non_overlapping_sources: list[Source]
+
+
+"""
+Checkpointable is an interface for driving state snapshotting, left purposely vague for now.
+
+copy_graphstate() -> T, a somewhat legacy name, is expected to emit a snapshot of any type that
+can also be taken in at restore_graphstate(T) calls.
+
+When to snapshot, is, at the moment, an implementation detail of upstream callers. Checkpointable
+does not provide any guarantees around consistency, idempotency, or safety of calling its APIs, yet.
+
+In the future, it will have a closer coupling to a generic Checkpoint management system.
+"""
+
+
+class Checkpointable(Generic[T]):
+    @abstractmethod
+    def copy_graphstate(self) -> T: ...
+
+    @abstractmethod
+    def restore_graphstate(self, state: T) -> None: ...
+
+
+class GuardsCheckpointState:
+    """
+    The GuardCheckpointState - it is the T of Checkpointable[T] for GuardsContext
+    """
+
+    dynamo_guards: OrderedSet[Guard]
+
+    def __init__(self, dynamo_guards: OrderedSet[Guard]) -> None:
+        self.dynamo_guards = dynamo_guards
+
+    def diff(self, other: GuardsCheckpointState) -> OrderedSet[Guard] | None:
+        """
+        Produces a delta against another GuardsCheckpointState.
+
+        Returns None if no delta is found, otherwise, return an OrderedSet() of mismatched
+        Guard type objects.
+        """
+        r = self.dynamo_guards.difference(other.dynamo_guards)
+        if len(r) == 0:
+            return None
+        return r
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, GuardsCheckpointState):
+            return False
+        return self.diff(other) is None
+
+
+class ModuleContextCheckpointState:
+    nn_modules: dict[str, torch.nn.Module] = {}
+
+    def __init__(self, nn_modules: dict[str, torch.nn.Module]) -> None:
+        self.nn_modules = nn_modules
+
+    def diff(self, other: ModuleContextCheckpointState) -> set[str] | None:
+        """
+        Produces a delta against another ModuleContextCheckpointState.
+
+        Returns None if no delta is found, otherwise, return a set() of mismatched
+        module key names.
+        """
+        r = set(self.nn_modules.keys()).difference(set(other.nn_modules.keys()))
+        if len(r) == 0:
+            return None
+        return r
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ModuleContextCheckpointState):
+            return False
+        return self.diff(other) is None
+
+
+class ModuleContext(Checkpointable[ModuleContextCheckpointState]):
+    def __init__(self) -> None:
+        self.nn_modules: dict[str, Any] = {}
+
+    def copy_graphstate(self) -> ModuleContextCheckpointState:
+        return ModuleContextCheckpointState(dict(self.nn_modules))
+
+    def restore_graphstate(self, state: ModuleContextCheckpointState) -> None:
+        if not isinstance(state, ModuleContextCheckpointState):
+            raise AssertionError(
+                f"expected ModuleContextCheckpointState, got {type(state)}"
+            )
+        self.nn_modules = state.nn_modules
+
+
+class GlobalContextCheckpointState:
+    global_state: dict[str, tuple[Callable, Any]] = {}
+
+    def __init__(self, global_states: dict[str, tuple[Callable, Any]]) -> None:
+        self.global_state = global_states
+
+    def diff(self, other: GlobalContextCheckpointState) -> set[str] | None:
+        """
+        Produces a delta against another GlobalContextCheckpointState.
+
+        Returns None if no delta is found, otherwise, return a set() of mismatched
+        global key names.
+        """
+        r = set(self.global_state.keys()).difference(set(other.global_state.keys()))
+        if len(r) == 0:
+            return None
+        return r
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, GlobalContextCheckpointState):
+            return False
+        return self.diff(other) is None
+
+
+class GlobalContext(Checkpointable[GlobalContextCheckpointState]):
+    """
+    This keeps track of the global torch state during tracing of a function.
+    For example, torch.is_grad_enabled.
+    """
+
+    _supported_global_states = {
+        "grad_enabled",
+        "autocast_enabled",
+        "autocast_cpu_enabled",
+        "autocast_gpu_dtype",
+        "autocast_cpu_dtype",
+        "autocast_cache_enabled",
+    }
+
+    def __init__(self) -> None:
+        self.global_state: dict[str, tuple[Callable, Any]] = {}
+
+    def copy_graphstate(self) -> GlobalContextCheckpointState:
+        return GlobalContextCheckpointState(self.global_state)
+
+    def restore_graphstate(self, state: GlobalContextCheckpointState) -> None:
+        if not isinstance(state, GlobalContextCheckpointState):
+            raise AssertionError(
+                f"expected GlobalContextCheckpointState, got {type(state)}"
+            )
+        self.global_state = state.global_state
+        if not (
+            len(self.global_state) == len(self._supported_global_states)
+            and set(self.global_state.keys()) == self._supported_global_states
+        ):
+            raise AssertionError(
+                f"Global state mismatch: got keys {set(self.global_state.keys())}, "
+                f"expected {self._supported_global_states}"
+            )
+        for func, args in self.global_state.values():
+            func(args)
+
+
+# Like a Set[Guard] but will record the user stack on all guards at the
+# time they were installed at their destination
+class GuardsSet:
+    def __init__(self, inner: OrderedSet[Guard] | None = None) -> None:
+        if inner is None:
+            self.inner: OrderedSet[Guard] = OrderedSet()
+        else:
+            self.inner = inner
+        # Map from source to list of guards with that source. Incrementally
+        # built in `add` method.
+        self.source_to_guards: defaultdict[Source, list[Guard]] = defaultdict(list)
+        for guard in self.inner:
+            self.track_guard_by_source(guard)
+
+    def track_guard_by_source(self, guard: Guard) -> None:
+        source = guard.originating_source
+        self.source_to_guards[source].append(guard)
+
+    def __iter__(self) -> Iterator[Guard]:
+        return iter(self.inner)
+
+    def __len__(self) -> int:
+        return len(self.inner)
+
+    # Subtraction along with bool is typically used to determine the delta of
+    # added guards between checkpoints for higher order ops
+    def __sub__(self, other: GuardsSet) -> GuardsSet:
+        return GuardsSet(self.inner - other.inner)
+
+    def __bool__(self) -> bool:
+        return bool(self.inner)
+
+    def clear(self) -> None:
+        self.inner = OrderedSet()
+        self.source_to_guards = defaultdict(list)
+
+    def add(
+        self, guard: Guard, *, collect_debug_stack: bool = True, skip: int = 0
+    ) -> None:
+        if guard in self.inner:
+            return
+        if collect_debug_stack:
+            if guard.stack is None:
+                guard.stack = CapturedTraceback.extract(skip=1 + skip)
+        if guard.user_stack is None:
+            guard.user_stack = TracingContext.extract_stack()
+        self.inner.add(guard)
+        self.track_guard_by_source(guard)
+
+    def update(self, *others: set[Guard]) -> None:
+        for o in others:
+            for g in o:
+                self.add(g, skip=1)
+
+    def get_guards_for_source(self, source: Source) -> list[Guard]:
+        """Return all guards with the given originating_source."""
+        return list(self.source_to_guards[source])
+
+    def remove_guards_with_source(self, source: Source) -> None:
+        """Delete all guards that contains a given source"""
+        from ._dynamo.source import is_from_source
+
+        self.inner = OrderedSet(
+            g for g in self.inner if not is_from_source(g.originating_source, source)
+        )
+        # Rebuild the index since is_from_source walks the chain, so
+        # multiple source keys may need removal.
+        self.source_to_guards = defaultdict(list)
+        for guard in self.inner:
+            self.track_guard_by_source(guard)
+
+
+"""
+A GuardsContext is a checkpointable representation of all the guards in the current tracing
+context. Its lifecycle is bound 1:1 to the tracing context, and it should never be instantiated
+directly outside of it. For passing around internal state representations of this object,
+prefer to extract them with copy_graphstate to produce a GuardsCheckpointState.
+"""
+
+
+class GuardsContext(Checkpointable[GuardsCheckpointState]):
+    def __init__(self) -> None:
+        self.dynamo_guards: GuardsSet = GuardsSet()
+        self.aotautograd_guards: list[GuardEnvExpr] = []
+        self.skip_install: bool = False
+
+    @contextlib.contextmanager
+    def skip_guard_install(self) -> Generator[None, None, None]:
+        old = self.skip_install
+        self.skip_install = True
+        try:
+            yield
+        finally:
+            self.skip_install = old
+
+    def copy_graphstate(self) -> GuardsCheckpointState:
+        return GuardsCheckpointState(OrderedSet(self.dynamo_guards.inner))
+
+    def restore_graphstate(self, state: GuardsCheckpointState) -> None:
+        # NB: "steals" the passed in state
+        if not isinstance(state, GuardsCheckpointState):
+            raise AssertionError(f"expected GuardsCheckpointState, got {type(state)}")
+        self.dynamo_guards = GuardsSet(state.dynamo_guards)
+
+
+class HopSubgraphCache:
+    @abstractmethod
+    def add_dynamo_installed_submodule(
+        self, fn_code: CodeType, identifier: str
+    ) -> None: ...
+
+    @abstractmethod
+    def get_dynamo_installed_submodules(self, fn_code: CodeType) -> list[str]: ...
+
+    @abstractmethod
+    def add_autograd_key_entry(self, identifier: str, key: Callable) -> None: ...
+
+    @abstractmethod
+    def get_autograd_key_entry(self, identifier: str) -> Callable | None: ...
+
+    @abstractmethod
+    def add_proxy_dispatch_entry(self, identifier: str, key: Callable) -> None: ...
+
+    @abstractmethod
+    def get_proxy_dispatch_entry(self, identifier: str) -> Callable | None: ...
+
+    @abstractmethod
+    def add_functionalize_schema_entry(
+        self, key: object, schema: torch._C.FunctionSchema
+    ) -> None: ...
+
+    @abstractmethod
+    def get_functionalize_schema_entry(
+        self, key: object
+    ) -> torch._C.FunctionSchema | None: ...
+
+    @abstractmethod
+    def add_lazy_bwd_entry(
+        self,
+        identifier: str,
+        tangent_metadata: tuple[object],
+        gmod: torch.fx.GraphModule,
+    ) -> int: ...
+
+    @abstractmethod
+    def get_lazy_bwd_entry(
+        self, identifier: str, tangent_metadata: tuple[object]
+    ) -> tuple[torch.fx.GraphModule | None, int | None]: ...
+
+
+@dataclass
+class InvokeSubgraphReuseEntry:
+    body_name: str
+    body_gmod: torch.fx.GraphModule
+    config: NestedCompileRegionOptions | None
+    subgraph_input_mapping: list[
+        Any
+    ]  # list[LiftedArgOrigin] - defined in invoke_subgraph.py
+    single_tensor_output: bool
+    # Per-output tensor metadata (shape, stride, dtype, device, requires_grad)
+    # cached from the first trace so we can construct fresh FakeTensors on
+    # cache hit without re-running body_gmod.
+    output_metadata: list[
+        tuple[torch.Size, tuple[int, ...], torch.dtype, torch.device, bool]
+    ]
+    # 1-1 mapping to flat_vts: source for each flattened arg/kwarg, or None if
+    # the VT has no source. On cache hit, we build a source replacement mapping
+    # (old arg sources → new arg sources) to rewrite captured variable sources
+    # for the current invocation.
+    arg_sources: list[Source | None]
+    # Number of user-visible outputs (from the function return value).
+    # The graph may have additional outputs from side-effect intermediates;
+    # stamp_out_subgraph uses this to return only the user-visible slice.
+    num_user_outputs: int = 0
+
+
+@dataclass
+class InvokeSubgraphReuseCondition:
+    # Per flattened input VT: (InputTag, metadata).
+    #   (InputTag.TENSOR, TensorMetadata)
+    #   (InputTag.SYMNODE, sym_num — same object implies same symbol)
+    #   (InputTag.CONSTANT, value)
+    #   (InputTag.OBJECT, None)
+    # Tensor metadata is checked here because TENSOR_MATCH guards for
+    # subgraph inputs may already exist before tracing and thus won't
+    # appear in the guard delta.
+    input_checks: list[tuple[Any, object]]  # list[tuple[InputTag, object]]
+
+    # Guards captured during the trace (delta + source-mapped).
+    # Each entry: (source, handler, expected_value, guard)
+    # handler is a pre-resolved GuardCheckSpec from GUARD_VALUE_DISPATCH.
+    guards: list[tuple[Source, GuardCheckSpec, object, Guard]]
+
+    # TreeSpec from pytree.tree_flatten of the (args, kwargs) structure.
+    # On cache hit, we verify the new call has the same treespec.
+    treespec: pytree.TreeSpec | None = None
+
+    # All sources accessed via VariableBuilder during the subgraph trace.
+    # On cache hit, we check if any modified VT's source is a base of one
+    # of these to detect mutations on captured variables.
+    traced_sources: OrderedSet[Source] = dataclasses.field(default_factory=OrderedSet)
+
+
+class InvokeSubgraphCache(HopSubgraphCache):
+    def __init__(self) -> None:
+        self.autograd_cache: dict[str, Callable] = {}
+        self.proxy_dispatch_cache: dict[str, Callable] = {}
+        self.functionalize_schema_cache: dict[object, torch._C.FunctionSchema] = {}
+        self.dynamo_installed_submodules: dict[CodeType, list[str]] = defaultdict(list)
+        self.lazy_bwd_cache: dict[
+            str, dict[tuple[object], tuple[torch.fx.GraphModule, int]]
+        ] = defaultdict(dict)
+        self.effects_cache: dict[
+            str, set
+        ] = {}  # Maps identifier -> set of effect types
+        # fn.__code__ → list of (condition, cache_entry) pairs. Walked linearly
+        # on lookup; first matching condition wins.
+        self.subgraph_reuse_cache: dict[
+            CodeType,
+            list[tuple[InvokeSubgraphReuseCondition, InvokeSubgraphReuseEntry]],
+        ] = defaultdict(list)
+        # fn_code → {hash_key → cache_entry}. Used by user-provided
+        # reuse_hash_fn for O(1) subgraph reuse lookup.
+        self.subgraph_reuse_key_cache: dict[
+            CodeType, dict[int, InvokeSubgraphReuseEntry]
+        ] = defaultdict(dict)
+
+    def add_dynamo_installed_submodule(
+        self, fn_code: CodeType, identifier: str
+    ) -> None:
+        self.dynamo_installed_submodules[fn_code].append(identifier)
+
+    def get_dynamo_installed_submodules(self, fn_code: CodeType) -> list[str]:
+        return self.dynamo_installed_submodules.get(fn_code, [])
+
+    def add_autograd_key_entry(self, identifier: str, key: Callable) -> None:
+        self.autograd_cache[identifier] = key
+
+    def get_autograd_key_entry(self, identifier: str) -> Callable | None:
+        return self.autograd_cache.get(identifier, None)
+
+    def add_proxy_dispatch_entry(self, identifier: str, key: Callable) -> None:
+        self.proxy_dispatch_cache[identifier] = key
+
+    def get_proxy_dispatch_entry(self, identifier: str) -> Callable | None:
+        return self.proxy_dispatch_cache.get(identifier, None)
+
+    def add_functionalize_schema_entry(
+        self, key: object, schema: torch._C.FunctionSchema
+    ) -> None:
+        self.functionalize_schema_cache[key] = schema
+
+    def get_functionalize_schema_entry(
+        self, key: object
+    ) -> torch._C.FunctionSchema | None:
+        return self.functionalize_schema_cache.get(key, None)
+
+    def add_lazy_bwd_entry(
+        self,
+        identifier: str,
+        tangent_metadata: tuple[object],
+        gmod: torch.fx.GraphModule,
+    ) -> int:
+        # Save the number of existing graph modules in the dictionary to get the suffix
+        num_gmods = len(self.lazy_bwd_cache[identifier])
+        self.lazy_bwd_cache[identifier][tangent_metadata] = (gmod, num_gmods)
+        return num_gmods
+
+    def get_lazy_bwd_entry(
+        self, identifier: str, tangent_metadata: tuple[object]
+    ) -> tuple[torch.fx.GraphModule | None, int | None]:
+        if identifier not in self.lazy_bwd_cache:
+            return (None, None)
+
+        return self.lazy_bwd_cache[identifier].get(tangent_metadata, (None, None))
+
+    def add_effects(self, identifier: str, effects: set) -> None:
+        """Store the effect types for a given invoke_subgraph identifier."""
+        if prev_effects := self.effects_cache.get(identifier, None):
+            if effects != prev_effects:
+                raise AssertionError(
+                    "Different number of effects were found for invoke_subgraph "
+                    f"call with identifier {identifier}. \n"
+                    f"Previously we had the following effects: {prev_effects}.\n"
+                    f"But now we have: {effects}."
+                )
+        self.effects_cache[identifier] = effects
+
+    def get_effects(self, identifier: str) -> set | None:
+        """Retrieve the effect types for a given invoke_subgraph identifier."""
+        return self.effects_cache.get(identifier, None)
+
+    def add_reuse_entry(
+        self,
+        fn_code: CodeType,
+        condition: InvokeSubgraphReuseCondition,
+        entry: InvokeSubgraphReuseEntry,
+        max_reuse_entries: int = 8,
+    ) -> None:
+        entries = self.subgraph_reuse_cache[fn_code]
+        if len(entries) >= max_reuse_entries:
+            raise RuntimeError(
+                f"invoke_subgraph: exceeded maximum reuse entries "
+                f"({max_reuse_entries}) for function code {fn_code}. "
+                f"This most likely means a guard keeps failing on every "
+                f"invocation, preventing subgraph reuse. "
+                f"Set TORCH_LOGS='+hierarchical_compile' to identify which "
+                f"guard is failing. If reuse is genuinely not possible and "
+                f"you need more cache entries, increase the limit via the "
+                f"max_reuse_entries argument to nested_compile_region()."
+            )
+        entries.append((condition, entry))
+
+    def find_reuse_entry(
+        self,
+        fn_code: CodeType,
+        evaluator: Callable[
+            [InvokeSubgraphReuseCondition, InvokeSubgraphReuseEntry], bool
+        ],
+    ) -> InvokeSubgraphReuseEntry | None:
+        entries = self.subgraph_reuse_cache.get(fn_code, [])
+        for i, (condition, entry) in enumerate(entries):
+            if evaluator(condition, entry):
+                # MRU: move the hit entry to the front for faster future lookups
+                if i > 0:
+                    entries.insert(0, entries.pop(i))
+                return entry
+        return None
+
+    def find_reuse_entry_by_key(
+        self, fn_code: CodeType, hash_key: int
+    ) -> InvokeSubgraphReuseEntry | None:
+        return self.subgraph_reuse_key_cache.get(fn_code, {}).get(hash_key)
+
+    def add_reuse_entry_by_key(
+        self,
+        fn_code: CodeType,
+        hash_key: int,
+        entry: InvokeSubgraphReuseEntry,
+        max_reuse_entries: int = 8,
+    ) -> None:
+        key_cache = self.subgraph_reuse_key_cache[fn_code]
+        if len(key_cache) >= max_reuse_entries and hash_key not in key_cache:
+            raise RuntimeError(
+                f"invoke_subgraph: exceeded maximum reuse entries "
+                f"({max_reuse_entries}) for function code {fn_code} (hash-key path). "
+                f"Increase the limit via the max_reuse_entries argument to "
+                f"nested_compile_region()."
+            )
+        key_cache[hash_key] = entry
+
+
+class HopDispatchSetCache:
+    def __init__(self) -> None:
+        # Delayed import to avoid circular dependency
+        from torch._higher_order_ops.invoke_subgraph import invoke_subgraph
+
+        self.hop_cache_map = {invoke_subgraph: InvokeSubgraphCache()}
+
+    def get_cache(self, op: torch._ops.HigherOrderOperator) -> HopSubgraphCache | None:
+        if op not in self.hop_cache_map:
+            return None
+        return self.hop_cache_map[op]  # type: ignore[index]
+
+
+class _TLSStorage(threading.local):
+    # Default the hot-path attributes to None per thread so that
+    # TracingContext.try_get() / CompileContext.try_get() -- called on every
+    # torch.compile'd call -- hit a present attribute instead of paying for an
+    # AttributeError raise+catch inside getattr(). Without this, a thread that
+    # never ran compilation itself (e.g. a worker thread executing compiled code
+    # compiled on another thread) takes the slow getattr-miss path on every call.
+    def __init__(self) -> None:
+        self.tracing_context: TracingContext | None = None
+        self.compile_context: CompileContext | None = None
+
+
+_TLS = _TLSStorage()
+
+"""
+TracingContext is the source of truth for all currently accumulated information
+needed to trace. Its lifecycle is kept 1:1 when using TorchDynamo, but other systems
+are open to managing their own TracingContext with that in mind.
+
+The purpose of TracingContext is not to be a dumping ground, or god object, but rather to avoid
+having to plumb complex subsystems across multiple verticals.
+
+Ex: A common example is guard accumulation between dynamo, shape_env, aot_autograd, and inductor.
+Accessing the current tracing context via
+TracingContext.get() allows users to accumulate their own guards for processing, without needing to know how
+to plumb objects back up to where frame interpretation happened.
+
+Note that you can end up with multiple TracingContext for a single compilation
+of a frame, as we reset the TracingContext whenever we restart analysis.
+CompileContext is a more overarching context that encompasses multiple restarts.
+"""
+
+
+class CompileContext:
+    @staticmethod
+    def get() -> CompileContext:
+        if _TLS.compile_context is None:
+            raise AssertionError("compile_context is not set")
+        return _TLS.compile_context
+
+    @staticmethod
+    def try_get() -> CompileContext | None:
+        return getattr(_TLS, "compile_context", None)
+
+    def __init__(self, compile_id: CompileId | None) -> None:
+        if compile_id is not None and not isinstance(compile_id, CompileId):
+            raise AssertionError(
+                f"compile_id must be None or CompileId, got {type(compile_id)}"
+            )
+        self.compile_id: CompileId | None = compile_id
+        self.attempt = 0
+        # Verbose ShapeEnv guards produced.
+        self.shape_env_guards: list[str] = []
+
+    @staticmethod
+    def current_compile_id() -> CompileId | None:
+        self = CompileContext.try_get()
+        if self is None:
+            return None
+        return self.compile_id
+
+    @staticmethod
+    def current_trace_id() -> TraceId | None:
+        self = CompileContext.try_get()
+        if self is None:
+            return None
+        if self.compile_id is None:
+            return None
+        return TraceId(self.compile_id, self.attempt)
+
+
+@dataclass
+class InlinedCodeCache:
+    """Cache for code-object-derived data used during inlining."""
+
+    instructions: list[Any]
+    indexof: dict[Any, int]
+    code_options: CodeOptions
+
+
+class TracingContext:
+    """
+    Provides the currently installed TracingContext, or None.
+
+    Note that it is a staticmethod, and invocations outside of `with tracing()` (see below), are valid but
+    will return None.
+    """
+
+    @staticmethod
+    def try_get() -> TracingContext | None:
+        return getattr(_TLS, "tracing_context", None)
+
+    @staticmethod
+    def get() -> TracingContext:
+        if ctx := TracingContext.try_get():
+            return ctx
+        raise RuntimeError(
+            "TracingContext.get() must be called within an ongoing trace."
+        )
+
+    def __init__(self, fake_mode: FakeTensorMode | None) -> None:
+        self.guards_context = GuardsContext()
+        self.module_context = ModuleContext()
+        self.global_context = GlobalContext()
+        self.previously_inlined_functions: dict[Any, Any] = dict()
+        self.previously_cleaned_instructions: dict[Any, Any] = dict()
+        # Combined cache for inlined code data (instructions, indexof, code_options)
+        self.inlined_code_cache: dict[Any, InlinedCodeCache] = dict()
+        self.fake_mode: FakeTensorMode | None = fake_mode
+        self.frame_summary_stack: list[traceback.FrameSummary] = []
+        # This is morally part of frame_summary_stack, but it is kept separate
+        # for clarity.  As we process a frame, this variable gets updated
+        # to keep track of what line we are in the function.  We make a
+        # function call, this gets cleared and the frame location is pushed
+        # to frame_summary_stack (prepping this variable for the inner frame's
+        # progress)
+        self.loc_in_frame: tuple[str, int, str] | None = None
+        self.loc_in_frame_positions: dis.Positions | None = None
+        # this is only set after aot_autograd
+        self.fw_metadata: ViewAndMutationMeta | None = None
+        # this is only set when the DDPOptimizer is used
+        self.ddp_optimizer_ctx: DDPOptimizerContext | None = None
+        # this is only set after aot_autograd
+        self.aot_graph_name: list[str] | None = None
+        self.params_flat: list[Any] | None = None
+        self.params_flat_unwrap_subclasses: list[Any] | None = None
+        self.params_unwrapped_to_flat_index: list[Any] | None = None
+        # this is for extended return calling convention from backend
+        # compiler to aot_autograd
+        # Per output, what the compiler specified stride of the output is,
+        # or None if no stride is known.  This is always the HINT, it
+        # is never a SymInt (it would be better if it was a SymInt, but
+        # I can't conveniently get this from Inductor atm.  Also, be
+        # careful not to accidentally induce guards on the SymInt if
+        # you ever do change this in aot_autograd.py; you should check
+        # on permutations preferentially.)
+        self.output_strides: list[tuple[int, ...] | None] | None = None
+        # When this is True, whenever we encounter an int in Dynamo tracing,
+        # we will (1) force unspec it and (2) force it as a size-like unbacked
+        # integer.  This is currently used when processing certain lists of
+        # ints that are known to be size-like and may have 0/1 entries that we
+        # must not specialize on.
+        self.force_unspec_int_unbacked_size_like = False
+        # See note [Tensor Fakification and Symbol Caching]
+        self.tensor_to_context = WeakTensorKeyDictionary()
+
+        # If this true, Aot Autograd will return output Fake Tensors with appropriate
+        # meta on the first invocation
+        # see note: [Returning Fake Tensors on First AOT Autograd Call]
+        self.fakify_first_call = False
+        self.hop_dispatch_set_cache = HopDispatchSetCache()
+        # list of code objects for inlined functions
+        self.traced_code: list[CodeType] = []
+        self.cudagraph_annotation: Any = None
+
+    def clear(self) -> None:
+        # Look at the note in output_graph.py in function `save_global_state`
+        # for the context on clearing global context.
+        self.global_context.global_state = {}
+        self.previously_inlined_functions.clear()
+        self.previously_cleaned_instructions.clear()
+        self.inlined_code_cache.clear()
+
+    @staticmethod
+    @contextmanager
+    def patch(**kwargs: Any) -> Generator[None, None, None]:
+        prior = {}
+        ctx = TracingContext.get()
+
+        for key in kwargs:
+            # KeyError on invalid entry
+            prior[key] = getattr(ctx, key)
+        for key, val in kwargs.items():
+            setattr(ctx, key, val)
+        try:
+            yield
+        finally:
+            for key, val in prior.items():
+                setattr(ctx, key, val)
+
+    @staticmethod
+    def extract_stack() -> traceback.StackSummary:
+        self = TracingContext.try_get()
+        if self is None:
+            return traceback.StackSummary()
+        stack = self.frame_summary_stack
+        if self.loc_in_frame is not None:
+            stack = stack + [self._populate_loc_in_frame_summary()]
+        return traceback.StackSummary.from_list(stack)
+
+    def _populate_loc_in_frame_summary(self) -> traceback.FrameSummary:
+        if self.loc_in_frame is None:
+            raise AssertionError("loc_in_frame must not be None")
+        filename, lineno, frame_name = self.loc_in_frame
+        # colno/end_colno kwargs were added to FrameSummary in 3.11
+        kwargs: dict[str, Any] = {}
+        if sys.version_info >= (3, 11) and self.loc_in_frame_positions is not None:
+            kwargs["colno"] = self.loc_in_frame_positions.col_offset
+            kwargs["end_colno"] = self.loc_in_frame_positions.end_col_offset
+        return traceback.FrameSummary(
+            filename,
+            lineno,
+            frame_name,
+            lookup_line=False,
+            **kwargs,
+        )
+
+    # Call this when you want to call into some code that isn't necessarily
+    # associated with the current frame state
+    @staticmethod
+    @contextlib.contextmanager
+    def clear_frame() -> Generator[None, None, None]:
+        tc = TracingContext.get()
+        with (
+            unittest.mock.patch.object(tc, "frame_summary_stack", []),
+            unittest.mock.patch.object(tc, "loc_in_frame", None),
+            unittest.mock.patch.object(tc, "loc_in_frame_positions", None),
+        ):
+            try:
+                yield
+            except Exception as e:
+                # Prevent real_stack from getting attached
+                #
+                # The invariant is that if an Exception as real_stack, we've
+                # appropriately attached a user stack and we no longer need to
+                # attach anything. Because we cannot conveniently interpose
+                # when an exception is thrown, we instead interpose everywhere
+                # we set what the user stack is set (using the context
+                # manager). However, our compiler stack does "tail calls"
+                # (when it calls into user compiler), at which point the
+                # parent exception frames would incorrectly attach an
+                # incorrect frame.
+                #
+                # However, if, somehow, someone raised an exception with this
+                # scope that had a stack (for example, because they are
+                # restoring the user stack state appropriately as they process
+                # node by node), we should respect it. Thus, we cannot
+                # unconditionally set None.
+                if not hasattr(e, "real_stack"):
+                    e.real_stack = None  # type: ignore[attr-defined]
+                raise
+
+    @staticmethod
+    @contextlib.contextmanager
+    def current_frame(
+        frame_summary: traceback.FrameSummary | None,
+    ) -> Generator[None, None, None]:
+        # frame_summary can be None to solely take advantage of real_stack
+        # attachment to thrown exceptions
+        tc = TracingContext.get()
+        if frame_summary is not None:
+            tc.frame_summary_stack.append(frame_summary)
+        old = tc.loc_in_frame
+        old_positions = tc.loc_in_frame_positions
+        tc.loc_in_frame = None
+        tc.loc_in_frame_positions = None
+        try:
+            yield
+        except Exception as e:
+            if not hasattr(e, "real_stack"):
+                e.real_stack = tc.extract_stack()  # type: ignore[attr-defined]
+            raise
+        finally:
+            if frame_summary is not None:
+                tc.frame_summary_stack.pop()
+            tc.loc_in_frame = old
+            tc.loc_in_frame_positions = old_positions
+
+    @staticmethod
+    @contextlib.contextmanager
+    def report_output_strides() -> Generator[
+        list[tuple[int, ...] | None] | None, None, None
+    ]:
+        tc = TracingContext.try_get()
+        if tc is None:
+            yield None
+            return
+        old_output_strides = tc.output_strides
+        tc.output_strides = []
+        try:
+            yield tc.output_strides
+        finally:
+            tc.output_strides = old_output_strides
+
+    @staticmethod
+    def set_current_loc(
+        filename: str,
+        lineno: int,
+        frame_name: str,
+        positions: dis.Positions | None = None,
+    ) -> None:
+        # Save the current location in the frame. Lazily generate the
+        # framesummary.
+        tc = TracingContext.get()
+        tc.loc_in_frame = (filename, lineno, frame_name)
+        tc.loc_in_frame_positions = positions
+
+    @staticmethod
+    def get_traced_code() -> list[CodeType] | None:
+        tc = TracingContext.try_get()
+        if tc is None:
+            return None
+        return tc.traced_code
+
+
+@contextmanager
+def compile_context(
+    context: CompileContext | None,
+) -> Generator[CompileContext | None, None, None]:
+    old_context = getattr(_TLS, "compile_context", None)
+    _TLS.compile_context = context
+    try:
+        yield context
+    finally:
+        _TLS.compile_context = old_context
+
+
+@contextmanager
+def tracing(
+    context: TracingContext | None,
+) -> Generator[TracingContext | None, None, None]:
+    """
+    This function installs the passed in tracing context as a dynamic scoped
+    global variable.
+
+    Calls to TracingContext.get() while not under a `with tracing()` context
+    will return None.
+    """
+    old_context = getattr(_TLS, "tracing_context", None)
+    _TLS.tracing_context = context
+    try:
+        yield context
+    except Exception as e:
+        if not hasattr(e, "real_stack") and context is not None:
+            e.real_stack = context.extract_stack()  # type: ignore[attr-defined]
+        raise
+    finally:
+        if (
+            context is not None
+            and context.fake_mode is not None
+            and context.fake_mode.shape_env is not None
+        ):
+            context.fake_mode.shape_env.cleanup()
+        _TLS.tracing_context = old_context
+
+
+@overload
+def dataclass_with_cached_hash(cls: type[T], **kwargs: Any) -> type[T]: ...
+
+
+@overload
+def dataclass_with_cached_hash(
+    cls: None = None, **kwargs: Any
+) -> Callable[[type[T]], type[T]]: ...
+
+
+@dataclass_transform()
+def dataclass_with_cached_hash(
+    cls: type[T] | None = None, **kwargs: Any
+) -> type[T] | Callable[[type[T]], type[T]]:
+    def wrap(cls_inner: type[T]) -> type[T]:
+        new_cls = dataclasses.dataclass(cls_inner, **kwargs)
+        old_hash = cls_inner.__hash__
+
+        def __hash__(self) -> int:
+            if not hasattr(self, "_hash"):
+                object.__setattr__(self, "_hash", old_hash(self))
+            return self._hash
+
+        def __reduce__(self):
+            # Exclude _hash from pickling to ensure deterministic cache keys.
+            # The _hash is a cached value that can be nondeterministically computed
+            # (e.g., based on id() of objects), so it should not affect pickling.
+            fields = dataclasses.fields(self)
+            field_values = tuple(getattr(self, f.name) for f in fields if f.init)
+            return (self.__class__, field_values)
+
+        new_cls.__hash__ = __hash__
+        new_cls.__reduce__ = __reduce__
+        return new_cls  # type: ignore[return-value]
+
+    if cls is None:
+        return wrap
+
+    return wrap(cls)
+
+
+# Subclasses can be found in torch/_dynamo/source.py
+# TODO(voz): Consider a toplevel torch/_source.py
+@dataclass_with_cached_hash(frozen=True)
+class Source:
+    def is_dict_key(self) -> bool:
+        return False
+
+    def is_ephemeral(self) -> bool:
+        return False
+
+    def reconstruct(self, codegen: PyCodegen) -> None:
+        raise NotImplementedError
+
+    def reconstruct_pycode(self, codegen: PyCodegen) -> str:
+        """
+        Reconstructs the source into a string of Python code. This method should
+        be eventually implemented for all subclasses of Source to achieve full
+        coverage of python wrapper code generation.
+        """
+        raise NotImplementedError
+
+    @functools.cached_property
+    def guard_source(self) -> GuardSource:
+        raise NotImplementedError
+
+    @property
+    def _name_template(self) -> str:
+        """
+        A template for the name of the source. Used to prevent code duplication between
+        `name` and `get_value`.
+
+        For non-ChainedSources, `name` and `get_value` use the returned string directly.
+
+        For ChainedSources, `name` and `get_value` expect the return to be a format string
+        with `{0}` present - `name` and `get_value` will apply different values to this function's
+        returned format string.
+        """
+        raise NotImplementedError
+
+    @functools.cached_property
+    def name(self) -> str:
+        return self._name_template
+
+    def get_value(
+        self,
+        globals: dict[str, Any],
+        locals: dict[str, Any],
+        cache: dict[Source, Any],
+    ) -> Any:
+        if self in cache:
+            return cache[self]
+        value = eval(self._name_template, globals, locals)
+        cache[self] = value
+        return value
+
+    def make_guard(self, fn: Callable[..., Any]) -> Guard:
+        if self.guard_source is GuardSource.CONSTANT:
+            raise NotImplementedError
+        return Guard(self, fn)
+
+    def is_specialized_nn_module(self) -> bool:
+        return self.guard_source.is_specialized_nn_module()
+
+    def subguards_allowed(self) -> bool:
+        """True if you can guard on attributes of this"""
+        return self.guard_source != GuardSource.SYNTHETIC_LOCAL
+
+    def clone(self, transform_fn: Callable[[Source], Source] | None = None) -> Source:
+        # Frozen dataclass, so returning self is effectively a clone.
+        # Subclasses with mutable state should override.
+        if transform_fn is not None:
+            return transform_fn(self)
+        return self
+
+
+# Subclasses can be found in torch/_dynamo/source.py
+@dataclass_with_cached_hash(frozen=True)
+class ChainedSource(Source):
+    base: Source
+
+    def is_dict_key(self) -> bool:
+        # Recurse until you either hit a ConstDictKey or a Source
+        return self.base.is_dict_key()
+
+    def is_ephemeral(self) -> bool:
+        return self.base.is_ephemeral()
+
+    @functools.cached_property
+    def guard_source(self) -> GuardSource:
+        return self.base.guard_source
+
+    def get_base(self) -> Source:
+        current: Source = self
+        while isinstance(current, ChainedSource):
+            current = current.base
+        return current
+
+    @functools.cached_property
+    def name(self) -> str:
+        return self._name_template.format(self.base.name)
+
+    def get_value(
+        self,
+        globals: dict[str, Any],
+        locals: dict[str, Any],
+        cache: dict[Source, Any],
+    ) -> Any:
+        if self in cache:
+            return cache[self]
+        tmpvar = "tmp"
+        counter = 0
+        while tmpvar in locals:
+            tmpvar = f"tmp{counter}"
+            counter += 1
+        locals[tmpvar] = self.base.get_value(globals, locals, cache)
+        value = eval(self._name_template.format(tmpvar), globals, locals)
+        del locals[tmpvar]
+        cache[self] = value
+        return value
+
+    def clone(self, transform_fn: Callable[[Source], Source] | None = None) -> Source:
+        cloned_fields: dict[str, Any] = {"base": self.base.clone(transform_fn)}
+        for f in dataclasses.fields(self):
+            if f.name == "base":
+                continue
+            val = getattr(self, f.name)
+            if isinstance(val, Source):
+                cloned_fields[f.name] = val.clone(transform_fn)
+        result = dataclasses.replace(self, **cloned_fields)
+        if transform_fn is not None:
+            result = transform_fn(result)
+        return result
+
+
+def detect_fake_mode(inputs: Any = None) -> FakeTensorMode | None:
+    """
+    Attempts to "detect" what the current fake mode is.  If there is one ambiently
+    available from TracingContext, we preferentially use that.  Otherwise, we
+    heuristically detect the fake mode via the following sources, in order of
+    priority:
+
+        - Currently active fake mode on stack
+        - Fake mode associated with passed in tensors (inputs does not
+          have to be flattened)
+    """
+    from torch._subclasses.fake_tensor import (
+        FakeTensor,
+        FakeTensorMode,
+        get_plain_tensors,
+        is_fake_tensor,
+        maybe_get_fake_mode,
+    )
+
+    # If TracingContext has a fake_mode, use it authoritatively.
+    # This is the case when Dynamo is driving compilation - any fake tensors
+    # from other modes in the inputs will be refakified by the caller.
+    if context := TracingContext.try_get():
+        fake_mode = context.fake_mode
+        if fake_mode is not None:
+            return fake_mode
+
+    fake_modes = []
+
+    from torch.utils._python_dispatch import _get_current_dispatch_mode_stack
+
+    for i, m in enumerate(reversed(_get_current_dispatch_mode_stack())):
+        if isinstance(m, FakeTensorMode):
+            fake_modes.append((m, "active fake mode", i))
+
+    flat_inputs = pytree.tree_leaves(inputs)
+    for i, flat_input in enumerate(flat_inputs):
+        if is_fake_tensor(flat_input):
+            fake_modes.append((maybe_get_fake_mode(flat_input), "fake tensor input", i))
+        if is_traceable_wrapper_subclass(flat_input):
+            out: list[torch.Tensor | int | torch.SymInt] = []
+            get_plain_tensors(flat_input, out=out)  # type: ignore[arg-type]
+            fake_tensors: list[FakeTensor] = [
+                x
+                for x in out
+                if isinstance(x, FakeTensor)  # noqa: ISINSTANCE_FAKE_TENSOR
+            ]
+            fake_modes.extend(
+                [
+                    (maybe_get_fake_mode(tensor), f"subclass input {i}", ix)
+                    for ix, tensor in enumerate(fake_tensors)
+                ]
+            )
+
+    if fake_modes:
+        fake_mode, desc1, i1 = fake_modes[0]
+        for m, desc2, i2 in fake_modes[1:]:
+            if fake_mode is not m:
+                raise AssertionError(
+                    f"fake mode ({fake_mode}) from {desc1} {i1} doesn't match mode ({m}) from {desc2} {i2}\n\n"
+                    f"fake mode from {desc1} {i1} allocated at:\n{fake_mode.stack}\n"
+                    f"fake mode from {desc2} {i2} allocated at:\n{m.stack}"
+                )
+
+        return fake_mode
+    else:
+        return None
+
+
+def active_fake_mode() -> FakeTensorMode | None:
+    """
+    Inspects the dispatch mode stack for an active fake mode and returns it.
+    Returns None if no fake mode is active.
+    """
+    from torch._subclasses.fake_tensor import FakeTensorMode
+    from torch.utils._python_dispatch import _get_current_dispatch_mode_stack
+
+    for _, m in enumerate(reversed(_get_current_dispatch_mode_stack())):
+        if isinstance(m, FakeTensorMode):
+            return m
+
+    return None

.venv/lib/python3.12/site-packages/torch/_higher_order_ops/__init__.py

@@ -0,0 +1,91 @@
+from torch._higher_order_ops._invoke_quant import (
+    invoke_quant,
+    invoke_quant_packed,
+    InvokeQuant,
+)
+from torch._higher_order_ops.aoti_call_delegate import aoti_call_delegate
+from torch._higher_order_ops.associative_scan import associative_scan
+from torch._higher_order_ops.auto_functionalize import (
+    auto_functionalized,
+    auto_functionalized_v2,
+)
+from torch._higher_order_ops.base_hop import BaseHOP
+from torch._higher_order_ops.cond import cond
+from torch._higher_order_ops.effects import with_effects
+from torch._higher_order_ops.executorch_call_delegate import executorch_call_delegate
+from torch._higher_order_ops.flat_apply import flat_apply
+from torch._higher_order_ops.flex_attention import (
+    flex_attention,
+    flex_attention_backward,
+)
+from torch._higher_order_ops.flex_gemm import flex_gemm
+from torch._higher_order_ops.foreach_map import _foreach_map, foreach_map
+from torch._higher_order_ops.hints_wrap import hints_wrapper
+from torch._higher_order_ops.inline_asm_elementwise import inline_asm_elementwise
+from torch._higher_order_ops.invoke_leaf_function import invoke_leaf_function
+from torch._higher_order_ops.invoke_subgraph import invoke_subgraph
+from torch._higher_order_ops.local_map import local_map_hop
+from torch._higher_order_ops.map import map
+from torch._higher_order_ops.out_dtype import out_dtype
+from torch._higher_order_ops.print import print
+from torch._higher_order_ops.run_const_graph import run_const_graph
+from torch._higher_order_ops.scan import scan
+from torch._higher_order_ops.strict_mode import strict_mode
+from torch._higher_order_ops.switch import switch
+from torch._higher_order_ops.torchbind import call_torchbind
+from torch._higher_order_ops.while_loop import (
+    while_loop,
+    while_loop_stack_output_op as while_loop_stack_output,
+)
+from torch._higher_order_ops.wrap import (
+    dynamo_bypassing_wrapper,
+    inductor_compiled_code,
+    tag_activation_checkpoint,
+    wrap_activation_checkpoint,
+    wrap_with_autocast,
+    wrap_with_set_grad_enabled,
+)
+
+
+__all__ = [
+    "cond",
+    "switch",
+    "while_loop",
+    "invoke_subgraph",
+    "scan",
+    "map",
+    "flex_attention",
+    "flex_attention_backward",
+    "hints_wrapper",
+    "BaseHOP",
+    "flat_apply",
+    "foreach_map",
+    "_foreach_map",
+    "flex_gemm",
+    "with_effects",
+    "tag_activation_checkpoint",
+    "auto_functionalized",
+    "auto_functionalized_v2",
+    "associative_scan",
+    "out_dtype",
+    "executorch_call_delegate",
+    "call_torchbind",
+    "run_const_graph",
+    "InvokeQuant",
+    "invoke_leaf_function",
+    "invoke_quant",
+    "invoke_quant_packed",
+    "wrap_with_set_grad_enabled",
+    "wrap_with_autocast",
+    "wrap_activation_checkpoint",
+    "dynamo_bypassing_wrapper",
+    "strict_mode",
+    "aoti_call_delegate",
+    "map",
+    "while_loop_stack_output",
+    "local_map_hop",
+    "print",
+    "inductor_compiled_code",
+    "inline_asm_elementwise",
+    "register_hook",
+]