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

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

@@ -0,0 +1,83 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import sys
+import tempfile
+
+
+class paddle_frontend_converter:
+    def __init__(self, model, inputs=None, outputs=None):
+        self.model = model
+        self.inputs = inputs
+        self.outputs = outputs
+        self.tmp = None
+        self.model_name = None
+        self.pdmodel = None
+        self.pdiparams = None
+        self.pdiparams_info = None
+        self.is_generated = False
+
+    def destroy(self):
+        # close tmp file
+        if isinstance(self.tmp, tempfile._TemporaryFileWrapper):
+            self.tmp.close()
+
+        # remove the *.pdmodel
+        if os.path.exists(self.pdmodel):
+            os.remove(self.pdmodel)
+
+        # remove the *.pdiparams
+        if os.path.exists(self.pdiparams):
+            os.remove(self.pdiparams)
+
+        # remove the *.pdiparams.info
+        if os.path.exists(self.pdiparams_info):
+            os.remove(self.pdiparams_info)
+
+    def convert_paddle_to_pdmodel(self):
+        '''
+            There are three paddle model categories:
+            - High Level API: is a wrapper for dynamic or static model, use `self.save` to serialize
+            - Dynamic Model: use `paddle.jit.save` to serialize
+            - Static Model: use `paddle.static.save_inference_model` to serialize
+        '''
+        try:
+            self.tmp = tempfile.NamedTemporaryFile(delete=True)
+            self.model_name = self.tmp.name
+            self.pdmodel = "{}.pdmodel".format(self.model_name)
+            self.pdiparams = "{}.pdiparams".format(self.model_name)
+            self.pdiparams_info = "{}.pdiparams.info".format(self.model_name)
+
+            import paddle  # pylint: disable=import-error
+            if isinstance(self.model, paddle.hapi.model.Model):
+                self.model.save(self.model_name, False)
+            else:
+                if self.inputs is None:
+                    raise RuntimeError(
+                        "Saving inference model needs 'inputs' before saving. Please specify 'example_input'"
+                    )
+                if isinstance(self.model, paddle.fluid.dygraph.layers.Layer):
+                    with paddle.fluid.framework._dygraph_guard(None):
+                        paddle.jit.save(self.model, self.model_name, input_spec=self.inputs, output_spec=self.outputs)
+                elif isinstance(self.model, paddle.fluid.executor.Executor):
+                    if self.outputs is None:
+                        raise RuntimeError(
+                            "Model is static. Saving inference model needs 'outputs' before saving. Please specify 'output' for this model"
+                        )
+                    paddle.static.save_inference_model(self.model_name, self.inputs, self.outputs, self.model)
+                else:
+                    raise RuntimeError(
+                        "Conversion just support paddle.hapi.model.Model, paddle.fluid.dygraph.layers.Layer and paddle.fluid.executor.Executor"
+                    )
+
+            if not os.path.exists(self.pdmodel):
+                print("Failed generating paddle inference format model")
+                sys.exit(1)
+
+            self.is_generated = True
+            return self.pdmodel
+        finally:
+            # close tmp file
+            if isinstance(self.tmp, tempfile._TemporaryFileWrapper):
+                self.tmp.close()

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

