mct-nightly 2.2.0.20241106.458__py3-none-any.whl → 2.2.0.20241108.459__py3-none-any.whl

model_compression_toolkit/core/common/statistics_correction/compute_activation_bias_correction_of_graph.py

@@ -0,0 +1,190 @@
+# Copyright 2024 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+import numpy as np
+from typing import Any, Callable
+
+from model_compression_toolkit.core import QuantizationConfig
+from model_compression_toolkit.core.common import BaseNode, Graph
+from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
+from model_compression_toolkit.core.common.framework_info import FrameworkInfo
+
+
+def get_previous_node_with_activation_quantization(linear_node: BaseNode,
+                                                   graph: Graph) -> Any:
+    """
+    Search recursively for the previous node with activation quantization.
+
+    Args:
+        linear_node: Node to search for its previous node.
+        graph: Graph the node is in.
+
+    Returns:
+        The previous node (if found) or None if it was not found or there are multiple incoming edges to one of
+        nodes during the search (which means, the substitution can not be applied).
+    """
+
+    prev_nodes = graph.get_prev_nodes(linear_node)
+
+    if len(prev_nodes) != 1:
+        return None  # pragma: no cover
+
+    prev_node = prev_nodes[0]
+
+    activation_quantization_config = prev_node.final_activation_quantization_cfg
+
+    # Search for node with activation quantization
+    if (activation_quantization_config.enable_activation_quantization and
+            not activation_quantization_config.quantization_preserving):
+        return prev_node
+    else:
+        return get_previous_node_with_activation_quantization(prev_node, graph)
+
+
+def calculate_bin_centers(bin_edges: np.ndarray) -> np.ndarray:
+    """
+    Calculate the centers of bins given their edges.
+
+    Args:
+        bin_edges: Array of bin edges.
+
+    Returns:
+        np.ndarray: Array of bin centers.
+    """
+    # Calculate the centers by averaging continuous bin edges
+    bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2.0
+    return bin_centers
+
+
+def compute_activation_bias_correction(graph: Graph,
+                                       quant_config: QuantizationConfig,
+                                       fw_info: FrameworkInfo,
+                                       fw_impl: FrameworkImplementation,
+                                       linear_node: BaseNode,
+                                       prev_node: BaseNode,
+                                       kernel_size: str) -> Graph:
+    """
+    Compute the activation bias correction term, and store it in the final activation
+    quantization configuration.
+
+    Args:
+        graph: Graph with nodes to compute the activation bias correction for each node's final activation quantization configuration.
+        quant_config: QuantizationConfig of how the model should be quantized.
+        fw_info: Framework info like lists of nodes their kernel should quantized.
+        fw_impl: FrameworkImplementation object with a specific framework methods implementation.
+        linear_node: Node to compute the activation bias correction for.
+        prev_node: Node to compute the activation error caused by his activation quantization.
+        kernel_size: The framework specific attribute name of the convolution layer's kernel size.
+
+    Returns:
+        Graph with activation bias correction term for each node.
+    """
+
+    # Retrieve the 'kernel_size' value if it exists and ensure it is None, 1, or (1, 1). This feature supports only
+    # Dense/Linear layers and convolution layers with kernel size  of 1 or (1, 1).
+    # For Dense/Linear layers, which lack a 'kernel_size' attribute, the result will be None, and no restriction
+    # applies in that case.
+    if linear_node.framework_attr.get(kernel_size) not in [None, 1, (1, 1)]:
+        # If the kernel size is not 1 or (1, 1), return the current graph unmodified
+        return graph
+
+    prev_node_act_quant_cfg = prev_node.final_activation_quantization_cfg
+
+    # Check if the previous node's has activation quantization configuration and if the previous node have the
+    # histogram collector.
+    if prev_node_act_quant_cfg is None or not hasattr(graph.get_out_stats_collector(prev_node), 'hc'):
+        return graph  # pragma: no cover
+
+    float_bins, float_count = graph.get_out_stats_collector(prev_node).hc.get_histogram()
+
+    # Calculate the centers of the float bins
+    float_centers = calculate_bin_centers(float_bins)
+
+    # Quantize the bin edges and calculate the centers of the quantized bins
+    quant_bins = prev_node_act_quant_cfg.quantize_node_output(fw_impl.to_tensor(float_bins))
+    quant_bins = fw_impl.to_numpy(quant_bins)
+    quant_centers = calculate_bin_centers(quant_bins)
+
+    # Calculate the mean of the both the float and the quantized bin centers, weighted by the bin counts
+    mean_float_centers = np.sum(float_centers * float_count) / np.sum(float_count)
+    mean_quant_centers = np.sum(quant_centers * float_count) / np.sum(float_count)
+
+    # Compute the difference between the mean quantized center and the mean float center
+    mean_diff = mean_quant_centers - mean_float_centers
+
+    # Calculate the normalized bias as a percentage of the float center norm
+    float_centers_norm1 = np.abs(mean_float_centers)
+    normalized_bias = 100 * np.abs(mean_diff) / float_centers_norm1
+
+    # If the normalized bias is below the activation bias correction threshold, return the graph unmodified.
+    # By default, the threshold is set to 0, allowing all nodes to proceed in this case.
+    if normalized_bias < quant_config.activation_bias_correction_threshold:
+        return graph
+
+    kernel = linear_node.get_weights_by_keys(fw_info.kernel_ops_attributes_mapping.get(linear_node.type)[0])
+
+    # Compute the activation bias correction by applying the quantization error to the kernel, resulting in an output
+    # size matching the number of output channels.
+    if kernel is not None:
+
+        # Get the axes that are not the output channel.
+        output_channel_index, input_channel_index = fw_info.kernel_channels_mapping.get(linear_node.type)
+        axis_not_output_channel = list(range(len(kernel.shape)))
+        axis_not_output_channel.remove(output_channel_index)
+
+        # Special case of depthwise_conv2d in tensorflow, where we have a depth multiplier for the filters.
+        if output_channel_index == input_channel_index:
+            axis_not_output_channel.remove(3)  # 3 is the depth multiplier index.
+
+        activation_bias_correction_term = mean_diff * np.sum(kernel, axis=tuple(axis_not_output_channel))
+        linear_node.final_activation_quantization_cfg.activation_bias_correction_term = (
+            activation_bias_correction_term.flatten())
+    return graph
+
+
+def compute_activation_bias_correction_of_graph(graph: Graph,
+                                                quant_config: QuantizationConfig,
+                                                fw_info: FrameworkInfo,
+                                                fw_impl: FrameworkImplementation,
+                                                activation_bias_correction_node_matchers: Callable,
+                                                kernel_size: str) -> Graph:
+    """
+    Compute the activation bias correction term for the graph.
+
+    Args:
+        graph: Graph with nodes to compute the activation bias correction.
+        quant_config: QuantizationConfig of how the model should be quantized.
+        fw_info: Framework info like lists of nodes their kernel should quantized.
+        fw_impl: FrameworkImplementation object with a specific framework methods implementation.
+        activation_bias_correction_node_matchers: Function to match the layers for activation bias correction.
+        kernel_size: The framework specific attribute name of the convolution layer's kernel size.
+
+
+    Returns:
+        Graph with activation bias correction term for each relevant node.
+    """
+    linear_node_types = activation_bias_correction_node_matchers()
+
+    for n in graph.nodes:
+        if linear_node_types.apply(n):
+            prev_node = get_previous_node_with_activation_quantization(n, graph)
+            if prev_node is not None:
+                graph = compute_activation_bias_correction(graph=graph,
+                                                           quant_config=quant_config,
+                                                           fw_info=fw_info,
+                                                           fw_impl=fw_impl,
+                                                           linear_node=n,
+                                                           prev_node=prev_node,
+                                                           kernel_size=kernel_size)
+    return graph

