PyPI - mct-nightly - Versions diffs - 2.0.0.20240519.436__tar.gz → 2.0.0.20240520.424__tar.gz - Mend

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 2.0.0.20240519.436
+Version: 2.0.0.20240520.424
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mct-nightly
-Version: 2.0.0.20240519.436
+Version: 2.0.0.20240520.424
 Summary: A Model Compression Toolkit for neural networks
 Home-page: UNKNOWN
 License: UNKNOWN

@@ -27,4 +27,4 @@ from model_compression_toolkit import data_generation
 from model_compression_toolkit import pruning
 from model_compression_toolkit.trainable_infrastructure.keras.load_model import keras_load_quantized_model
-__version__ = "2.0.0.20240519.000436"
+__version__ = "2.0.0.20240520.000424"

@@ -96,6 +96,16 @@ class BaseNode:
         """
         return self.has_activation
+    @property
+    def has_positional_weights(self):
+        """
+        Returns has_positional_weights attribute.
+        Returns: Whether the node has positional weights.
+        """
+        return any(isinstance(key, int) for key in self.weights.keys())
     def is_activation_quantization_enabled(self) -> bool:
         """

@@ -285,7 +285,7 @@ def _bops_utilization(mp_cfg: List[int],
     # Go over all nodes that should be taken into consideration when computing the BOPS utilization.
     bops = []
     for n in graph.get_topo_sorted_nodes():
-        if n.has_kernel_weight_to_quantize(fw_info):
+        if n.has_kernel_weight_to_quantize(fw_info) and not n.has_positional_weights:
             # If node doesn't have weights then its MAC count is 0, and we shouldn't consider it in the BOPS count.
             incoming_edges = graph.incoming_edges(n, sort_by_attr=EDGE_SINK_INDEX)
             if len(incoming_edges) != 1:

@@ -49,11 +49,16 @@ def compute_bias_correction_of_graph(graph: Graph,
         if fw_info.is_kernel_op(n.type):
             kernel_attr = fw_info.get_kernel_op_attributes(n.type)[0]
             if n.is_weights_quantization_enabled(kernel_attr):
-                _compute_bias_correction_per_candidate_qc(n,
-                                                          kernel_attr,
-                                                          fw_info,
-                                                          graph.get_in_stats_collector(n),
-                                                          fw_impl=fw_impl)
+                # Bias correction is not applied to layers with constant inputs.
+                if n.has_positional_weights:
+                    for candidate_qc in n.candidates_quantization_cfg:
+                        candidate_qc.weights_quantization_cfg.weights_bias_correction = False
+                else:
+                    _compute_bias_correction_per_candidate_qc(n,
+                                                              kernel_attr,
+                                                              fw_info,
+                                                              graph.get_in_stats_collector(n),
+                                                              fw_impl=fw_impl)
     return graph

@@ -67,7 +67,8 @@ class ResidualCollapsing(common.BaseSubstitution):
             return graph
         # Check if convolution and residual satisfy the collapsing conditions, otherwise skip substitution
-        if len(graph.get_next_nodes(first_node)) > 1 or len(graph.get_prev_nodes(second_node)) != 2:
+        if (len(graph.get_next_nodes(first_node)) > 1 or len(graph.get_prev_nodes(first_node)) < 1 or
+                len(graph.get_prev_nodes(second_node)) != 2):
             return graph
         # Check if Add is residual connection, otherwise skip substitution

@@ -33,7 +33,8 @@ def node_builder(n: BaseNode) -> Module:
     framework_attr = copy.copy(n.framework_attr)
     node_instance = n.type(**framework_attr)
-    node_instance.load_state_dict({k: torch.tensor(v) for k, v in n.weights.items()}, strict=False)
+    # Positional weights act as inputs to the PyTorch layer, rather than serving as its weights.
+    node_instance.load_state_dict({k: torch.tensor(v) for k, v in n.weights.items() if isinstance(k, str)}, strict=False)
     set_model(node_instance)
     return node_instance

@@ -71,7 +71,7 @@ def _build_input_tensors_list(node: BaseNode,
             input_tensors = node.insert_positional_weights_to_input_list(input_tensors)
         # convert inputs from positional weights (numpy arrays) to tensors. Must handle each element in the
         # list separately, because in FX the tensors are FX objects and fail to_torch_tensor
-        input_tensors = [to_torch_tensor(t) if isinstance(t, np.ndarray) else t
+        input_tensors = [to_torch_tensor(t, numpy_type=t.dtype) if isinstance(t, np.ndarray) else t
                          for t in input_tensors]
     return input_tensors

@@ -138,6 +138,7 @@ def nodes_builder(model: GraphModule,
                 if input_node in consts_dict:
                     used_consts.add(input_node)
                     weights.update({i: consts_dict[input_node]})
                 tensor_meta = input_node.meta
                 if tensor_meta[TYPE] == torch.Tensor:
                     input_shape += [list(tensor_meta[TENSOR_META].shape)]

@@ -38,11 +38,13 @@ def set_model(model: torch.nn.Module, train_mode: bool = False):
     model.to(device)
-def to_torch_tensor(tensor):
+def to_torch_tensor(tensor,
+                    numpy_type=np.float32):
     """
     Convert a Numpy array to a Torch tensor.
     Args:
         tensor: Numpy array.
+        numpy_type: The desired data type for the tensor. Default is np.float32.
     Returns:
         Torch tensor converted from the input Numpy array.
@@ -55,9 +57,9 @@ def to_torch_tensor(tensor):
     elif isinstance(tensor, tuple):
         return (to_torch_tensor(t) for t in tensor)
     elif isinstance(tensor, np.ndarray):
-        return torch.from_numpy(tensor.astype(np.float32)).to(working_device)
+        return torch.from_numpy(tensor.astype(numpy_type)).to(working_device)
     elif isinstance(tensor, (int, float)):
-        return torch.from_numpy(np.array(tensor).astype(np.float32)).to(working_device)
+        return torch.from_numpy(np.array(tensor).astype(numpy_type)).to(working_device)
     else:
         Logger.critical(f'Unsupported type for conversion to Torch.tensor: {type(tensor)}.')

mct-nightly 2.0.0.20240519.436__tar.gz → 2.0.0.20240520.424__tar.gz