Merge branch 'master' into gha/pgzip_fix

docs/CMakeLists.txt

@@ -6,6 +6,7 @@ add_subdirectory(snippets)
 
 set(ENABLE_CPP_API OFF CACHE BOOL "Build with C/C++ API.")
 set(ENABLE_PYTHON_API OFF CACHE BOOL "Build with Python API.")
+set(ENABLE_GENAI_API OFF CACHE BOOL "Build with GenAI API.")
 set(ENABLE_NOTEBOOKS OFF CACHE BOOL "Build with openvino notebooks.")
 set(ENABLE_OMZ OFF CACHE BOOL "Build with open_model_zoo.")
 set(ENABLE_OVMS OFF CACHE BOOL "Build with ovms.")
@@ -61,11 +62,12 @@ function(build_docs)
         list(APPEND commands COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --green "FINISHED preprocessing OpenVINO C/C++ API reference")
     endif()
 
-    if(${ENABLE_PYTHON_API})
+    if(${ENABLE_PYTHON_API} OR ${ENABLE_GENAI_API})
         list(APPEND commands COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --green "STARTED preprocessing OpenVINO Python API")
         list(APPEND commands COMMAND ${Python3_EXECUTABLE} ${OV_INSTALLATION_SCRIPT}
         --ov_dir=${SPHINX_SETUP_DIR}
-        --python=${Python3_EXECUTABLE})
+        --python=${Python3_EXECUTABLE}
+        --enable_genai=${ENABLE_GENAI_API})
         list(APPEND commands COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --green "FINISHED preprocessing OpenVINO Python API")
     endif()
 
@@ -83,7 +85,7 @@ function(build_docs)
         list(APPEND commands COMMAND ${Python3_EXECUTABLE} ${FILE_HELPER_SCRIPT}
         --filetype=md
         --input_dir=${OVMS_DOCS_DIR}
-        --output_dir=${SPHINX_SOURCE_DIR}
+        --output_dir=${SPHINX_SOURCE_DIR}/openvino-workflow/model-server
         --exclude_dir=${SPHINX_SOURCE_DIR})
         list(APPEND commands COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --green "FINISHED preprocessing OVMS")
     endif()

docs/articles_en/openvino-workflow.rst

@@ -14,7 +14,7 @@ OpenVINO Workflow
    openvino-workflow/model-optimization
    Running Inference <openvino-workflow/running-inference>
    Deployment on a Local System  <openvino-workflow/deployment-locally>
-   Deployment on a Model Server <ovms_what_is_openvino_model_server>
+   Deployment on a Model Server <openvino-workflow/model-server/ovms_what_is_openvino_model_server>
    openvino-workflow/torch-compile
 
 

docs/scripts/install_appropriate_openvino_version.py

@@ -2,64 +2,64 @@
 import argparse
 import subprocess
 import requests
-import pkg_resources
 from packaging import version
 from pathlib import Path
 
 
 def determine_openvino_version(file_path):
     pattern = r"version_name\s*=\s*['\"]([^'\"]+)['\"]"
-
     with open(file_path, 'r') as file:
         content = file.read()
-
     match = re.search(pattern, content)
-
-    if match:
-        return match.group(1)
-    else:
-        return None
+    return match.group(1) if match else None
 
 
-def get_latest_version(major_version):
-    url = f"https://pypi.org/pypi/openvino/json"
+def get_latest_version(package, major_version):
+    url = f"https://pypi.org/pypi/{package}/json"
     response = requests.get(url)
-
     if response.status_code == 200:
         data = response.json()
         versions = data['releases'].keys()
-
-        # Filter versions by the major version prefix
         matching_versions = [v for v in versions if v.startswith(major_version)]
-
-        # Sort the matching versions and return the latest one
         if matching_versions:
             matching_versions.sort(key=version.parse)
             return matching_versions[-1]
-
     return None
 
 
+def install_package(python_executable, package):
+    subprocess.check_call([f'{python_executable}', '-m', 'pip', 'install', '-U', package, '--no-cache-dir'])
+
+
 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('--ov_dir', type=Path, help='OpenVINO docs directory')
     parser.add_argument('--python', type=Path, help='Python executable')
+    parser.add_argument('--enable_genai', type=str, choices=['ON', 'OFF'], default='OFF', help='Enable GenAI API installation')
     args = parser.parse_args()
-    ov_dir = args.ov_dir
-    python_executable = args.python
-    version_name = determine_openvino_version(ov_dir.joinpath("conf.py"))
-
-    if version_name is None:
-        ov_version = "openvino"
-    elif version_name == "nightly":
-        ov_version = "openvino-nightly"
+
+    version_name = determine_openvino_version(args.ov_dir.joinpath("conf.py"))
+
+    if version_name == "nightly":
+        install_package(args.python, "openvino-nightly")
+        print("OpenVINO nightly version installed. OpenVINO GenAI nightly version is not available.")
+    elif version_name is None or version_name == "latest":
+        install_package(args.python, "openvino")
+        if args.enable_genai == 'ON':
+            install_package(args.python, "openvino-genai")
     else:
-        latest_version = get_latest_version(version_name)
-        if latest_version:
-            ov_version = f"openvino=={latest_version}"
+        ov_version = get_latest_version("openvino", version_name)
+        if ov_version:
+            install_package(args.python, f"openvino=={ov_version}")
         else:
-            ov_version = f"openvino=={version_name}"
-    subprocess.check_call([f'{python_executable}', '-m', 'pip', 'install', '-U', ov_version, '--no-cache-dir'])
+            print(f"No matching OpenVINO version found for {version_name}")
+
+        if args.enable_genai == 'ON':
+            ov_genai_version = get_latest_version("openvino-genai", version_name)
+            if ov_genai_version:
+                install_package(args.python, f"openvino-genai=={ov_genai_version}")
+            else:
+                print(f"No matching OpenVINO GenAI version found for {version_name}")
 
 
 if __name__ == "__main__":

docs/scripts/tests/suppress_warnings.txt

@@ -61,3 +61,4 @@ toctree contains reference to nonexisting document
 pygments lexer name
 non-consecutive header level increase
 document headings start at
+inline strong start-string without end-string

docs/sphinx_setup/api/api_reference.rst

@@ -15,6 +15,7 @@ API Reference
    OpenVINO Runtime C++ API <c_cpp_api/group__ov__cpp__api>
    OpenVINO Runtime C API <c_cpp_api/group__ov__c__api>
    OpenVINO Node.js API <nodejs_api/nodejs_api>
+   GenAI Python API <genai_api/api>
 
 
 

docs/sphinx_setup/api/genai_api/api.rst

@@ -0,0 +1,12 @@
+OpenVINO GenAI API
+===================
+
+.. meta::
+   :description: Explore OpenVINO GenAI Python API and implementation of its features in Intel® Distribution of OpenVINO™ GenAI.
+
+
+.. autosummary::
+   :toctree: _autosummary
+   :template: custom-module-template.rst
+
+   openvino_genai

docs/sphinx_setup/conf.py

@@ -34,11 +34,21 @@
     'breathe'
     ]
 
+autodoc_mock_imports = []
+
 try:
     import openvino
 except ImportError:
-    autodoc_mock_imports = ["openvino"]
+    autodoc_mock_imports.append("openvino")
+    autodoc_mock_imports.append("openvino_genai")  # Mock openvino_genai too, as it depends on openvino
+
+if "openvino" not in autodoc_mock_imports:
+    try:
+        import openvino_genai
+    except ImportError:
+        autodoc_mock_imports.append("openvino_genai")
 
+
 breathe_projects = {
     "openvino": "../xml/"
 }

src/bindings/python/src/openvino/frontend/pytorch/fx_decoder.py

