bigdl-core-npu 2.5.0__cp310-cp310-win_amd64.whl

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

@@ -0,0 +1,45 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+def get_convert_model_help_specifics():
+    from openvino.tools.ovc.cli_parser import CanonicalizePathCheckExistenceAction, readable_dirs_or_files_or_empty
+    from openvino.tools.ovc.version import VersionChecker
+    return {
+        'input_model':
+            {'description':
+                 'Input model file(s) from TensorFlow, ONNX, PaddlePaddle. '
+                 'Use openvino.convert_model in Python to convert models from PyTorch.'
+                 '',
+             'action': CanonicalizePathCheckExistenceAction,
+             'type': readable_dirs_or_files_or_empty,
+             'aliases': {}},
+        'input':
+            {'description':
+                 'Information of model input required for model conversion. '
+                 'This is a comma separated list with optional '
+                 'input names and shapes. The order of inputs '
+                 'in converted model will match the order of '
+                 'specified inputs. The shape is specified as comma-separated list. '
+                 'Example, to set `input_1` input with shape [1,100] and `sequence_len` input '
+                 'with shape [1,?]: \"input_1[1,100],sequence_len[1,?]\", where "?" is a dynamic dimension, '
+                 'which means that such a dimension can be specified later in the runtime. '
+                 'If the dimension is set as an integer (like 100 in [1,100]), such a dimension is not supposed '
+                 'to be changed later, during a model conversion it is treated as a static value. '
+                 'Example with unnamed inputs: \"[1,100],[1,?]\".'},
+        'output':
+            {'description':
+                 '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: ovc model.onnx output=out_1,out_2'},
+        'extension':
+            {'description':
+                 'Paths or a comma-separated list of paths to libraries '
+                 '(.so or .dll) with extensions.'},
+        'version':
+            {'action': 'version',
+             # FIXME: Why the following is not accessible from arg parser?
+             'version': 'OpenVINO Model Converter (ovc) {}'.format(VersionChecker().get_ie_version())},
+    }

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

@@ -0,0 +1,91 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import importlib.util
+import logging as log
+import os
+import re
+from copy import copy
+
+# WA for abseil bug that affects logging while importing TF starting 1.14 version
+# Link to original issue: https://github.com/abseil/abseil-py/issues/99
+if importlib.util.find_spec('absl') is not None:
+    import absl.logging # pylint: disable=import-error
+
+    log.root.removeHandler(absl.logging._absl_handler)
+
+handler_num = 0
+
+
+class LvlFormatter(log.Formatter):
+    format_dict = {
+        log.DEBUG: "[ %(asctime)s ] [ %(levelname)s ] [ %(module)s:%(lineno)d ]  %(msg)s",
+        log.INFO: "[ %(levelname)s ]  %(msg)s",
+        log.WARNING: "[ WARNING ]  %(msg)s",
+        log.ERROR: "[ %(levelname)s ]  %(msg)s",
+        log.CRITICAL: "[ %(levelname)s ]  %(msg)s",
+        'framework_error': "[ FRAMEWORK ERROR ]  %(msg)s",
+        'analysis_info': "[ ANALYSIS INFO ]  %(msg)s"
+    }
+
+    def __init__(self, lvl, fmt=None):
+        log.Formatter.__init__(self, fmt)
+        self.lvl = lvl
+
+    def format(self, record: log.LogRecord):
+        if self.lvl == 'DEBUG':
+            self._style._fmt = self.format_dict[log.DEBUG]
+        else:
+            self._style._fmt = self.format_dict[record.levelno]
+        if 'is_warning' in record.__dict__.keys():
+            self._style._fmt = self.format_dict[log.WARNING]
+        if 'framework_error' in record.__dict__.keys():
+            self._style._fmt = self.format_dict['framework_error']
+        if 'analysis_info' in record.__dict__.keys():
+            self._style._fmt = self.format_dict['analysis_info']
+        return log.Formatter.format(self, record)
+
+
+class TagFilter(log.Filter):
+    def __init__(self, regex: str):
+        self.regex = regex
+
+    def filter(self, record: log.LogRecord):
+        if record.__dict__['funcName'] == 'load_grammar':  # for nx not to log into our logs
+            return False
+        if self.regex:
+            if 'tag' in record.__dict__.keys():
+                tag = record.__dict__['tag']
+                return re.findall(self.regex, tag)
+            else:
+                return False
+        return True  # if regex wasn't set print all logs
+
+
+def init_logger(lvl: str, verbose: bool):
+    global handler_num
+    log_exp = os.environ.get('MO_LOG_PATTERN')
+    if not verbose:
+        lvl = 'ERROR'
+    fmt = LvlFormatter(lvl=lvl)
+    handler = log.StreamHandler()
+    handler.setFormatter(fmt)
+    logger = log.getLogger()
+    logger.setLevel(lvl)
+    logger.addFilter(TagFilter(regex=log_exp))
+    if handler_num == 0 and len(logger.handlers) == 0:
+        logger.addHandler(handler)
+        handler_num += 1
+
+
+def get_logger_state():
+    logger = log.getLogger()
+    return logger.level, copy(logger.filters), copy(logger.handlers)
+
+
+def restore_logger_state(state: tuple):
+    level, filters, handlers = state
+    logger = log.getLogger()
+    logger.setLevel(level)
+    logger.filters = filters
+    logger.handlers = handlers

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