model_compression_toolkit/core/common/statistics_correction/statistics_correction.py

@@ -18,6 +18,8 @@ from model_compression_toolkit.core.common import FrameworkInfo
 from model_compression_toolkit.core.common import Graph
 from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
 from model_compression_toolkit.core.common.quantization.core_config import CoreConfig
+from model_compression_toolkit.core.common.statistics_correction.apply_activation_bias_correction_to_graph import \
+    apply_activation_bias_correction_to_graph
 from model_compression_toolkit.core.common.statistics_correction.apply_bias_correction_to_graph import \
     apply_bias_correction_to_graph
 from model_compression_toolkit.core.common.statistics_correction.apply_second_moment_correction_to_graph import \
@@ -73,7 +75,7 @@ def apply_statistics_correction(transformed_graph: Graph,
                                 fw_impl: FrameworkImplementation,
                                 tb_w: TensorboardWriter = None, ) -> Graph:
     """
-     Apply statistics moment correction on graph.
+     Apply statistics correction on graph.
      Args:
         transformed_graph: Graph to apply statistics correction.
         representative_data_gen (Callable): Dataset used for calibration.
@@ -84,7 +86,7 @@ def apply_statistics_correction(transformed_graph: Graph,
         tb_w (TensorboardWriter): TensorboardWriter object to use for logging events such as graphs, histograms, etc.
 
      Returns:
-         Graph after statistics correction correction.
+         Graph after statistics correction.
      """
 
     #############################################
