replied to comments

Author: alexsu52

nncf/quantization/algorithms/weight_compression/algorithm.py

@@ -212,39 +212,40 @@ def _proportion_str(num_weights_list: List[int], total_num_weights: int, total_n
         return f"{percentage:.0f}% ({len(num_weights_list)} / {total_num_params})"
 
     def _get_bitwidth_distribution_str(
-        self, all_params: List[WeightCompressionParameters], internal_params: List[WeightCompressionParameters]
+        self, all_params: List[WeightCompressionParameters], ratio_defining_params: List[WeightCompressionParameters]
     ) -> str:
         """
         Generates a table that shows the ratio of weights quantized to different number of bits.
 
-        :param all_params: List of information about each weight node.
-        :param internal_params: List of information about weight nodes that are considered for mixed precision.
+        :param all_params: Information about each weight node.
+        :param ratio_defining_params: Information about weights that are used for calculating ratio between primary and
+            backup precisions.
         :return: A string containing the table.
         """
         num_bits_vs_num_weights_map = {}
-        internal_weight_names = set(wp.weight_name for wp in internal_params)
+        ratio_defining_weight_names = set(wp.weight_name for wp in ratio_defining_params)
         for data in all_params:
             num_bits = data.compression_config.num_bits
-            n_total, n_internal = num_bits_vs_num_weights_map.get(num_bits, ([], []))
-            if data.weight_name in internal_weight_names:
-                n_internal.append(data.num_weights)
+            n_total, n_ratio_defining = num_bits_vs_num_weights_map.get(num_bits, ([], []))
+            if data.weight_name in ratio_defining_weight_names:
+                n_ratio_defining.append(data.num_weights)
             n_total.append(data.num_weights)
-            num_bits_vs_num_weights_map[num_bits] = (n_total, n_internal)
+            num_bits_vs_num_weights_map[num_bits] = (n_total, n_ratio_defining)
 
-        num_internal_weights = sum(ws.num_weights for ws in internal_params)
-        num_internal_params = len(internal_params)
+        num_ratio_defining_weights = sum(ws.num_weights for ws in ratio_defining_params)
+        num_ratio_defining_params = len(ratio_defining_params)
         num_total_weights = sum(ws.num_weights for ws in all_params)
         num_params = len(all_params)
         num_bits_vs_num_weights_map = OrderedDict(sorted(num_bits_vs_num_weights_map.items(), reverse=True))
         # Table creation
-        header = ["Num bits (N)", "% all parameters (layers)", "% internal parameters (layers)"]
+        header = ["Num bits (N)", "% all parameters (layers)", "% ratio-defining parameters (layers)"]
         rows = []
-        for bitwidth, (n_total, n_internal) in num_bits_vs_num_weights_map.items():
+        for bitwidth, (n_total, n_ratio_defining) in num_bits_vs_num_weights_map.items():
             rows.append(
                 [
                     bitwidth,
                     self._proportion_str(n_total, num_total_weights, num_params),
-                    self._proportion_str(n_internal, num_internal_weights, num_internal_params),
+                    self._proportion_str(n_ratio_defining, num_ratio_defining_weights, num_ratio_defining_params),
                 ]
             )
 

nncf/quantization/algorithms/weight_compression/backend.py

@@ -96,7 +96,7 @@ def transform_model(
         Applies weight compression transformations to the model.
 
         :param model: Model in which the weights will be compressed according to the weight compression description.
-        :param graph: The graph ssociated with the model.
+        :param graph: The graph associated with the model.
         :param weight_compression_parameters: List of weight compression parameters.
         :return: The transformed model.
         """

nncf/quantization/algorithms/weight_compression/torch_backend.py

@@ -9,7 +9,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict, Iterable, List, Optional, Tuple, Union
+from typing import Iterable, List, Optional, Tuple, Union
 
 import torch
 
@@ -238,9 +238,3 @@ def transform_model(
         transformed_model = PTModelTransformer(model).transform(transformation_layout)
 
         return transformed_model
-
-    @staticmethod
-    def dump_parameters(
-        model: torch.nn.Module, parameters: Dict, algo_name: Optional[str] = "quantization", path: Optional[List] = None
-    ) -> None:
-        pass

tests/torch/test_model_transformer.py

@@ -609,7 +609,8 @@ def _insert_external_op_mocked():
         model = NNCFNetwork(InsertionPointTestModel(), FillerInputInfo([FillerInputElement([1, 1, 10, 10])]))
         if compression_module_registered:
             model.nncf.register_compression_module_type(ExtraCompressionModuleType.EXTERNAL_OP)
-        command = PTSharedFnInsertionCommand(tps, hook_instance, OP_UNIQUE_NAME, priority)
+        unique_name = f"{OP_UNIQUE_NAME}[{';'.join([tp.target_node_name for tp in tps])}]"
+        command = PTSharedFnInsertionCommand(tps, hook_instance, unique_name, priority)
         transformation_layout = PTTransformationLayout()
         transformation_layout.register(command)