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/frontend/jax/jaxpr_decoder.py

@@ -0,0 +1,283 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# flake8: noqa
+# mypy: ignore-errors
+
+import jax.core
+from openvino.frontend.jax.py_jax_frontend import _FrontEndJaxDecoder as Decoder
+from openvino.runtime import PartialShape, Type as OVType, OVAny
+from openvino.frontend.jax.utils import jax_array_to_ov_const, get_ov_type_for_value, \
+    ivalue_to_constant
+
+import jax
+import numpy as np
+
+from typing import List
+import logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.WARNING)
+
+class JaxprPythonDecoder (Decoder):
+    '''
+    The jaxpr decoder uses Jaxpr to get graph information from a jax module.
+    It takes use of the following parts.
+    
+    - `ClosedJaxpr`: the jaxpr object that contains the jaxpr and literals.
+        - `Jaxpr`: the jaxpr object that contains the invars, outvars, and eqns.
+            - `JaxEqns`: A list of jaxpr equations, which contains the information of the operation.
+                - `Primitive`: the operation that is used in the equation.
+                - `invars`: the input variables of the equation.
+                    - `aval`: the abstract value.
+                - `outvars`: the output variables of the equation.
+                    - `aval`: the abstract value.
+                - `params`: the named params of this equation.
+            - `invars`: the inputs of the model (traced graph).
+                - `aval`: the abstract value.
+            - `outvars`: the outputs of the model (traced graph).
+                - `aval`: the abstract value.
+            - `constvars`: the constant variables used in this model.
+                - `aval`: the abstract value.
+        - `Literal`: the literal object that contains the value of the constants.
+    '''
+    
+    def __init__(self, jaxpr, name=None, literals=None):
+        '''
+        Inputs: 
+            - jaxpr: for users, `ClosedJaxpr` is expected here. See https://github.com/google/jax/blob/jaxlib-v0.4.29/jax/_src/core.py#L197
+            - name: the name for the model.
+            - literals: the literals (constants) that are used in the model.
+        '''
+        Decoder.__init__(self)
+        
+        if isinstance(jaxpr, (jax.core.JaxprEqn, jax.core.Jaxpr)):
+            self.jaxpr = jaxpr
+        elif isinstance(jaxpr, jax.core.ClosedJaxpr):
+            # Take the `Jaxpr` from `ClosedJaxpr`, see https://github.com/google/jax/blob/jaxlib-v0.4.29/jax/_src/core.py#L85
+            self.jaxpr = jaxpr.jaxpr
+            # Literal should be a `Jax.core.Var`, see https://github.com/google/jax/blob/jaxlib-v0.4.29/jax/_src/core.py#L85
+            self.literals = jaxpr.literals
+        else:
+            raise ValueError(f"Unexpected type of jaxpr: {type(jaxpr)}")
+        self.name = name
+        if self.name is None:
+            self.name = "jax_module"
+        if literals is not None:
+            self.literals = literals
+            
+        self.params = {}
+        if hasattr(self.jaxpr, 'params') and isinstance(self.jaxpr.params, dict):
+            for k in self.jaxpr.params.keys():
+                self.params[k] = self.convert_param_to_constant_node(self.jaxpr, k)
+                
+        # TODO: this implementation may lead to memory increasing. Any better solution?
+        self.m_decoders = []
+        
+    def inputs(self) -> List[int]:
+        if isinstance(self.jaxpr, jax.core.JaxprEqn):
+            idx = 0
+            res = []
+            for inp in self.jaxpr.invars:
+                if isinstance(inp, jax.core.Literal):
+                    res.append(self.literals[idx].output(0))
+                    idx += 1
+                else:
+                    res.append(id(inp))
+            return res
+        else:
+            return [id(v) for v in self.jaxpr.invars]
+    
+    def input(self, idx: int) -> int:
+        return id(self.jaxpr.invars[idx])
+    
+    def get_input_shape(self, index):
+        return PartialShape(self.jaxpr.invars[index].aval.shape)
+    
+    def get_input_signature_name(self, index) -> str:
+        return "jaxpr_invar_" + str(index)
+    
+    def get_input_type(self, index) -> OVType:
+        return get_ov_type_for_value(self.jaxpr.invars[index])
+        
+    def get_named_param(self, name):
+        '''
+        Get the object id of the named parameter by the name.
+        '''
+        return self.params[name].output(0)
+    
+    def get_named_param_as_constant(self, name):
+        '''
+        The named parameter in JAX is a python object but we want to use its value in cpp.
+        Therefore this API is used to get the named parameter as a constant, which can be used
+        to extract the value of it in cpp-level.
+        '''
+        return self.params[name].as_constant()
+    
+    def get_param_names(self):
+        '''
+        In JAX, the named parameters may exist in `params` attribute of `JaxEqn`.
+        For example, the `jax.lax.cat` operation has a named parameter `dim`, 
+        which is used to indicate the dimension to concatenate the tensors.
+        
+        Here we return the names of all the named params that appear in the model for the current `JaxEqn`.
+        '''
+        return list(self.params.keys())
+    
+    def get_output_type(self, index) -> OVType:
+        return get_ov_type_for_value(self.jaxpr.outvars[index])
+        
+    def get_output_name(self, index) -> str:
+        return "jaxpr_outvar_" + str(index)
+    
+    def get_output_shape(self, index):
+        return PartialShape(self.jaxpr.outvars[index].aval.shape)
+    
+    def visit_subgraph(self, node_visitor) -> None:
+        if isinstance(self.jaxpr, jax.core.JaxprEqn):
+            return
+        for _, decoder in self.params.items():
+            self.m_decoders.append(decoder)
+            node_visitor(decoder)
+        for idx, node in enumerate(self.jaxpr.constvars):
+            decoder = self.convert_literal_to_constant_node(
+                literal=self.literals[idx], 
+                name=self.name + "/" + f"const({id(node)})", 
+                output_id=id(node)
+            )
+            self.m_decoders.append(decoder)
+            node_visitor(decoder)
+        # Visit every `JaxEqn` in the jaxpr, see https://github.com/google/jax/blob/jaxlib-v0.4.29/jax/_src/core.py#L285
+        for node in self.jaxpr.eqns:
+            literal_decoders = []
+            for inp in node.invars:
+                if isinstance(inp, jax.core.Literal):
+                    literal_decoder = self.convert_literal_to_constant_node(inp)
+                    literal_decoders.append(literal_decoder)
+                    node_visitor(literal_decoder)
+            decoder = JaxprPythonDecoder(node, name=self.name + "/" + node.primitive.name, literals=literal_decoders)
+            self.m_decoders.append(decoder)
+            node_visitor(decoder)
+            
+    def get_op_type(self) -> str:
+        if isinstance(self.jaxpr, jax.core.JaxprEqn):
+            return self.jaxpr.primitive.name
+        else:
+            return "root"
+    
+    def outputs(self) -> List[int]:
+        return [id(v) for v in self.jaxpr.outvars]
+    
+    def output(self, idx: int) -> int:
+        return id(self.jaxpr.outvars[idx])
+    
+    def num_inputs(self) -> int:
+        return len(self.jaxpr.invars)
+    
+    def num_outputs(self) -> int:
+        return len(self.jaxpr.outvars)
+    
+    def as_constant(self):
+        if self.get_op_type() == 'constant':
+            value = self.literals
+            # TODO: dig out how to share the memory.
+            # Currently, using shared_memory will raise `ValueError: array is not writeable``
+            ov_const = jax_array_to_ov_const(value, shared_memory=False)
+            return ov_const.outputs()
+        else:
+            raise ValueError("This is not a constant node so it cannot be converted to a constant.")
+        
+    @staticmethod
+    def convert_param_to_constant_node(jaxpr, param):
+        assert hasattr(jaxpr, 'params'), "The jaxpr does not have params."
+        constant = ivalue_to_constant(jaxpr.params[param], shared_memory=False)
+        return _JaxprPythonConstantDecoder(constant=constant)
+    
+    @staticmethod
+    def convert_literal_to_constant_node(literal, name=None, output_id=None):
+        if isinstance(literal, jax.core.Literal):
+            constant = ivalue_to_constant(literal.val, shared_memory=False)
+        elif isinstance(literal, (jax.Array, np.ndarray)):
+            constant = ivalue_to_constant(literal, shared_memory=False)
+        else:
+            raise TypeError( f"The input should be a literal or jax array, but got {type(literal)}.")
+        return _JaxprPythonConstantDecoder(constant=constant, name=name, output_id=output_id)
+        
+class _JaxprPythonConstantDecoder (Decoder):
+    def __init__(self, name=None, constant=None, output_id=None):
+        '''
+        A decoder specially for constants and named parameters.
+        
+        Inputs:
+            - name: the name for the model.
+            - literals: the literals (constants) that are used in the model.
+            - output_id: the id specified for this decoder's output. If none, use `id(self.constant)`.
+        '''
+        Decoder.__init__(self)
+        
+        self.name = name
+        self.constant = constant
+        self.output_id = id(self.constant) if output_id is None else output_id
+        
+    def inputs(self) -> List[int]:
+        return []
+    
+    def input(self, idx: int) -> int:
+        raise ValueError("This is a constant node so it does not have input.")
+    
+    def get_input_shape(self, index):
+        raise ValueError("This is a constant node so it does not have input shape.")
+    
+    def get_input_signature_name(self, index) -> str:
+        raise ValueError("This is a constant node so it does not have input signature name.")
+    
+    def get_input_type(self, index) -> OVType:
+        raise ValueError("This is a constant node so it does not have input type.")
+        
+    def get_named_param(self, name):
+        raise ValueError("This is a constant node so it does not have named param.")
+    
+    def get_named_param_as_constant(self, name):
+        raise ValueError("This is a constant node so it does not have named param.")
+    
+    def get_param_names(self):
+        '''
+        In JAX, the named parameters may exist in `params` attribute of `JaxEqn`.
+        For example, the `jax.lax.cat` operation has a named parameter `dim`, 
+        which is used to indicate the dimension to concatenate the tensors.
+        
+        However, `_JaxprPythonConstantDecoder` is already a named param or a constant.
+        So it will never have a named param.
+        '''
+        return []
+    
+    def get_output_type(self, index) -> OVType:
+        assert len(self.constant) == 1
+        return OVAny(self.constant[0].element_type)
+        
+    def get_output_name(self, index) -> str:
+        return "jaxpr_outvar_" + str(index)
+    
+    def get_output_shape(self, index):
+        assert len(self.constant) == 1
+        return PartialShape(self.constant[0].shape)
+    
+    def visit_subgraph(self, node_visitor) -> None:
+        return
+            
+    def get_op_type(self) -> str:
+        return "constant"
+    
+    def outputs(self) -> List[int]:
+        return [self.output_id]
+    
+    def output(self, idx: int) -> int:
+        return self.output_id
+    
+    def num_inputs(self) -> int:
+        return 0
+    
+    def num_outputs(self) -> int:
+        return 1
+    
+    def as_constant(self):
+        return self.constant

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