@@ -0,0 +1,246 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import argparse
+import logging as log
+import sys
+from typing import List
+
+import numpy as np
+import os
+
+from openvino.frontend import FrontEnd, InputModel, NotImplementedFailure, \
+    Place  # pylint: disable=no-name-in-module,import-error
+from openvino.runtime import PartialShape, Type  # pylint: disable=no-name-in-module,import-error
+from openvino.runtime.utils.types import get_element_type, \
+    get_numpy_ctype  # pylint: disable=no-name-in-module,import-error
+from openvino.tools.ovc.moc_frontend.analysis import json_model_analysis_dump
+from openvino.tools.ovc.moc_frontend.extractor import fe_user_data_repack, convert_params_lists_to_dicts, \
+    fe_output_user_data_repack
+from openvino.tools.ovc.error import Error
+from openvino.tools.ovc.utils import np_map_cast, mo_array
+
+
+def get_enabled_and_disabled_transforms():
+    """
+    :return: tuple of lists with force enabled and disabled id of transformations.
+    """
+    disabled_transforms = os.environ['MO_DISABLED_TRANSFORMS'] if 'MO_DISABLED_TRANSFORMS' in os.environ else ''
+    enabled_transforms = os.environ['MO_ENABLED_TRANSFORMS'] if 'MO_ENABLED_TRANSFORMS' in os.environ else ''
+
+    assert isinstance(enabled_transforms, str)
+    assert isinstance(disabled_transforms, str)
+
+    disabled_transforms = disabled_transforms.split(',')
+    enabled_transforms = enabled_transforms.split(',')
+
+    return enabled_transforms, disabled_transforms
+
+
+def raise_exception_for_input_output_cut(model_inputs_or_outputs: List[Place], new_nodes: List[dict], is_input: bool):
+    for new_node in new_nodes:
+        node = new_node['node']
+
+        if not any([item.is_equal(node) for item in model_inputs_or_outputs]):
+            if is_input:
+                raise Exception("Name {} is not found among model inputs.".format(new_node['input_name']))
+            else:
+                raise Exception("Name {} is not found among model outputs.".format(new_node['output_name']))
+
+
+def moc_pipeline(argv: argparse.Namespace, moc_front_end: FrontEnd):
+    """
+    Load input model and convert it to nGraph function
+    :param: argv: parsed command line arguments
+    :param: moc_front_end: Loaded Frontend for converting input model
+    :return: converted nGraph function ready for serialization
+    """
+
+    share_weights = getattr(argv, 'share_weights', True)  # FIXME: Should be controlled by default value
+    if isinstance(argv.input_model, (tuple, list)) and len(argv.input_model) == 2:
+        # frozen format with v1 checkpoints
+        input_model = moc_front_end.load([part for part in argv.input_model], share_weights)
+    else:
+        input_model = moc_front_end.load(argv.input_model, share_weights)
+
+    '''elif argv.input_meta_graph: # TODO: Cover this case
+        input_model = moc_front_end.load(argv.input_meta_graph, share_weights)
+        if argv.output:
+            # Simulate original behavior with freezing model
+            # While freezing we do a cutting of model, to keep similar behavior we
+            # need to simulate similar behavior with natively supported model
+            outputs = fe_output_user_data_repack(input_model, argv.output, moc_front_end.get_name())
+            input_model.override_all_outputs([x['node'] for x in outputs])
+    '''
+    argv.placeholder_shapes, argv.placeholder_data_types = convert_params_lists_to_dicts(
+        input_model, argv.placeholder_shapes, argv.placeholder_data_types)
+
+    user_shapes, outputs, freeze_placeholder = fe_user_data_repack(
+        input_model, argv.placeholder_shapes, argv.placeholder_data_types,
+        argv.output, {}, moc_front_end.get_name())
+
+    def check_places_are_same(places_original: List[Place], places_new: List[Place]):
+        """
+        Check if set of new places is same as original or not.
+        :param places_original: List[Place] Original model places
+        :param places_new: List[Place] New list of places
+        :return: True if new list of places is same as original
+        """
+        return len(places_original) == len(places_new) and len(
+            [item for item in places_original if any(
+                [item.is_equal(item2['node']) for item2 in places_new])]) == len(places_original)
+
+    def add_names_to_tensors(model: InputModel, places: List[Place]):
+        """
+        Adds additional names to some model input tensors. This helper should be used
+        when a model modification is going to happen.
+        :param model The input model loaded by a given frontend
+        :param places An object containing Places and names that will be used for model modification
+        """
+        for new_input in places:
+            if 'input_name' not in new_input:
+                continue
+            try:
+                model.add_name_for_tensor(new_input['node'], new_input['input_name'])
+            except NotImplementedFailure as e:
+                # some frontends might not implement this method
+                log.warning('Could not add an additional name to a tensor pointed to by \'{}\'. Details: {}'.format(
+                    new_input['input_name'], str(e)))
+
+    enabled_transforms, disabled_transforms = get_enabled_and_disabled_transforms()
+    if 'ANALYSIS_JSON_PRINT' in enabled_transforms:
+        # NOTE that model analysis is performed before applying user's settings (inputs's shapes etc.)
+        framework_model = moc_front_end.decode(input_model)
+        json_model_analysis_dump(framework_model)
+        # a model is not processed further in json analysis mode
+        sys.exit(0)
+
+    model_inputs = input_model.get_inputs()
+    inputs_equal = True
+    if user_shapes:
+        # TODO: Remove this line when new 'cut' helper is introduced
+        raise_exception_for_input_output_cut(model_inputs, user_shapes, True)
+
+        inputs_equal = check_places_are_same(model_inputs, user_shapes)
+
+    outputs_equal = True
+    if outputs:
+        # TODO: Remove this line when new 'cut' helper is introduced
+        raise_exception_for_input_output_cut(input_model.get_outputs(), outputs, False)
+
+        outputs_equal = check_places_are_same(input_model.get_outputs(), outputs)
+    log.debug('Inputs are same: {}, outputs are same: {}'.format(
+        inputs_equal, outputs_equal))
+
+    def create_target_input_shapes(new_input_places):
+        if isinstance(new_input_places, list) and len(new_input_places) > 1 \
+                and isinstance(new_input_places[0], tuple):
+            return new_input_places
+        new_input_place_names = [x.get_names()[0] for x in new_input_places]
+        shapes = [shape for shape in argv.placeholder_shapes.values()]
+        return dict(zip(new_input_place_names, shapes))
+
+    if not inputs_equal and not outputs_equal:
+        log.debug('Using extract subgraph')
+        new_input_places = [x['node'] for x in user_shapes]
+        new_output_places = [x['node'] for x in outputs]
+        add_names_to_tensors(input_model, user_shapes)
+        input_model.extract_subgraph(new_input_places, new_output_places)
+        # invalidation of existing Place objects could have happened in the operation above
+        if user_shapes:
+            placeholder_shapes = create_target_input_shapes(new_input_places)
+            new_output_places_name = [x.get_names()[0] for x in new_output_places]
+
+            user_shapes, outputs, _ = fe_user_data_repack(
+                input_model, placeholder_shapes, argv.placeholder_data_types,
+                new_output_places_name, {}, moc_front_end.get_name())
+    elif not inputs_equal:
+        log.debug('Using override_all_inputs')
+        add_names_to_tensors(input_model, user_shapes)
+        new_input_places = [x['node'] for x in user_shapes]
+        input_model.override_all_inputs(new_input_places)
+        # invalidation of existing Place objects could have happened in the operation above
+        if user_shapes:
+            placeholder_shapes = create_target_input_shapes(new_input_places)
+
+            user_shapes, outputs, _ = fe_user_data_repack(
+                input_model, placeholder_shapes, argv.placeholder_data_types,
+                argv.output, {}, moc_front_end.get_name())
+    elif not outputs_equal:
+        log.debug('Using override_all_outputs')
+        add_names_to_tensors(input_model, user_shapes)
+        new_output_places = [x['node'] for x in outputs]
+        input_model.override_all_outputs(new_output_places)
+        # invalidation of existing Place objects could have happened in the operation above
+        if user_shapes:
+            model_inputs = input_model.get_inputs()
+
+    if user_shapes:
+        for user_shape in user_shapes:
+            if user_shape.get('shape') is not None:
+                input_model.set_partial_shape(
+                    user_shape['node'], user_shape['shape'])
+            if user_shape.get('data_type') is not None:
+                data_type = user_shape['data_type']
+                log.debug('Set data type: {}'.format(data_type))
+                input_model.set_element_type(user_shape['node'], data_type)
+
+    if freeze_placeholder:
+        for name, value in freeze_placeholder.items():
+            node = None
+            # look for the certain place in user_shapes
+            for node_cur in user_shapes:
+                if node_cur.get('input_name') == name:
+                    node = node_cur
+                    break
+            if node is None:
+                raise Error("Please check correctness of the command-line. "
+                            "Place (operation or tensor) with name {} is not found.".format(name))
+            place = node.get('node')
+
+            if node.get('data_type'):
+                dtype = node['data_type']
+                ov_type = Type(dtype)
+            else:
+                # we need to detect type of Placeholder
+                try:
+                    ov_type = input_model.get_element_type(place)
+                except NotImplementedFailure:
+                    raise Error("Please specify type for value freezing {} node explicitly "
+                                "because the frontend does not support automatic type detection.".format(name))
+                # in case of cutting graph (or using custom inputs) and unspecified or dynamic type,
+                # the default type is fp32
+                if ov_type == Type.undefined or ov_type == Type.dynamic:
+                    ov_type = Type.f32
+                dtype = get_numpy_ctype(ov_type)
+
+            input_model.set_element_type(place, ov_type)
+            # prepare and cast value to dtype
+            if isinstance(value, list):
+                casted_list = list()
+                for v in mo_array(value):
+                    casted_list.append(np_map_cast[dtype](v))
+                value = mo_array(casted_list, dtype=dtype)
+            else:
+                value = np_map_cast[dtype](value)
+            value = np.array(value, dtype=dtype)
+
+            ov_shape = input_model.get_partial_shape(place)
+            if node.get('shape'):
+                # set user defined shape
+                ov_shape = PartialShape(node['shape'])
+                input_model.set_partial_shape(place, ov_shape)
+            elif ov_shape.is_dynamic:
+                # in case of dynamic shape (dynamic rank or dynamic dimension)
+                # deduce it based on the value shape and set it
+                ov_shape = PartialShape(value.shape)
+                input_model.set_partial_shape(place, ov_shape)
+
+            input_model.set_tensor_value(place, value)
+
+    def shape_to_array(shape: PartialShape):
+        return [shape.get_dimension(i) for i in range(shape.rank.get_length())]
+
+    ov_model = moc_front_end.convert(input_model)
+
+    return ov_model

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

