mct-nightly 1.1.0.7012022.post2611__py3-none-any.whl → 1.1.0.07122021-002414__py3-none-any.whl

model_compression_toolkit/common/network_editors/actions.py

@@ -16,8 +16,7 @@
 from abc import ABC, abstractmethod
 from collections import namedtuple
 
-from model_compression_toolkit.common.graph.base_node import BaseNode
-from model_compression_toolkit.common.quantization import quantization_params_generation
+from model_compression_toolkit.common.graph.node import Node
 from model_compression_toolkit.common.quantization.quantization_params_fn_selection import \
     get_activation_quantization_params_fn, get_weights_quantization_params_fn
 
@@ -51,7 +50,7 @@ class BaseAction(ABC):
     """
 
     @abstractmethod
-    def apply(self, node: BaseNode, graph, fw_info):
+    def apply(self, node: Node, graph, fw_info):
         """
         Apply an action on the node after matching the node with a node filter.
 
@@ -82,7 +81,7 @@ class ChangeCandidatesWeightsQuantConfigAttr(BaseAction):
         """
         self.kwargs = kwargs
 
-    def apply(self, node: BaseNode, graph, fw_info):
+    def apply(self, node: Node, graph, fw_info):
         """
         Change the attribute 'attr_name' in quant_config with 'attr_value'.
 
@@ -94,9 +93,10 @@ class ChangeCandidatesWeightsQuantConfigAttr(BaseAction):
         Returns:
             The node after its quant_config has been modified.
         """
-        for nqc in node.candidates_weights_quantization_cfg:
-            for attr_name, attr_value in self.kwargs.items():
-                nqc.set_quant_config_attr(attr_name, attr_value)
+        if node.candidates_weights_quantization_cfg is not None:
+            for nqc in node.candidates_weights_quantization_cfg:
+                for attr_name, attr_value in self.kwargs.items():
+                    nqc.set_quant_config_attr(attr_name, attr_value)
 
 
 class ChangeFinalWeightsQuantConfigAttr(BaseAction):
@@ -113,7 +113,7 @@ class ChangeFinalWeightsQuantConfigAttr(BaseAction):
         """
         self.kwargs = kwargs
 
-    def apply(self, node: BaseNode, graph, fw_info):
+    def apply(self, node: Node, graph, fw_info):
         if node.final_weights_quantization_cfg is not None:
             for attr_name, attr_value in self.kwargs.items():
                 node.final_weights_quantization_cfg.set_quant_config_attr(attr_name, attr_value)
@@ -134,7 +134,7 @@ class ChangeActivationQuantConfigAttr(BaseAction):
         """
         self.kwargs = kwargs
 
-    def apply(self, node: BaseNode, graph, fw_info):
+    def apply(self, node: Node, graph, fw_info):
         """
         Change the attribute 'attr_name' in quant_config with 'attr_value'.
 
@@ -146,8 +146,9 @@ class ChangeActivationQuantConfigAttr(BaseAction):
         Returns:q
             The node after its quant_config has been modified.
         """
-        for attr_name, attr_value in self.kwargs.items():
-            node.activation_quantization_cfg.set_quant_config_attr(attr_name, attr_value)
+        if node.activation_quantization_cfg is not None:
+            for attr_name, attr_value in self.kwargs.items():
+                node.activation_quantization_cfg.set_quant_config_attr(attr_name, attr_value)
 
 
 class ChangeQuantizationParamFunction(BaseAction):
@@ -166,7 +167,7 @@ class ChangeQuantizationParamFunction(BaseAction):
         self.activation_quantization_params_fn = activation_quantization_params_fn
         self.weights_quantization_params_fn = weights_quantization_params_fn
 
-    def apply(self, node: BaseNode, graph, fw_info):
+    def apply(self, node: Node, graph, fw_info):
         """
         Change the node's weights/activations quantization params function.
 
@@ -201,7 +202,7 @@ class ChangeActivationQuantizationMethod(BaseAction):
         """
         self.activation_quantization_method = activation_quantization_method
 
-    def apply(self, node: BaseNode, graph, fw_info):
+    def apply(self, node: Node, graph, fw_info):
         """
         Change the node's activations quantization function.
 