@@ -0,0 +1,129 @@
+# Copyright (C) 2018-2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+
+# flake8: noqa
+# mypy: ignore-errors
+
+import jax
+import numpy as np
+import jax.numpy as jnp
+
+from openvino.runtime import op, Type as OVType, Shape, OVAny
+
+numpy_to_ov_type_map = {
+    np.float32: OVType.f32,
+    bool: OVType.boolean,
+    jax.dtypes.bfloat16: OVType.bf16, # TODO: check this
+    np.float16: OVType.f16,
+    np.float32: OVType.f32,
+    np.float64: OVType.f64,
+    np.uint8: OVType.u8,
+    np.int8: OVType.i8,
+    np.int16: OVType.i16,
+    np.int32: OVType.i32,
+    np.int64: OVType.i64,
+}
+
+jax_to_ov_type_map = {
+    jnp.float32: OVType.f32,
+    jnp.bfloat16: OVType.bf16, # TODO: check this
+    jnp.float16: OVType.f16,
+    jnp.float64: OVType.f64,
+    jnp.uint8: OVType.u8,
+    jnp.int8: OVType.i8,
+    jnp.int16: OVType.i16,
+    jnp.int32: OVType.i32,
+    jnp.int64: OVType.i64,
+}
+
+try:
+    jax_to_ov_type_map[jnp.bool] = OVType.boolean
+except:
+    pass
+
+basic_to_ov_type_map = {
+    int: OVType.i64,
+    float: OVType.f32,
+    bool: OVType.boolean,
+}
+
+ov_type_to_int_map = {
+    OVType.u8: 0,
+    OVType.i8: 1,
+    OVType.i16: 2,
+    OVType.i32: 3,
+    OVType.i64: 4,
+    OVType.f16: 5,
+    OVType.f32: 6,
+    OVType.f64: 7,
+    OVType.boolean: 11,
+    OVType.bf16: 15,
+}
+
+def get_type_from_py_type(value):
+    if isinstance(value, float):
+        return OVType.f32
+    if isinstance(value, bool):
+        return OVType.boolean
+    if isinstance(value, int):
+        return OVType.i64
+    return OVType.dynamic
+
+def get_ov_type_for_value(value):
+    if isinstance(value, (jax.core.Var, jax.core.Literal)):
+        if value.aval.dtype in jax_to_ov_type_map:
+            return OVAny(jax_to_ov_type_map[value.aval.dtype])
+        for k, v in numpy_to_ov_type_map.items():
+            if value.aval.dtype == k:
+                return OVAny(v)
+        for k, v in basic_to_ov_type_map.items():
+            if isinstance(value.aval.dtype, k):
+                return OVAny(v)
+    elif isinstance(value, (int, float, bool)):
+        return OVAny(jax_to_ov_type_map[type(value)])
+    else:
+        raise NotImplementedError(f"dtype for {value} of type {type(value)} has not been supported yet.")
+    
+def get_ov_type_from_jax_type(dtype):
+    if dtype in jax_to_ov_type_map:
+        return OVAny(jax_to_ov_type_map[dtype])
+    for k, v in numpy_to_ov_type_map.items():
+        if dtype == k:
+            return OVAny(v)
+    for k, v in basic_to_ov_type_map.items():
+        if isinstance(dtype, k):
+            return OVAny(v)
+    return None
+
+def jax_array_to_ov_const(arr: np.ndarray, shared_memory=True):
+    # TODO: deal with bfloat16 dtype here.
+    if isinstance(arr, np.ndarray):
+        return op.Constant(arr, shared_memory=shared_memory)
+    elif isinstance(arr, jax.Array):
+        return op.Constant(np.array(jax.device_get(arr)), shared_memory=shared_memory)
+    else:
+        raise ValueError(f"Constant is expected to be a numpy array or jax array but got {type(arr)}")
+
+def ivalue_to_constant(ivalue, shared_memory=True):
+    '''
+    Convert a python object to an openvino constant.
+    '''
+    ov_type = get_type_from_py_type(ivalue)
+    if ov_type.is_static():
+        return op.Constant(ov_type, Shape([]), [ivalue]).outputs()
+
+    if isinstance(ivalue, (list, tuple)):
+        assert len(ivalue) > 0, "Can't deduce type for empty list"
+        ov_type = get_type_from_py_type(ivalue[0])
+        assert ov_type.is_static(), "Can't deduce type for list"
+        return op.Constant(ov_type, Shape([len(ivalue)]), ivalue).outputs()
+
+    if isinstance(ivalue, (jax.Array, np.ndarray)):
+        return jax_array_to_ov_const(ivalue, shared_memory=shared_memory).outputs()
+            
+    ov_dtype_value = get_ov_type_from_jax_type(ivalue)
+    if ov_dtype_value is not None:
+        return op.Constant(OVType.i64, Shape([]), [ov_type_to_int_map[ov_dtype_value]]).outputs()
+    
+    print(f"[WARNING][JAX FE] Cannot get constant from value {ivalue}")
+    return None

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

@@ -30,6 +30,7 @@ class TorchFXPythonDecoder (Decoder):
         self.input_shapes = input_shapes
 
         self._input_signature = []
+        self._example_input = None
 
         if issubclass(type(pt_module), torch.fx.graph_module.GraphModule):
 
@@ -316,6 +317,13 @@ class TorchFXPythonDecoder (Decoder):
     def num_of_outputs(self):
         return len(self.outputs())
 
+    def output_list_size(self):
+        max_out_id = -1
+        for user in self.pt_module.users:
+            if "<built-in function getitem>" == str(user.target) and max_out_id < user.args[1]:
+                max_out_id = user.args[1]
+        return max_out_id + 1
+
     def output(self, index):
         return self.outputs()[index]
 

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

@@ -32,7 +32,7 @@ def patched_forward(self, *args, **kwargs):
     x = args[0]
     dtype = x.dtype
     outshape = x.shape[:-1] + (self.width,)
-    x = x.view(-1, x.shape[-1])
+    x = x.contiguous().view(-1, x.shape[-1])
     groups = self.qzeros.shape[0]
     height = self.qweight.shape[0]
 

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

@@ -30,6 +30,7 @@ def patch_model(model, module_extensions, orig_forward_name):
 
         if extension:
             # The Trampoline class is instantiated for every module replacement, so we can use class members individually for each module.