@@ -104,4 +106,14 @@ def apply_statistics_correction(transformed_graph: Graph,
     if tb_w is not None:
         tb_w.add_graph(transformed_graph, 'after_statistics_correction')
 
+    #############################################
+    # Apply Activation Bias Correction
+    #############################################
+    if core_config.quantization_config.activation_bias_correction:
+        transformed_graph = apply_activation_bias_correction_to_graph(graph=transformed_graph,
+                                                                      core_config=core_config,
+                                                                      fw_impl=fw_impl)
+    if tb_w is not None:
+        tb_w.add_graph(transformed_graph, 'after_activation_bias_correction')
+
     return transformed_graph

model_compression_toolkit/core/keras/keras_implementation.py

@@ -28,6 +28,8 @@ from model_compression_toolkit.core.keras.graph_substitutions.substitutions.remo
 from model_compression_toolkit.core.keras.hessian.activation_hessian_scores_calculator_keras import \
     ActivationHessianScoresCalculatorKeras
 from model_compression_toolkit.core.keras.hessian.weights_hessian_scores_calculator_keras import WeightsHessianScoresCalculatorKeras
+from model_compression_toolkit.core.keras.statistics_correction.keras_compute_activation_bias_correction_of_graph import \
+    keras_compute_activation_bias_correction_of_graph
 from model_compression_toolkit.exporter.model_wrapper.fw_agnostic.get_inferable_quantizers import \
     get_inferable_quantizers
 from model_compression_toolkit.exporter.model_wrapper.keras.builder.node_to_quantizer import \
@@ -84,7 +86,7 @@ from model_compression_toolkit.core.keras.graph_substitutions.substitutions.line
 from model_compression_toolkit.core.keras.graph_substitutions.substitutions.residual_collapsing import \
     keras_residual_collapsing
 from model_compression_toolkit.core.keras.graph_substitutions.substitutions.input_scaling import InputScaling, \
-    InputScalingWithPad 
+    InputScalingWithPad
 from model_compression_toolkit.core.keras.graph_substitutions.substitutions.concat_threshold_update import ConcatThresholdUpdate
 from model_compression_toolkit.core.keras.graph_substitutions.substitutions.relu_bound_to_power_of_2 import \
     ReLUBoundToPowerOfTwo
@@ -218,6 +220,25 @@ class KerasImplementation(FrameworkImplementation):
                                                      core_config,
                                                      fw_info)
 
