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

intel_npu_acceleration_library/external/openvino/frontend/pytorch/torchdynamo/partition.py

@@ -25,6 +25,13 @@ logger = logging.getLogger(__name__)
 logger.setLevel(logging.WARNING)
 
 
+class PatternNode:
+    op_types = {}
+
+    def __init__(self):
+        self.op_types = {}
+
+
 class Partitioner:
     def __init__(self, options):
         self.supported_ops = OperatorSupport(options)
@@ -56,55 +63,56 @@ class Partitioner:
             return True
         return False
 
-    def capture_gptq_patterns(self, graph_module: GraphModule) -> bool:
+    def check_pattern(self, node: torch.fx.Node, pattern: PatternNode, enabled_ops: list) -> bool:
+        if node.op == "call_function":
+            if ("call_function" + ":" + str(node.target)) in pattern.op_types:
+                pt_input_nodes = node.all_input_nodes
+                pattern_input_ops = pattern.op_types["call_function" + ":" + str(node.target)]
+                if pattern_input_ops is None:
+                    enabled_ops.append(node)
+                    return True
+                if len(pt_input_nodes) != len(pattern_input_ops):
+                    return False
+                for i in range(len(pt_input_nodes)):
+                    if not self.check_pattern(pt_input_nodes[i], pattern_input_ops[i], enabled_ops):
+                        return False
+                enabled_ops.append(node)
+                return True
+        elif node.op == "get_attr":
+            if "get_attr" in pattern.op_types:
+                return True
+            else:
+                return False
+        return False
+
+    def capture_gptq_patterns(self, graph_module: GraphModule):
+        const_0_node = PatternNode
+        const_0_node.op_types["get_attr"] = None
+        unsqueeze_0_node = PatternNode
+        unsqueeze_0_node.op_types["call_function:aten.unsqueeze.default"] = [const_0_node,]
+        expand_node = PatternNode
+        expand_node.op_types["call_function:aten.expand.default"] = [unsqueeze_0_node,]
+        const_1_node = PatternNode
+        const_1_node.op_types["get_attr"] = None
+        unsqueeze_1_node = PatternNode
+        unsqueeze_1_node.op_types["call_function:aten.unsqueeze.default"] = [const_1_node,]
+        bitwise_right_shift_node = PatternNode
+        bitwise_right_shift_node.op_types["call_function:aten.bitwise_right_shift.Tensor"] = [expand_node, unsqueeze_1_node]
+        to_copy_node = PatternNode
+        to_copy_node.op_types["call_function:aten._to_copy.default"] = [bitwise_right_shift_node,]
+        add_or_to_copy_node = PatternNode
+        add_or_to_copy_node.op_types["call_function:aten._to_copy.default"] = [bitwise_right_shift_node,]
+        add_or_to_copy_node.op_types["call_function:aten.add.Tensor"] = [to_copy_node,]
+        bitwise_and_node = PatternNode
+        bitwise_and_node.op_types["call_function:aten.bitwise_and.Scalar"] = [add_or_to_copy_node,]
+
         for node in graph_module.graph.nodes:
             if str(node.op) == "call_function" and str(node.target) == "aten.bitwise_and.Scalar":