@@ -24,7 +24,8 @@ def __init__(self, data) -> None:
 
 class TorchFXPythonDecoder (Decoder):
 
-    def __init__(self, pt_module, fx_gm=None, nodes=None, mark_node_callback=None, input_shapes=[], input_types=[]):
+    def __init__(self, pt_module, fx_gm=None, nodes=None,
+                 mark_node_callback=None, input_shapes=[], input_types=[], dynamic_shapes=False):
         Decoder.__init__(self)
         self.mark_node_callback = mark_node_callback
         # We store every decoder created by this decoder so that all them are not deleted until the first decoder is deleted
@@ -67,7 +68,7 @@ def __init__(self, pt_module, fx_gm=None, nodes=None, mark_node_callback=None, i
                 if shape is not None:
                     new_shape = []
                     for dim in range(0, len(shape)):
-                        if (type(shape[dim]).__name__ == "SymInt"):
+                        if (dynamic_shapes or type(shape[dim]).__name__ == "SymInt"):
                             new_shape.append(-1)
                         else:
                             new_shape.append(shape[dim])

src/plugins/intel_cpu/src/emitters/plugin/aarch64/jit_eltwise_emitters.cpp

@@ -1928,6 +1928,60 @@ std::set<std::vector<element::Type>> jit_sigmoid_emitter::get_supported_precisio
     return {{element::f32}};
 }
 
+/// SOFT_SIGN ///
+jit_soft_sign_emitter::jit_soft_sign_emitter(dnnl::impl::cpu::aarch64::jit_generator* host,
+                                             dnnl::impl::cpu::aarch64::cpu_isa_t host_isa,
+                                             const std::shared_ptr<ov::Node>& node)
+        : jit_emitter(host, host_isa, node, get_arithmetic_binary_exec_precision(node)) {
+    prepare_table();
+}
+
+jit_soft_sign_emitter::jit_soft_sign_emitter(dnnl::impl::cpu::aarch64::jit_generator* host,
+                                             dnnl::impl::cpu::aarch64::cpu_isa_t host_isa,
+                                             const ov::element::Type exec_prc) : jit_emitter(host, host_isa, exec_prc) {
+    prepare_table();
+}
+
+size_t jit_soft_sign_emitter::get_inputs_count() const { return 1; }
+
+size_t jit_soft_sign_emitter::get_aux_vecs_count() const { return 2; }
+
+size_t jit_soft_sign_emitter::get_aux_gprs_count() const { return 1; }
+
+void jit_soft_sign_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+    if (host_isa_ == dnnl::impl::cpu::aarch64::asimd) {
+        emit_isa<dnnl::impl::cpu::aarch64::asimd>(in_vec_idxs, out_vec_idxs);
+    } else {
+        OPENVINO_THROW("Can't create jit eltwise kernel");
+    }
+}
+
+template <dnnl::impl::cpu::aarch64::cpu_isa_t isa>
+void jit_soft_sign_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+    if (exec_prc_ != ov::element::f32) {
+        OPENVINO_THROW("unsupported precision: " + exec_prc_.to_string());
+    }
+
+    using TReg = typename dnnl::impl::cpu::aarch64::cpu_isa_traits<isa>::TReg;
+    const TReg src(in_vec_idxs[0]);
+    const TReg dst(out_vec_idxs[0]);
+    const TReg aux1(aux_vec_idxs[0]);
+    const TReg aux2(aux_vec_idxs[1]);
+
+    h->fabs(aux1.s, src.s);
+    h->ld1r(aux2.s, table_val2("one"));
+    h->fadd(aux1.s, aux1.s, aux2.s);
+    h->fdiv(dst.s, src.s, aux1.s);
+}
+
+void jit_soft_sign_emitter::register_table_entries() {
+    push_arg_entry_of("one", 0x3f800000, true);
+}
+
+std::set<std::vector<element::Type>> jit_soft_sign_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+    return {{element::f32}};
+}
+
 /// SUBTRACT ///
 jit_subtract_emitter::jit_subtract_emitter(dnnl::impl::cpu::aarch64::jit_generator* host,
                                            dnnl::impl::cpu::aarch64::cpu_isa_t host_isa,

src/plugins/intel_cpu/src/emitters/plugin/aarch64/jit_eltwise_emitters.hpp

@@ -779,6 +779,35 @@ class jit_sigmoid_emitter : public jit_emitter {
     void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
 };
 
+class jit_soft_sign_emitter : public jit_emitter {
+public:
+    jit_soft_sign_emitter(dnnl::impl::cpu::aarch64::jit_generator* host,
+                          dnnl::impl::cpu::aarch64::cpu_isa_t host_isa,
+                          const ov::element::Type exec_prc = ov::element::f32);
+
+    jit_soft_sign_emitter(dnnl::impl::cpu::aarch64::jit_generator* host,
+                          dnnl::impl::cpu::aarch64::cpu_isa_t host_isa,
+                          const std::shared_ptr<ov::Node>& node);
+
+    size_t get_inputs_count() const override;
+
+    size_t get_aux_vecs_count() const override;
+
+    size_t get_aux_gprs_count() const override;
+
+    void register_table_entries() override;
+
+    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+
+private:
+    std::unique_ptr<jit_exp_emitter> exp_emitter;
+
+    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+
+    template <dnnl::impl::cpu::aarch64::cpu_isa_t isa>
+    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+};
+
 class jit_subtract_emitter : public jit_emitter {
 public:
     jit_subtract_emitter(dnnl::impl::cpu::aarch64::jit_generator *host,

src/plugins/intel_cpu/src/nodes/executors/aarch64/jit_eltwise.cpp

@@ -47,6 +47,7 @@ bool JitEltwiseExecutor::isSupported(
                                      Algorithm::EltwiseRelu,
                                      Algorithm::EltwiseSelect,
                                      Algorithm::EltwiseSigmoid,
+                                     Algorithm::EltwiseSoftSign,
                                      Algorithm::EltwiseSubtract,
                                      Algorithm::EltwiseSwish,
                                      Algorithm::EltwiseTanh);

src/plugins/intel_cpu/src/nodes/kernels/aarch64/jit_uni_eltwise_generic.cpp

@@ -669,6 +669,7 @@ std::shared_ptr<jit_emitter> jit_uni_eltwise_generic<isa>::create_eltwise_emitte
     OV_CASE(Algorithm::EltwiseRelu, ov::intel_cpu::aarch64::jit_relu_emitter),
     OV_CASE(Algorithm::EltwiseSelect, ov::intel_cpu::aarch64::jit_select_emitter),
     OV_CASE(Algorithm::EltwiseSigmoid, ov::intel_cpu::aarch64::jit_sigmoid_emitter),
+    OV_CASE(Algorithm::EltwiseSoftSign, ov::intel_cpu::aarch64::jit_soft_sign_emitter),
     OV_CASE(Algorithm::EltwiseSubtract, ov::intel_cpu::aarch64::jit_subtract_emitter),
     OV_CASE(Algorithm::EltwiseSwish, ov::intel_cpu::aarch64::jit_swish_emitter),
     OV_CASE(Algorithm::EltwiseTanh, ov::intel_cpu::aarch64::jit_tanh_emitter));
@@ -845,6 +846,7 @@ std::set<std::vector<element::Type>> eltwise_precision_helper::get_supported_pre
         OV_CASE(Algorithm::EltwisePowerStatic, jit_power_static_emitter),
         OV_CASE(Algorithm::EltwiseSelect, jit_select_emitter),
         OV_CASE(Algorithm::EltwiseSigmoid, jit_sigmoid_emitter),
+        OV_CASE(Algorithm::EltwiseSoftSign, jit_soft_sign_emitter),
         OV_CASE(Algorithm::EltwiseSubtract, jit_subtract_emitter),
         OV_CASE(Algorithm::EltwiseSwish, jit_swish_emitter),
         OV_CASE(Algorithm::EltwiseTanh, jit_tanh_emitter));

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/activation.cpp

@@ -192,6 +192,7 @@ std::string ActivationLayerCPUTest::getPrimitiveType(const utils::ActivationType
         (activation_type == utils::ActivationTypes::GeluTanh) ||
         (activation_type == utils::ActivationTypes::Relu) ||
         (activation_type == utils::ActivationTypes::Sigmoid) ||
+        (activation_type == utils::ActivationTypes::SoftSign) ||
         (activation_type == utils::ActivationTypes::Swish) ||
         (activation_type == utils::ActivationTypes::LogicalNot) ||
         (activation_type == utils::ActivationTypes::Tanh))) {

src/plugins/intel_gpu/src/kernel_selector/kernels/gather/gather_kernel_ref.cpp

@@ -155,6 +155,19 @@ static inline std::vector<std::string> GetOrder(size_t size) {
     return idx_order;
 }
 
+static inline std::vector<std::string> GetFinalIndexOrder(size_t size) {
+    std::vector<std::string> idx_order;
+
+    OPENVINO_ASSERT(size > 4, "[GPU] Only support 5 or 6 dimensions");
+
+    if (size == 5) {
+        idx_order = {"b", "f", "0", "z", "0"};
+    } else if (size == 6) {
+        idx_order = {"b", "f", "0", "w", "z", "0"};
+    }
+    return idx_order;
+}
+
 static std::string GetDictionaryIndexOrder(const gather_params& params, size_t axis) {
     auto idx_order = GetOrder(params.outputs[0].GetDims().size());
     auto input_axis_index_macro = "INPUT_AXIS_INDEX";
@@ -181,21 +194,27 @@ static std::string GetDictionaryIndexOrder(const gather_params& params, size_t a
 }
 
 static std::string GetIndicesIdxOrder(const gather_params& params, size_t axis, int64_t batch_dim) {
-    std::vector<std::string> idx_order = GetOrder(params.outputs[0].GetDims().size());
-    auto zero_val = "0";
+    std::vector<std::string> idx_order;
 
-    size_t indices_dims_num = GetNonEmptyDimsNumber(params.inputs[1]);
+    if ((axis == (size_t)batch_dim) && (axis > 1) && (params.inputs[1].GetDims().size() > 4)) {
+        idx_order = GetFinalIndexOrder(params.outputs[0].GetDims().size());
+    } else {
+        idx_order = GetOrder(params.outputs[0].GetDims().size());
+        auto zero_val = "0";
 
-    // Shift indices of Gather indices input related to output dims
-    for (size_t i = batch_dim; i < indices_dims_num; i++)
-        idx_order[i] = idx_order[axis + i - batch_dim];
+        size_t indices_dims_num = GetNonEmptyDimsNumber(params.inputs[1]);
 
-    for (size_t i = indices_dims_num; i < idx_order.size(); i++)
-        idx_order[i] = zero_val;
+        // Shift indices of Gather indices input related to output dims
+        for (size_t i = batch_dim; i < indices_dims_num; i++)
+            idx_order[i] = idx_order[axis + i - batch_dim];
 
-    // Fix size to inputs[1] dims size
-    for (size_t i = 0; i < params.outputs[0].GetDims().size() - params.inputs[1].GetDims().size(); i++)
-        idx_order.pop_back();
+        for (size_t i = indices_dims_num; i < idx_order.size(); i++)
+            idx_order[i] = zero_val;
+
+        // Fix size to inputs[1] dims size
+        for (size_t i = 0; i < params.outputs[0].GetDims().size() - params.inputs[1].GetDims().size(); i++)
+            idx_order.pop_back();
+    }
 
     return GetOrderString(idx_order);
 }