bigdl-core-npu 2.6.0b20241112__cp310-cp310-win_amd64.whl → 2.6.0b20241114__cp310-cp310-win_amd64.whl

intel_npu_acceleration_library/external/openvino/runtime/opset13/ops.py

@@ -180,8 +180,7 @@ def multinomial(
     inputs = as_nodes(probs, num_samples, name=name)
 
     if global_seed < 0:
-        raise RuntimeError(
-            f"global_seed should be positive or 0. Got: {global_seed}")
+        raise RuntimeError(f"global_seed should be positive or 0. Got: {global_seed}")
 
     if op_seed < 0:
         raise RuntimeError(f"op_seed should be positive or 0. Got: {op_seed}")
@@ -223,8 +222,7 @@ def nms_rotated(
     :param clockwise: Flag that specifies direction of the box rotation.
     :return: The new node which performs NMSRotated
     """
-    inputs = as_nodes(boxes, scores, max_output_boxes_per_class,
-                      iou_threshold, score_threshold, name=name)
+    inputs = as_nodes(boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold, name=name)
 
     attributes = {
         "sort_result_descending": sort_result_descending,
@@ -301,6 +299,7 @@ def constant(
                           - dtype force conversion of data.
     :return: The Constant node initialized with provided data.
     """
+
     def display_shared_memory_warning(warning_message: str) -> None:
         if shared_memory:
             log.warning(f"{warning_message}. Memory sharing is disabled by default. Set shared_memory=False to hide this warning.")
@@ -313,10 +312,10 @@ def constant(
     # Handle type casting, when dtype is not None:
     if dtype:
         # Expect packed data, use different constructor to handle it correctly:
-        if dtype in [Type.u1, Type.i4, Type.u4, Type.nf4]:
+        if dtype in [Type.u1, Type.i4, Type.u4, Type.nf4, Type.f4e2m1]:
             display_shared_memory_warning(f"Constant initialized with packed type of {dtype}")
             return Constant(dtype, Shape(_value.shape), _value.flatten().tolist())
-        elif dtype in [Type.bf16]:
+        elif dtype in [Type.bf16, Type.f8e8m0, Type.f8e4m3, Type.f8e5m2]:
             display_shared_memory_warning(f"Constant initialized with OpenVINO custom {dtype}")
             return Constant(dtype, Shape(_value.shape), _value.flatten().tolist())
         # General use-case for all other types:

intel_npu_acceleration_library/external/openvino/runtime/opset15/__init__.py

@@ -7,4 +7,6 @@
 # TODO (ticket 138273): Add previous opset operators at the end of opset15 development
 from openvino.runtime.opset1.ops import parameter
 from openvino.runtime.opset15.ops import col2im
+from openvino.runtime.opset15.ops import embedding_bag_offsets
+from openvino.runtime.opset15.ops import embedding_bag_packed
 from openvino.runtime.opset15.ops import scatter_nd_update

intel_npu_acceleration_library/external/openvino/runtime/opset15/ops.py

@@ -4,9 +4,12 @@
 
 """Factory functions for ops added to openvino opset15."""
 from functools import partial
-from typing import Optional, Literal, List
+from typing import List, Literal, Optional
 
+import numpy as np
 from openvino.runtime import Node, Type
+from openvino.runtime.opset1 import convert_like
+from openvino.runtime.opset14 import constant
 from openvino.runtime.opset_utils import _get_node_factory
 from openvino.runtime.utils.decorators import nameable_op
 from openvino.runtime.utils.types import NodeInput, as_nodes
@@ -83,3 +86,61 @@ def col2im(
             "pads_end": pads_end,
         },
     )
+
+
+@nameable_op
+def embedding_bag_offsets(
+    emb_table: NodeInput,
+    indices: NodeInput,
+    offsets: NodeInput,
+    default_index: Optional[NodeInput] = None,
+    per_sample_weights: Optional[NodeInput] = None,
+    reduction: Literal["sum", "mean"] = "sum",
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs sums or means of bags of embeddings without the intermediate embeddings.
+
+    :param emb_table: Tensor containing the embedding lookup table.
+    :param indices: 1D Tensor with indices.
+    :param offsets: 1D Tensor containing the starting index positions of each bag in indices.
+    :param per_sample_weights: Tensor with weights for each sample.
+    :param default_index: Scalar containing default index in embedding table to fill empty bags.
+                          If unset or set to -1, empty bags will be filled with 0.
+                          Reverse indexing using negative indices is not supported.
+    :param reduction: String to select algorithm used to perform reduction of elements in bag.
+    :param name: Optional name for output node.
+    :return: The new node performing EmbeddingBagOffsets operation.
+    """
+    inputs = [emb_table, indices, offsets]
+    if default_index is not None:
+        inputs.append(default_index)
+    elif per_sample_weights is not None:
+        inputs.append(convert_like(constant(np.array(-1, np.int32)), inputs[1]))
+    if per_sample_weights is not None:
+        inputs.append(per_sample_weights)
+
+    return _get_node_factory_opset15().create("EmbeddingBagOffsets", as_nodes(*inputs, name=name), {"reduction": reduction})
+
+
+@nameable_op
+def embedding_bag_packed(
+    emb_table: NodeInput,
+    indices: NodeInput,
+    per_sample_weights: Optional[NodeInput] = None,
+    reduction: Literal["sum", "mean"] = "sum",
+    name: Optional[str] = None,
+) -> Node:
+    """Return a node which performs sums or means of "bags" of embeddings, without the intermediate embeddings.
+
+    :param emb_table: Tensor containing the embedding lookup table.
+    :param indices: 2D Tensor of shape [batch, indices_per_bag] with indices.
+    :param per_sample_weights: Tensor of weights to be multiplied with embedding table with same shape as indices.
+    :param reduction: Operator to perform reduction of elements in bag.
+    :param name: Optional name for output node.
+    :return: The new node performing EmbeddingBagPacked operation.
+    """
+    inputs = [emb_table, indices]
+    if per_sample_weights is not None:
+        inputs.append(per_sample_weights)
+
+    return _get_node_factory_opset15().create("EmbeddingBagPacked", as_nodes(*inputs, name=name), {"reduction": reduction})

intel_npu_acceleration_library/external/openvino/runtime/opset6/ops.py

@@ -2,35 +2,26 @@
 # Copyright (C) 2018-2024 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 
+import numpy as np
+
 """Factory functions for all openvino ops."""
-from typing import Callable, Iterable, List, Optional, Set, Union, Dict, Any
+from typing import Optional, Union
 
-import numpy as np
 from functools import partial, singledispatch
 
-from openvino.runtime import Node, Shape, Type, PartialShape
+from openvino.runtime import Node, Type, PartialShape, Output, Shape
 from openvino.runtime.op import assign, Constant, Parameter
+from openvino.runtime.op import read_value as _read_value
+from openvino.runtime.op.util import VariableInfo, Variable
 from openvino.runtime.opset_utils import _get_node_factory
-from openvino.runtime.utils.decorators import binary_op, nameable_op, unary_op
-from openvino.runtime.utils.input_validation import (
-    assert_list_of_ints,
-    check_valid_attributes,
-    is_non_negative_value,
-    is_positive_value,
-)
-from openvino.runtime.utils.node_factory import NodeFactory
+from openvino.runtime.utils.decorators import nameable_op, overloading
 from openvino.runtime.utils.types import (
     NodeInput,
-    NumericData,
     NumericType,
-    ScalarData,
     TensorShape,
     as_node,
     as_nodes,
-    get_dtype,
     get_element_type,
-    get_element_type_str,
-    make_constant_node,
 )
 
 _get_node_factory_opset6 = partial(_get_node_factory, "opset6")
@@ -124,12 +115,12 @@ def mvn(
     return _get_node_factory_opset6().create("MVN", inputs, attributes)
 
 
-@singledispatch
+@overloading(Union[Node, Output], str, Optional[Union[type, np.dtype, Type, str]], Optional[Union[TensorShape, Shape, PartialShape]], Optional[str])
 @nameable_op
-def read_value(init_value: NodeInput,
+def read_value(init_value: Union[Node, Output],
                variable_id: str,
-               variable_type: Optional[Union[NumericType, Type, str]] = None,
-               variable_shape: Optional[TensorShape] = None,
+               variable_type: Optional[Union[type, np.dtype, Type, str]] = None,
+               variable_shape: Optional[Union[TensorShape, Shape, PartialShape]] = None,
                name: Optional[str] = None) -> Node:
     """Return a node which produces the Assign operation.
 
@@ -140,29 +131,28 @@ def read_value(init_value: NodeInput,
     :param name:         Optional name for output node.
     :return: ReadValue node
     """
-    attr_map: Dict[str, Any] = {"variable_id": variable_id}
+    info = VariableInfo()
+    info.variable_id = variable_id
 
     if variable_type is not None:
         if not isinstance(variable_type, Type) and not isinstance(variable_type, str):
-            attr_map["variable_type"] = get_element_type_str(variable_type)
+            info.data_type = get_element_type(variable_type)
         else:
-            attr_map["variable_type"] = variable_type
+            info.data_type = variable_type
 
     if variable_shape is not None:
-        attr_map["variable_shape"] = PartialShape(variable_shape)
+        info.data_shape = PartialShape(variable_shape)
 
-    return _get_node_factory_opset6().create(
-        "ReadValue",
-        [as_node(init_value, name=name)],
-        attr_map,
-    )
+    var_from_info = Variable(info)
+    return _read_value(new_value=as_node(init_value, name=name), variable=var_from_info)
 
 
-@read_value.register
-def _(variable_id: str,
-      variable_type: Optional[Union[NumericType, Type, str]] = None,
-      variable_shape: Optional[TensorShape] = None,
-      name: Optional[str] = None) -> Node:
+@overloading(str, Optional[Union[type, np.dtype, Type, str]], Optional[Union[TensorShape, Shape, PartialShape]], Optional[str])  # type: ignore
+@nameable_op
+def read_value(variable_id: str,  # noqa: F811
+               variable_type: Optional[Union[type, np.dtype, Type, str]] = None,
+               variable_shape: Optional[Union[TensorShape, Shape, PartialShape]] = None,
+               name: Optional[str] = None) -> Node:
     """Return a node which produces the Assign operation.
 
     :param variable_id:  Id of a variable to be read.
@@ -171,19 +161,46 @@ def _(variable_id: str,
     :param name:         Optional name for output node.
     :return: ReadValue node
     """
-    attr_map: Dict[str, Any] = {"variable_id": variable_id}
+    info = VariableInfo()
+    info.variable_id = variable_id
 
     if variable_type is not None:
         if not isinstance(variable_type, Type) and not isinstance(variable_type, str):
-            attr_map["variable_type"] = get_element_type_str(variable_type)
+            info.data_type = get_element_type(variable_type)
         else:
-            attr_map["variable_type"] = variable_type
+            info.data_type = variable_type
 
     if variable_shape is not None:
-        attr_map["variable_shape"] = PartialShape(variable_shape)
+        info.data_shape = PartialShape(variable_shape)
+
+    var_from_info = Variable(info)
+
+    return _read_value(var_from_info)
+
+
+@overloading(Variable, Optional[str])    # type: ignore
+@nameable_op
+def read_value(ov_variable: Variable,  # noqa: F811
+               name: Optional[str] = None) -> Node:
+    """Return a node which produces the Assign operation.
 
-    return _get_node_factory_opset6().create(
-        "ReadValue",
-        [],
-        attr_map,
-    )
+    :param ov_variable:  Variable to be read.
+    :param name:         Optional name for output node.
+    :return: ReadValue node
+    """
+    return _read_value(ov_variable)
+
+
+@overloading(Union[Node, Output], Variable, Optional[str])  # type: ignore
+@nameable_op
+def read_value(init_value: Union[Node, Output],  # noqa: F811
+               ov_variable: Variable,
+               name: Optional[str] = None) -> Node:
+    """Return a node which produces the Assign operation.
+
+    :param init_value:   Optional node producing a value to be returned instead of an unassigned variable.
+    :param ov_variable:  Variable to be read.
+    :param name:         Optional name for output node.
+    :return: ReadValue node
+    """
+    return _read_value(as_node(init_value, name=name), ov_variable)

intel_npu_acceleration_library/external/openvino/runtime/opset8/ops.py

@@ -336,6 +336,7 @@ def random_uniform(
     output_type: str,
     global_seed: int = 0,
     op_seed: int = 0,
+    alignment: str = "tensorflow",
     name: Optional[str] = None,
 ) -> Node:
     """Return a node which generates sequence of random values from uniform distribution.
@@ -347,6 +348,8 @@ def random_uniform(
                                 'i64', 'i32', 'f64', 'f32', 'f16', 'bf16'.
     :param global_seed: Specifies global seed value. Required to be a positive integer or 0.
     :param op_seed: Specifies operational seed value. Required to be a positive integer or 0.
+    :param alignment: Specifies alignment of the randomly generated numbers to a given framework.
+                                Possible values: 'tensorflow', 'pytorch'. Default is 'tensorflow'.
     :param name: Optional output node name.
 
     :return: The new node which performs generation of random values from uniform distribution.
@@ -363,6 +366,7 @@ def random_uniform(
         "output_type": output_type,
         "global_seed": global_seed,
         "op_seed": op_seed,
+        "alignment": alignment.lower()
     }
     return _get_node_factory_opset8().create("RandomUniform", inputs, attributes)
 

intel_npu_acceleration_library/external/openvino/runtime/properties/__init__.py

@@ -5,6 +5,7 @@
 # Enums
 from openvino._pyopenvino.properties import Affinity
 from openvino._pyopenvino.properties import CacheMode
+from openvino._pyopenvino.properties import WorkloadType
 
 # Properties
 from openvino._pyopenvino.properties import enable_profiling

intel_npu_acceleration_library/external/openvino/runtime/utils/decorators.py

@@ -4,7 +4,7 @@
 
 from functools import wraps
 from inspect import getfullargspec
-from typing import Any, Callable, List, Optional
+from typing import Any, Callable, Dict, Optional, Union, get_origin, get_args
 
 from openvino.runtime import Node, Output
 from openvino.runtime.utils.types import NodeInput, as_node, as_nodes
@@ -68,3 +68,69 @@ def custom_preprocess_function(custom_function: Callable) -> Callable:
         return Output._from_node(custom_function(node))
 
     return wrapper
+
+
+class MultiMethod(object):
+    def __init__(self, name: str):
+        self.name = name
+        self.typemap: Dict[tuple, Callable] = {}
+
+    # Checks if actual_type is a subclass of any type in the union
+    def matches_union(self, union_type, actual_type) -> bool:  # type: ignore
+        for type_arg in get_args(union_type):
+            if isinstance(type_arg, type) and issubclass(actual_type, type_arg):
+                return True
+            elif get_origin(type_arg) == list:
+                if issubclass(actual_type, list):
+                    return True
+        return False
+
+    def matches_optional(self, optional_type, actual_type) -> bool:  # type: ignore
+        return actual_type is None or self.matches_union(optional_type, actual_type)
+
+    # Checks whether there is overloading which matches invoked argument types
+    def check_invoked_types_in_overloaded_funcs(self, tuple_to_check: tuple, key_structure: tuple) -> bool:
+        for actual_type, expected_type in zip(tuple_to_check, key_structure):
+            origin = get_origin(expected_type)
+            if origin is Union:
+                if not self.matches_union(expected_type, actual_type):
+                    return False
+            elif origin is Optional:
+                if not self.matches_optional(expected_type, actual_type):
+                    return False
+            elif not issubclass(actual_type, expected_type):
+                return False
+        return True
+
+    def __call__(self, *args) -> Any:  # type: ignore
+        types = tuple(arg.__class__ for arg in args)
+        key_matched = None
+        for key in self.typemap.keys():
+            if self.check_invoked_types_in_overloaded_funcs(types, key):
+                key_matched = key
+                break
+
+        if key_matched is None:
+            raise TypeError("no match")
+
+        function = self.typemap.get(key_matched)
+        return function(*args)  # type: ignore
+
+    def register(self, types: tuple, function: Callable) -> None:
+        if types in self.typemap:
+            raise TypeError("duplicate registration")
+        self.typemap[types] = function
+
+
+registry: Dict[str, MultiMethod] = {}
+
+
+def overloading(*types: tuple) -> Callable:
+    def register(function: Callable) -> MultiMethod:
+        name = function.__name__
+        mm = registry.get(name)
+        if mm is None:
+            mm = registry[name] = MultiMethod(name)
+        mm.register(types, function)
+        return mm
+    return register

intel_npu_acceleration_library/external/openvino/tools/benchmark/utils/inputs_filling.py

@@ -266,7 +266,7 @@ def get_numpy_tensors(numpy_paths: List[str], info: AppInputInfo, batch_sizes: L
                 else:
                     try:
                         if info.layout.has_name("N"):
-                            numpy_arrays[[None] * info.layout.get_index_by_name("N") + [b]] = numpy_arr
+                            numpy_arrays[[None] * info.layout.get_index_by_name("N") + [b]] = numpy_arr[b]
                         else:
                             numpy_arrays = numpy_arr
                     except ValueError:
@@ -291,7 +291,7 @@ def get_binary_tensors(binary_paths: List[str], info: AppInputInfo, batch_sizes:
     tensors = []
     for i in range(niter):
         shape_id = i % num_shapes
-        dtype = get_dtype(info.element_type)
+        dtype = np.uint8() if info.element_type.bitwidth < 8 else get_dtype(info.element_type)
         shape = list(info.shapes[shape_id])
         binaries = np.ndarray(shape=shape, dtype=dtype)
         binary_index = processed_frames
@@ -301,14 +301,14 @@ def get_binary_tensors(binary_paths: List[str], info: AppInputInfo, batch_sizes:
             binary_filename: str = binary_paths[binary_index]
             extension = binary_filename.lower().split('.')[-1]
             if extension == "bin":
-                binary_file_size = os.path.getsize(binary_filename)
-                blob_size = dtype.itemsize * int(np.prod(shape))
-                if blob_size != binary_file_size:
+                binary_file_bit_size = os.path.getsize(binary_filename) * 8
+                blob_bit_size = info.element_type.bitwidth * int(np.prod(shape))
+                if blob_bit_size != binary_file_bit_size:
                     raise Exception(
-                        f"File {binary_filename} contains {binary_file_size} bytes but model expects {blob_size}")
-                from_file = np.reshape(np.fromfile(binary_filename, dtype), shape)
+                        f"File {binary_filename} contains {binary_file_bit_size} bites but model expects {blob_bit_size}")
+                from_file = np.fromfile(binary_filename, dtype)
                 if info.layout.has_name("N"):
-                    binaries[[None] * info.layout.get_index_by_name("N") + [b]] = from_file
+                    binaries[[None] * info.layout.get_index_by_name("N") + [b]] = from_file[b]
                 else:
                     binaries = from_file
             else:
@@ -317,7 +317,7 @@ def get_binary_tensors(binary_paths: List[str], info: AppInputInfo, batch_sizes:
 
             binary_index += 1
         processed_frames += current_batch_size
-        tensors.append(Tensor(binaries))
+        tensors.append(Tensor(binaries, shape, info.element_type))
     return tensors
 
 

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

@@ -36,6 +36,10 @@ from openvino.tools.ovc.telemetry_utils import send_params_info, send_conversion
     init_mo_telemetry
 from openvino.tools.ovc.moc_frontend.pytorch_frontend_utils import get_pytorch_decoder, extract_input_info_from_example
 from openvino.tools.ovc.moc_frontend.paddle_frontend_utils import paddle_frontend_converter
+try:
+    from openvino.tools.ovc.moc_frontend.jax_frontend_utils import get_jax_decoder
+except:
+    get_jax_decoder = None
 
 # pylint: disable=no-name-in-module,import-error
 from openvino.frontend import FrontEndManager, OpConversionFailure, TelemetryExtension
@@ -228,6 +232,11 @@ def check_model_object(argv):
                                                                     paddle.fluid.dygraph.layers.Layer) or isinstance(
             model, paddle.fluid.executor.Executor):
             return "paddle"
+        
+    if 'jax' in sys.modules:
+        import jax
+        if isinstance(model, (jax.core.Jaxpr, jax.core.ClosedJaxpr)):
+            return "jax"
 
     raise Error('Unknown model type: {}'.format(type(model)))
 
@@ -319,6 +328,7 @@ def normalize_inputs(argv: argparse.Namespace):
     """
     # Parse input to list of InputCutInfo
     inputs = input_to_input_cut_info(argv.input)
+    argv.input = inputs
 
     # Make list of input names
     input_names_list = []
@@ -329,8 +339,6 @@ def normalize_inputs(argv: argparse.Namespace):
         assert len(input_names_list) == len(inputs), "\"input\" parameter has unnamed inputs and named inputs. " \
                                                      "Please either set names for all inputs, " \
                                                      "or do not set names for all inputs."
-    argv.inputs_list = input_names_list
-    argv.input = ','.join(input_names_list)
 
     if len(input_names_list) > 0:
         # Named inputs case
@@ -462,6 +470,12 @@ def _convert(cli_parser: argparse.ArgumentParser, args, python_api_used):
                                                                      outputs)
                 pdmodel = paddle_runtime_converter.convert_paddle_to_pdmodel()
                 args['input_model'] = pdmodel
+            if model_framework == "jax":
+                if get_jax_decoder is not None:
+                    get_jax_decoder(args['input_model'], args)
+                else:
+                    raise Error("JAX Frontend is not available.")
+                
 
         argv = pack_params_to_args_namespace(args, cli_parser, python_api_used)
         argv.framework = model_framework

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

@@ -10,6 +10,11 @@ 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
+from openvino.tools.ovc.utils import import_openvino_tokenizers
+
+# TODO 131000: temporal workaround to patch OpenVINO Core and frontends with tokenizers extensions
+# make OVC tool to convert models requiring openvino-tokenizers extensions
+import_openvino_tokenizers()
 
 # pylint: disable=no-name-in-module,import-error
 from openvino.runtime import save_model

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

@@ -0,0 +1,19 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+import logging as log
+
+
+def get_jax_decoder(model, args):
+    try:
+        from openvino.frontend.jax.jaxpr_decoder import JaxprPythonDecoder
+    except Exception as e:
+        log.error("JAX frontend loading failed")
+        raise e
+    
+    if not isinstance(model, JaxprPythonDecoder):
+        decoder = JaxprPythonDecoder(model)
+    else:
+        decoder = model
+    
+    args['input_model'] = decoder

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

@@ -72,12 +72,14 @@ def moc_pipeline(argv: argparse.Namespace, moc_front_end: FrontEnd):
             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())
+    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)
 
     def check_places_are_same(places_original: List[Place], places_new: List[Place]):
         """
@@ -90,6 +92,67 @@ def moc_pipeline(argv: argparse.Namespace, moc_front_end: FrontEnd):
             [item for item in places_original if any(
                 [item.is_equal(item2['node']) for item2 in places_new])]) == len(places_original)
 
+    if getattr(argv, "framework", None) == "pytorch":
+        iplaces = []
+        for idx, input_info in enumerate(argv.input):
+            if getattr(input_info, "name", None):
+                place = input_model.get_place_by_tensor_name(input_info.name)
+                if not input_info.shape and not input_info.type:
+                    # If we received place by name, we need to use it for FE to verify
+                    # that such name exist, otherwise we silently ignore it.
+                    # Using dynamic shape should be safe, because FE will not overwrite
+                    # the shape that was produced after conversion, but merge it, so
+                    # dynamic shape will not change anything.
+                    input_model.set_partial_shape(place, PartialShape.dynamic())
+            else:
+                place = input_model.get_place_by_input_index(idx)
+            iplaces.append(place)
+            if input_info.shape is not None:
+                input_model.set_partial_shape(place, input_info.shape)
+            if input_info.type is not None:
+                input_model.set_element_type(place, input_info.type)
+        model_inputs = input_model.get_inputs()
+        def merge_inputs(inputs, to_set_list):
+            # use input places instead of obtained by index if they are the same
+            res = []
+            for p in to_set_list:
+                found = False
+                for i in inputs:
+                    if p.is_equal(i):
+                        res.append(i)
+                        found = True
+                        break
+                if not found:
+                    res.append(p)
+            return res
+        iplaces = merge_inputs(model_inputs, iplaces)
+        # Currently this only work to reorder inputs/outputs
+        to_override_all_inputs = check_places_are_same(model_inputs, [{"node": p} for p in iplaces])
+        to_override_all_outputs = False
+        if argv.output:
+            oplaces = []
+            _outputs = fe_output_user_data_repack(input_model, argv.output, moc_front_end.get_name())
+            for out_desc in _outputs:
+                oplaces.append(out_desc["name"])
+            model_outputs = input_model.get_outputs()
+            to_override_all_outputs = check_places_are_same(model_outputs, [{"node": p} for p in oplaces])
+        if to_override_all_inputs and to_override_all_outputs:
+            input_model.extract_subgraph(iplaces, oplaces)
+        elif to_override_all_inputs:
+            input_model.override_all_inputs(iplaces)
+        elif to_override_all_outputs:
+            input_model.override_all_outputs(oplaces)
+
+        ov_model = moc_front_end.convert(input_model)
+        return ov_model
+
+    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 add_names_to_tensors(model: InputModel, places: List[Place]):
         """
         Adds additional names to some model input tensors. This helper should be used
@@ -107,14 +170,6 @@ def moc_pipeline(argv: argparse.Namespace, moc_front_end: FrontEnd):
                 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:
@@ -238,9 +293,6 @@ def moc_pipeline(argv: argparse.Namespace, moc_front_end: FrontEnd):
 
             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