+    def compute_activation_bias_correction(self,
+                                           graph: Graph,
+                                           quant_config: QuantizationConfig,
+                                           fw_info: FrameworkInfo):
+        """
+        Compute activation bias correction on a graph.
+
+        Args:
+            graph: Graph to apply activation bias correction on.
+            quant_config: QuantizationConfig of how the model should be quantized.
+            fw_info: FrameworkInfo object with information about the specific framework's model.
+
+        Returns:
+            Graph after activation bias correction computing.
+        """
+        return keras_compute_activation_bias_correction_of_graph(graph=graph,
+                                                                 quant_config=quant_config,
+                                                                 fw_info=fw_info,
+                                                                 fw_impl=self)
 
     def get_substitutions_channel_equalization(self,
                                                quant_config: QuantizationConfig,
@@ -309,7 +330,7 @@ class KerasImplementation(FrameworkImplementation):
         """
         return keras_op2d_add_const_collapsing()
 
-    def get_substitutions_post_statistics_collection(self, 
+    def get_substitutions_post_statistics_collection(self,
                                                      quant_config: QuantizationConfig) -> List[common.BaseSubstitution]:
         """
         Return a list of the framework substitutions used after we collect statistics.

model_compression_toolkit/core/keras/statistics_correction/keras_compute_activation_bias_correction_of_graph.py

@@ -0,0 +1,67 @@
+# Copyright 2024 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import tensorflow as tf
+from packaging import version
+
+from model_compression_toolkit.core.keras.constants import KERNEL_SIZE
+
+if version.parse(tf.__version__) >= version.parse("2.13"):
+    from keras.src.layers import Conv2D, DepthwiseConv2D, Dense, Conv2DTranspose
+else:
+    from keras.layers import Conv2D, DepthwiseConv2D, Dense, Conv2DTranspose
+
+from model_compression_toolkit.core import QuantizationConfig
+from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
+from model_compression_toolkit.core.common.framework_info import FrameworkInfo
+from model_compression_toolkit.core.common import Graph
+from model_compression_toolkit.core.common.graph.graph_matchers import NodeOperationMatcher
+from model_compression_toolkit.core.common.statistics_correction.compute_activation_bias_correction_of_graph import \
+    compute_activation_bias_correction_of_graph
+
+
+def activation_bias_correction_node_matchers():
+    # Match linear layers where we can add a correction.
+    linear_node = NodeOperationMatcher(Conv2D) | \
+                  NodeOperationMatcher(Dense) | \
+                  NodeOperationMatcher(DepthwiseConv2D) | \
+                  NodeOperationMatcher(Conv2DTranspose)
+    return linear_node
+
+
+def keras_compute_activation_bias_correction_of_graph(graph: Graph,
+                                                      quant_config: QuantizationConfig,
+                                                      fw_info: FrameworkInfo,
+                                                      fw_impl: FrameworkImplementation) -> Graph:
+    """
+    Compute the activation bias correction term for graph based on a Keras model.
+
+    Args:
+        graph: Graph with nodes to compute the activation bias correction.
+        quant_config: QuantizationConfig of how the model should be quantized.
+        fw_info: Framework info like lists of nodes their kernel should quantized.
+        fw_impl: FrameworkImplementation object with a specific framework methods implementation.
+
+    Returns:
+        Graph with activation bias correction term for each relevant node.
+    """
+    graph = compute_activation_bias_correction_of_graph(graph=graph,
+                                                        quant_config=quant_config,
+                                                        fw_info=fw_info,
+                                                        fw_impl=fw_impl,
+                                                        activation_bias_correction_node_matchers=
+                                                        activation_bias_correction_node_matchers,
+                                                        kernel_size=KERNEL_SIZE)
+    return graph

model_compression_toolkit/core/pytorch/pytorch_implementation.py

@@ -92,6 +92,8 @@ from model_compression_toolkit.core.pytorch.pytorch_node_prior_info import creat
 from model_compression_toolkit.core.pytorch.reader.reader import model_reader
 from model_compression_toolkit.core.pytorch.statistics_correction.apply_second_moment_correction import \
     pytorch_apply_second_moment_correction
+from model_compression_toolkit.core.pytorch.statistics_correction.pytorch_compute_activation_bias_correction_of_graph import \
+    pytorch_compute_activation_bias_correction_of_graph
 from model_compression_toolkit.core.pytorch.utils import to_torch_tensor, torch_tensor_to_numpy, set_model
 from model_compression_toolkit.exporter.model_wrapper.fw_agnostic.get_inferable_quantizers import \
     get_inferable_quantizers
@@ -212,6 +214,25 @@ class PytorchImplementation(FrameworkImplementation):
                                                        core_config,
                                                        fw_info)
 
