bigdl-core-npu 2.5.0__cp311-cp311-win_amd64.whl

intel_npu_acceleration_library/external/openvino/tools/ovc/convert.py

@@ -0,0 +1,102 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import pathlib
+from typing import Any
+
+from openvino.runtime import Model  # pylint: disable=no-name-in-module,import-error
+from openvino.tools.ovc.cli_parser import get_all_cli_parser
+from openvino.tools.ovc.convert_impl import _convert
+from openvino.tools.ovc.logger import get_logger_state, restore_logger_state
+
+
+def convert_model(
+        input_model: [str, pathlib.Path, Any, list],
+        # TODO: Instead of list just accept arbitrary number of positional arguments
+
+        # Framework-agnostic parameters
+        input: [list, dict, str] = None,
+        output: [str, list] = None,
+        example_input: Any = None,
+        extension: [str, pathlib.Path, list, Any] = None,
+        verbose: bool = False,
+        share_weights: bool = True,
+) -> Model:
+    """
+    Converts the model from original framework to OpenVino Model.
+
+    Framework-agnostic parameters:
+        :param input_model:
+            Model object in original framework (PyTorch, Tensorflow) or path to model file.
+
+            Supported formats of input model:
+
+            PyTorch
+            torch.nn.Module
+            torch.jit.ScriptModule
+            torch.jit.ScriptFunction
+
+            TF
+            tf.compat.v1.Graph
+            tf.compat.v1.GraphDef
+            tf.compat.v1.wrap_function
+            tf.compat.v1.session
+
+            TF2 / Keras
+            tf.keras.Model
+            tf.keras.layers.Layer
+            tf.function
+            tf.Module
+            tf.train.checkpoint
+
+            PaddlePaddle
+            paddle.hapi.model.Model
+            paddle.fluid.dygraph.layers.Layer
+            paddle.fluid.executor.Executor
+
+        :param input:
+            Information of model input required for model conversion.
+            Input can be set by a list of tuples or a dictionary. Each tuple can contain optionally input name (string),
+            input type (ov.Type, numpy.dtype) or input shape (ov.Shape, ov.PartialShape, list, tuple).
+            Example: input=("op_name", PartialShape([-1, 3, 100, 100]), ov.Type.f32).
+            Alternatively input can be set by a dictionary, where key - input name,
+            value - tuple with input parameters (shape or type).
+            Example 1: input={"op_name_1": ([1, 2, 3], ov.Type.f32), "op_name_2": ov.Type.i32}
+            Example 2: input=[("op_name_1", [1, 2, 3], ov.Type.f32), ("op_name_2", ov.Type.i32)]
+            Example 3: input=[([1, 2, 3], ov.Type.f32), ov.Type.i32]
+            The order of inputs in converted model will match the order of specified inputs.
+            If data type is not specified explicitly data type is taken from the original node data type.
+
+        :param output:
+            One or more comma-separated model outputs to be preserved in the converted model. Other outputs are removed.
+            If `output` parameter is not specified then all outputs from the original model are preserved.
+            Do not add :0 to the names for TensorFlow. The order of outputs in the converted model is the same as
+            the order of specified names. Example: output="out_1", or output=["out_1", "out_2"].
+            For PaddlePaddle model represented as a Python object, you can specify outputs as a PaddlePaddle Python
+            objects or a list of such objects.
+        :param example_input:
+            Sample of model input in original framework.
+            For PyTorch it can be torch.Tensor.
+            For Tensorflow it can be tf.Tensor or numpy.ndarray.
+            For PaddlePaddle it can be Paddle Variable.
+        :param extension:
+            Paths to libraries (.so or .dll) with extensions, comma-separated
+            list of paths, objects derived from BaseExtension class or lists of
+            objects.
+        :param verbose:
+            Print detailed information about conversion.
+        :param share_weights:
+            Reuse weights allocated in the original model. If input model is in file,
+            then mmap is used to allocate weights directly from file. If input model is
+            runtime object, then original memory regions allocated in the original model
+            are reused for weights in the converted model.
+
+    Returns:
+        openvino.runtime.Model
+    """
+    params = locals()
+    logger_state = get_logger_state()
+    cli_parser = get_all_cli_parser()
+    ov_model, _ = _convert(cli_parser, params, True)
+    restore_logger_state(logger_state)
+    return ov_model

intel_npu_acceleration_library/external/openvino/tools/ovc/convert_data_type.py

@@ -0,0 +1,82 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import numpy as np
+
+from openvino.tools.ovc.error import Error
+
+"""
+Packed data of custom types are stored in numpy uint8 data type.
+To distinguish true uint8 and custom data we introduce this class not to store,
+but to have unique data type in SUPPORTED_DATA_TYPES map
+"""
+
+
+class packed_U1(np.generic):
+    pass
+
+
+class packed_U4(np.generic):
+    pass
+
+
+class packed_I4(np.generic):
+    pass
+
+
+SUPPORTED_DATA_TYPES = {
+    'float': (np.float32, 'FP32', 'f32'),
+    'half': (np.float16, 'FP16', 'f16'),
+    'FP32': (np.float32, 'FP32', 'f32'),
+    'FP64': (np.float64, 'FP64', 'f64'),
+    'FP16': (np.float16, 'FP16', 'f16'),
+    'I32': (np.int32, 'I32', 'i32'),
+    'I64': (np.int64, 'I64', 'i64'),
+    'int8': (np.int8, 'I8', 'i8'),
+    'int32': (np.int32, 'I32', 'i32'),
+    'int64': (np.int64, 'I64', 'i64'),
+    'bool': (bool, 'BOOL', 'boolean'),
+    'uint8': (np.uint8, 'U8', 'u8'),
+    'uint32': (np.uint32, 'U32', 'u32'),
+    'uint64': (np.uint64, 'U64', 'u64'),
+
+    # custom types
+    'U1': (packed_U1, 'U1', 'u1'),
+    'int4': (packed_I4, 'I4', 'i4'),
+    'uint4': (packed_U4, 'U4', 'u4'),
+    'I4': (packed_I4, 'I4', 'i4'),
+    'U4': (packed_U4, 'U4', 'u4'),
+}
+
+
+def data_type_str_to_np(data_type_str: str):
+    return SUPPORTED_DATA_TYPES[data_type_str][0] if data_type_str in SUPPORTED_DATA_TYPES else None
+
+
+def data_type_str_to_precision(data_type_str: str):
+    return SUPPORTED_DATA_TYPES[data_type_str][1] if data_type_str in SUPPORTED_DATA_TYPES else None
+
+
+def data_type_str_to_destination_type(data_type_str: str):
+    return SUPPORTED_DATA_TYPES[data_type_str][2] if data_type_str in SUPPORTED_DATA_TYPES else None
+
+
+def np_data_type_to_precision(np_data_type):
+    for np_t, precision, _ in SUPPORTED_DATA_TYPES.values():
+        if np_t == np_data_type:
+            return precision
+    raise Error('Data type "{}" is not supported'.format(np_data_type))
+
+
+def np_data_type_to_destination_type(np_data_type):
+    for np_t, _, destination_type in SUPPORTED_DATA_TYPES.values():
+        if np_t == np_data_type:
+            return destination_type
+    raise Error('Data type "{}" is not supported'.format(np_data_type))
+
+
+def precision_to_destination_type(data_type_str):
+    for _, precision, destination_type in SUPPORTED_DATA_TYPES.values():
+        if precision == data_type_str:
+            return destination_type
+    raise Error('Data type "{}" is not supported'.format(data_type_str))