[jit] Remove more reference to TorchScript (#10856)

Summary: Remove some occurrences in comments.

Test Plan: None

Reviewers:

Subscribers:

Tasks:

Tags:

### Summary
[PLEASE REMOVE] See [CONTRIBUTING.md's Pull
Requests](https://github.com/pytorch/executorch/blob/main/CONTRIBUTING.md#pull-requests)
for ExecuTorch PR guidelines.

[PLEASE REMOVE] If this PR closes an issue, please add a `Fixes
#<issue-id>` line.

[PLEASE REMOVE] If this PR introduces a fix or feature that should be
the upcoming release notes, please add a "Release notes: <area>" label.
For a list of available release notes labels, check out
[CONTRIBUTING.md's Pull
Requests](https://github.com/pytorch/executorch/blob/main/CONTRIBUTING.md#pull-requests).

### Test plan
[PLEASE REMOVE] How did you test this PR? Please write down any manual
commands you used and note down tests that you have written if
applicable.

Author: larryliu0820

exir/dialects/_ops.py

@@ -100,7 +100,7 @@ def __getattr__(self, op_name):
             parent_packet = getattr(self._op_namespace, op_name)
         except AttributeError as e:
             # Turn this into AttributeError so getattr(obj, key, default)
-            # works (this is called by TorchScript with __origin__)
+            # works
             raise AttributeError(
                 f"'_OpNamespace' '{self._dialect}.{self._name}' object has no attribute '{op_name}'"
             ) from e

exir/serde/TARGETS

@@ -12,7 +12,6 @@ python_library(
         "schema_check.py",
         "serialize.py",
         "union.py",
-        "upgrade.py",
     ],
     deps = [
         "fbsource//third-party/pypi/sympy:sympy",

exir/serde/export_serialize.py

@@ -114,7 +114,6 @@
     "ExportedProgramDeserializer",
 ]
 
-from .upgrade import GraphModuleOpUpgrader
 
 log = logging.getLogger(__name__)
 
@@ -2220,12 +2219,8 @@ def deserialize_module_call_graph(
 
 
 class ExportedProgramDeserializer:
-    def __init__(self, expected_opset_version: Optional[Dict[str, int]] = None):
-        self.expected_opset_version: Dict[str, int] = {}
-        if expected_opset_version:
-            self.expected_opset_version.update(expected_opset_version)
-        if "aten" not in self.expected_opset_version:
-            self.expected_opset_version["aten"] = torch._C._get_max_operator_version()
+    def __init__(self):
+        pass
 
     def deserialize_range_constraints(
         self,
@@ -2278,13 +2273,6 @@ def deserialize(
             symbol_name_to_range,
             res.names_to_symbols,
         )
-        model_opset_version: Optional[Dict[str, int]] = exported_program.opset_version
-        self._validate_model_opset_version(model_opset_version)
-
-        upgrader = GraphModuleOpUpgrader(
-            self.expected_opset_version, model_opset_version
-        )
-
         exported_program = ep.ExportedProgram(
             root=res.graph_module,
             graph=res.graph_module.graph,
@@ -2296,56 +2284,7 @@ def deserialize(
             verifier=load_verifier(exported_program.dialect),
             constants=res.constants,
         )
-        return upgrader.upgrade(exported_program)
-
-    def _validate_model_opset_version(
-        self, model_opset_version: Optional[Dict[str, int]]
-    ):
-        """Compare model_opset_version with expected_opset_version and raise error if we can't resolve the version
-        difference.
-        E.g., model_opset_version = {"aten": 3, "custom": 4}
-        expected_opset_version = {"aten": 4, "custom": 4}
-        This means we can use an upgrader for ATen to reconcile the deserialized model.
-
-        The logic of this method:
-
-        For common op namespaces:
-        1. if model version < expected version, this case can be handled by upgraders.
-        2. if model version > expected version, we need downgraders but not implemented yet.
-        3. if model version == expected version, we don't need extra handling.
-
-        For op namespace only in model_opset_version, we should give a warning because it is missing from
-        expected_opset_version.
-        """
-        if not model_opset_version:
-            raise RuntimeError("Serialized model should have opset version.")
-        common_namespaces = {
-            key for key in model_opset_version if key in self.expected_opset_version
-        }
-        for namespace in common_namespaces:
-            model_version = model_opset_version[namespace]
-            assert isinstance(
-                model_version, int
-            ), f"model_opset_version value should be int, got {model_version}"
-
-            compiler_version = self.expected_opset_version[namespace]
-            assert isinstance(
-                compiler_version, int
-            ), f"expected_opset_version value should be int, got {compiler_version}"
-
-            # TODO(larryliu0820): Add support for upgrader & downgrader
-            if model_version != compiler_version:
-                raise NotImplementedError(
-                    f"Model opset version {model_opset_version} doesn't match to compiler opset version "
-                    f"{self.expected_opset_version}! Upgrader/downgrader is not implemented yet."
-                )
-        for namespace in model_opset_version:
-            if namespace in common_namespaces:
-                continue
-            log.warning(
-                "Compiler doesn't have a version table for op namespace: {ns}. ",
-                extra={"ns": namespace},
-            )
+        return exported_program
 
 
 class EnumEncoder(json.JSONEncoder):
@@ -2435,15 +2374,14 @@ def _dict_to_dataclass(cls, data):
 
 def deserialize(
     artifact: SerializedArtifact,
-    expected_opset_version: Optional[Dict[str, int]] = None,
 ) -> ep.ExportedProgram:
     assert isinstance(artifact.exported_program, bytes)
     exported_program_str = artifact.exported_program.decode("utf-8")
     exported_program_dict = json.loads(exported_program_str)
     serialized_exported_program = _dict_to_dataclass(
         ExportedProgram, exported_program_dict
     )
-    return ExportedProgramDeserializer(expected_opset_version).deserialize(
+    return ExportedProgramDeserializer().deserialize(
         serialized_exported_program,
         artifact.state_dict,
         artifact.constants,

exir/serde/serialize.py

@@ -32,7 +32,7 @@
 from executorch.exir.lowered_backend_module import (
     LoweredBackendModule as ExirLoweredBackendModule,
 )
-from executorch.exir.serde.export_serialize import GraphModuleOpUpgrader, SerializeError
+from executorch.exir.serde.export_serialize import SerializeError
 from executorch.exir.serde.schema import (
     CompileSpec,
     LoweredBackendModule as SerdeLoweredBackendModule,
@@ -617,12 +617,6 @@ def deserialize(
             symbol_name_to_range,
             res.names_to_symbols,
         )
-        model_opset_version: Optional[Dict[str, int]] = exported_program.opset_version
-        self._validate_model_opset_version(model_opset_version)
-
-        upgrader = GraphModuleOpUpgrader(
-            self.expected_opset_version, model_opset_version
-        )
 
         dummy_g = torch.fx.Graph()
         dummy_g.output(())
@@ -656,7 +650,7 @@ def deserialize(
                     node.target,
                     getattr(res.graph_module, node.target),
                 )
-        return upgrader.upgrade(exported_program)
+        return exported_program
 
 
 def serialize(
@@ -683,15 +677,14 @@ def serialize(
 
 def deserialize(
     artifact: export_serialize.SerializedArtifact,
-    expected_opset_version: Optional[Dict[str, int]] = None,
 ) -> ep.ExportedProgram:
     assert isinstance(artifact.exported_program, bytes)
     exported_program_str = artifact.exported_program.decode("utf-8")
     exported_program_dict = json.loads(exported_program_str)
     serialized_exported_program = export_serialize._dict_to_dataclass(
         schema.ExportedProgram, exported_program_dict
     )
-    return ExportedProgramDeserializer(expected_opset_version).deserialize(
+    return ExportedProgramDeserializer().deserialize(
         serialized_exported_program,
         artifact.state_dict,
         artifact.constants,
@@ -735,7 +728,6 @@ def load(
     f: Union[str, os.PathLike[str], io.BytesIO],
     *,
     extra_files: Optional[Dict[str, Any]] = None,
-    expected_opset_version: Optional[Dict[str, int]] = None,
 ) -> ep.ExportedProgram:
     if isinstance(f, (str, os.PathLike)):
         f = os.fspath(str(f))
@@ -796,6 +788,6 @@ def load(
         )
 
         # Deserialize ExportedProgram
-        ep = deserialize(artifact, expected_opset_version)
+        ep = deserialize(artifact)
 
         return ep