Add files using upload-large-folder tool

ckpts/universal/global_step120/zero/12.input_layernorm.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f05b11c06efbb6011e46324aeff91d6969c207cfbb4d3f538988ba16202597d
+size 9372

ckpts/universal/global_step120/zero/12.input_layernorm.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7acaaa34c1c1a2fa21ffeba8bb02a1e5e3c53df61fec46e5e720bc2503086377
+size 9387

ckpts/universal/global_step120/zero/12.input_layernorm.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5440dd1c78e8a135fde05c1aafdfc6ca2addb712ea8ba21ea6775829fec29d71
+size 9293

ckpts/universal/global_step120/zero/14.mlp.dense_4h_to_h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44799c5eca0f7b814a36ada8a2a985441812e58a613f68fbf4a527c11bf0f9da
+size 33555612

ckpts/universal/global_step120/zero/14.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d4ff2ab006f3da15b9bfe65118d2106bd3d58e3948524bd1543866e56ef9957
+size 33555627

ckpts/universal/global_step120/zero/14.mlp.dense_4h_to_h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3108e7a90cec5a3472de3afd1e14002a69023393be351abf71a3efbcd21582c1
+size 33555533

ckpts/universal/global_step120/zero/14.post_attention_layernorm.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b67e13b1af7d8d5c6d522c93188eb1b59b42d6562bc2eb65983c44e8f96a127
+size 9372

ckpts/universal/global_step120/zero/14.post_attention_layernorm.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:22fcdc17c849cd6418aae8ea5104e5c4fa7e7741611e1946c5644b2a5dcfad48
+size 9387

ckpts/universal/global_step120/zero/14.post_attention_layernorm.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:98d25990e3302cd65f6895327519b14c5fceb54e98ba62d0c1bff59dd9a53d10
+size 9293

ckpts/universal/global_step120/zero/19.mlp.dense_h_to_4h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b21979a3ecb173071fbb2f4162e2729cd7d7c076edf8738243484e51c01ee749
+size 33555612

ckpts/universal/global_step120/zero/19.mlp.dense_h_to_4h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc1efd776071f65554aacd4cb630512eab6db181ec866f208bbd1f699d90d303
+size 33555627

ckpts/universal/global_step120/zero/19.mlp.dense_h_to_4h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e436534b1d579979b5dc8db187e435a1fea6fc1713ca7dd5b8e412a90a4723e
+size 33555533

ckpts/universal/global_step120/zero/21.attention.dense.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a6e2d7fd20d792282caae21ed4736b2acfcfa2641a4d52061cd2d59b7818a484
+size 16778396

ckpts/universal/global_step120/zero/23.mlp.dense_4h_to_h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d25a4818c7340186511af210b151ebe56995bd46863faea70e4c5a923fc21386
+size 33555612

ckpts/universal/global_step120/zero/23.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33a92271a223d91e65ca0abe5a87b9b03f404d0a4ab1d8895d05084be74421c6
+size 33555627

ckpts/universal/global_step120/zero/23.mlp.dense_4h_to_h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05c9f973e08ceaedabdf8dc136cfd9579b6dfeca3d437125d515cbd1c91d15cb
+size 33555533

ckpts/universal/global_step120/zero/24.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41200e7c76d1d8d858393328284a376692c2ebdc13db3055a2ce3fa15723c866
+size 33555612

ckpts/universal/global_step120/zero/24.mlp.dense_h_to_4h_swiglu.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f66caeb5b4e74302196d38db5cd119b791be8b6d1811ad3099489c5c9f3b5d46
+size 33555627

ckpts/universal/global_step120/zero/24.mlp.dense_h_to_4h_swiglu.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:82b02754a37e50b45da0958d132c2b74fb1c7d56bbaca856ac59800b72a7194c
+size 33555533

ckpts/universal/global_step120/zero/25.mlp.dense_h_to_4h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b52420175eca60bb5df5d9e84e2bbf745fb9a25a992fe84d0f7eefcd6ad7ae8e
+size 33555612

ckpts/universal/global_step120/zero/25.mlp.dense_h_to_4h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d79a52574022fc5d55a24ca3ba3164f445138534a2203641d17d34fad714a0ef
+size 33555627

ckpts/universal/global_step120/zero/25.mlp.dense_h_to_4h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:acd0074ae34fd37c15d1b698532bdc2101a5d5949484b38a55573c3f7a00f4d9
+size 33555533

ckpts/universal/global_step120/zero/26.post_attention_layernorm.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9acd645cb2197f7697afb3eade5575c1e41c0fd53f2bb5449d04c0a9ebafd8e0
+size 9372

ckpts/universal/global_step120/zero/26.post_attention_layernorm.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56dc8af36b686f4bd61b94bf34ab79073c751c5f1f3939c9b985246c445e4062
+size 9387

ckpts/universal/global_step120/zero/26.post_attention_layernorm.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd2df67d75555ac4678a88f301d379694bbafbb8ee6ffc6a47acc1f43827f063
+size 9293

ckpts/universal/global_step120/zero/8.attention.dense.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9474660312ed211cad82f8dcb9fda0c509688ebc5c56192005f0d55cab49621f
+size 16778396

ckpts/universal/global_step120/zero/8.attention.dense.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:162c890f9519502cdab7a9f1f7a770cbaba48bb56d2baa58bd5b682ba3898fa5
+size 16778411

ckpts/universal/global_step120/zero/8.attention.dense.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60c4e65e4bceb984b2965f7e6cfc0ed6b59369efbe4bc7b9aa2b0ec63aff7506
+size 16778317

ckpts/universal/global_step120/zero/8.mlp.dense_h_to_4h_swiglu.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ea3507607b2c129631b16b1a49d6699d411f01dcc57d598f117e53f4967efb4
+size 33555612

ckpts/universal/global_step120/zero/8.mlp.dense_h_to_4h_swiglu.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2fd36949e611fd74b5fbfcd4f0c6bcd04fd97f37ab3ac449a94827e7e5b2a87e
+size 33555627

ckpts/universal/global_step120/zero/8.mlp.dense_h_to_4h_swiglu.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:846a3b0c05469d767c79a0e0edb03ce465bf10046b8a0651f2f6a366339a0a51
+size 33555533

ckpts/universal/global_step120/zero/9.mlp.dense_4h_to_h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd8e20433c17f091607c9862366643b5085e338b08d0a411b7d94da49e389dd3
+size 33555612

ckpts/universal/global_step120/zero/9.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c877cbf4a06255c7db9d34dc5ec8a425822ad1a94fee46f54ab9e51cca3461e0
+size 33555627

ckpts/universal/global_step120/zero/9.mlp.dense_4h_to_h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d26c26cf100853a6b3cfc71917f8dab485919dc440cdbf2ee3eb6ef9ec634ee2
+size 33555533

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

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

venv/lib/python3.10/site-packages/torch/_export/db/examples/cond_closed_over_variable.py

@@ -0,0 +1,23 @@
+import torch
+
+from torch._export.db.case import export_case
+from functorch.experimental.control_flow import cond
+
+
+@export_case(
+    example_inputs=(torch.tensor(True), torch.ones(3, 2)),
+    tags={"torch.cond", "python.closure"},
+)
+class CondClosedOverVariable(torch.nn.Module):
+    """
+    torch.cond() supports branches closed over arbitrary variables.
+    """
+
+    def forward(self, pred, x):
+        def true_fn(val):
+            return x * 2
+
+        def false_fn(val):
+            return x - 2
+
+        return cond(pred, true_fn, false_fn, [x + 1])

venv/lib/python3.10/site-packages/torch/_export/db/examples/constrain_as_value_example.py

@@ -0,0 +1,30 @@
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.tensor(4), torch.randn(5, 5)),
+    tags={
+        "torch.dynamic-value",
+        "torch.escape-hatch",
+    },
+)
+class ConstrainAsValueExample(torch.nn.Module):
+    """
+    If the value is not known at tracing time, you can provide hint so that we
+    can trace further. Please look at constrain_as_value and constrain_as_size APIs.
+    constrain_as_value is used for values that don't need to be used for constructing
+    tensor.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x, y):
+        a = x.item()
+        torch._constrain_as_value(a, min=0, max=5)
+
+        if a < 6:
+            return y.sin()
+        return y.cos()

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

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

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

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

venv/lib/python3.10/site-packages/torch/_export/db/examples/null_context_manager.py

@@ -0,0 +1,26 @@
+import contextlib
+
+import torch
+
+from torch._export.db.case import export_case
+
+
+@export_case(
+    example_inputs=(torch.ones(3, 2),),
+    tags={"python.context-manager"},
+)
+class NullContextManager(torch.nn.Module):
+    """
+    Null context manager in Python will be traced out.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        """
+        Null context manager in Python will be traced out.
+        """
+        ctx = contextlib.nullcontext()
+        with ctx:
+            return x.sin() + x.cos()

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+from .cond import cond

venv/lib/python3.10/site-packages/torch/_higher_order_ops/auto_functionalize.py

@@ -0,0 +1,261 @@
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import torch
+import torch.utils._pytree as pytree
+from torch import Tensor
+from torch._C import DispatchKey
+from torch._ops import HigherOrderOperator
+from torch._prims_common import clone_preserve_strides
+from torch._subclasses.fake_tensor import FakeTensorMode
+from torch.fx.experimental.proxy_tensor import (
+    disable_proxy_modes_tracing,
+    ProxyTorchDispatchMode,
+    track_tensor_tree,
+)
+
+
+# NOTE: [auto-functionalizing custom ops]
+# Users may wish to torch.compile custom ops that mutate their inputs.
+# torch.compile will automatically support this op without anyone needing
+# to provide a functionalization kernel for it. Here's how.
+#
+# Let's say we have a hypothetical mylib::sin_(Tensor(a!) x) -> ()
+# op. First, when FakeTensor sees this op:
+# - If the schema says it returns nothing, we can generate a trivial
+#   FakeTensor rule for it (that returns nothing).
+# - Otherwise, the user needs to provide a FakeTensor rule (abstract impl)
+#
+# Next, when Python FunctionalTensor sees the op, it will functionalize
+# it by emitting a call to an auto_functionalize(op, ["x"], {"x": ...})
+# HOP and replacing the mutated inputs with corresponding outputs of this HOP.
+# This HOP effectively runs the functional version of the op when
+# called: it clones inputs that will be mutated, runs the op, and
+# then returns (output, Tensors with the new values)
+
+
+class AutoFunctionalized(HigherOrderOperator):
+    """auto_functionalized(_mutable_op, **kwargs)
+
+    This HOP runs a "functional" version of _mutable_op.
+
+    Concretely, it looks at all the arguments that are mutable through
+    _mutable_op's operator schema, clones those kwargs, runs
+    `out = _mutable_op(**kwargs)` with the cloned values, and then returns the
+    operator output concatenated with the cloned values that were mutated.
+
+    We have some restrictions on `_mutable_op`.
+    See `can_auto_functionalize` for the restrictions. We can likely lift
+    many of these if users request it.
+
+    The reason why _mutable_op is prefixed with an
+    underscore is to prevent collisions with kwarg names in **kwargs.
+    """
+
+    def __init__(self):
+        super().__init__("auto_functionalized")
+
+    def __call__(
+        self,
+        _mutable_op: torch._ops.OpOverload,
+        **kwargs: Dict[str, Any],
+    ) -> Tuple[Any, Tuple[Tensor, ...]]:
+        assert can_auto_functionalize(_mutable_op)
+        assert isinstance(kwargs, dict)
+        return super().__call__(_mutable_op, **kwargs)
+
+
+auto_functionalized = AutoFunctionalized()
+
+
+def can_auto_functionalize(op: torch._ops.OperatorBase) -> bool:
+    if not isinstance(op, torch._ops.OpOverload):
+        return False
+
+    if torch._library.utils.is_builtin(op):
+        # We control the built-ins. These may (in rare cases)
+        # do input metadata mutation (which we have banned on custom ops)
+        return False
+    schema = op._schema
+    if not schema.is_mutable:
+        return False
+    schema = op._schema
+
+    for arg in schema.arguments:
+        if arg.alias_info is None:
+            continue
+        if not arg.alias_info.is_write:
+            continue
+        if type(arg.type) is torch.TensorType:
+            continue
+        if (
+            type(arg.type) is torch.OptionalType
+            and type(arg.type.getElementType()) is torch.TensorType
+        ):
+            continue
+        # Not yet supported: other Tensor types. This includes things like
+        # Tensor[], Tensor?[], Tensor[]?.
+        return False
+
+    # The returns must not alias anything
+    for ret in schema.returns:
+        if ret.alias_info is None and type(ret.type) is torch.TensorType:
+            continue
+        # Not yet supported: List[Tensor] return.
+        return False
+    return True
+
+
+@auto_functionalized.py_impl(DispatchKey.CompositeExplicitAutograd)
+def auto_functionalized_dense(
+    _mutable_op: torch._ops.OpOverload,
+    _only_clone_these_tensors: Optional[Tuple[str, ...]] = None,
+    **kwargs: Dict[str, Any],
+) -> Tuple[Any, Tuple[Tensor, ...]]:
+    new_kwargs = dict(**kwargs)
+    result = []
+
+    _mutable_args_names = get_mutable_arg_names(_mutable_op)
+    for name in _mutable_args_names:
+        if (
+            _only_clone_these_tensors is not None
+            and name not in _only_clone_these_tensors
+        ):
+            new_kwargs[name] = kwargs[name]
+        else:
+            new_kwargs[name] = (
+                clone_preserve_strides(kwargs[name])
+                if kwargs[name] is not None
+                else None
+            )
+        result.append(new_kwargs[name])
+    out = _mutable_op(**new_kwargs)
+
+    if isinstance(out, tuple):
+        return (*out, *result)  # type: ignore[return-value]
+    else:
+        return (out, *result)  # type: ignore[return-value]
+
+
+@auto_functionalized.py_impl(FakeTensorMode)
+def auto_functionalized_fake(
+    mode,
+    _mutable_op: torch._ops.OpOverload,
+    **kwargs: Dict[str, Any],
+) -> Tuple[Any, Tuple[Tensor, ...]]:
+    with mode:
+        result = auto_functionalized_dense(_mutable_op, **kwargs)
+        return result
+
+
+@auto_functionalized.py_impl(ProxyTorchDispatchMode)
+def auto_functionalized_proxy(
+    mode,
+    _mutable_op: torch._ops.OpOverload,
+    **kwargs: Dict[str, Any],
+) -> Tuple[Any, Tuple[Tensor, ...]]:
+    if not mode.enable_tracing:
+        return auto_functionalized(_mutable_op, **kwargs)
+
+    with disable_proxy_modes_tracing():
+        out = auto_functionalized(_mutable_op, **kwargs)
+
+    proxy_kwargs = pytree.tree_map(mode.tracer.unwrap_proxy, kwargs)
+    out_proxy = mode.tracer.create_proxy(
+        "call_function",
+        auto_functionalized,
+        (_mutable_op,),
+        proxy_kwargs,
+    )
+    result = track_tensor_tree(out, out_proxy, constant=None, tracer=mode.tracer)
+    return result
+
+
+auto_functionalized.fallthrough(DispatchKey.AutogradCPU)
+auto_functionalized.fallthrough(DispatchKey.AutogradCUDA)
+
+
+def get_mutable_arg_names(op: torch._ops.OpOverload) -> List[str]:
+    """
+    Returns the list of argument names that get mutated according to the
+    schema.
+    """
+    mutable_args_names = [
+        arg.name
+        for arg in op._schema.arguments
+        if arg.alias_info is not None and arg.alias_info.is_write
+    ]
+    return mutable_args_names
+
+
+def do_auto_functionalize(
+    op: torch._ops.OpOverload, args: Tuple[Any, ...], kwargs: Dict[str, Any]
+) -> Any:
+    """Functionalizes a call to op(*args, **kwargs) by emitting a call to
+    `outs = auto_functionalized(op, normalized_kwargs)`
+    and replacing the mutated (args, kwargs) with the corresponding outputs.
+
+    The normalized_kwargs are just the (args, kwargs), but all in kwarg form.
+    This makes handling easier for the auto_functionalized HOP.
+    """
+    from torch._subclasses.functional_tensor import PythonFunctionalizeAPI
+
+    ctx = PythonFunctionalizeAPI()
+
+    # All of the (args, kwargs), but all as kwargs. The names for the
+    # args come from the schema. This makes it easier for us to work with them.
+    normalized_kwargs = {}
+    schema = op._schema
+    for idx, arg in enumerate(schema.arguments):
+        # NB: torch_dispatch kwargs are the args defined as kwarg-only in the schema
+        if arg.name in kwargs:
+            normalized_kwargs[arg.name] = kwargs[arg.name]
+        elif idx < len(args):
+            # if its out of bounds we don't need to do anything
+            # as it means the the optional arg was passed with its default
+            # value
+            normalized_kwargs[arg.name] = args[idx]
+        else:
+            normalized_kwargs[arg.name] = arg.default_value
+
+    unwrapped_kwargs = ctx.unwrap_tensors(normalized_kwargs)  # type: ignore[arg-type]
+    with ctx.redispatch_to_next():
+        unwrapped_outs = auto_functionalized(
+            op, **unwrapped_kwargs  # type: ignore[arg-type]
+        )
+
+    # List of the name of args that get mutated (according to the schema)
+    mutable_args_names = get_mutable_arg_names(op)
+
+    unwrapped_actual_out: Union[Any, Tuple[Any]] = unwrapped_outs[
+        : -len(mutable_args_names)
+    ]
+    unwrapped_mutable_out = unwrapped_outs[-len(mutable_args_names) :]
+
+    if len(op._schema.returns) == 0:
+        assert unwrapped_actual_out[0] is None
+        unwrapped_actual_out = None
+    elif len(op._schema.returns) == 1:
+        assert len(unwrapped_actual_out) == 1
+        unwrapped_actual_out = unwrapped_actual_out[0]
+    else:
+        assert len(unwrapped_actual_out) == len(op._schema.returns)
+
+    for name, unwrapped_out in zip(mutable_args_names, unwrapped_mutable_out):
+        # Can be None if input was `Tensor(a!)?`
+        if unwrapped_out is None:
+            continue
+        assert isinstance(unwrapped_out, torch.Tensor)
+        orig_arg = normalized_kwargs[name]
+        ctx.replace(orig_arg, unwrapped_out)
+        ctx.commit_update(orig_arg)
+        ctx.sync(orig_arg)
+
+    return ctx.wrap_tensors(unwrapped_actual_out)  # type: ignore[arg-type]
+
+
+@auto_functionalized.py_functionalize_impl
+def auto_functionalized_func(ctx, _mutable_op, **kwargs):
+    unwrapped_kwargs = ctx.unwrap_tensors(kwargs)
+    with ctx.redispatch_to_next():
+        result = auto_functionalized(_mutable_op, **unwrapped_kwargs)
+    return ctx.wrap_tensors(result)