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

model_compression_toolkit/common/graph/functional_node.py

@@ -1,59 +0,0 @@
-from typing import Dict, Any, Tuple, List
-
-from model_compression_toolkit.common.graph.base_node import BaseNode
-import numpy as np
-
-class FunctionalNode(BaseNode):
-    """
-    Node that represents function ops with arguments to pass when building back the model.
-    """
-
-    def __init__(self,
-                 name: str,
-                 framework_attr: Dict[str, Any],
-                 input_shape: Tuple[Any],
-                 output_shape: Tuple[Any],
-                 weights: Dict[str, np.ndarray],
-                 layer_class: type,
-                 op_call_args: List[Any] = None,
-                 op_call_kwargs: Dict[str, Any] = None,
-                 reuse: bool = False,
-                 reuse_group: str = None,
-                 quantization_attr: Dict[str, Any] = None,
-                 functional_op: Any = None,
-                 inputs_as_list: bool = False):
-        """
-        Init a FunctionalNode object.
-
-        Args:
-            name: Node's name
-            framework_attr: Framework attributes the layer had which the node holds.
-            input_shape: Input tensor shape of the node.
-            output_shape: Input tensor shape of the node.
-            weights: Dictionary from a variable name to the weights with that name in the layer the node represents.
-            layer_class: Class path of the layer this node represents.
-            op_call_args: Arguments list to pass when calling the layer.
-            op_call_kwargs: Key-Word Arguments dictionary with values to pass when calling the layer.
-            reuse: Whether this node was duplicated and represents a reused layer.
-            reuse_group: Name of group of nodes from the same reused layer.
-            quantization_attr: Attributes the node holds regarding how it should be quantized.
-            functional_op: The op the node implements.
-            inputs_as_list: Whether to pass the node its input tensors as a list or not when calling the layer.
-
-        """
-
-        super().__init__(name,
-                         framework_attr,
-                         input_shape,
-                         output_shape,
-                         weights,
-                         layer_class,
-                         reuse,
-                         reuse_group,
-                         quantization_attr)
-
-        self.op_call_kwargs = op_call_kwargs
-        self.op_call_args = op_call_args
-        self.functional_op = functional_op
-        self.inputs_as_list = inputs_as_list
-

model_compression_toolkit/common/model_validation.py

@@ -1,43 +0,0 @@
-from abc import abstractmethod
-from typing import Any
-
-from model_compression_toolkit import FrameworkInfo
-
-
-class ModelValidation:
-    """
-    Class to define validation methods in order to validate the received model to quantize.
-    """
-
-    def __init__(self,
-                 model: Any,
-                 fw_info:FrameworkInfo):
-        """
-        Initialize a ModelValidation object.
-
-        Args:
-            model: Model to check its validity.
-            fw_info: Information about the specific framework of the model.
-        """
-        self.model = model
-        self.fw_info = fw_info
-
-    @abstractmethod
-    def validate_output_channel_consistency(self):
-        """
-
-        Validate that output channels index in all layers of the model are the same.
-        If the model has layers with different output channels index, it should throw an exception.
-
-        """
-        raise NotImplemented(f'Framework validation class did not implement validate_output_channel_consistency')
-
-    def validate(self):
-        """
-
-        Run all validation methods before the quantization process starts.
-
-        """
-        self.validate_output_channel_consistency()
-
-

model_compression_toolkit/common/node_prior_info.py

@@ -1,29 +0,0 @@
-from model_compression_toolkit.common.collectors.statistics_collector import is_number
-
-
-class NodePriorInfo:
-    """
-    Class to wrap all prior information we have on a node.
-    """
-
-    def __init__(self,
-                 min_output: float = None,
-                 max_output: float = None):
-        """
-        Initialize a NodePriorInfo object.
-
-        Args:
-            min_output: Minimal output value of the node.
-            max_output: Maximal output value of the node.
-        """
-
-        self.min_output = min_output
-        self.max_output = max_output
-
-    def is_output_bounded(self) -> bool:
-        """
-
-        Returns: Whether the node's output is bounded within a known range or not.
-
-        """
-        return is_number(self.min_output) and is_number(self.max_output)