+    def compute_activation_bias_correction(self,
+                                           graph: Graph,
+                                           quant_config: QuantizationConfig,
+                                           fw_info: FrameworkInfo):
+        """
+        Compute activation bias correction on a graph.
+
+        Args:
+            graph: Graph to apply activation bias correction on.
+            quant_config: QuantizationConfig of how the model should be quantized.
+            fw_info: FrameworkInfo object with information about the specific framework's model.
+
+        Returns:
+            Graph after activation bias correction computing.
+        """
+        return pytorch_compute_activation_bias_correction_of_graph(graph=graph,
+                                                                   quant_config=quant_config,
+                                                                   fw_info=fw_info,
+                                                                   fw_impl=self)
 
     def get_substitutions_channel_equalization(self,
                                                quant_config: QuantizationConfig,

model_compression_toolkit/core/pytorch/statistics_correction/pytorch_compute_activation_bias_correction_of_graph.py

@@ -0,0 +1,57 @@
+# Copyright 2024 Sony Semiconductor Israel, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from torch.nn import Conv2d, Linear, ConvTranspose2d
+
+from model_compression_toolkit.core import QuantizationConfig
+from model_compression_toolkit.core.common import Graph
+from model_compression_toolkit.core.common.framework_implementation import FrameworkImplementation
+from model_compression_toolkit.core.common.framework_info import FrameworkInfo
+from model_compression_toolkit.core.common.graph.graph_matchers import NodeOperationMatcher
+from model_compression_toolkit.core.common.statistics_correction.compute_activation_bias_correction_of_graph import \
+    compute_activation_bias_correction_of_graph
+from model_compression_toolkit.core.pytorch.constants import KERNEL_SIZE
+
+
+def activation_bias_correction_node_matchers():
+    # Match linear layers where we can add a correction.
+    linear_node = NodeOperationMatcher(Linear) | NodeOperationMatcher(Conv2d) | NodeOperationMatcher(ConvTranspose2d)
+    return linear_node
+
+
+def pytorch_compute_activation_bias_correction_of_graph(graph: Graph,
+                                                        quant_config: QuantizationConfig,
+                                                        fw_info: FrameworkInfo,
+                                                        fw_impl: FrameworkImplementation) -> Graph:
+    """
+    Compute the activation bias correction term for graph based on a PyTorch model.
+
+    Args:
+        graph: Graph with nodes to compute the activation bias correction.
+        quant_config: QuantizationConfig of how the model should be quantized.
+        fw_info: Framework info like lists of nodes their kernel should quantized.
+        fw_impl: FrameworkImplementation object with a specific framework methods implementation.
+
+    Returns:
+        Graph with activation bias correction term for each relevant node.
+    """
+    graph = compute_activation_bias_correction_of_graph(graph=graph,
+                                                        quant_config=quant_config,
+                                                        fw_info=fw_info,
+                                                        fw_impl=fw_impl,
+                                                        activation_bias_correction_node_matchers=
+                                                        activation_bias_correction_node_matchers,
+                                                        kernel_size=KERNEL_SIZE)
+    return graph

model_compression_toolkit/core/runner.py

@@ -164,6 +164,14 @@ def core_runner(in_model: Any,
                         tg,
                         bit_widths_config)
 
+    ######################################
+    # Compute Activation Bias Correction
+    ######################################
+    if core_config.quantization_config.activation_bias_correction:
+        tg = fw_impl.compute_activation_bias_correction(graph=tg,
+                                                        quant_config=core_config.quantization_config,
+                                                        fw_info=fw_info)
+
     # Edit the graph again after finalizing the configurations.
     # This is since some actions regard the final configuration and should be edited.
     edit_network_graph(tg, fw_info, core_config.debug_config.network_editor)

tests_pytest/__init__.py

@@ -1,14 +0,0 @@
-# Copyright 2024 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================

tests_pytest/keras/__init__.py

@@ -1,14 +0,0 @@
-# Copyright 2024 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================

tests_pytest/keras/core/__init__.py

@@ -1,14 +0,0 @@
-# Copyright 2024 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================

tests_pytest/keras/core/test_data_util.py

@@ -1,91 +0,0 @@
-# Copyright 2024 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-import numpy as np
-import pytest
-
-from model_compression_toolkit.core.keras.data_util import data_gen_to_dataloader, TFDatasetFromGenerator
-
-
-@pytest.fixture(scope='session')
-def fixed_dataset():
-    # generate 320 images with data1[i] = i and data2[i] = i+10
-    data1 = np.stack([np.full((3, 30, 20), v) for v in range(320)], axis=0)
-    data2 = np.stack([np.full((10,), v + 10) for v in range(320)], axis=0)
-    return data1, data2
-
-
-@pytest.fixture
-def fixed_gen(fixed_dataset):
-    def f():
-        for i in range(10):
-            yield [fixed_dataset[0][32 * i: 32 * (i + 1)], fixed_dataset[1][32 * i: 32 * (i + 1)]]
-
-    return f
-
-
-def get_random_data_gen_fn(seed=42):
-    """ get gen factory for reproducible gen yielding different samples in each epoch """
-    rng = np.random.default_rng(seed)
-
-    def f():
-        for i in range(10):
-            yield [rng.random((32, 3, 20, 30)).astype(np.float32), rng.random((32, 10)).astype(np.float32)]
-    return f
-
-
-class TestTFDataUtil:
-    create_dataloader_fn = data_gen_to_dataloader
-
-    def test_iterable_dataset_from_fixed_gen(self, fixed_gen):
-        """ tests iterable dataset from fixed gen - same samples are generated in each epoch in the same order """
-        ds = TFDatasetFromGenerator(fixed_gen, batch_size=1)
-        self._validate_ds_from_fixed_gen(ds, 320)
-
-    def test_iterable_dataset_from_random_gen(self):
-        """ test that dataset samples over epochs are identical to the original data generator """
-        ds = TFDatasetFromGenerator(get_random_data_gen_fn(), batch_size=1)
-        pass1 = np.concatenate([t[0] for t in ds], axis=0)
-        pass2 = np.concatenate([t[0] for t in ds], axis=0)
-
-        gen_fn = get_random_data_gen_fn()
-        # one invocation is used for validation and batch size in dataset, so promote the reference gen for comparison
-        next(gen_fn())
-        gen_pass1 = np.concatenate([t[0] for t in gen_fn()], axis=0)
-        gen_pass2 = np.concatenate([t[0] for t in gen_fn()], axis=0)
-        # check that each pass is identical to corresponding pass in the original gen
-        assert np.array_equal(pass1, gen_pass1)
-        assert np.array_equal(pass2, gen_pass2)
-        assert not np.allclose(pass1, pass2)
-
-    def test_dataloader(self, fixed_gen):
-        ds = TFDatasetFromGenerator(fixed_gen, batch_size=25)
-        ds_iter = iter(ds)
-        batch1 = next(ds_iter)
-        assert batch1[0].shape[0] == batch1[1].shape[0] == 25
-        assert np.array_equal(batch1[0][0], np.full((3, 30, 20), 0))
-        assert np.array_equal(batch1[1][0], np.full((10,), 10))
-        assert np.array_equal(batch1[0][-1], np.full((3, 30, 20), 24))
-        assert np.array_equal(batch1[1][-1], np.full((10,), 34))
-        assert len(ds) == 13
-        assert ds.orig_batch_size == 32
-
-    def _validate_ds_from_fixed_gen(self, ds, exp_len):
-        for _ in range(2):
-            for i, sample in enumerate(ds):
-                assert np.array_equal(sample[0].cpu().numpy(), np.full((1, 3, 30, 20), i))
-                assert np.array_equal(sample[1].cpu().numpy(), np.full((1, 10,), i + 10))
-            assert i == exp_len - 1
-            assert ds.orig_batch_size == 32
-            assert len(ds) == exp_len

tests_pytest/keras/gptq/__init__.py

@@ -1,14 +0,0 @@
-# Copyright 2024 Sony Semiconductor Israel, Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================