@@ -0,0 +1,35 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import sys
+
+try:
+    import openvino_telemetry as tm
+    from openvino_telemetry.backend import backend_ga4
+except ImportError:
+    import openvino.tools.ovc.telemetry_stub as tm
+from openvino.tools.ovc.convert_impl import _convert
+from openvino.tools.ovc.cli_parser import get_model_name_from_args
+
+# pylint: disable=no-name-in-module,import-error
+from openvino.runtime import save_model
+
+
+def main():
+    from openvino.tools.ovc.cli_parser import get_all_cli_parser
+    ngraph_function, argv = _convert(get_all_cli_parser(), {}, False)
+    if ngraph_function is None:
+        return 1
+
+    model_path = get_model_name_from_args(argv)
+
+    compress_to_fp16 = 'compress_to_fp16' in argv and argv.compress_to_fp16
+    save_model(ngraph_function, model_path.encode('utf-8'), compress_to_fp16)
+
+    print('[ SUCCESS ] XML file: {}'.format(model_path))
+    print('[ SUCCESS ] BIN file: {}'.format(model_path.replace('.xml', '.bin')))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

intel_npu_acceleration_library/external/openvino/tools/ovc/moc_frontend/__init__.py

@@ -0,0 +1,2 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0

intel_npu_acceleration_library/external/openvino/tools/ovc/moc_frontend/analysis.py

@@ -0,0 +1,46 @@
+# Copyright (C) 2022 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+
+from openvino.runtime import PartialShape, Model, Type  # pylint: disable=no-name-in-module,import-error
+from openvino.runtime.utils.types import get_dtype  # pylint: disable=no-name-in-module,import-error
+
+
+def json_model_analysis_dump(framework_model: Model):
+    def dump_partial_shape(shape: PartialShape):
+        if shape.rank.is_dynamic:
+            return 'None'
+        return [dim.get_length() if dim.is_static else 0 for dim in shape]
+
+    def dump_element_type(ov_type: Type):
+        try:
+            return str(get_dtype(ov_type))
+        except:
+            return 'None'
+
+    json_dump = {}
+    json_dump['inputs'] = {}
+    for param in framework_model.get_parameters():
+        param_name = param.get_friendly_name()
+        json_dump['inputs'][param_name] = {}
+        json_dump['inputs'][param_name]['shape'] = dump_partial_shape(param.get_partial_shape())
+        json_dump['inputs'][param_name]['data_type'] = dump_element_type(param.get_element_type())
+        json_dump['inputs'][param_name]['value'] = 'None'  # not supported in 22.1
+
+    json_dump['intermediate'] = {}
+    # TODO: extend model analysis dump for operations with body graphs (If, Loop, and TensorIterator)
+    for op in filter(lambda node: node.type_info.name != "NullNode", framework_model.get_ordered_ops()):
+        for out_idx in range(op.get_output_size()):
+            output = op.output(out_idx)
+            tensor_name = output.get_any_name()
+            json_dump['intermediate'][tensor_name] = {}
+            json_dump['intermediate'][tensor_name]['shape'] = dump_partial_shape(output.get_partial_shape())
+            json_dump['intermediate'][tensor_name]['data_type'] = dump_element_type(output.get_element_type())
+            json_dump['intermediate'][tensor_name]['value'] = 'None'  # not supported in 22.1
+
+    json_model_analysis_print(json_dump)
+
+
+def json_model_analysis_print(json_dump: str):
+    print(json.dumps(json_dump))

intel_npu_acceleration_library/external/openvino/tools/ovc/moc_frontend/check_config.py

@@ -0,0 +1,57 @@
+# Copyright (C) 2022-2023 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import argparse
+import os
+from pathlib import Path
+
+from openvino.tools.ovc.error import Error
+
+
+def default_path():
+    EXT_DIR_NAME = '.'
+    return os.path.abspath(os.getcwd().join(EXT_DIR_NAME))
+
+
+def any_extensions_used(argv: argparse.Namespace):
+    # Checks that extensions are provided.
+    # Allowed types are string containing path to legacy extension directory
+    # or path to new extension .so file, or classes inherited from BaseExtension.
+    if not hasattr(argv, 'extension') or argv.extension is None:
+        return False
+    if not isinstance(argv.extension, (list, tuple)):
+        argv.extension = [argv.extension]
+
+    if isinstance(argv.extension, (list, tuple)) and len(argv.extension) > 0:
+        has_non_default_path = False
+        has_non_str_objects = False
+        for ext in argv.extension:
+            if not isinstance(ext, str):
+                has_non_str_objects = True
+                continue
+            if len(ext) == 0 or ext == default_path():
+                continue
+            has_non_default_path = True
+
+        return has_non_default_path or has_non_str_objects
+
+    raise Exception("Expected list of extensions, got {}.".format(type(argv.extension)))
+
+
+def get_transformations_config_path(argv: argparse.Namespace) -> Path:
+    if hasattr(argv, 'transformations_config') \
+            and argv.transformations_config is not None and len(argv.transformations_config):
+        if isinstance(argv.transformations_config, str):
+            path = Path(argv.transformations_config)
+            if path.is_file():
+                return path
+    return None
+
+
+def legacy_transformations_config_used(argv: argparse.Namespace):
+    return get_transformations_config_path(argv) != None
+
+
+def tensorflow_custom_operations_config_update_used(argv: argparse.Namespace):
+    return hasattr(argv, 'tensorflow_custom_operations_config_update') and \
+           argv.tensorflow_custom_operations_config_update is not None