@@ -0,0 +1,220 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import argparse
+import logging as log
+
+from openvino.preprocess import PrePostProcessor  # pylint: disable=no-name-in-module,import-error
+# pylint: disable=no-name-in-module,import-error
+from openvino.runtime import Model, Layout, PartialShape
+from openvino.tools.ovc.error import Error
+from openvino.tools.ovc.moc_frontend.layout_utils import update_layout_to_dict
+from openvino.tools.ovc.utils import refer_to_faq_msg
+
+
+def check_keys_valid(ov_function: Model, dict_to_validate: dict, search_outputs: bool):
+    """
+    Internal function: checks if keys from cmd line arguments correspond to ov_function's inputs/outputs
+    Throws if some key is not found
+    Throws if some different keys point to the same actual input/output
+    """
+    nodes_used = {}
+    nodes = ov_function.inputs
+    if search_outputs:
+        nodes += ov_function.outputs
+
+    # We need to replace all node names from dict to tensor names
+    rename_dict = {}
+    # Find names for replacing
+    for name in dict_to_validate.keys():
+        for ov_node in nodes:
+            if name in ov_node.get_tensor().get_names():
+                break
+            elif name == ov_node.get_node().get_friendly_name():
+                assert len(ov_node.get_tensor().get_names()) > 0, 'Node must have at least one tensor name'
+                new_name = list(ov_node.get_tensor().get_names())[0]
+                rename_dict[name] = new_name
+                break
+
+    # Replace found node names with tensor names
+    for name, new_name in rename_dict.items():
+        assert name in dict_to_validate, 'Key {} is not in initial dict'.format(name)
+        assert new_name not in dict_to_validate, 'Key {} is already in initial dict'.format(new_name)
+        dict_to_validate[new_name] = dict_to_validate[name]
+        del dict_to_validate[name]
+
+    # validate the dict
+    for name in dict_to_validate.keys():
+        node_found = False
+        for ov_node in nodes:
+            if name in ov_node.get_tensor().get_names():
+                if ov_node in nodes_used:
+                    raise Error('Key for {} and {} point to same model input/output.'
+                                .format(name, nodes_used[ov_node]))
+                nodes_used[ov_node] = name
+                node_found = True
+                break
+
+        if not node_found:
+            if not search_outputs:
+                raise Error('Input with name {} wasn\'t found! {}'.format(name, refer_to_faq_msg(83)))
+            else:
+                raise Error('Input/Output with name {} wasn\'t found! {}'.format(name, refer_to_faq_msg(83)))
+
+
+def update_layout_is_input_flag(ov_function: Model, layout_values: dict):
+    """
+    Internal function: updates layout_values with flag whether each layout belongs to input or to output
+    """
+    for name, layout_value in layout_values.items():
+        layout_value['is_input'] = False
+        for ov_input in ov_function.inputs:
+            if name in ov_input.get_tensor().get_names():
+                layout_value['is_input'] = True
+                break
+    return layout_values
+
+
+def find_channels_dimension(shape: PartialShape, num_channels: int, name: str, layout_values):
+    """
+    Internal function. Finds dimension index matching with expected channels number
+    Raises error if there is no candidates or number of candidates is > 1
+    :param: shape Parameter's partial shape
+    :param: num_channels Number of channels to find in shape
+    :param: name Parameter's name, used for Error-handling purposes
+    :param: layout_values Existing source/target layout items specified by user
+    :return: updated layout items with guessed layouts
+    """
+    if shape.rank.is_dynamic:
+        raise Error('Can\'t determine channels dimension for dynamic shape for parameter {}.'
+                    .format(name))
+
+    dim_idx_found = -1
+    for dim_idx in range(shape.rank.get_length()):
+        dim = shape.get_dimension(dim_idx)
+        if dim.is_static and dim.get_length() == num_channels:
+            if dim_idx_found >= 0:
+                raise Error('Can\'t determine channels dimension for {}. '
+                            'Input shape is {}, needed channels {}. '
+                            'Conflicting dimensions: {} and {}. Please specify layout manually.'
+                            .format(name, shape, num_channels, dim_idx_found, dim_idx))
+            dim_idx_found = dim_idx
+    if dim_idx_found < 0:
+        raise Error('Can\'t determine channels dimension for {}. '
+                    'Input shape is {}, needed channels {}'
+                    .format(name, shape, num_channels))
+
+    # Restrict guessed channels index to particular position depending on tensor shape(3d, 4d, 5d)
+    if shape.rank.get_length() == 3:
+        # CHW or HWC, possible channels index is 0 or 2
+        if dim_idx_found != 0 and dim_idx_found != 2:
+            raise Error('Can\'t determine channels dimension for 3D input {} (CHW or HWC) with shape {}. '
+                        'Please specify layout containing \'C\' channels manually.'.format(name, shape))
+    elif shape.rank.get_length() == 4:
+        # NCHW or NHWC, possible channels index is 1 or 3
+        if dim_idx_found != 1 and dim_idx_found != 3:
+            raise Error('Can\'t determine channels dimension for 4D input {} (NCHW or NHWC) with shape {}. '
+                        'Please specify layout containing \'C\' channels manually.'.format(name, shape))
+    elif shape.rank.get_length() == 5:
+        # NCDHW or NDHWC, possible channels index is 1 or 4
+        if dim_idx_found != 1 and dim_idx_found != 4:
+            raise Error('Can\'t determine channels dimension for 5D input {} (NCDHW or NDHWC) with shape {}. '
+                        'Please specify layout containing \'C\' channels manually.'.format(name, shape))
+    else:
+        raise Error('Can\'t determine channels dimension for {}D input {} with shape {}.'
+                    'Please specify layout containing \'C\' channels manually.'
+                    .format(shape.rank.get_length(), name, shape))
+
+    layout_str = "?" * shape.rank.get_length()
+    layout_str = layout_str[:dim_idx_found] + 'C' + layout_str[dim_idx_found + 1:]
+    layout_values[name] = {
+        'source_layout': layout_str,
+        'target_layout': None,
+        'source_guessed': True,
+        'is_input': True
+    }
+    return layout_values
+
+
+def update_tensor_names_to_first_in_sorted_list(values_dict: dict, ov_function: Model):
+    if not isinstance(values_dict, dict):
+        return values_dict
+    updated_dict = {}
+    used_nodes = {}
+    for name, value in values_dict.items():
+        input_found = False
+        for input in ov_function.inputs:
+            tensor_names = list(input.names)
+            tensor_names.sort()
+            if not (name in tensor_names or name == input.node.get_friendly_name()):
+                continue
+            if input in used_nodes:
+                raise Error("Tensor names {} and {} refer to the same node.".format(name, used_nodes[input]))
+            used_nodes.update({input: name})
+            updated_dict[tensor_names[0]] = value
+            input_found = True
+            break
+        if not input_found:
+            raise Error('Input with name {} wasn\'t found! {}'.format(name, refer_to_faq_msg(83)))
+
+    return updated_dict
+
+
+def apply_preprocessing(ov_function: Model, argv: argparse.Namespace):
+    """
+    Applies pre-processing of model inputs by adding appropriate operations
+    On return, 'ov_function' object will be updated
+    Expected 'argv.mean_scale_values' formats examples:
+        a) Dict: {'inputName': {'mean': [1., 2., 3.], 'scale': [2., 4., 8.]}}
+        b) List: list(np.array([(np.array([1., 2., 3.]), np.array([2., 4., 6.])),
+                     (np.array([7., 8., 9.]), np.array([5., 6., 7.])))
+    Expected 'argv.layout_values' format examples:
+        a) Specific layouts for inputs and outputs
+        { 'input1': {
+                 'source_layout': 'nchw',
+                 'target_layout': 'nhwc'
+             },
+             'output2': {
+                 'source_layout': 'nhwc'
+             }
+        }
+        b) Layout for single input: {'': {'source_layout': 'nchw'}}
+    :param: ov_function OV function for applying mean/scale pre-processing
+    :param: argv Parsed command line arguments
+    """
+    prep = PrePostProcessor(ov_function)
+
+    layout_values = {}
+    if 'layout_values' in argv and argv.layout_values:
+        layout_values = update_layout_to_dict(ov_function.inputs, argv.layout_values,
+                                              lambda ov_input: ov_input.get_tensor().get_names())
+
+    check_keys_valid(ov_function=ov_function, dict_to_validate=layout_values, search_outputs=True)
+
+    layout_values = update_layout_is_input_flag(ov_function, layout_values)
+
+    for node_name, layout_value in layout_values.items():
+        if layout_value.get('source_layout'):
+            if layout_value.get('is_input'):
+                prep.input(node_name).model().set_layout(Layout(layout_value['source_layout']))
+            else:
+                prep.output(node_name).model().set_layout(Layout(layout_value['source_layout']))
+        if layout_value.get('target_layout'):
+            if layout_value.get('is_input'):
+                prep.input(node_name).tensor().set_layout(Layout(layout_value['target_layout']))
+            else:
+                prep.output(node_name).tensor().set_layout(Layout(layout_value['target_layout']))
+
+    # Apply pre-processing builder to a function
+    ov_function = prep.build()
+
+    # Remove guessed layout values from ov_function (these values shall not be serialized to IR
+    for node_name, layout_value in layout_values.items():
+        if layout_value.get('source_guessed') and \
+                not layout_value.get('target_layout'):
+            # search for parameter object
+            for idx, ov_input in enumerate(ov_function.inputs):
+                if node_name in ov_input.get_tensor().get_names():
+                    log.debug('Clearing guessed layout {} for {}'
+                              .format(layout_value['source_layout'], node_name))
+                ov_function.get_parameters()[idx].layout = Layout()