-                bitwise_and_in_nodes = node.all_input_nodes
-                if len(bitwise_and_in_nodes) != 1:
-                    continue
-                to_copy_node = bitwise_and_in_nodes[0]
-                if str(to_copy_node.op) != "call_function" or str(to_copy_node.target) != "aten._to_copy.default":
-                    continue
-                to_copy_in_nodes = to_copy_node.all_input_nodes
-                if len(to_copy_in_nodes) != 1:
-                    continue
-                bitwise_right_shift_node = to_copy_in_nodes[0]
-                if str(bitwise_right_shift_node.op) != "call_function" or str(bitwise_right_shift_node.target) != "aten.bitwise_right_shift.Tensor":
-                    continue
-                bitwise_right_shift_in_nodes = bitwise_right_shift_node.all_input_nodes
-                if len(bitwise_right_shift_in_nodes) != 2:
-                    continue
-                expand_node = bitwise_right_shift_in_nodes[0]
-                if str(expand_node.op) != "call_function" or str(expand_node.target) != "aten.expand.default":
-                    continue
-                expand_in_nodes = expand_node.all_input_nodes
-                if len(expand_in_nodes) != 1:
-                    continue
-                unsqueeze_0_node = expand_in_nodes[0]
-                if str(unsqueeze_0_node.op) != "call_function" or str(unsqueeze_0_node.target) != "aten.unsqueeze.default":
-                    continue
-                unsqueeze_0_in_nodes = unsqueeze_0_node.all_input_nodes
-                if len(unsqueeze_0_in_nodes) != 1:
-                    continue
-                const_0_node = unsqueeze_0_in_nodes[0]
-                if str(const_0_node.op) != "get_attr":
-                    continue
-                unsqueeze_1_node = bitwise_right_shift_in_nodes[1]
-                if str(unsqueeze_1_node.op) != "call_function" or str(unsqueeze_1_node.target) != "aten.unsqueeze.default":
-                    continue
-                unsqueeze_1_in_nodes = unsqueeze_1_node.all_input_nodes
-                if len(unsqueeze_1_in_nodes) != 1:
-                    continue
-                const_1_node = unsqueeze_1_in_nodes[0]
-                if str(const_1_node.op) != "get_attr":
-                    continue
-
-                self.supported_ops.enable_by_name(node)
-                self.supported_ops.enable_by_name(to_copy_node)
-                self.supported_ops.enable_by_name(bitwise_right_shift_node)
-                self.supported_ops.enable_by_name(expand_node)
-                self.supported_ops.enable_by_name(unsqueeze_0_node)
-                self.supported_ops.enable_by_name(unsqueeze_1_node)
+                enabled_ops = []
+                pattern_match = self.check_pattern(node, bitwise_and_node, enabled_ops)
+                if pattern_match:
+                    for pattern_op in enabled_ops:
+                        self.supported_ops.enable_by_name(pattern_op)
 
     def make_partitions(self, graph_module: GraphModule, options) -> GraphModule:
         allow_single_node_partition = _is_testing(options)

intel_npu_acceleration_library/external/openvino/frontend/pytorch/ts_decoder.py

@@ -7,7 +7,14 @@
 from openvino.frontend.pytorch.py_pytorch_frontend import _FrontEndPytorchDecoder as Decoder
 from openvino.frontend.pytorch.py_pytorch_frontend import _Type as DecoderType
 from openvino.runtime import op, PartialShape, Type as OVType, OVAny
-from openvino.frontend.pytorch.utils import ivalue_to_constant, get_value_from_getattr, pt_to_ov_type_map, prepare_example_inputs_and_model, convert_quantized_tensor, graph_has_ops
+from openvino.frontend.pytorch.utils import (
+    ivalue_to_constant,
+    get_value_from_getattr,
+    pt_to_ov_type_map,
+    prepare_example_inputs_and_model,
+    convert_quantized_tensor,
+    graph_has_ops,
+)
 from openvino.runtime import opset11 as ops
 from openvino.frontend.pytorch import gptq
 from openvino.frontend.pytorch import patch_model
@@ -15,20 +22,22 @@ from openvino.frontend.pytorch.module_extension import ModuleExtension
 
 import typing
 import torch
+import inspect
 
 
-class TorchScriptPythonDecoder (Decoder):
+class TorchScriptPythonDecoder(Decoder):
     def __init__(
-            self,
-            pt_module,
-            graph_element=None,
-            example_input=None,
-            alias_db=None,
-            shared_memory=True,
-            skip_freeze=False,
-            constant_cache=None,
-            module_extensions=None):
-        Decoder.__init__(self)
+        self,
+        pt_module,
+        graph_element=None,
+        example_input=None,
+        alias_db=None,
+        shared_memory=True,
+        skip_freeze=False,
+        constant_cache=None,
+        module_extensions=None,
+    ):
+        super().__init__()
         # We store every decoder created by this decoder so that all them are not deleted until the first decoder is deleted
         self.m_decoders = []
         self._input_signature = None
