modelconv 0.5.3__tar.gz → 0.5.4__tar.gz

{modelconv-0.5.3 → modelconv-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelconv
-Version: 0.5.3
+Version: 0.5.4
 Summary: Converter for neural models into various formats.
 Author-email: Luxonis <support@luxonis.com>
 Maintainer-email: Luxonis <support@luxonis.com>
@@ -33,6 +33,7 @@ Requires-Dist: depthai~=3.0; extra == "bench"
 Provides-Extra: analysis
 Requires-Dist: polars; extra == "analysis"
 Requires-Dist: plotly; extra == "analysis"
+Requires-Dist: depthai~=3.0; extra == "analysis"
 Provides-Extra: dev
 Requires-Dist: pre-commit==3.2.1; extra == "dev"
 Requires-Dist: pytest-cov>=4.1.0; extra == "dev"

{modelconv-0.5.3 → modelconv-0.5.4}/modelconv.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelconv
-Version: 0.5.3
+Version: 0.5.4
 Summary: Converter for neural models into various formats.
 Author-email: Luxonis <support@luxonis.com>
 Maintainer-email: Luxonis <support@luxonis.com>
@@ -33,6 +33,7 @@ Requires-Dist: depthai~=3.0; extra == "bench"
 Provides-Extra: analysis
 Requires-Dist: polars; extra == "analysis"
 Requires-Dist: plotly; extra == "analysis"
+Requires-Dist: depthai~=3.0; extra == "analysis"
 Provides-Extra: dev
 Requires-Dist: pre-commit==3.2.1; extra == "dev"
 Requires-Dist: pytest-cov>=4.1.0; extra == "dev"

{modelconv-0.5.3 → modelconv-0.5.4}/modelconv.egg-info/SOURCES.txt

@@ -45,11 +45,11 @@ modelconverter/packages/rvc4/inferer.py
 modelconverter/packages/rvc4/requirements.txt
 modelconverter/packages/rvc4/visualize.py
 modelconverter/utils/__init__.py
-modelconverter/utils/adb_handler.py
-modelconverter/utils/adb_monitor.py
 modelconverter/utils/calibration_data.py
 modelconverter/utils/config.py
 modelconverter/utils/constants.py
+modelconverter/utils/device_handlers.py
+modelconverter/utils/device_monitors.py
 modelconverter/utils/docker_utils.py
 modelconverter/utils/environ.py
 modelconverter/utils/exceptions.py

{modelconv-0.5.3 → modelconv-0.5.4}/modelconv.egg-info/requires.txt

@@ -14,6 +14,7 @@ psutil
 [analysis]
 polars
 plotly
+depthai~=3.0
 
 [bench]
 depthai~=3.0

{modelconv-0.5.3 → modelconv-0.5.4}/modelconverter/__init__.py

@@ -4,7 +4,7 @@ from typing import Final
 from luxonis_ml.utils import PUT_FILE_REGISTRY
 from pydantic_extra_types.semantic_version import SemanticVersion
 
-__version__: Final[str] = "0.5.3"
+__version__: Final[str] = "0.5.4"
 __semver__: Final[SemanticVersion] = SemanticVersion.parse(__version__)
 
 

{modelconv-0.5.3 → modelconv-0.5.4}/modelconverter/packages/base_exporter.py

@@ -5,6 +5,7 @@ from importlib.metadata import version
 from pathlib import Path
 from typing import Any
 
+import cv2
 import numpy as np
 from loguru import logger
 
@@ -225,7 +226,24 @@ class Exporter(ABC):
                 arr = np.clip(arr, calib.min_value, calib.max_value)
 
                 arr = arr.astype(calib.data_type.as_numpy_dtype())
-                np.save(dest / f"{i}.npy", arr)
+                if len(arr.shape) in {2, 3} or (
+                    len(arr.shape) in {3, 4} and arr.shape[0] == 1
+                ):
+                    layout = inp.layout
+                    if arr.shape[0] == 1 and len(arr.shape) > 2:
+                        arr = arr.squeeze(0)
+                        if layout is not None:
+                            layout = layout[1:]
+
+                    if layout is not None and "C" in layout:
+                        channel_dim = layout.index("C")
+                        if channel_dim == 0 and len(arr.shape) == 3:
+                            arr = arr.transpose(1, 2, 0)
+                    elif arr.shape[0] in {1, 3}:  # type: ignore
+                        arr = arr.transpose(1, 2, 0)
+                    cv2.imwrite(str(dest / f"{i}.png"), arr)
+                else:
+                    np.save(dest / f"{i}.npy", arr)
 
             self.inputs[name].calibration = ImageCalibrationConfig(path=dest)
 

{modelconv-0.5.3 → modelconv-0.5.4}/modelconverter/packages/rvc3/exporter.py

@@ -31,6 +31,7 @@ class RVC3Exporter(RVC2Exporter):
         self.mo_args = config.rvc3.mo_args
         self.compile_tool_args = config.rvc3.compile_tool_args
         self.device = "VPUX.3400"
+        self.reverse_input_channels = False
         self._device_specific_buildinfo = {}
 
     def export(self) -> Path:

{modelconv-0.5.3 → modelconv-0.5.4}/modelconverter/packages/rvc4/analyze.py

@@ -14,7 +14,7 @@ from PIL import Image
 
 from modelconverter.packages.base_analyze import Analyzer
 from modelconverter.packages.rvc4.benchmark import get_device_info
-from modelconverter.utils import AdbHandler, constants, subprocess_run
+from modelconverter.utils import constants, create_handler, subprocess_run
 
 
 class RVC4Analyzer(Analyzer):
@@ -27,7 +27,7 @@ class RVC4Analyzer(Analyzer):
     ):
         super().__init__(dlc_model_path, image_dirs)
         _, device_adb_id = get_device_info(device_ip, device_id)
-        self.adb = AdbHandler(device_adb_id)
+        self.handler = create_handler(device_ip, device_adb_id)
 
     def analyze_layer_outputs(self, onnx_model_path: Path) -> None:
         input_matcher = self._prepare_input_matcher()
@@ -76,8 +76,8 @@ class RVC4Analyzer(Analyzer):
         self, input_matcher: dict[str, dict[str, str]], type: type = np.uint8
     ) -> dict[str, str]:
         logger.info("Preparing raw inputs for RVC4 analysis.")
-        self.adb.shell(f"rm -rf /data/modelconverter/{self.model_name}")
-        self.adb.shell(
+        self.handler.shell(f"rm -rf /data/modelconverter/{self.model_name}")
+        self.handler.shell(
             f"mkdir -p /data/modelconverter/{self.model_name}/inputs"
         )
 
@@ -109,7 +109,7 @@ class RVC4Analyzer(Analyzer):
 
                 with tempfile.NamedTemporaryFile() as f:
                     raw_image.tofile(f)
-                    self.adb.push(
+                    self.handler.push(
                         f.name,
                         f"/data/modelconverter/{self.model_name}/inputs/{input_name}_{img_name}.raw",
                     )
@@ -122,7 +122,7 @@ class RVC4Analyzer(Analyzer):
         with tempfile.NamedTemporaryFile() as f:
             f.write(input_list.encode())
             f.flush()
-            self.adb.push(
+            self.handler.push(
                 f.name,
                 f"/data/modelconverter/{self.model_name}/input_list.txt",
             )
@@ -133,8 +133,12 @@ class RVC4Analyzer(Analyzer):
         return dlc_matcher
 
     def _add_outputs_to_all_layers(self, onnx_file_path: str) -> Path:
-        if Path(onnx_file_path.replace(".onnx", "-all-layers.onnx")).exists():
-            Path(onnx_file_path.replace(".onnx", "-all-layers.onnx")).unlink()
+        onnx_path = Path(onnx_file_path)
+        all_output_path = onnx_path.with_name(
+            f"{onnx_path.stem}-all-layers{onnx_path.suffix}"
+        )
+        if all_output_path.exists():
+            all_output_path.unlink()
 
         model = onnx.load(onnx_file_path)
         onnx.checker.check_model(model)
@@ -152,10 +156,10 @@ class RVC4Analyzer(Analyzer):
 
         for output in orig_graph_output:
             graph.output.append(output)
-        all_output_name = onnx_file_path.replace(".onnx", "-all-layers.onnx")
-        onnx.save(model, all_output_name)
+        all_output_path.parent.mkdir(parents=True, exist_ok=True)
+        onnx.save(model, all_output_path)
 
-        return Path(all_output_name)
+        return all_output_path
 
     def transpose_to_match(
         self, src: np.ndarray, target_shape: tuple[int, ...]
@@ -321,14 +325,14 @@ class RVC4Analyzer(Analyzer):
     def _run_dlc(self, command: str) -> str:
         logger.info("Inferencing DLC model on device.")
         try:
-            self.adb.push(
+            self.handler.push(
                 str(self.dlc_model_path),
                 f"/data/modelconverter/{self.model_name}/{self.model_name}.dlc",
             )
-            self.adb.shell(
+            self.handler.shell(
                 f"rm -rf /data/modelconverter/{self.model_name}/output"
             )
-            self.adb.shell(
+            self.handler.shell(
                 f"cd /data/modelconverter/{self.model_name} && {command}"
             )
 
@@ -337,7 +341,7 @@ class RVC4Analyzer(Analyzer):
                 shutil.rmtree(target_dir / "output")
 
             target_dir.mkdir(parents=True, exist_ok=True)
-            self.adb.pull(
+            self.handler.pull(
                 f"/data/modelconverter/{self.model_name}/output",
                 f"{target_dir}/output",
             )
@@ -397,7 +401,7 @@ class RVC4Analyzer(Analyzer):
 
         logger.info("Running DLC model to analyze layer cycles.")
         output_dir = self._run_dlc(
-            f"snpe-net-run --container {self.model_name}.dlc --input_list input_list.txt --use_dsp --use_native_input_files --use_native_output_files --perf_profile balanced --userbuffer_tf8"
+            f"snpe-net-run --container {self.model_name}.dlc --input_list input_list.txt --use_dsp --use_native_input_files --use_native_output_files --perf_profile balanced --userbuffer_auto"
         )
 
         csv_path = Path(output_dir + "/layer_stats.csv")
@@ -456,7 +460,7 @@ class RVC4Analyzer(Analyzer):
 
     # cleanup
     def _cleanup_dlc_outputs(self) -> None:
-        self.adb.shell(f"rm -rf /data/modelconverter/{self.model_name}")
+        self.handler.shell(f"rm -rf /data/modelconverter/{self.model_name}")
 
         output_dir = Path(
             f"{constants.OUTPUTS_DIR!s}/analysis/{self.model_name}/output"

{modelconv-0.5.3 → modelconv-0.5.4}/modelconverter/packages/rvc4/benchmark.py

@@ -4,9 +4,9 @@ import re
 import shutil
 import tempfile
 from collections.abc import Iterable
-from contextlib import suppress
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Final, cast
+from typing import Final
 
 import depthai as dai
 import numpy as np
@@ -19,9 +19,9 @@ from modelconverter.packages.base_benchmark import (
     Configuration,
 )
 from modelconverter.utils import (
-    AdbHandler,
-    AdbMonitorDSP,
-    AdbMonitorPower,
+    MonitorDSP,
+    MonitorPower,
+    create_handler,
     create_progress_handler,
     environ,
     subprocess_run,
@@ -45,6 +45,26 @@ RUNTIMES: dict[str, str] = {
     "cpu": "use_cpu",
 }
 
+DLC_TO_DAI_DATA_TYPE: Final[dict[str, dai.TensorInfo.DataType]] = {
+    "Float_32": dai.TensorInfo.DataType.FP32,
+    "Float_16": dai.TensorInfo.DataType.FP16,
+    "Float_64": dai.TensorInfo.DataType.FP64,
+    "Int_8": dai.TensorInfo.DataType.I8,
+    "Int_32": dai.TensorInfo.DataType.INT,
+    # DAI does not currently expose a 16-bit fixed-point/int tensor type.
+    # Until it does, keep uFxp_16 on the closest supported 16-bit path.
+    "uFxp_16": dai.TensorInfo.DataType.FP16,
+    "uFxp_8": dai.TensorInfo.DataType.U8F,
+}
+
+
+@dataclass(frozen=True)
+class InputSpec:
+    name: str
+    shape: list[int]
+    dlc_dtype: str
+    dai_dtype: dai.TensorInfo.DataType
+
 
 class RVC4Benchmark(Benchmark):
     @property
@@ -80,15 +100,29 @@ class RVC4Benchmark(Benchmark):
             for threads in [1, 2]
         ]
 
-    def _get_input_sizes(
+    def _get_dlc_input_specs(
         self, model_path: str | Path | None = None
-    ) -> tuple[dict[str, list[int]], dict[str, str]]:
+    ) -> list[InputSpec]:
+        """Retrieve normalized input specs from a DLC or NNArchive."""
+        model_path = self.model_path if model_path is None else model_path
+
+        if str(model_path).endswith(".tar.xz"):
+            with tempfile.TemporaryDirectory() as tmp_dir:
+                shutil.unpack_archive(model_path, tmp_dir)
+                dlc_files = list(Path(tmp_dir).rglob("*.dlc"))
+                if not dlc_files:
+                    raise ValueError("No .dlc file found in the archive.")
+                return self._get_dlc_input_specs(dlc_files[0])
+
+        if not str(model_path).endswith(".dlc"):
+            raise ValueError("Expected .dlc, or .tar.xz model format.")
+
         csv_path = Path("info.csv")
         subprocess_run(
             [
                 "snpe-dlc-info",
                 "-i",
-                self.model_path if model_path is None else model_path,
+                model_path,
                 "-s",
                 csv_path,
             ],
@@ -110,146 +144,70 @@ class RVC4Benchmark(Benchmark):
         )
 
         rows = df.rows(named=True)
-        sizes = {row["Input Name"]: row["Dimensions"] for row in rows}
-        data_types = {row["Input Name"]: row["Type"] for row in rows}
+        data_types = [str(row["Type"]) for row in rows]
+        unsupported_types = sorted(set(data_types) - set(DLC_TO_DAI_DATA_TYPE))
+        if unsupported_types:
+            raise ValueError(
+                f"Unsupported data types {unsupported_types}. Expected one of: {sorted(DLC_TO_DAI_DATA_TYPE)}."
+            )
 
-        return sizes, data_types
+        return [
+            InputSpec(
+                name=str(row["Input Name"]),
+                shape=list(row["Dimensions"]),
+                dlc_dtype=str(row["Type"]),
+                dai_dtype=DLC_TO_DAI_DATA_TYPE[str(row["Type"])],
+            )
+            for row in rows
+        ]
 
-    def _prepare_raw_inputs(self, num_images: int) -> None:
-        input_sizes, data_types = self._get_input_sizes()
+    def _prepare_raw_inputs(
+        self, input_specs: list[InputSpec], num_images: int
+    ) -> None:
         input_list = ""
-        self.adb.shell(
+        self.handler.shell(
             f"mkdir -p /data/modelconverter/{self.model_name}/inputs"
         )
         for i in range(num_images):
-            for name, size in input_sizes.items():
-                if data_types[name] == "Float_32":
-                    numpy_type = np.float32
-                elif data_types[name] in ["uFxp_16", "Float_16"]:
-                    numpy_type = np.float16
-                elif data_types[name] == "uFxp_8":
-                    numpy_type = np.uint8
-                else:
-                    raise ValueError(
-                        f"Unsupported data type {data_types[name]} for input {name}."
-                    )
-                img = cast(np.ndarray, np.random.rand(*size)).astype(
-                    numpy_type
-                )
+            for spec in input_specs:
+                input_data = self._create_random_input(spec)
                 with tempfile.NamedTemporaryFile() as f:
-                    img.tofile(f)
-                    self.adb.push(
+                    input_data.tofile(f)
+                    self.handler.push(
                         f.name,
-                        f"/data/modelconverter/{self.model_name}/inputs/{name}_{i}.raw",
+                        f"/data/modelconverter/{self.model_name}/inputs/{spec.name}_{i}.raw",
                     )
 
-                input_list += f"{name}:=/data/modelconverter/{self.model_name}/inputs/{name}_{i}.raw "
+                input_list += f"{spec.name}:=/data/modelconverter/{self.model_name}/inputs/{spec.name}_{i}.raw "
             input_list += "\n"
 
         with tempfile.NamedTemporaryFile() as f:
             f.write(input_list.encode())
-            self.adb.push(
+            self.handler.push(
                 f.name,
                 f"/data/modelconverter/{self.model_name}/input_list.txt",
             )
 
-    def _get_data_type_from_dlc(self) -> dai.TensorInfo.DataType:
-        """Retrieve the data type of the dlc model info.
-
-        If the model is in NNArchive format, decompress it and then
-        retrieve the data type.
-        """
-
-        if str(self.model_path).endswith(".dlc"):
-            _, data_types = self._get_input_sizes()
-        elif str(self.model_path).endswith(".tar.xz"):
-            with tempfile.TemporaryDirectory() as tmp_dir:
-                shutil.unpack_archive(self.model_path, tmp_dir)
-
-                dlc_files = list(Path(tmp_dir).rglob("*.dlc"))
-                if not dlc_files:
-                    raise ValueError("No .dlc file found in the archive.")
-                dlc_path = dlc_files[0]
-
-                _, data_types = self._get_input_sizes(dlc_path)
-        else:
-            raise ValueError("Expected .dlc, or .tar.xz model format.")
-
-        model_input = next(iter(data_types.values()))
-        if model_input == "Float_32":
-            return dai.TensorInfo.DataType.FP32
-        if model_input in ["uFxp_16", "Float_16"]:
-            return dai.TensorInfo.DataType.FP16
-        if model_input == "uFxp_8":
-            return dai.TensorInfo.DataType.U8F
-        raise ValueError(
-            f"Unsupported data type {model_input}. Expected Float_32, Float_16, or uFxp_8."
-        )
-
-    def _get_data_type(self) -> dai.TensorInfo.DataType:
-        """Retrieve the data type of the model inputs. If the model is
-        not a HubAI model, it defaults to dai.TensorInfo.DataType.U8F
-        (INT8).
-
-        @return: The data type of the model inputs.
-        @rtype: dai.TensorInfo.DataType
-        """
-        from modelconverter.cli import Request, slug_to_id
-
-        if not isinstance(
-            self.model_path, str
-        ) or not self.HUB_MODEL_PATTERN.match(self.model_path):
-            return self._get_data_type_from_dlc()
-
-        model_id = slug_to_id(self.model_name, "models")
-        model_variant = self.model_path.split(":")[1]
-
-        model_variants = []
-        for is_public in [True, False]:
-            with suppress(Exception):
-                model_variants += Request.get(
-                    "modelVersions/",
-                    params={"model_id": model_id, "is_public": is_public},
-                )
-
-        model_version_id = None
-        for version in model_variants:
-            if version["variant_slug"] == model_variant:
-                model_version_id = version["id"]
-                break
-
-        if not model_version_id:
-            return dai.TensorInfo.DataType.U8F
-
-        model_instances = []
-        for is_public in [True, False]:
-            with suppress(Exception):
-                model_instances += Request.get(
-                    "modelInstances/",
-                    params={
-                        "model_id": model_id,
-                        "model_version_id": model_version_id,
-                        "is_public": is_public,
-                    },
-                )
-
-        model_precision_type = "INT8"
-        for instance in model_instances:
-            if instance["platforms"] == ["RVC4"] and (
-                self.model_instance is None
-                or instance["hash_short"] == self.model_instance
-            ):
-                model_precision_type = instance.get(
-                    "model_precision_type", "INT8"
-                )
-                break
-
-        if model_precision_type == "FP16":
-            return dai.TensorInfo.DataType.FP16
-        if model_precision_type == "FP32":
-            return dai.TensorInfo.DataType.FP32
-
-        return dai.TensorInfo.DataType.U8F
+    @staticmethod
+    def _create_random_input(
+        spec: InputSpec,
+    ) -> np.ndarray:
+        if spec.dai_dtype == dai.TensorInfo.DataType.FP32:
+            return np.random.rand(*spec.shape).astype(np.float32)
+        if spec.dai_dtype == dai.TensorInfo.DataType.FP16:
+            return np.random.rand(*spec.shape).astype(np.float16)
+        if spec.dai_dtype == dai.TensorInfo.DataType.FP64:
+            return np.random.rand(*spec.shape).astype(np.float64)
+        if spec.dai_dtype == dai.TensorInfo.DataType.I8:
+            return np.random.randint(-128, 128, size=spec.shape, dtype=np.int8)
+        if spec.dai_dtype == dai.TensorInfo.DataType.INT:
+            # INT inputs are often token/index tensors; zero keeps synthetic
+            # benchmark inputs in a safe range.
+            return np.zeros(spec.shape, dtype=np.int32)
+        if spec.dai_dtype == dai.TensorInfo.DataType.U8F:
+            return np.random.randint(0, 256, size=spec.shape, dtype=np.uint8)
+
+        raise ValueError(f"Unsupported DAI data type {spec.dai_dtype}.")
 
     def benchmark(self, configuration: Configuration) -> BenchmarkResult:
         dai_benchmark = configuration.get("dai_benchmark")
@@ -260,18 +218,18 @@ class RVC4Benchmark(Benchmark):
             configuration.get("device_ip"), configuration.get("device_id")
         )
         if power_benchmark or dsp_benchmark or not dai_benchmark:
-            self.adb = AdbHandler(device_adb_id)
+            self.handler = create_handler(device_ip, device_adb_id)
 
         configuration["device_ip"] = device_ip
 
         self.power_monitor = None
         if power_benchmark:
-            self.power_monitor = AdbMonitorPower(self.adb)
+            self.power_monitor = MonitorPower(self.handler)
             self.power_monitor.start()
 
         self.dsp_monitor = None
         if dsp_benchmark:
-            self.dsp_monitor = AdbMonitorDSP(self.adb)
+            self.dsp_monitor = MonitorDSP(self.handler)
             self.dsp_monitor.start()
 
         try:
@@ -315,7 +273,7 @@ class RVC4Benchmark(Benchmark):
                 # so we don't delete the wrong directory
                 assert self.model_name
 
-                self.adb.shell(
+                self.handler.shell(
                     f"rm -rf /data/modelconverter/{self.model_name}"
                 )
 
@@ -345,7 +303,6 @@ class RVC4Benchmark(Benchmark):
             dlc_path = next(tmp_dir.rglob(dlc_model_name), None)
             if not dlc_path:
                 raise ValueError("Could not find model.dlc in the archive.")
-            self.model_path = dlc_path
         elif str(model_path).endswith(".dlc"):
             dlc_path = model_path
         else:
@@ -353,13 +310,14 @@ class RVC4Benchmark(Benchmark):
                 "Unsupported model format. Supported formats: .dlc, or HubAI model slug."
             )
 
-        self.adb.shell(f"mkdir -p /data/modelconverter/{self.model_name}")
-        self.adb.push(
+        input_specs = self._get_dlc_input_specs(dlc_path)
+        self.handler.shell(f"mkdir -p /data/modelconverter/{self.model_name}")
+        self.handler.push(
             str(dlc_path), f"/data/modelconverter/{self.model_name}/model.dlc"
         )
-        self._prepare_raw_inputs(num_images)
+        self._prepare_raw_inputs(input_specs, num_images)
 
-        _, stdout, _ = self.adb.shell(
+        _, stdout, _ = self.handler.shell(
             # "source /data/modelconverter/source_me.sh && "
             "snpe-parallel-run "
             f"--container /data/modelconverter/{self.model_name}/model.dlc "
@@ -408,15 +366,17 @@ class RVC4Benchmark(Benchmark):
         )
 
         if isinstance(model_path, str):
-            modelPath = dai.getModelFromZoo(
-                dai.NNModelDescription(
-                    model_path,
-                    platform=device.getPlatformAsString(),
-                ),
-                apiKey=environ.HUBAI_API_KEY or "",
+            modelPath = Path(
+                dai.getModelFromZoo(
+                    dai.NNModelDescription(
+                        model_path,
+                        platform=device.getPlatformAsString(),
+                    ),
+                    apiKey=environ.HUBAI_API_KEY or "",
+                )
             )
         elif str(model_path).endswith(".tar.xz"):
-            modelPath = str(model_path)
+            modelPath = Path(model_path)
         elif str(model_path).endswith(".dlc"):
             raise ValueError(
                 "DLC model format is not currently supported for dai-benchmark. Please use SNPE for DLC models."
@@ -426,19 +386,15 @@ class RVC4Benchmark(Benchmark):
                 "Unsupported model format. Supported formats: .tar.xz, or HubAI model slug."
             )
 
-        inputSizes = []
-        inputNames = []
+        input_specs: list[InputSpec] = []
         if isinstance(model_path, str) or str(model_path).endswith(".tar.xz"):
-            modelArhive = dai.NNArchive(modelPath)  # type: ignore[arg-type]
-            for input in modelArhive.getConfig().model.inputs:
-                inputSizes.append(input.shape)
-                inputNames.append(input.name)
+            model_archive = dai.NNArchive(modelPath)  # type: ignore[arg-type]
+            input_specs = self._get_dlc_input_specs(modelPath)
 
-        data_type = self._get_data_type()
         inputData = dai.NNData()
-        for name, inputSize in zip(inputNames, inputSizes, strict=True):
-            img = np.random.randint(0, 255, inputSize, np.uint8)
-            inputData.addTensor(name, img, dataType=data_type)
+        for spec in input_specs:
+            input_data = self._create_random_input(spec)
+            inputData.addTensor(spec.name, input_data, dataType=spec.dai_dtype)
 
         with dai.Pipeline(device) as pipeline:
             benchmarkOut = pipeline.create(dai.node.BenchmarkOut)
@@ -449,7 +405,7 @@ class RVC4Benchmark(Benchmark):
             if isinstance(model_path, str) or str(model_path).endswith(
                 ".tar.xz"
             ):
-                neuralNetwork.setNNArchive(modelArhive)
+                neuralNetwork.setNNArchive(model_archive)
 
             neuralNetwork.setBackendProperties(
                 {

{modelconv-0.5.3 → modelconv-0.5.4}/modelconverter/packages/rvc4/exporter.py

@@ -187,6 +187,7 @@ class RVC4Exporter(Exporter):
             args.append("--override_params")
         elif self.quantization_mode == QuantizationMode.INT8_16_MIX:
             self._add_args(args, ["--act_bitwidth", "16"])
+            args.append("--override_params")
         elif self.encodings is not None:
             args.append("--override_params")
 

{modelconv-0.5.3 → modelconv-0.5.4}/modelconverter/utils/__init__.py

@@ -1,6 +1,11 @@
-from .adb_handler import AdbHandler
-from .adb_monitor import AdbMonitorDSP, AdbMonitorPower
 from .calibration_data import download_calibration_data
+from .device_handlers import (
+    AdbHandler,
+    DeviceHandler,
+    SSHHandler,
+    create_handler,
+)
+from .device_monitors import MonitorDSP, MonitorPower
 from .docker_utils import (
     check_docker,
     docker_build,
@@ -46,16 +51,19 @@ from .subprocess import SubprocessHandle, subprocess_run
 
 __all__ = [
     "AdbHandler",
-    "AdbMonitorDSP",
-    "AdbMonitorPower",
+    "DeviceHandler",
     "Metadata",
     "ModelconverterException",
+    "MonitorDSP",
+    "MonitorPower",
     "ONNXModifier",
     "S3Exception",
+    "SSHHandler",
     "SubprocessException",
     "SubprocessHandle",
     "archive_from_model",
     "check_docker",
+    "create_handler",
     "create_progress_handler",
     "docker_build",
     "docker_exec",