model_compression_toolkit/keras/keras_model_validation.py

@@ -1,38 +0,0 @@
-from tensorflow.keras.models import Model
-
-from model_compression_toolkit import FrameworkInfo
-from model_compression_toolkit.common.framework_info import ChannelAxis
-from model_compression_toolkit.common.model_validation import ModelValidation
-from model_compression_toolkit.keras.constants import CHANNELS_FORMAT, CHANNELS_FORMAT_LAST, CHANNELS_FORMAT_FIRST
-
-
-class KerasModelValidation(ModelValidation):
-    """
-    Class to define validation methods in order to validate the received Keras model to quantize.
-    """
-
-    def __init__(self, model: Model, fw_info: FrameworkInfo):
-        """
-        Initialize a KerasModelValidation object.
-
-        Args:
-            model: Keras model to check its validity.
-            fw_info: Information about the framework of the model (Keras).
-        """
-
-        super(KerasModelValidation, self).__init__(model=model,
-                                                   fw_info=fw_info)
-
-    def validate_output_channel_consistency(self):
-        """
-
-        Validate that output channels index in all layers of the model are the same.
-        If the model has layers with different output channels index, an exception is thrown.
-
-        """
-        for layer in self.model.layers:
-            data_format = layer.get_config().get(CHANNELS_FORMAT)
-            if data_format is not None:
-                assert (data_format == CHANNELS_FORMAT_LAST and self.fw_info.output_channel_index == ChannelAxis.NHWC
-                        or data_format == CHANNELS_FORMAT_FIRST and self.fw_info.output_channel_index == ChannelAxis.NCHW), \
-                    f'Model can not have layers with different data formats.'

model_compression_toolkit/keras/keras_node_prior_info.py

@@ -1,60 +0,0 @@
-from typing import Any, Tuple
-
-import tensorflow as tf
-if tf.__version__ < "2.6":
-    from tensorflow.keras.layers import Activation, ReLU
-else:
-    from keras.layers import Activation, ReLU
-
-from model_compression_toolkit import FrameworkInfo
-from model_compression_toolkit.common import BaseNode
-from model_compression_toolkit.common.node_prior_info import NodePriorInfo
-from model_compression_toolkit.keras.constants import ACTIVATION, RELU_MAX_VALUE, NEGATIVE_SLOPE, THRESHOLD
-
-
-def create_node_prior_info(node: BaseNode,
-                           fw_info: FrameworkInfo):
-    """
-    Create a NodePriorInfo object for a given node.
-
-    Args:
-        node: Node to create its prior info.
-        fw_info: Information about a specific framework the node was generated from.
-
-    Returns:
-        NodePriorInfo object with info about the node.
-    """
-
-    min_output, max_output = _get_min_max_outputs(node=node,
-                                                  fw_info=fw_info)
-    return NodePriorInfo(min_output=min_output,
-                         max_output=max_output)
-
-
-def _get_min_max_outputs(node: BaseNode,
-                         fw_info: FrameworkInfo) -> Tuple[Any,Any]:
-    """
-    Return the min/max output values of a node if known.
-    If one of them (or both of them) is unknown - return None instead of a value.
-    Args:
-        node: Node to create its prior info.
-        fw_info: Information about a specific framework the node was generated from.
-
-    Returns:
-        Min/max output values if known.
-    """
-    min_output, max_output = None, None
-
-    if node.layer_class == ReLU:
-        min_output = node.framework_attr[THRESHOLD] if node.framework_attr[NEGATIVE_SLOPE] == 0 else None
-        max_output = node.framework_attr[RELU_MAX_VALUE]
-
-    elif fw_info.layers_has_min_max(node.layer_class):
-        min_output, max_output = fw_info.layer_min_max_mapping[node.layer_class]
-
-    elif node.layer_class == Activation and fw_info.activation_has_min_max(node.framework_attr[ACTIVATION]):
-        min_output, max_output = fw_info.activation_min_max_mapping[node.framework_attr[ACTIVATION]]
-
-    return min_output, max_output
-
-