bigdl-core-npu 2.6.0b20241119__cp311-cp311-win_amd64.whl → 2.6.0b20241122__cp311-cp311-win_amd64.whl

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

@@ -115,9 +115,10 @@ def mvn(
     return _get_node_factory_opset6().create("MVN", inputs, attributes)
 
 
-@overloading(Union[Node, Output], str, Optional[Union[type, np.dtype, Type, str]], Optional[Union[TensorShape, Shape, PartialShape]], Optional[str])
+@overloading(Union[Node, Output, int, float, np.ndarray], str, Optional[Union[type, np.dtype, Type, str]],
+             Optional[Union[TensorShape, Shape, PartialShape]], Optional[str])
 @nameable_op
-def read_value(init_value: Union[Node, Output],
+def read_value(init_value: Union[Node, Output, int, float, np.ndarray],
                variable_id: str,
                variable_type: Optional[Union[type, np.dtype, Type, str]] = None,
                variable_shape: Optional[Union[TensorShape, Shape, PartialShape]] = None,
@@ -139,9 +140,13 @@ def read_value(init_value: Union[Node, Output],
             info.data_type = get_element_type(variable_type)
         else:
             info.data_type = variable_type
+    else:
+        info.data_type = Type.dynamic
 
     if variable_shape is not None:
         info.data_shape = PartialShape(variable_shape)
+    else:
+        info.data_shape = PartialShape.dynamic()
 
     var_from_info = Variable(info)
     return _read_value(new_value=as_node(init_value, name=name), variable=var_from_info)
@@ -169,9 +174,13 @@ def read_value(variable_id: str,  # noqa: F811
             info.data_type = get_element_type(variable_type)
         else:
             info.data_type = variable_type
+    else:
+        info.data_type = Type.dynamic
 
     if variable_shape is not None:
         info.data_shape = PartialShape(variable_shape)
+    else:
+        info.data_shape = PartialShape.dynamic()
 
     var_from_info = Variable(info)
 
@@ -191,9 +200,9 @@ def read_value(ov_variable: Variable,  # noqa: F811
     return _read_value(ov_variable)
 
 
-@overloading(Union[Node, Output], Variable, Optional[str])  # type: ignore
+@overloading(Union[Node, Output, int, float, np.ndarray], Variable, Optional[str])  # type: ignore
 @nameable_op
-def read_value(init_value: Union[Node, Output],  # noqa: F811
+def read_value(init_value: Union[Node, Output, int, float, np.ndarray],  # noqa: F811
                ov_variable: Variable,
                name: Optional[str] = None) -> Node:
     """Return a node which produces the Assign operation.

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

@@ -366,7 +366,7 @@ def random_uniform(
         "output_type": output_type,
         "global_seed": global_seed,
         "op_seed": op_seed,
-        "alignment": alignment.lower()
+        "alignment": alignment.lower(),
     }
     return _get_node_factory_opset8().create("RandomUniform", inputs, attributes)
 

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

@@ -28,6 +28,7 @@ from openvino._pyopenvino.properties import max_batch_size
 from openvino._pyopenvino.properties import range_for_async_infer_requests
 from openvino._pyopenvino.properties import execution_devices
 from openvino._pyopenvino.properties import loaded_from_cache
+from openvino._pyopenvino.properties import cache_encryption_callbacks
 
 # Submodules
 from openvino.runtime.properties import hint

intel_npu_acceleration_library/external/openvino/runtime/utils/data_helpers/data_dispatcher.py

@@ -7,7 +7,7 @@ from typing import Any, Dict, Union, Optional
 
 import numpy as np
 
-from openvino._pyopenvino import ConstOutput, Tensor, Type
+from openvino._pyopenvino import ConstOutput, Tensor, Type, RemoteTensor
 from openvino.runtime.utils.data_helpers.wrappers import _InferRequestWrapper, OVDict
 
 ContainerTypes = Union[dict, list, tuple, OVDict]
@@ -61,6 +61,16 @@ def _(
     return value
 
 
+@value_to_tensor.register(RemoteTensor)
+def _(
+    value: RemoteTensor,
+    request: Optional[_InferRequestWrapper] = None,
+    is_shared: bool = False,
+    key: Optional[ValidKeys] = None,
+) -> RemoteTensor:
+    return value
+
+
 @value_to_tensor.register(np.ndarray)
 def _(
     value: np.ndarray,
@@ -137,7 +147,11 @@ def _(
 def to_c_style(value: Any, is_shared: bool = False) -> Any:
     if not isinstance(value, np.ndarray):
         if hasattr(value, "__array__"):
-            return to_c_style(np.array(value, copy=False), is_shared) if is_shared else np.array(value, copy=True)
+            if np.lib.NumpyVersion(np.__version__) >= "2.0.0":
+                # https://numpy.org/devdocs/numpy_2_0_migration_guide.html#adapting-to-changes-in-the-copy-keyword
+                return to_c_style(np.asarray(value), is_shared) if is_shared else np.asarray(value, copy=True)  # type: ignore
+            else:
+                return to_c_style(np.array(value, copy=False), is_shared) if is_shared else np.array(value, copy=True)
         return value
     return value if value.flags["C_CONTIGUOUS"] else np.ascontiguousarray(value)
 
@@ -152,7 +166,11 @@ def normalize_arrays(
 ) -> Any:
     # Check the special case of the array-interface
     if hasattr(inputs, "__array__"):
-        return to_c_style(np.array(inputs, copy=False), is_shared) if is_shared else np.array(inputs, copy=True)
+        if np.lib.NumpyVersion(np.__version__) >= "2.0.0":
+            # https://numpy.org/devdocs/numpy_2_0_migration_guide.html#adapting-to-changes-in-the-copy-keyword
+            return to_c_style(np.asarray(inputs), is_shared) if is_shared else np.asarray(inputs, copy=True)  # type: ignore
+        else:
+            return to_c_style(np.array(inputs, copy=False), is_shared) if is_shared else np.array(inputs, copy=True)
     # Error should be raised if type does not match any dispatchers
     raise TypeError(f"Incompatible inputs of type: {type(inputs)}")
 

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

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from functools import wraps
-from inspect import getfullargspec
+from inspect import signature
 from typing import Any, Callable, Dict, Optional, Union, get_origin, get_args
 
 from openvino.runtime import Node, Output
@@ -102,19 +102,39 @@ class MultiMethod(object):
                 return False
         return True
 
-    def __call__(self, *args) -> Any:  # type: ignore
-        types = tuple(arg.__class__ for arg in args)
+    def __call__(self, *args, **kwargs) -> Any:  # type: ignore
+        arg_types = tuple(arg.__class__ for arg in args)
+        kwarg_types = {key: type(value) for key, value in kwargs.items()}
+
         key_matched = None
-        for key in self.typemap.keys():
-            if self.check_invoked_types_in_overloaded_funcs(types, key):
-                key_matched = key
-                break
+        if len(kwarg_types) == 0 and len(arg_types) != 0:
+            for key in self.typemap.keys():
+                # compare types of called function with overloads
+                if self.check_invoked_types_in_overloaded_funcs(arg_types, key):
+                    key_matched = key
+                    break
+        elif len(arg_types) == 0 and len(kwarg_types) != 0:
+            for key, func in self.typemap.items():
+                func_signature = {arg_name: types.annotation for arg_name, types in signature(func).parameters.items()}
+                # if kwargs of called function are subset of overloaded function, we use this overload
+                if kwarg_types.keys() <= func_signature.keys():
+                    key_matched = key
+                    break
+        elif len(arg_types) != 0 and len(kwarg_types) != 0:
+            for key, func in self.typemap.items():
+                func_signature = {arg_name: types.annotation for arg_name, types in signature(func).parameters.items()}
+                # compare types of called function with overloads
+                if self.check_invoked_types_in_overloaded_funcs(arg_types, tuple(func_signature.values())):
+                    # if kwargs of called function are subset of overloaded function, we use this overload
+                    if kwarg_types.keys() <= func_signature.keys():
+                        key_matched = key
+                        break
 
         if key_matched is None:
-            raise TypeError("no match")
+            raise TypeError(f"The necessary overload for {self.name} was not found")
 
         function = self.typemap.get(key_matched)
-        return function(*args)  # type: ignore
+        return function(*args, **kwargs)  # type: ignore
 
     def register(self, types: tuple, function: Callable) -> None:
         if types in self.typemap:

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

@@ -134,7 +134,6 @@ def extract_input_info_from_example(args, inputs):
                                                                    0] == "self" else args.input_model._input_signature
     if input_names and not is_dict_input:
         example_inputs = dict(zip(input_names, example_inputs))
-    print(input_names)
     example_inputs = flatten_inputs(example_inputs, input_names)
     input_arg = []
     for example in example_inputs: