Add unlifting pass under private config (#4)

Summary:
X-link: pytorch/pytorch#104897

Pull Request resolved: #4

We wanna do this little by little. For now, I tried only on DissectedPartsModel which needs to use aot_export version.

Differential Revision: D46785735

fbshipit-source-id: fbd661dd25ae9b820192e850937a3dc01551dc13

Author: tugsbayasgalan

backends/test/test_backends.py

@@ -617,17 +617,13 @@ def forward(self, x_raw, h, c):
         orig_res = composite_m(*inputs)
 
         traced = (
-            exir.capture(composite_m, inputs, exir.CaptureConfig(pt2_mode=True))
+            exir.capture(composite_m, inputs)
             .to_edge(exir.EdgeCompileConfig(_check_ir_validity=False))
             .graph_module
         )
 
         program_without_delegates = (
-            exir.capture(
-                composite_m,
-                (input_x, input_h, input_c),
-                exir.CaptureConfig(pt2_mode=True),
-            )
+            exir.capture(CompositeModel(3), inputs)
             .to_edge(exir.EdgeCompileConfig(_check_ir_validity=False))
             .to_executorch(
                 config=exir.ExecutorchBackendConfig(extract_segments=extract_segments),
@@ -732,7 +728,7 @@ def forward(self, x_raw, h, c):
 
         program_without_delegates = (
             exir.capture(
-                composite_m,
+                CompositeModel(3),
                 (input_x, input_h, input_c),
                 exir.CaptureConfig(pt2_mode=True),
             )
@@ -983,7 +979,8 @@ def test_quantized_with_delegate(self) -> None:
             example_inputs,
             exir.CaptureConfig(
                 pt2_mode=True,
-                enable_functionalization=False,
+                enable_aot=True,
+                _unflatten=True,
             ),
         ).to_edge(exir.EdgeCompileConfig(_check_ir_validity=False))
         FileCheck().check_count("quantize_per_tensor.default", 3).check("addmm").run(

exir/__init__.py

@@ -5,9 +5,11 @@
 from collections import namedtuple
 from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Union
+from unittest.mock import patch
 
 import sympy
 import torch
+import torch._export
 from executorch.exir.dynamic_shape import DynamicMemoryPlanningMode
 from executorch.exir.emit import emit_program, EmitterOutput
 from executorch.exir.error import ExportError, ExportErrorType, InternalError
@@ -32,6 +34,7 @@
 from executorch.exir.schema import Program
 from executorch.exir.serialize import serialize_to_flatbuffer
 from executorch.exir.tracer import (
+    _default_decomposition_table,
     dispatch_trace,
     dynamo_trace,
     ExirDynamoConfig,
@@ -48,6 +51,7 @@
 from torch._dynamo.eval_frame import Constraint
 from torch._export import CallSpec, export, ExportGraphSignature
 from torch._export.exported_program import ExportedProgram
+from torch._export.passes import ReplaceViewOpsWithViewCopyOpsPass
 from torch._export.passes.add_runtime_assertions_for_constraints_pass import (
     InputDim,
     RangeConstraint,
@@ -56,12 +60,156 @@
 from torch.fx._compatibility import compatibility
 from torch.fx.experimental.proxy_tensor import make_fx
 from torch.fx.experimental.symbolic_shapes import ShapeEnv
+from torch.fx.graph import _PyTreeCodeGen, _PyTreeInfo
 from torch.utils import _pytree as pytree
 
 
 Val = Any
 
 
+def _unlift(gm, inp_pos_to_param_buffer_name, in_spec, out_spec, state_dict):
+    count = 0
+    # Step 1: make lifted params as get_attr
+    for node in gm.graph.nodes:
+        if node.op == "placeholder":
+            if count in inp_pos_to_param_buffer_name:
+                with gm.graph.inserting_after(node):
+                    getattr_node = gm.graph.get_attr(
+                        inp_pos_to_param_buffer_name[count]
+                    )
+                    node.replace_all_uses_with(getattr_node)
+                    metadata = node.meta
+                    gm.graph.erase_node(node)
+                    getattr_node.meta = metadata
+            count += 1
+
+    # Step 2: Fix the input/output of the graph now that we deleted
+    # some args.
+    gm.graph.lint()
+    names = [f"arg_{i}" for i in range(len(in_spec.children_specs))]
+    gm.graph._codegen = _PyTreeCodeGen(
+        _PyTreeInfo(
+            names,
+            in_spec,
+            out_spec,
+        )
+    )
+    gm.recompile()
+
+    # Step 3: Find state references in HigherOrderOps and recursively
+    # fix them.
+    for node in gm.graph.nodes:
+        if node.op == "call_function" and node.target == torch.ops.cond:
+            pred, true_graph, false_graph, operands = node.args
+            true_gm = getattr(gm, true_graph.name)
+            false_gm = getattr(gm, false_graph.name)
+            inp_pos_to_param_buffer_name_for_submod = {}
+            real_operands = []
+            for ix, operand in enumerate(operands):
+                if operand.target in inp_pos_to_param_buffer_name.values():
+                    inp_pos_to_param_buffer_name_for_submod[ix] = operand.target
+                    true_gm.register_buffer(operand.target, state_dict[operand.target])
+                    false_gm.register_buffer(operand.target, state_dict[operand.target])
+                else:
+                    real_operands.append(operand)
+            node.args = (pred, true_graph, false_graph, real_operands)
+
+            _, in_spec = pytree.tree_flatten(real_operands)
+
+            _unlift(
+                true_gm,
+                inp_pos_to_param_buffer_name_for_submod,
+                in_spec,
+                None,
+                state_dict,
+            )
+            _unlift(
+                false_gm,
+                inp_pos_to_param_buffer_name_for_submod,
+                in_spec,
+                None,
+                state_dict,
+            )
+        if node.op == "call_function" and node.target.__name__ == "map_impl":
+            body_graph, num_mapped, *operands = node.args
+            body_gm = getattr(gm, body_graph.name)
+            inp_pos_to_buffer_name_for_submod = {}
+            real_operands = []
+            for ix, operand in enumerate(operands):
+                if operand.target in inp_pos_to_param_buffer_name.values():
+                    inp_pos_to_buffer_name_for_submod[ix] = operand.target
+                    body_gm.register_buffer(operand.target, state_dict[operand.target])
+                else:
+                    real_operands.append(operand)
+            node.args = (body_graph, num_mapped, *real_operands)
+
+            _, in_spec = pytree.tree_flatten(real_operands)
+
+            _unlift(
+                body_gm, inp_pos_to_buffer_name_for_submod, in_spec, None, state_dict
+            )
+    gm.graph.lint()
+    gm.graph.eliminate_dead_code()
+    gm.recompile()
+    return gm
+
+
+def unlift_exported_program_lifted_states(
+    ep: torch._export.exported_program.ExportedProgram,
+):
+    new_gm = copy.deepcopy(ep.graph_module)
+
+    # TODO Fix the period in params/buffers names later
+    # maybe a pass to replace graph signature with fixed names
+    param_buffer_name_to_corrected_name = {}
+
+    for name, stuff in ep.state_dict.items():
+        if name in ep.graph_signature.buffers:
+            if "." in name:
+                new_gm.register_buffer(name.replace(".", "_"), stuff)
+                param_buffer_name_to_corrected_name[name] = name.replace(".", "_")
+            else:
+                new_gm.register_buffer(name, stuff)
+        elif name in ep.graph_signature.parameters:
+            if "." in name:
+                new_gm.register_parameter(name.replace(".", "_"), stuff)
+                param_buffer_name_to_corrected_name[name] = name.replace(".", "_")
+            else:
+                new_gm.register_parameter(name, stuff)
+        else:
+            raise AssertionError("encountered not registered param/buffer")
+
+    count = 0
+    inp_pos_to_param_buffer_name = {}
+    for node in new_gm.graph.nodes:
+        if node.op == "placeholder":
+            if node.name in ep.graph_signature.inputs_to_buffers:
+                buffer_name = ep.graph_signature.inputs_to_buffers[node.name]
+                if buffer_name in param_buffer_name_to_corrected_name:
+                    inp_pos_to_param_buffer_name[
+                        count
+                    ] = param_buffer_name_to_corrected_name[buffer_name]
+                else:
+                    inp_pos_to_param_buffer_name[count] = buffer_name
+            if node.name in ep.graph_signature.inputs_to_parameters:
+                param_name = ep.graph_signature.inputs_to_parameters[node.name]
+                if param_name in param_buffer_name_to_corrected_name:
+                    inp_pos_to_param_buffer_name[
+                        count
+                    ] = param_buffer_name_to_corrected_name[param_name]
+                else:
+                    inp_pos_to_param_buffer_name[count] = param_name
+            count += 1
+    new_gm = _unlift(
+        new_gm,
+        inp_pos_to_param_buffer_name,
+        ep.call_spec.in_spec,
+        ep.call_spec.out_spec,
+        ep.state_dict,
+    )
+    return new_gm
+
+
 @compatibility(is_backward_compatible=False)
 @dataclass
 class CaptureConfig:
@@ -70,6 +218,7 @@ class CaptureConfig:
     enable_dynamic_shape: bool = False
     enable_aot: bool = False
     _dynamo_config: "ExirDynamoConfig" = ExirDynamoConfig()
+    _unflatten: bool = False
 
 
 @compatibility(is_backward_compatible=False)
@@ -469,8 +618,15 @@ def capture(
                     "Functionalization is required for enable_aot.",
                 )
 
-            ep = export(f, args, _add_runtime_assertions=False, constraints=constraints)
-            return ep  # pyre-ignore
+            # TODO remove this later
+            with patch("torch._export.DECOMP_TABLE", _default_decomposition_table()):
+                ep = export(
+                    f, args, _add_runtime_assertions=False, constraints=constraints
+                )
+            ep = ep.transform(ReplaceViewOpsWithViewCopyOpsPass())
+            if not config._unflatten:
+                return ep  # pyre-ignore
+            graph_module = unlift_exported_program_lifted_states(ep)
 
         elif config.enable_dynamic_shape:
             if not config._dynamo_config.dynamic_shapes:

exir/tests/test_quant_lowering_custom_backend_pass.py

@@ -645,11 +645,7 @@ def test_quantized_linear_dynamic(self) -> None:
         )
 
         # Step 2: EXIR capturing
-        dynamo_config = ExirDynamoConfig(
-            dynamic_shapes=False,
-        )
-
-        capture_config = CaptureConfig(pt2_mode=True, _dynamo_config=dynamo_config)
+        capture_config = CaptureConfig(pt2_mode=True, enable_aot=True, _unflatten=True)
         captured_mod = (
             exir.capture(converted_mod, example_inputs, config=capture_config)
             .to_edge(exir.EdgeCompileConfig(_check_ir_validity=False))
@@ -780,11 +776,7 @@ def test_quantized_linear_dynamic_symmetric_act_per_channel_weight(self) -> None
         print("converted:", converted_mod)
 
         # Step 2: EXIR capturing
-        dynamo_config = ExirDynamoConfig(
-            dynamic_shapes=False,
-        )
-
-        capture_config = CaptureConfig(pt2_mode=True, _dynamo_config=dynamo_config)
+        capture_config = CaptureConfig(pt2_mode=True, enable_aot=True, _unflatten=True)
         captured_mod = exir.capture(
             converted_mod, example_inputs, config=capture_config
         ).to_edge(exir.EdgeCompileConfig(_check_ir_validity=False))
@@ -842,10 +834,7 @@ def test_quantized_linear_dynamic_symmetric_act_per_tensor_weight(self) -> None:
         print("converted:", converted_mod)
 
         # Step 2: EXIR capturing
-        dynamo_config = ExirDynamoConfig(
-            dynamic_shapes=False,
-        )
-        capture_config = CaptureConfig(pt2_mode=True, _dynamo_config=dynamo_config)
+        capture_config = CaptureConfig(pt2_mode=True, enable_aot=True, _unflatten=True)
         captured_mod = exir.capture(
             converted_mod, example_inputs, config=capture_config
         ).to_edge(exir.EdgeCompileConfig(_check_ir_validity=False))