mct-nightly 2.3.0.20250410.526__tar.gz → 2.3.0.20250411.529__tar.gz

{mct_nightly-2.3.0.20250410.526 → mct_nightly-2.3.0.20250411.529}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250410.526
+Version: 2.3.0.20250411.529
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License

{mct_nightly-2.3.0.20250410.526 → mct_nightly-2.3.0.20250411.529}/mct_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mct-nightly
-Version: 2.3.0.20250410.526
+Version: 2.3.0.20250411.529
 Summary: A Model Compression Toolkit for neural networks
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License

{mct_nightly-2.3.0.20250410.526 → mct_nightly-2.3.0.20250411.529}/mct_nightly.egg-info/SOURCES.txt

@@ -444,6 +444,7 @@ model_compression_toolkit/target_platform_capabilities/immutable.py
 model_compression_toolkit/target_platform_capabilities/tpc_io_handler.py
 model_compression_toolkit/target_platform_capabilities/schema/__init__.py
 model_compression_toolkit/target_platform_capabilities/schema/mct_current_schema.py
+model_compression_toolkit/target_platform_capabilities/schema/schema_compatability.py
 model_compression_toolkit/target_platform_capabilities/schema/schema_functions.py
 model_compression_toolkit/target_platform_capabilities/schema/v1.py
 model_compression_toolkit/target_platform_capabilities/schema/v2.py