@@ -36,7 +45,12 @@ class TorchScriptPythonDecoder (Decoder):
         self._input_is_list = False
         self.constant_cache = constant_cache if constant_cache is not None else dict()
         self.module_extensions = module_extensions
+        self.config = None
+        self.out_debug_name_overwrites = {}
         if graph_element is None:
+            if hasattr(pt_module, "config"):
+                self.config = pt_module.config.to_dict() if not isinstance(
+                    pt_module.config, dict) else pt_module.config
             try:
                 pt_module = self._get_scripted_model(
                     pt_module, example_input, skip_freeze)
@@ -53,7 +67,8 @@ class TorchScriptPythonDecoder (Decoder):
                     f"Couldn't get TorchScript module by {msg}. With exception:\n{e}\n{help_msg} "
                     "You can also provide TorchScript module that you obtained"
                     " yourself, please refer to PyTorch documentation: "
-                    "https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html.")
+                    "https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html."
+                )
             self.graph_element = pt_module.inlined_graph
             self.alias_db = self.graph_element.alias_db()
         else:
@@ -77,26 +92,27 @@ class TorchScriptPythonDecoder (Decoder):
             self._transform_tensor_list_constants_to_listconstruct(
                 self.graph_element)
             self._transform_optional_constants(self.graph_element)
-        self.out_debug_name_overwrites = {}
 
     @staticmethod
     def _get_preserved_attributes(model) -> list:
         preserved_attributes = []
         for name, module in model.named_modules():
-            if hasattr(module, "weight"):
-                if module.weight is not None and getattr(module.weight, "dtype", None) in [torch.int8, torch.uint8, torch.float16, torch.bfloat16]:
-                    preserved_attributes.append(name)
+            compressed_types = [torch.int8, torch.uint8,
+                                torch.float16, torch.bfloat16]
+            if hasattr(module, "weight") and getattr(module.weight, "dtype", None) in compressed_types:
+                preserved_attributes.append(name)
         return preserved_attributes
 
     def _get_scripted_model(self, pt_module, example_inputs=None, skip_freeze=False):
-        import torch
-        import inspect
-
         freeze_by_default = False
         if isinstance(pt_module, torch.nn.Module):
             pt_module.eval()
         input_signature = None
-        if isinstance(pt_module, torch.nn.Module) and not isinstance(pt_module, (torch.jit._trace.TopLevelTracedModule, torch.jit._script.RecursiveScriptModule)):
+        input_parameters = None
+        if isinstance(pt_module, torch.nn.Module) and not isinstance(
+            pt_module, (torch.jit._trace.TopLevelTracedModule,
+                        torch.jit._script.RecursiveScriptModule)
+        ):
             # input params is dictionary contains input names and their signature values (type hints and default values if any)
             input_params = inspect.signature(pt_module.forward if hasattr(
                 pt_module, "forward") else pt_module.__call__).parameters
@@ -104,7 +120,8 @@ class TorchScriptPythonDecoder (Decoder):
 
             if example_inputs is None:
                 if self.module_extensions:
-                    raise RuntimeError("ModuleExtension is not supported for scripting. Please provide valid example_input argument to run tracing.")
+                    raise RuntimeError(
+                        "ModuleExtension is not supported for scripting. Please provide valid example_input argument to run tracing.")
                 scripted = torch.jit.script(pt_module)
                 freeze_by_default = True
             else:
@@ -112,9 +129,10 @@ class TorchScriptPythonDecoder (Decoder):
                     example_inputs, input_params, pt_module)
 
                 # name of attribute in a patched module where the original forward method is kept