+
             class Trampoline(torch.autograd.Function):
                 target_extension = extension
                 original_module = m
@@ -83,16 +84,35 @@ def unpatch_model(model, orig_forward_name):
 
 
 def __make_16bit_traceable(model: torch.nn.Module):
-    # Replace torch.nn.Linear with ModuleExtension and move other modules to fp32
-    extensions = {torch.nn.Linear: ModuleExtension(
-        torch.nn.Linear,
-        "aten::linear",
-        evaluate=lambda module, *args, **kwargs: torch.ones(
-            list(args[0].shape[:-1]) + [module.out_features], dtype=torch.float32) * 0.5,
-        convert=lambda module, target_op, *args, **kwargs: target_op(args[0], module.weight, module.bias))
+    """
+    Prepare a 16-bit PyTorch model for tracing with OpenVINO.
+     - Replace known list of modules with ModuleExtension.
+     - Convert other modules with weights to FP32.
+    """
+    extensions = {
+        torch.nn.Linear: ModuleExtension(
+            torch.nn.Linear, "ov_ext::linear",
+            evaluate=lambda module, *args, **kwargs: torch.full(
+                list(args[0].shape[:-1]) + [module.out_features], 0.5, dtype=torch.float32),
+            convert=lambda module, target_op, *args, **kwargs: target_op(args[0], module.weight, module.bias)),
+        torch.nn.Embedding: ModuleExtension(
+            torch.nn.Embedding, "ov_ext::embedding",
+            evaluate=lambda module, *args, **kwargs: torch.full(
+                list(args[0].shape) + [module.embedding_dim], 0.5, dtype=torch.float32),
+            convert=lambda module, target_op, *args, **kwargs: target_op(module.weight, args[0], module.padding_idx, module.scale_grad_by_freq, module.sparse)),
     }
+    try:
+        from transformers.pytorch_utils import Conv1D
+        extensions[Conv1D] = ModuleExtension(
+            Conv1D, "ov_ext::conv1d",
+            evaluate=lambda module, *args, **kwargs: torch.full(
+                list(args[0].shape[:-1]) + [module.nf], 0.5, dtype=torch.float32),
+            convert=lambda module, target_op, *args, **kwargs: target_op(args[0], module.weight, module.bias))
+    except:
+        pass
     patch_model(model, extensions,
                 "_openvino_module_extension_patch_orig_forward")
     for _, module in model.named_modules():
-        if module.__class__ not in extensions and hasattr(module, "weight") and module.weight.dtype in [torch.float16, torch.bfloat16]:
+        if module.__class__ not in extensions and (any([p.dtype in [torch.float16, torch.bfloat16] for p in module.parameters(False)])
+                                                   or any([b.dtype in [torch.float16, torch.bfloat16] for b in module.buffers(False)])):
             module.float()

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

@@ -241,6 +241,7 @@ class OperatorSupport(OperatorSupport):
             "torch.ops.aten.transpose.int": None,
             "torch.ops.aten.tril.default": None,
             "torch.ops.aten.tril_.default": None,
+            "torch.ops.aten.triu.default": None,
             "torch.ops.aten.unbind.int": None,
             "torch.ops.aten.unfold.default": None,
             "torch.ops.aten.unsqueeze.default": None,

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

@@ -96,6 +96,7 @@ class TorchScriptPythonDecoder (Decoder):
         if isinstance(pt_module, torch.nn.Module):
             pt_module.eval()
         input_signature = None
+        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(
@@ -150,8 +151,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

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

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

@@ -15,4 +15,5 @@ from openvino._pyopenvino.op import Parameter
 from openvino._pyopenvino.op import if_op
 from openvino._pyopenvino.op import loop
 from openvino._pyopenvino.op import tensor_iterator
+from openvino._pyopenvino.op import read_value
 from openvino._pyopenvino.op import Result

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

@@ -31,7 +31,7 @@ from openvino.runtime.utils.types import (
     get_element_type_str,
     make_constant_node,
 )
-
+from openvino.utils import deprecated
 
 _get_node_factory_opset1 = partial(_get_node_factory, "opset1")
 
@@ -1532,6 +1532,7 @@ def lstm_cell(
     return _get_node_factory_opset1().create("LSTMCell", node_inputs, attributes)
 
 
+@deprecated(version="2025.0", message="Use lstm_sequence from opset 5")
 @nameable_op
 def lstm_sequence(
     X: NodeInput,