{mct_nightly-2.3.0.20250410.526 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/__init__.py

@@ -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.3.0.20250410.000526"
+__version__ = "2.3.0.20250411.000529"

mct_nightly-2.3.0.20250411.529/model_compression_toolkit/target_platform_capabilities/schema/schema_compatability.py

@@ -0,0 +1,84 @@
+# Copyright 2025 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 typing import Any, Union
+
+import model_compression_toolkit.target_platform_capabilities.schema.v1 as schema_v1
+import model_compression_toolkit.target_platform_capabilities.schema.v2 as schema_v2
+import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as current_schema
+
+ALL_SCHEMA_VERSIONS = [schema_v1]  # needs to be updated with all active schema versions
+FUTURE_SCHEMA_VERSIONS = [schema_v2]  # once future schema becomes current schema, move to it ALL_SCHEMA_VERSIONS
+all_tpc_types = tuple([s.TargetPlatformCapabilities for s in ALL_SCHEMA_VERSIONS])
+tpc_or_str_type = all_tpc_types + (str,)
+
+
+def is_tpc_instance(tpc_obj_or_path: Any) -> bool:
+    """
+    Checks if the given object is an instance of a TargetPlatformCapabilities
+    :param tpc_obj_or_path: Object to check its type
+    :return: True if the given object is an instance of a TargetPlatformCapabilities, False otherwise
+    """
+    return type(tpc_obj_or_path) in all_tpc_types
+
+
+def _schema_v1_to_v2(tpc: schema_v1.TargetPlatformCapabilities) -> schema_v2.TargetPlatformCapabilities:  # pragma: no cover
+    """
+    Converts given tpc of schema version 1 to schema version 2
+    :return: TargetPlatformCapabilities instance of of schema version 2
+    """
+    raise NotImplementedError("Once schema v2 is implemented, add necessary adaptations to _schema_v1_to_v2 function and remove 'pragma: no cover'")
+    return schema_v2.TargetPlatformCapabilities(default_qco=tpc.default_qco,
+                                             operator_set=tpc.operator_set,
+                                             fusing_patterns=tpc.fusing_patterns,
+                                             tpc_minor_version=tpc.tpc_minor_version,
+                                             tpc_patch_version=tpc.tpc_patch_version,
+                                             tpc_platform_type=tpc.tpc_platform_type,
+                                             add_metadata=tpc.add_metadata)
+
+def get_conversion_map() -> dict:
+    """
+    Retrieves the schema conversion map.
+    :return: A dictionary where:
+        - Keys representing supported source schema versions.
+        - Values are Callable functions that take tpc in one schema version and return it in the next (higher) version
+    """
+    conversion_map = {
+        schema_v1.TargetPlatformCapabilities: _schema_v1_to_v2,
+    }
+    return conversion_map
+
+
+def tpc_to_current_schema_version(tpc: Union[all_tpc_types]) -> current_schema.TargetPlatformCapabilities:  # pragma: no cover
+    """
+    Given tpc instance of some schema version, convert it to the current MCT schema version.
+
+    In case a new schema is added to MCT, need to add a conversion function from the previous version to the new
+    version, e.g. if the current schema version was updated from v4 to v5, need to add _schema_v4_to_v5 function to
+    this file, and add it to the conversion_map.
+
+    :param tpc: TargetPlatformCapabilities of some schema version
+    :return: TargetPlatformCapabilities with the current MCT schema version
+    """
+    conversion_map = get_conversion_map()
+    prev_tpc_type = type(tpc)
+    while not isinstance(tpc, current_schema.TargetPlatformCapabilities):
+        if type(tpc) not in conversion_map:
+            raise KeyError(f"TPC using schema version {tpc.SCHEMA_VERSION} which is not in schemas conversion map. "
+                           f"Make sure the schema version is supported, or add it in case it's a new schema version")
+        tpc = conversion_map[type(tpc)](tpc)
+        if isinstance(tpc, prev_tpc_type):
+            raise RuntimeError(f"TPC of type {prev_tpc_type} failed to update to next schema version")
+        prev_tpc_type = type(tpc)
+    return tpc

{mct_nightly-2.3.0.20250410.526 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/target_platform_capabilities/schema/v2.py

@@ -110,4 +110,5 @@ class TargetPlatformCapabilities(BaseModel):
         """
         Display the TargetPlatformCapabilities.
         """
-        pprint.pprint(self.get_info(), sort_dicts=False)
+        pprint.pprint(self.get_info(), sort_dicts=False)
+

{mct_nightly-2.3.0.20250410.526 → mct_nightly-2.3.0.20250411.529}/model_compression_toolkit/target_platform_capabilities/tpc_io_handler.py

@@ -15,12 +15,39 @@
 from pathlib import Path
 from typing import Union
 
-from model_compression_toolkit.logger import Logger
-from model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema import TargetPlatformCapabilities
-import json
+import model_compression_toolkit.target_platform_capabilities.schema.mct_current_schema as schema
+from model_compression_toolkit.target_platform_capabilities.schema.schema_compatability import is_tpc_instance, \
+    tpc_to_current_schema_version, tpc_or_str_type
 
 
-def load_target_platform_capabilities(tpc_obj_or_path: Union[TargetPlatformCapabilities, str]) -> TargetPlatformCapabilities:
+def _get_tpc_from_json(tpc_path: str) -> schema.TargetPlatformCapabilities:
+    """
+    Given a TPC json file path, parse it and returns a TargetPlatformCapabilities instance
+    :param tpc_path: json file path
+    :return: Parsed TargetPlatformCapabilities instance
+    """
+    path = Path(tpc_path)
+
+    if not path.exists() or not path.is_file():
+        raise FileNotFoundError(f"The path '{tpc_path}' is not a valid file.")
+    # Verify that the file has a .json extension
+    if path.suffix.lower() != '.json':
+        raise ValueError(f"The file '{path}' does not have a '.json' extension.")
+    try:
+        with path.open('r', encoding='utf-8') as file:
+            data = file.read()
+    except OSError as e:
+        raise ValueError(f"Error reading the file '{tpc_path}': {e.strerror}.") from e
+
+    try:
+        return schema.TargetPlatformCapabilities.parse_raw(data)
+    except ValueError as e:
+        raise ValueError(f"Invalid JSON for loading TargetPlatformCapabilities in '{tpc_path}': {e}.") from e
+    except Exception as e:
+        raise ValueError(f"Unexpected error while initializing TargetPlatformCapabilities: {e}.") from e
+
+
+def load_target_platform_capabilities(tpc_obj_or_path: Union[tpc_or_str_type]) -> schema.TargetPlatformCapabilities:
     """
         Parses the tpc input, which can be either a TargetPlatformCapabilities object
         or a string path to a JSON file.
@@ -36,37 +63,22 @@ def load_target_platform_capabilities(tpc_obj_or_path: Union[TargetPlatformCapab
             ValueError: If the JSON content is invalid or cannot initialize the TargetPlatformCapabilities.
             TypeError: If the input is neither a TargetPlatformCapabilities nor a valid JSON file path.
         """
-    if isinstance(tpc_obj_or_path, TargetPlatformCapabilities):
-        return tpc_obj_or_path
-
-    if isinstance(tpc_obj_or_path, str):
-        path = Path(tpc_obj_or_path)
-
-        if not path.exists() or not path.is_file():
-            raise FileNotFoundError(f"The path '{tpc_obj_or_path}' is not a valid file.")
-        # Verify that the file has a .json extension
-        if path.suffix.lower() != '.json':
-            raise ValueError(f"The file '{path}' does not have a '.json' extension.")
-        try:
-            with path.open('r', encoding='utf-8') as file:
-                data = file.read()
-        except OSError as e:
-            raise ValueError(f"Error reading the file '{tpc_obj_or_path}': {e.strerror}.") from e
-
-        try:
-            return TargetPlatformCapabilities.parse_raw(data)
-        except ValueError as e:
-            raise ValueError(f"Invalid JSON for loading TargetPlatformCapabilities in '{tpc_obj_or_path}': {e}.") from e
-        except Exception as e:
-            raise ValueError(f"Unexpected error while initializing TargetPlatformCapabilities: {e}.") from e
-
-    raise TypeError(
-        f"tpc_obj_or_path must be either a TargetPlatformCapabilities instance or a string path to a JSON file, "
-        f"but received type '{type(tpc_obj_or_path).__name__}'."
-    )
-
-
-def export_target_platform_capabilities(model: TargetPlatformCapabilities, export_path: Union[str, Path]) -> None:
+    if is_tpc_instance(tpc_obj_or_path):
+        tpc = tpc_obj_or_path
+    elif isinstance(tpc_obj_or_path, str):
+        tpc = _get_tpc_from_json(tpc_obj_or_path)
+    else:
+        raise TypeError(
+            f"tpc_obj_or_path must be either a TargetPlatformCapabilities instance or a string path to a JSON file, "
+            f"but received type '{type(tpc_obj_or_path).__name__}'."
+        )
+
+    if isinstance(tpc, schema.TargetPlatformCapabilities):  # if tpc is of current schema version
+        return tpc
+    return tpc_to_current_schema_version(tpc)
+
+
+def export_target_platform_capabilities(model: schema.TargetPlatformCapabilities, export_path: Union[str, Path]) -> None:
     """
     Exports a TargetPlatformCapabilities instance to a JSON file.
 
@@ -78,7 +90,7 @@ def export_target_platform_capabilities(model: TargetPlatformCapabilities, expor
         ValueError: If the model is not an instance of TargetPlatformCapabilities.
         OSError: If there is an issue writing to the file.
     """
-    if not isinstance(model, TargetPlatformCapabilities):
+    if not is_tpc_instance(model):
         raise ValueError("The provided model is not a valid TargetPlatformCapabilities instance.")
 
     path = Path(export_path)