-                orig_forward_name = '_openvino_module_extension_patch_orig_forward'
+                orig_forward_name = "_openvino_module_extension_patch_orig_forward"
                 if self.module_extensions:
-                    patch_model.patch_model(pt_module, self.module_extensions, orig_forward_name)
+                    patch_model.patch_model(
+                        pt_module, self.module_extensions, orig_forward_name)
 
                 gptq_patched = False
                 if gptq.detect_gptq_model(pt_module):
@@ -123,9 +141,9 @@ class TorchScriptPythonDecoder (Decoder):
                         gptq_patched = True
                     except Exception as error:
                         print(
-                            '[ WARNING ] Failed patching of AutoGPTQ model. Error message:\n', error)
+                            "[ WARNING ] Failed patching of AutoGPTQ model. Error message:\n", error)
                         print(
-                            '[ WARNING ] Tracing of the model will likely be unsuccessful or incorrect')
+                            "[ WARNING ] Tracing of the model will likely be unsuccessful or incorrect")
                         gptq.unpatch_model(pt_module)
                         gptq_patched = False
 
@@ -138,10 +156,13 @@ class TorchScriptPythonDecoder (Decoder):
                     if self.module_extensions:
                         patch_model.unpatch_model(pt_module, orig_forward_name)
 
-            if not freeze_by_default and graph_has_ops(scripted.inlined_graph, ["prim::Uninitialized", "prim::unchecked_cast", "aten::append"]):
+            have_to_freeze_ops = ["prim::Uninitialized",
+                                  "prim::unchecked_cast", "aten::append"]
+            if not freeze_by_default and graph_has_ops(scripted.inlined_graph, have_to_freeze_ops):
                 # freeze models with unsupported ops
                 freeze_by_default = True
-            if freeze_by_default and graph_has_ops(scripted.inlined_graph, ["quantized", "aten::as_strided"]):
+            quantized_hint_ops = ["quantized", "aten::as_strided"]
+            if freeze_by_default and graph_has_ops(scripted.inlined_graph, quantized_hint_ops):
                 # do not freeze quantized models and can't freeze for aten::as_strided it will result in incorrect inference
                 freeze_by_default = False
             if freeze_by_default and not skip_freeze:
@@ -150,8 +171,10 @@ class TorchScriptPythonDecoder (Decoder):
                     scripted, preserved_attrs=preserved_attrs)
             else:
                 f_model = scripted
+            self._example_input = input_parameters["example_inputs"] if input_parameters else None
         else:
             f_model = pt_module
+            self._example_input = example_inputs
 
         self._input_signature = input_signature
         return f_model
@@ -250,12 +273,14 @@ class TorchScriptPythonDecoder (Decoder):
     def visit_subgraph(self, node_visitor) -> None:
         # make sure topological order is satisfied
         for node in self.graph_element.nodes():
-            decoder = TorchScriptPythonDecoder(self.pt_module,
-                                               node,
-                                               alias_db=self.alias_db,
-                                               shared_memory=self._shared_memory,
-                                               constant_cache=self.constant_cache,
-                                               module_extensions=self.module_extensions)
+            decoder = TorchScriptPythonDecoder(
+                self.pt_module,
+                node,
+                alias_db=self.alias_db,
+                shared_memory=self._shared_memory,
+                constant_cache=self.constant_cache,
+                module_extensions=self.module_extensions,
+            )
             self.m_decoders.append(decoder)
             node_visitor(decoder)
 
@@ -275,31 +300,32 @@ class TorchScriptPythonDecoder (Decoder):
         return list(self.graph_element.blocks())
 
     def get_subgraph_decoder(self, index: int):
-        decoder = TorchScriptPythonDecoder(self.pt_module,
-                                           self.get_subgraphs()[index],
-                                           alias_db=self.alias_db,
-                                           shared_memory=self._shared_memory,
-                                           module_extensions=self.module_extensions)
+        decoder = TorchScriptPythonDecoder(
+            self.pt_module, self.get_subgraphs(
+            )[index], alias_db=self.alias_db, shared_memory=self._shared_memory, module_extensions=self.module_extensions
+        )
         self.m_decoders.append(decoder)
         return decoder
 
     def get_op_type(self) -> str:
         assert isinstance(
             self.graph_element, torch.Node), "Function can be called only when self.graph_element is of type torch.Node"
-        if self.graph_element.kind() == "prim::PythonOp":
-            if hasattr(self.graph_element, 'pyobj') and callable(self.graph_element.pyobj) and hasattr(self.graph_element.pyobj(), '__self__'):
-                trampoline = self.graph_element.pyobj().__self__
-                if hasattr(trampoline, 'target_extension') and isinstance(trampoline.target_extension, ModuleExtension):
-                    target_op = trampoline.target_extension.target_op
-                    if callable(target_op):
-                        target = target_op(trampoline.original_module)
-                    elif isinstance(target_op, str):
-                        target = target_op
-                    # TODO: Support target as a callable that will play a role of ConversionExtension for an entire module instead of a single op.
-                    # Without supporting target as a callable here, ConversionExtension functionality is still possible to implement
-                    # by combining two extensions: ModuleExtension that use temporary name as a target op and another extension of type ConversionExtension
-                    # that translates that particular temporary name to custom graph. But providing conversion code as a callable `target` is more convenient.
-                    return target
+        if self.graph_element.kind() == "prim::PythonOp" and callable(getattr(self.graph_element, "pyobj", None)):
+            pyobj = self.graph_element.pyobj()
+            trampoline = getattr(pyobj, "__self__", None)
+            target_extension = getattr(trampoline, "target_extension", None)
+
+            if isinstance(target_extension, ModuleExtension):
+                target_op = target_extension.target_op
+                if callable(target_op):
+                    target = target_op(trampoline.original_module)
+                elif isinstance(target_op, str):
+                    target = target_op
+                # TODO: Support target as a callable that will play a role of ConversionExtension for an entire module instead of a single op.
+                # Without supporting target as a callable here, ConversionExtension functionality is still possible to implement
+                # by combining two extensions: ModuleExtension that use temporary name as a target op and another extension of type ConversionExtension
+                # that translates that particular temporary name to custom graph. But providing conversion code as a callable `target` is more convenient.
+                return target
         return self.graph_element.kind()
 
     def get_schema(self) -> str:
@@ -339,8 +365,8 @@ class TorchScriptPythonDecoder (Decoder):
         self.constant_cache[name] = outputs
 
     def try_decode_get_attr(self):
-        pt_value, name = get_value_from_getattr(self.graph_element,
-                                                self.pt_module)
+        pt_value, name = get_value_from_getattr(
+            self.graph_element, self.pt_module)
         assert pt_value is not None, "Couldn't retrieve value from prim::GetAttr"
         if isinstance(pt_value, torch.ScriptObject):
             # We assume this is __torch__.torch.classes.quantized.Conv2dPackedParamsBase or __torch__.torch.classes.quantized.LinearPackedParamsBase
@@ -386,8 +412,8 @@ class TorchScriptPythonDecoder (Decoder):
             if name in self.constant_cache:
                 const = self.constant_cache[name]
             else:
-                const = ivalue_to_constant(pt_value,
-                                           shared_memory=self._shared_memory)
+                const = ivalue_to_constant(
+                    pt_value, shared_memory=self._shared_memory)
                 self._add_name_to_const_and_cache(const, name)
             return const
         else:
@@ -401,12 +427,11 @@ class TorchScriptPythonDecoder (Decoder):
         pt_value = self._raw_output(0)
         pt_type = pt_value.type()
         if isinstance(pt_type, torch.TensorType):
-            return ivalue_to_constant(pt_value.toIValue(),
-                                      shared_memory=self._shared_memory)
+            return ivalue_to_constant(pt_value.toIValue(), shared_memory=self._shared_memory)
         if isinstance(pt_type, torch.ListType):
             return self._as_constant_list(pt_value)
-        const = ivalue_to_constant(pt_value.toIValue(),
-                                   shared_memory=self._shared_memory)
+        const = ivalue_to_constant(
+            pt_value.toIValue(), shared_memory=self._shared_memory)
         if len(const) > 0:
             # set name corresponding to state_dict name
             const[0].get_node().set_friendly_name(
@@ -460,8 +485,8 @@ class TorchScriptPythonDecoder (Decoder):
             else:
                 in_node = r_input.node()
                 if in_node.kind() == "prim::GetAttr":
-                    pt_value, _ = get_value_from_getattr(in_node,
-                                                         self.pt_module)
+                    pt_value, _ = get_value_from_getattr(
+                        in_node, self.pt_module)
                     return pt_value is None
         return False
 
@@ -487,6 +512,13 @@ class TorchScriptPythonDecoder (Decoder):
     def get_named_input(self, name):
         raise RuntimeError("There is no named inputs in TS graph")
 
+    def get_rt_info(self):
+        rt_info = {}
+        if self.config is not None and "quantization_config" in self.config and "sym" in self.config["quantization_config"]:
+            rt_info["symmetric_quantization"] = OVAny(
+                self.config["quantization_config"]["sym"])
+        return rt_info
+
     @staticmethod
     def _transform_tensor_list_constants_to_listconstruct(graph: torch.Graph):
         # Function replaces prim::Constant containing List of Tensors with

intel_npu_acceleration_library/external/openvino/frontend/pytorch/utils.py

@@ -25,7 +25,7 @@ def fetch_attr(self_module, target: str):
     Return:
         Any: The value of the attribute.
     """
-    target_atoms = target.split('.')
+    target_atoms = target.split(".")
     attr_itr = self_module
     for i, atom in enumerate(target_atoms):
         if not hasattr(attr_itr, atom):
@@ -91,12 +91,13 @@ def get_value_from_getattr(getattr_node, self_module):
         node = stack.pop()
         attr_name = node.s("name")
         assert hasattr(
-            module, attr_name), f"No attribute with name \"{attr_name}\" found in module."
+            module, attr_name), f'No attribute with name "{attr_name}" found in module.'
         path_name = ".".join([path_name, attr_name])
         module = getattr(module, attr_name)
     return module, path_name
 
-def graph_has_ops(graph, op_types:list) -> bool:
+
+def graph_has_ops(graph, op_types: list) -> bool:
     res = False
     for n in graph.nodes():
         if any(kind in n.kind() for kind in op_types):
@@ -106,7 +107,7 @@ def graph_has_ops(graph, op_types:list) -> bool:
         if res:
             return res
     return res
-    
+
 
 pt_to_ov_type_map = {
     "float": OVType.f32,
@@ -134,7 +135,7 @@ pt_to_ov_type_map = {
     "torch.BoolTensor": OVType.boolean,
     "torch.quint8": OVType.u8,
     "torch.qint8": OVType.i8,
-    "torch.qint32": OVType.i32
+    "torch.qint32": OVType.i32,
 }
 
 
@@ -159,7 +160,7 @@ def process_dict_inputs(inputs, input_params, model):
             ordered_inputs.append(input_name)
 
     input_signature = list(input_params)
-    if ordered_inputs == input_signature[:len(ordered_inputs)]:
+    if ordered_inputs == input_signature[: len(ordered_inputs)]:
         example_inputs = [inputs[input_name] for input_name in ordered_inputs]
         if all([isinstance(inp, torch.Tensor) for inp in example_inputs]):
             return {"example_inputs": [inputs[name] for name in ordered_inputs]}, ordered_inputs, model
@@ -191,8 +192,8 @@ def process_dict_inputs(inputs, input_params, model):
             str(input_params[input_name]).replace("NoneType", "None"))
         input_params_str.append(f"{input_name}={input_name}")
 
-    wrapper_class = wrapper_template.format(input_sign=', '.join(
-        input_sign_str), example_input=', '.join(input_params_str))
+    wrapper_class = wrapper_template.format(input_sign=", ".join(
+        input_sign_str), example_input=", ".join(input_params_str))
     result = {}
     try:
         exec(wrapper_class, result)
@@ -210,7 +211,8 @@ def prepare_example_inputs_and_model(inputs, input_params, model):
     input_is_list = False
     input_signature = list(input_params)
     if isinstance(inputs, dict):
-        examples, ordered, wrapped = process_dict_inputs(inputs, input_params, model)
+        examples, ordered, wrapped = process_dict_inputs(
+            inputs, input_params, model)
         return examples, ordered, wrapped, input_is_list
     if isinstance(inputs, list) and len(inputs) == 1 and isinstance(inputs[0], torch.Tensor):
         if "typing.List" in str(input_params[input_signature[0]].annotation):
@@ -219,7 +221,7 @@ def prepare_example_inputs_and_model(inputs, input_params, model):
 
     if isinstance(inputs, torch.Tensor):
         inputs = [inputs]
-    input_signature = input_signature[:len(inputs)]
+    input_signature = input_signature[: len(inputs)]
     return {"example_inputs": inputs}, input_signature, model, input_is_list
 
 

intel_npu_acceleration_library/external/openvino/frontend/tensorflow/utils.py

@@ -6,13 +6,12 @@
 
 
 import logging as log
+import numpy as np
 import sys
+from openvino.runtime import PartialShape, Dimension, Type
 from packaging.version import parse, Version
 from typing import List, Dict, Union
 
-import numpy as np
-from openvino.runtime import PartialShape, Dimension, Type
-
 
 # TODO: reuse this method in ovc and remove duplication
 def get_static_shape(shape: [PartialShape, list, tuple], dynamic_value=None):
@@ -106,13 +105,32 @@ def trace_tf_model_if_needed(input_model, placeholder_shapes, placeholder_data_t
     return trace_tf_model(input_model, placeholder_shapes, placeholder_data_types, example_input)
 
 
-def get_input_spec_from_model(model):
+def partial_shape_to_list(partial_shape: PartialShape):
+    if partial_shape.rank.is_dynamic:
+        return None
+    res_list = []
+    for dim in partial_shape:
+        if dim.is_static:
+            res_list.append(dim.get_length())
+        else:
+            res_list.append(None)
+    return res_list
+
+
+def get_input_spec_from_model(model, input_shapes=None):
     import tensorflow as tf
     if hasattr(model, "_build_input_shape") and model._build_input_shape is not None:
         if isinstance(model._build_input_shape, list):
             input_spec = [[tf.TensorSpec(shape) for shape in model._build_input_shape]]
         else:
             input_spec = [tf.TensorSpec(model._build_input_shape)]
+    elif input_shapes and isinstance(input_shapes, list) and len(input_shapes) > 0:
+        input_spec = []
+        for input_shape in input_shapes:
+            if isinstance(input_shape, PartialShape):
+                input_spec.append(tf.TensorSpec(partial_shape_to_list(input_shape)))
+            else:
+                input_spec.append(tf.TensorSpec(None))
     else:
         input_spec = [tf.TensorSpec(None)]
     return input_spec
@@ -199,10 +217,13 @@ def create_generic_function_from_keras_model(keras_model):
     if tf_input_signature is not None:
         @tf.function(input_signature=tf_input_signature)
         def wrapper_function_dict(*args):
-            input_dict = {}
-            for ind, tensor_spec in enumerate(tf_input_signature):
-                input_dict[tensor_spec.name] = args[ind]
-            outputs = keras_model(input_dict)
+            if isinstance(keras_input_signature, list):
+                outputs = keras_model(args)
+            else:
+                input_dict = {}
+                for ind, tensor_spec in enumerate(tf_input_signature):
+                    input_dict[tensor_spec.name] = args[ind]
+                outputs = keras_model(input_dict)
             # need to wrap the output into dictionary
             # it helps to preserve original keras tensor names
             post_outputs = {}
@@ -276,7 +297,7 @@ def trace_tf_model(model, input_shapes, input_types, example_input):
                                               "Could not trace the TF model with the following error: {}",
                                               use_example_input=False)
         else:
-            input_spec = get_input_spec_from_model(model)
+            input_spec = get_input_spec_from_model(model, input_shapes)
             concrete_func = get_concrete_func(tf_function, input_spec, input_needs_packing,
                                               "Could not trace the TF model with the following error: {}.\n"
                                               "Please provide 'example_input'.")
@@ -457,4 +478,4 @@ def tf_type_to_ov_type(val):
     }
     if val not in tf_to_ov_type:
         raise Exception("The provided data type is not supported by OpenVino {}.".format(val))
-    return tf_to_ov_type[val]
+    return tf_to_ov_type[val]

intel_npu_acceleration_library/external/openvino/helpers/packing.py

@@ -20,10 +20,10 @@ def pack_data(array: np.ndarray, type: Type) -> np.ndarray:
 
     :param array: numpy array with values to pack.
     :type array: numpy array
-    :param type: Type to interpret the array values. Type must be u1, u4, i4 or nf4.
+    :param type: Type to interpret the array values. Type must be u1, u4, i4, nf4 or f4e2m1.
     :type type: openvino.runtime.Type
     """
-    assert type in [Type.u1, Type.u4, Type.i4, Type.nf4], "Packing algorithm for the" "data types stored in 1, 2 or 4 bits"
+    assert type in [Type.u1, Type.u4, Type.i4, Type.nf4, Type.f4e2m1], "Packing algorithm for the" "data types stored in 1, 2 or 4 bits"
 
     minimum_regular_dtype = np.int8 if type == Type.i4 else np.uint8
     casted_to_regular_type = array.astype(dtype=minimum_regular_dtype, casting="unsafe")
@@ -57,12 +57,12 @@ def unpack_data(array: np.ndarray, type: Type, shape: Union[list, Shape]) -> np.
 
     :param array: numpy array to unpack.
     :type array: numpy array
-    :param type: Type to extract from array values. Type must be u1, u4, i4 or nf4.
+    :param type: Type to extract from array values. Type must be u1, u4, i4, nf4 or f4e2m1.
     :type type: openvino.runtime.Type
     :param shape: the new shape for the unpacked array.
     :type shape: Union[list, openvino.runtime.Shape]
     """
-    assert type in [Type.u1, Type.u4, Type.i4, Type.nf4], "Unpacking algorithm for the" "data types stored in 1, 2 or 4 bits"
+    assert type in [Type.u1, Type.u4, Type.i4, Type.nf4, Type.f4e2m1], "Unpacking algorithm for the" "data types stored in 1, 2 or 4 bits"
     unpacked = np.unpackbits(array.view(np.uint8))
     shape = list(shape)
     if type.bitwidth == 1:

intel_npu_acceleration_library/external/openvino/preprocess/__init__.py

@@ -24,3 +24,5 @@ from openvino._pyopenvino.preprocess import PreProcessSteps
 from openvino._pyopenvino.preprocess import PostProcessSteps
 from openvino._pyopenvino.preprocess import ColorFormat
 from openvino._pyopenvino.preprocess import ResizeAlgorithm
+from openvino._pyopenvino.preprocess import PaddingMode
+

intel_npu_acceleration_library/external/openvino/preprocess/torchvision/requirements.txt

@@ -1,3 +1,4 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
 torch>=1.13
 torchvision; platform_machine == 'arm64' and python_version >= '3.8'
 torchvision; platform_machine != 'arm64'

intel_npu_acceleration_library/external/openvino/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
 import openvino._pyopenvino.properties as __properties