@@ -216,12 +217,15 @@ class ChangeActivationQuantizationMethod(BaseAction):
         """
         if self.activation_quantization_method is not None:
 
+            out_stats_container = graph.get_out_stats_collector(node)[0] if isinstance(
+                graph.get_out_stats_collector(node),
+                list) else graph.get_out_stats_collector(
+                node)
+
             activation_quantization_params_fn = get_activation_quantization_params_fn(
                 self.activation_quantization_method,
-                node.activation_quantization_cfg.activation_threshold_method)
-
-            if node.prior_info.is_output_bounded():
-                activation_quantization_params_fn = quantization_params_generation.no_clipping_selection_min_max
+                node.activation_quantization_cfg.activation_threshold_method,
+                out_stats_container.use_min_max)
 
             node.activation_quantization_cfg.set_activation_quantization_params_fn(activation_quantization_params_fn)
             activation_quantization_fn = fw_info.activation_quantizer_mapping.get(self.activation_quantization_method)
@@ -248,7 +252,7 @@ class ChangeFinalWeightsQuantizationMethod(BaseAction):
 
         self.weights_quantization_method = weights_quantization_method
 
-    def apply(self, node: BaseNode, graph, fw_info):
+    def apply(self, node: Node, graph, fw_info):
         """
         Change the node's weights quantization function.
 
@@ -292,7 +296,7 @@ class ChangeCandidtaesWeightsQuantizationMethod(BaseAction):
         """
         self.weights_quantization_method = weights_quantization_method
 
-    def apply(self, node: BaseNode, graph, fw_info):
+    def apply(self, node: Node, graph, fw_info):
         """
         Change the node's weights quantization function.
 

model_compression_toolkit/common/post_training_quantization.py

@@ -35,13 +35,11 @@ from model_compression_toolkit.common.network_editors.actions import EditRule
 from model_compression_toolkit.common.network_editors.edit_network import edit_network_graph
 from model_compression_toolkit.common.mixed_precision.mixed_precision_quantization_config import \
     MixedPrecisionQuantizationConfig
-from model_compression_toolkit.common.quantization.quantization_params_fn_selection import \
-    get_activation_quantization_params_fn
 from model_compression_toolkit.common.quantization.quantize_graph_weights import quantize_graph_weights
 from model_compression_toolkit.common.bias_correction.compute_bias_correction_of_graph import compute_bias_correction_of_graph
 
 from model_compression_toolkit.common.quantization.quantization_analyzer import analyzer_graph
-from model_compression_toolkit.common.quantization.quantization_config import DEFAULTCONFIG, ThresholdSelectionMethod
+from model_compression_toolkit.common.quantization.quantization_config import DEFAULTCONFIG
 from model_compression_toolkit.common.quantization.quantization_config import QuantizationConfig
 from model_compression_toolkit.common.quantization.quantization_params_generation.qparams_computation import \
     calculate_quantization_params
@@ -364,21 +362,6 @@ def _prepare_model_for_quantization(in_model: Any,
     if tb_w is not None:
         tb_w.add_graph(transformed_graph, 'pre_statistics_collection_substitutions')
 
-    #########################################
-    # Set prior info to nodes
-    ##########################################
-    for node in transformed_graph.nodes:
-        node.prior_info = fw_impl.get_node_prior_info(node=node,
-                                                      fw_info=fw_info)
-
-
-    ######################################
-    # Add quantization configurations
-    ######################################
-    transformed_graph = set_quantization_configuration_to_graph(graph=transformed_graph,
-                                                                quant_config=quant_config,
-                                                                fw_info=fw_info)
-
     ######################################
     # Graph marking points
     ######################################
@@ -398,7 +381,6 @@ def _prepare_model_for_quantization(in_model: Any,
     if tb_w is not None:
         tb_w.add_graph(transformed_graph, 'after_analyzer_graph')
 
-
     ######################################
     # Statistic collection
     ######################################
@@ -409,6 +391,12 @@ def _prepare_model_for_quantization(in_model: Any,
     for _ in tqdm(range(n_iter)):
         mi.infer(representative_data_gen())
 
+    ######################################
+    # Add quantization configurations
+    ######################################
+    transformed_graph = set_quantization_configuration_to_graph(transformed_graph,
+                                                                quant_config,
+                                                                fw_info)
 
     ######################################
     # Edit network according to user specific settings
@@ -469,4 +457,3 @@ def _prepare_model_for_quantization(in_model: Any,
         assert n.final_weights_quantization_cfg is None
 
     return tg_with_bias
-

model_compression_toolkit/common/quantization/node_quantization_config.py

@@ -62,7 +62,8 @@ class NodeActivationQuantizationConfig(BaseNodeNodeQuantizationConfig):
     def __init__(self,
                  qc: QuantizationConfig,
                  activation_quantization_fn: Callable,
-                 activation_quantization_params_fn: Callable
+                 activation_quantization_params_fn: Callable,
+                 activation_is_signed: bool = None
                  ):
         """
 
@@ -70,10 +71,11 @@ class NodeActivationQuantizationConfig(BaseNodeNodeQuantizationConfig):
             qc: QuantizationConfig to create the node's config from.
             activation_quantization_fn: Function to use when quantizing the node's activations.
             activation_quantization_params_fn: Function to use when computing the threshold for quantizing a node's activations.
+            activation_is_signed: Signedness of the activation quantized range.
         """
-
         self.activation_quantization_fn = activation_quantization_fn
         self.activation_quantization_params_fn = activation_quantization_params_fn
+        self.activation_is_signed = activation_is_signed
         self.activation_quantization_params = {}
         self.activation_threshold_method = qc.activation_threshold_method
         self.activation_quantization_method = qc.activation_quantization_method
@@ -89,14 +91,6 @@ class NodeActivationQuantizationConfig(BaseNodeNodeQuantizationConfig):
         self.shift_negative_ratio = qc.shift_negative_ratio
         self.shift_negative_threshold_recalculation = qc.shift_negative_threshold_recalculation
 
-    def generate_quantization_node(self) -> Callable:
-        """
-        Returns: Quantization function to use for quantizing the node's activations,
-        with the node's quantization configuration properties.
-        """
-        return self.activation_quantization_fn(self.activation_n_bits,
-                                               self.activation_quantization_params)
-
     def set_activation_quantization_fn(self, activation_quantization_fn: Callable):
         """
         Sets activation quantization function for the node.
@@ -126,7 +120,6 @@ class NodeActivationQuantizationConfig(BaseNodeNodeQuantizationConfig):
             activation_params: Dictionary that contains weight quantization params.
 
         """
-        assert self.enable_activation_quantization
         for param_name, param_value in activation_params.items():
             self.activation_quantization_params[param_name] = param_value
 
@@ -205,7 +198,6 @@ class NodeWeightsQuantizationConfig(BaseNodeNodeQuantizationConfig):
             weights_params: Dictionary that contains weight quantization params.
 
         """
-        assert self.enable_weights_quantization
         for param_name, param_value in weights_params.items():
             self.weights_quantization_params[param_name] = param_value
 
@@ -218,7 +210,7 @@ class NodeWeightsQuantizationConfig(BaseNodeNodeQuantizationConfig):
             Recalculated weights quantization params from the kernel and channel axis.
 
         """
-        assert self.enable_weights_quantization
+
         if self.weights_quantization_params_fn is not None:
             self.set_weights_quantization_param(self.weights_quantization_params_fn(tensor_data,
                                                                                     p=self.l_p_value,

model_compression_toolkit/common/quantization/quantization_analyzer.py

@@ -21,20 +21,17 @@ from model_compression_toolkit import common
 
 
 def create_tensor2node(graph: common.Graph,
-                       node: common.BaseNode,
-                       fw_info: common.FrameworkInfo):
+                       node: common.Node):
     """
     Force tensor creation and assignment for a node.
     Args:
         graph: Graph of the node (for retrieving the current tensor).
         node: Node to create a tensor for.
-        fw_info: Specific framework information (for example, output channels index).
 
     """
     current_tensor = graph.get_out_stats_collector(node)
-    is_list_nostat_collectors = isinstance(current_tensor, list) and len([sc for sc in current_tensor if not isinstance(sc, common.NoStatsCollector)]) == 0
-    if isinstance(current_tensor, common.NoStatsCollector) or current_tensor is None or is_list_nostat_collectors:
-        graph.set_out_stats_collector_to_node(node, common.StatsCollector(output_channel_index=fw_info.output_channel_index))
+    if isinstance(current_tensor, common.NoStatsContainer) or current_tensor is None:
+        graph.set_out_stats_collector_to_node(node, common.StatsContainer())
 
 
 def analyzer_graph(node_analyze_func: Callable,
@@ -56,7 +53,7 @@ def analyzer_graph(node_analyze_func: Callable,
     """
     nodes_sorted = topological_sort(graph)
     for n in nodes_sorted:
-        sc = node_analyze_func(n, output_channel_index=fw_info.output_channel_index)  # Get tensor for the node
+        t = node_analyze_func(n, fw_info)  # Get tensor for the node
         # If we use bias correction, and the node has coefficients to quantize, we need to make sure
         # its previous nodes' tensors are consistent with this node.
         # TODO: factor tensor marking in case of bias correction.
@@ -64,7 +61,6 @@ def analyzer_graph(node_analyze_func: Callable,
             for ie in graph.incoming_edges(n):
                 input_node = ie.source_node
                 create_tensor2node(graph,
-                                   input_node,
-                                   fw_info)
-        if sc is not None:
-            graph.set_out_stats_collector_to_node(n, sc)
+                                   input_node)
+        if t is not None:
+            graph.set_out_stats_collector_to_node(n, t)

model_compression_toolkit/common/quantization/quantization_config.py

@@ -155,12 +155,12 @@ DEFAULTCONFIG = QuantizationConfig(ThresholdSelectionMethod.MSE,
                                    ThresholdSelectionMethod.MSE,
                                    QuantizationMethod.POWER_OF_TWO,
                                    QuantizationMethod.POWER_OF_TWO,
-                                   weights_n_bits=8,
-                                   activation_n_bits=8,
-                                   relu_unbound_correction=False,
-                                   weights_bias_correction=True,
-                                   weights_per_channel_threshold=True,
-                                   input_scaling=False)
+                                   8,
+                                   8,
+                                   False,
+                                   True,
+                                   True,
+                                   False)
 
 
 

model_compression_toolkit/common/quantization/quantization_params_fn_selection.py

@@ -23,7 +23,8 @@ from model_compression_toolkit.common.quantization.quantization_params_generatio
 
 
 def get_activation_quantization_params_fn(activation_quantization_method: QuantizationMethod,
-                                          activation_threshold_method: ThresholdSelectionMethod) -> Callable:
+                                          activation_threshold_method: ThresholdSelectionMethod,
+                                          use_min_max: bool) -> Callable:
     """
     Generate a function for finding activation quantization threshold.
 
@@ -37,7 +38,7 @@ def get_activation_quantization_params_fn(activation_quantization_method: Quanti
     """
     if activation_quantization_method == QuantizationMethod.POWER_OF_TWO:
         # Use min/max as the threshold if we use NOCLIPPING
-        if activation_threshold_method == ThresholdSelectionMethod.NOCLIPPING:
+        if use_min_max or activation_threshold_method == ThresholdSelectionMethod.NOCLIPPING:
             params_fn = quantization_params_generation.no_clipping_selection_min_max
         # Use MSE to search_methods for the optimal threshold.
         elif activation_threshold_method == ThresholdSelectionMethod.MSE:

model_compression_toolkit/common/quantization/quantization_params_generation/qparams_activations_computation.py

@@ -15,13 +15,12 @@
 import numpy as np
 from typing import Tuple, Dict
 
-from model_compression_toolkit.common import BaseNode, Graph
-from model_compression_toolkit.common.constants import SIGNED
+from model_compression_toolkit.common import Node, Graph
 from model_compression_toolkit.common.quantization import quantization_params_generation
 
 
-def get_activations_qparams(n: BaseNode,
-                            graph: Graph) -> Dict[str, float]:
+def get_activations_qparams(n: Node,
+                            graph: Graph) -> Tuple[Dict[str, float], bool]:
     """
     Compute the activations params for a given node in a graph according to a params function.
 
@@ -30,29 +29,25 @@ def get_activations_qparams(n: BaseNode,
         graph: Graph the node is in.
 
     Returns:
-        The computed activation quantization params.
+        Tuple of the computed quantization params and sign for the node's activations quantization.
     """
-
     out_stats_container = graph.get_out_stats_collector(n)
     bins_values, bins_counts = None, None
 
     # If the statistics container collected the histogram, we start by filtering outliers using z threshold
     # filtering, and then computing the threshold based on the filtered histogram.
-    if out_stats_container.require_collection():
+    if out_stats_container.collect_histogram:
         bins_values, bins_counts = out_stats_container.hc.get_histogram()
         bins_counts = quantization_params_generation.z_score_filter(n.activation_quantization_cfg.z_threshold,
                                                                     bins_values,
                                                                     bins_counts)
     min_value, max_value = out_stats_container.get_min_max_values()
 
-    if n.prior_info.is_output_bounded():
+    if out_stats_container.use_min_max:
         signed = min_value < 0
     else:
         signed = np.any(bins_values < 0)
 
-    if n.prior_info.is_output_bounded():
-        n.activation_quantization_cfg.activation_quantization_params_fn = quantization_params_generation.no_clipping_selection_min_max
-
     activation_params = n.activation_quantization_cfg.activation_quantization_params_fn(bins_values,
                                                                                         bins_counts,
                                                                                         n.activation_quantization_cfg.l_p_value,
@@ -60,6 +55,5 @@ def get_activations_qparams(n: BaseNode,
                                                                                         min_value,
                                                                                         max_value,
                                                                                         min_threshold=n.activation_quantization_cfg.min_threshold)
-    activation_params.update({SIGNED: signed})
 
-    return activation_params
+    return activation_params, signed

model_compression_toolkit/common/quantization/quantization_params_generation/qparams_computation.py

@@ -16,7 +16,7 @@ from typing import List
 
 from model_compression_toolkit.common.framework_implementation import FrameworkImplementation
 from model_compression_toolkit.common.framework_info import FrameworkInfo
-from model_compression_toolkit.common import Graph, BaseNode, Logger
+from model_compression_toolkit.common import Graph, Node, Logger
 from model_compression_toolkit.common.quantization.quantization_params_generation.qparams_activations_computation \
     import \
     get_activations_qparams
@@ -26,7 +26,7 @@ from model_compression_toolkit.common.quantization.quantization_params_generatio
 
 def calculate_quantization_params(graph: Graph,
                                   fw_info: FrameworkInfo,
-                                  nodes: List[BaseNode] = [],
+                                  nodes: List[Node] = [],
                                   specific_nodes: bool = False,
                                   fw_impl: FrameworkImplementation = None):
     """
@@ -48,7 +48,7 @@ def calculate_quantization_params(graph: Graph,
     """
 
     # Create a list of nodes to compute their thresholds
-    nodes_list: List[BaseNode] = nodes if specific_nodes else graph.nodes()
+    nodes_list: List[Node] = nodes if specific_nodes else graph.nodes()
 
     for n in nodes_list:  # iterate only nodes that we should compute their thresholds
 
@@ -56,23 +56,25 @@ def calculate_quantization_params(graph: Graph,
         input_channels_axis, activation_threshold_float = {}, {}, None, None, None, None
 
         if fw_info.in_kernel_ops(n):  # If the node has a kernel to quantize
-            if n.is_weights_quantization_enabled():
-                for candidtae_qc in n.candidates_weights_quantization_cfg:
-                    output_channels_axis, _ = get_channels_axis(candidtae_qc, fw_info, n.layer_class)
-                    weights_params = get_weights_qparams(n.get_weights_by_keys(fw_impl.constants.KERNEL),
-                                                         candidtae_qc,
-                                                         output_channels_axis)
 
-                    candidtae_qc.set_weights_quantization_param(weights_params)
-                    candidtae_qc.weights_channels_axis = output_channels_axis
+            for candidtae_qc in n.candidates_weights_quantization_cfg:
+                output_channels_axis, _ = get_channels_axis(candidtae_qc, fw_info, n.layer_class)
+                weights_params = get_weights_qparams(n.get_weights_by_keys(fw_impl.constants.KERNEL),
+                                                     candidtae_qc,
+                                                     output_channels_axis)
 
-            if n.is_activation_quantization_enabled():  # If node's activations should be quantized as well, we compute its
+                candidtae_qc.set_weights_quantization_param(weights_params)
+                candidtae_qc.weights_channels_axis = output_channels_axis
+
+            if n.output_quantization:  # If node's activations should be quantized as well, we compute its
                 # activation threshold
-                activation_params = get_activations_qparams(n=n, graph=graph)
+                activation_params, activation_is_signed = get_activations_qparams(n=n,
+                                                                                  graph=graph)
 
         elif fw_info.in_activation_ops(n):  # If node has no kernel, but its activations should be quantized
-            if n.is_activation_quantization_enabled():
-                activation_params = get_activations_qparams(n=n, graph=graph)
+            if n.output_quantization:
+                activation_params, activation_is_signed = get_activations_qparams(n=n,
+                                                                                  graph=graph)
         # If node should not be quantized at all
         elif fw_info.in_no_quantization_ops(n):
             pass  # pragma: no cover
@@ -82,5 +84,6 @@ def calculate_quantization_params(graph: Graph,
             Logger.warning(f"Warning: unknown layer: {n.layer_class.__name__}")
 
         # Create a NodeQuantizationConfig containing all quantization params and attach it to the node
-        if n.is_activation_quantization_enabled():
-            n.activation_quantization_cfg.set_activation_quantization_param(activation_params)
+        if n.activation_quantization_cfg is not None:
+            n.activation_quantization_cfg.set_activation_quantization_param(activation_params)
+            n.activation_quantization_cfg.activation_is_signed = activation_is_signed

model_compression_toolkit/common/quantization/quantize_node.py

@@ -19,7 +19,7 @@ import copy
 from model_compression_toolkit import common
 from model_compression_toolkit.common import Logger
 from model_compression_toolkit.common.framework_implementation import FrameworkImplementation
-from model_compression_toolkit.common.graph.base_node import BaseNode
+from model_compression_toolkit.common.graph.node import Node
 from model_compression_toolkit.common.framework_info import FrameworkInfo
 from model_compression_toolkit.common.quantization.node_quantization_config import NodeWeightsQuantizationConfig
 from model_compression_toolkit.common.quantization.quantization_params_generation.qparams_weights_computation import \
@@ -27,7 +27,7 @@ from model_compression_toolkit.common.quantization.quantization_params_generatio
 
 
 def get_quantized_kernel_by_weights_qc(fw_info:FrameworkInfo,
-                                       n:BaseNode,
+                                       n:Node,
                                        weights_qc: NodeWeightsQuantizationConfig,
                                        fw_impl: FrameworkImplementation):
     """

model_compression_toolkit/common/quantization/set_node_quantization_config.py

@@ -17,7 +17,8 @@
 import copy
 from typing import List
 
-from model_compression_toolkit.common import Logger, BaseNode
+from model_compression_toolkit.common.quantization.quantization_config import QuantizationConfig
+from model_compression_toolkit.common import Logger
 from model_compression_toolkit.common.framework_info import FrameworkInfo
 from model_compression_toolkit.common.graph.base_graph import Graph
 from model_compression_toolkit.common.mixed_precision.mixed_precision_quantization_config import \
@@ -46,45 +47,38 @@ def set_quantization_configuration_to_graph(graph: Graph,
     """
 
     graph_with_qcs = copy.deepcopy(graph)
+
     for n in graph_with_qcs.nodes:
-        set_quantization_configs_to_node(node=n,
-                                         quant_config=quant_config,
-                                         fw_info=fw_info)
+        # Set qc only when needed
+        quantize_node_weights = False
+        quantize_node_activations = False
+
+        if fw_info.in_kernel_ops(n):
+            quantize_node_weights = True
+            quantize_node_activations = n.output_quantization
+        elif fw_info.in_activation_ops(n):
+            quantize_node_activations = True
+
+        if quantize_node_activations:
+            # Create activation QC for this node
+            out_sc = graph_with_qcs.get_out_stats_collector(n)
+            sc = out_sc[0] if isinstance(out_sc, list) else out_sc
+            use_min_max = sc.use_min_max
+            n.activation_quantization_cfg = create_node_activation_qc(quant_config,
+                                                                      fw_info,
+                                                                      use_min_max)
+        if quantize_node_weights:
+            # Create weights QC for this node
+            weight_channel_axis = fw_info.kernel_channels_mapping.get(n.layer_class)[0]
+            n.candidates_weights_quantization_cfg = _create_node_candidates_weights_qc(quant_config,
+                                                                                      fw_info,
+                                                                                      weight_channel_axis)
     return graph_with_qcs
 
 
-def set_quantization_configs_to_node(node: BaseNode,
-                                     quant_config: QuantizationConfig,
-                                     fw_info: FrameworkInfo):
-    """
-    Create and set quantization configurations to a node (for both weights and activation).
-
-    Args:
-        node: Node to set its quantization configurations.
-        quant_config: Quantization configuration to generate the node's configurations from.
-        fw_info: Information needed for quantization about the specific framework.
-
-    """
-    # Create activation QC for this node
-    node.activation_quantization_cfg = create_node_activation_qc(quant_config,
-                                                                 fw_info)
-
-    enable_activation_quantization = quant_config.enable_activation_quantization and (fw_info.in_activation_ops(node) or fw_info.in_kernel_ops(node))
-    node.activation_quantization_cfg.enable_activation_quantization = enable_activation_quantization
-
-    # Create weights QC for this node
-    weight_channel_axis = fw_info.kernel_channels_mapping.get(node.layer_class)[0]
-    node.candidates_weights_quantization_cfg = _create_node_candidates_weights_qc(quant_config,
-                                                                                  fw_info,
-                                                                                  weight_channel_axis)
-
-    enable_weights_quantization = quant_config.enable_weights_quantization and fw_info.in_kernel_ops(node)
-    for qc in node.candidates_weights_quantization_cfg:
-        qc.enable_weights_quantization = enable_weights_quantization
-
-
 def create_node_activation_qc(qc: QuantizationConfig,
-                              fw_info: FrameworkInfo) -> NodeActivationQuantizationConfig:
+                              fw_info: FrameworkInfo,
+                              use_min_max: bool) -> NodeActivationQuantizationConfig:
     """
     Create a activations quantization configuration from a QuantizationConfig object.
 
@@ -92,6 +86,7 @@ def create_node_activation_qc(qc: QuantizationConfig,
         qc: QuantizationConfig to create the node's config from.
         fw_info: Information about the specific framework the node was created from (e.g., whether or not its
         weights/activations should be quantized)
+        use_min_max: Whether the collected min/max statistics should be used when the threshold is computed or not.
 
     Returns:
         Activation quantization configuration of a node.
@@ -102,7 +97,8 @@ def create_node_activation_qc(qc: QuantizationConfig,
         Logger.critical('Unknown quantization method for activations')
 
     activation_quantization_params_fn = get_activation_quantization_params_fn(qc.activation_quantization_method,
-                                                                              qc.activation_threshold_method)
+                                                                              qc.activation_threshold_method,
+                                                                              use_min_max)
 
     return NodeActivationQuantizationConfig(qc,
                                             activation_quantization_fn,
@@ -139,9 +135,10 @@ def create_node_weights_qc(qc: QuantizationConfig,
                                          weight_channel_axis)
 
 
+
 def _create_node_candidates_weights_qc(qc: QuantizationConfig,
-                                       fw_info: FrameworkInfo,
-                                       weight_channel_axis: int) -> List[NodeWeightsQuantizationConfig]:
+                                      fw_info: FrameworkInfo,
+                                      weight_channel_axis: int) -> List[NodeWeightsQuantizationConfig]:
     """
     Create a list of candidates of weights quantization configurations for a node.
 
@@ -164,4 +161,4 @@ def _create_node_candidates_weights_qc(qc: QuantizationConfig,
     else:
         candidats.append(create_node_weights_qc(qc, fw_info, weight_channel_axis))
 
-    return candidats
+    return candidats