comment changes

remove unnecesary print

remove unnecesary FX metatype Registry

pre commit fix

Author: anzr299

nncf/common/graph/operator_metatypes.py

@@ -112,16 +112,17 @@ def wrap(obj: Type[OperatorMetatype]) -> Type[OperatorMetatype]:
                         )
                         raise nncf.InternalError(msg)
                     self._op_name_to_op_meta_dict[name] = obj
-                    if hasattr(obj, "module_to_function_names"):
-                        func_name = [
-                            f"{namespace.value}.{func}"
-                            for namespace, functions in obj.module_to_function_names.items()
-                            if functions
-                            for func in functions
-                        ]
-                        if len(func_name):
-                            for func in func_name:
-                                self._func_name_to_op_meta_dict[func] = obj
+                if hasattr(obj, "module_to_function_names"):
+                    for namespace, function_names in obj.module_to_function_names.items():
+                        for function_name in function_names:
+                            target_function_name = f"{namespace.value}.{function_name}"
+                            if target_function_name in self._func_name_to_op_meta_dict:
+                                msg = (
+                                    "Inconsistent operator metatype registry - single patched "
+                                    f"op name `{target_function_name}` maps to multiple metatypes!"
+                                )
+                                raise nncf.InternalError(msg)
+                            self._func_name_to_op_meta_dict[target_function_name] = obj
             return obj
 
         return wrap

nncf/experimental/torch/fx/nncf_graph_builder.py

@@ -65,22 +65,6 @@ def _get_layer_attributes(
             )
         return None
 
-    def _map_fx_unique_metatypes(node: torch.fx.Node, metatype: om.OperatorMetatype) -> om.OperatorMetatype:
-        """
-        Attempts to retrieve correct subtype for the given node.
-
-        :param node: Given node.
-        :param metatype: Given node metatype.
-        :param model: Target GraphModule instance.
-        :return: Correct FX metatype of the given node if it is exist or the original node metatype otherwise.
-        """
-        if metatype in [om.PTEmbeddingMetatype]:
-            weight_node = node.args[0]
-            if weight_node.op == "get_attr":
-                return om.PTAtenEmbeddingMetatype
-
-        return metatype
-
     @staticmethod
     def get_node_type_and_metatype(node: torch.fx.Node, model: torch.fx.GraphModule) -> Tuple[str, om.OperatorMetatype]:
         """
@@ -121,8 +105,7 @@ def get_node_type_and_metatype(node: torch.fx.Node, model: torch.fx.GraphModule)
             layer_attrs = GraphConverter._get_layer_attributes(node, node_metatype, model)
             node_subtype = node_metatype.determine_subtype(layer_attrs)
             node_metatype = node_subtype or node_metatype
-        if not node_type_name:
-            node_type_name = node_type
+        node_type_name = node_type_name or node_type
         return node_type_name, node_metatype
 
     @staticmethod
@@ -140,7 +123,6 @@ def create_nncf_graph(model: torch.fx.GraphModule) -> PTNNCFGraph:
         const_targets_counter = Counter([node.target for node in model.graph.nodes if node.op == "get_attr"])
         for source_node in model.graph.nodes:
             node_type, node_metatype = GraphConverter.get_node_type_and_metatype(source_node, model)
-            node_metatype = GraphConverter._map_fx_unique_metatypes(source_node, node_metatype)
             is_shared_node = source_node.op in ("get_attr",) and (
                 const_targets_counter[source_node.target] > 1 or len(source_node.users) > 1
             )

nncf/torch/graph/operator_metatypes.py

@@ -28,7 +28,6 @@
 ModuleAttributes = TypeVar("ModuleAttributes", bound=BaseLayerAttributes)
 
 PT_OPERATOR_METATYPES = OperatorMetatypeRegistry("operator_metatypes")
-FX_OPERATOR_METATYPES = OperatorMetatypeRegistry("operator_metatypes")
 
 
 class PTOperatorMetatype(OperatorMetatype):
@@ -962,15 +961,15 @@ class PTModuleEmbeddingMetatype(PTModuleOperatorSubtype):
 @PT_OPERATOR_METATYPES.register()
 class PTEmbeddingMetatype(PTOperatorMetatype):
     name = "EmbeddingOp"
-    module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["embedding"], NamespaceTarget.ATEN: ["embedding"]}
+    module_to_function_names = {NamespaceTarget.TORCH_NN_FUNCTIONAL: ["embedding"]}
     hw_config_names = [HWConfigOpName.EMBEDDING]
     subtypes = [PTModuleEmbeddingMetatype]
     weight_port_ids = [1]
 
 
-@FX_OPERATOR_METATYPES.register()
+@PT_OPERATOR_METATYPES.register()
 class PTAtenEmbeddingMetatype(OperatorMetatype):
-    name = "EmbeddingOp"
+    name = "AtenEmbeddingOp"
     module_to_function_names = {NamespaceTarget.ATEN: ["embedding"]}
     hw_config_names = [HWConfigOpName.EMBEDDING]
     weight_port_ids = [0]