[WIP][spec][ref][cpu][gpu]: Added OneHot v16

docs/articles_en/documentation/openvino-ir-format/operation-sets/operation-specs/sequence/one-hot-1.rst

@@ -37,9 +37,24 @@ The types of input scalars ``on_value`` and ``off_value`` should match and be eq
   * **Type**: ``int``
   * **Required**: *yes*
 
+* *negative_indices_mode*
+
+  * **Description**: controls how negative indices in indices tensor are handled.
+  * **Range of values**: 
+
+    * ``ignore-negative``: negative indices are ignored, and the corresponding output rows are filled with ``off_value``.
+    * ``normalize``: negative indices in the range ``[-depth, -1]`` are normalized by ``depth + index``; which effectively maps the range ``[-depth, depth-1]`` to ``[0, depth-1]``.
+
+  * **Type**: ``string``
+  * **Default value**: ignore-negative
+  * **Required**: *no*
+
+.. note::
+   Behavior before 2025.4 OpenVINO release: negative_indices_mode was not supported and negative indices were handled according to ignore-negative mode.
+
 **Inputs**:
 
-* **1**: ``indices``: input tensor of type *T1* with non-negative indices, behavior for negative indices is undefined. Can be 0D. **Required.**
+* **1**: ``indices``: input tensor of type *T1* with indices. Can be 0D. **Required.**
 * **2**: ``depth``: positive scalar (0D tensor) of type *T1* that specifies the number of classes and thus the size of the one-hot dimension. **Required.**
 * **3**: ``on_value``: scalar (0D tensor) of type *T2* that fills the locations in output tensor specified in ``indices``. **Required.**
 * **4**: ``off_value``: scalar (0D tensor) of type *T2* that fills the locations not represented in ``indices``. **Required.**
@@ -60,9 +75,9 @@ The types of input scalars ``on_value`` and ``off_value`` should match and be eq
    :force:
 
     <layer ... type="OneHot" ...>
-        <data axis="-1"/>
+        <data axis="-1" negative_indices_mode="normalize"/>
         <input>
-            <port id="0">    <!-- indices value: [0, 3, 1, 2] -->
+            <port id="0">    <!-- indices value: [0, -5, -2, 2] -->
                 <dim>4</dim>
             </port>
             <port id="1">    <!-- depth value: 3 -->

src/core/include/openvino/op/one_hot.hpp

@@ -4,15 +4,15 @@
 
 #pragma once
 
-#include "openvino/op/op.hpp"
+#include "openvino/op/util/one_hot_base.hpp"
 
 namespace ov {
 namespace op {
 namespace v1 {
 /// \brief OneHot operation.
 ///
 /// \ingroup ov_ops_cpp_api
-class OPENVINO_API OneHot : public Op {
+class OPENVINO_API OneHot : public util::OneHotBase {
 public:
     OPENVINO_OP("OneHot", "opset1", op::Op);
 
@@ -40,19 +40,73 @@ class OPENVINO_API OneHot : public Op {
 
     bool evaluate(TensorVector& outputs, const TensorVector& inputs) const override;
     bool has_evaluate() const override;
+};
+}  // namespace v1
+namespace v16 {
+/// \brief OneHot operation.
+///
+/// \ingroup ov_ops_cpp_api
+class OPENVINO_API OneHot : public util::OneHotBase {
+public:
+    OPENVINO_OP("OneHot", "opset16", op::Op);
+
+    /// \brief Lists the supported negative indices modes for this version of the operator.
+    ///        See the specification for the description of how negative indices are handled.
+    enum class NegativeIndicesMode { IGNORE_NEGATIVE, NORMALIZE };
+
+    /// \brief Constructs a one-hot operation.
+    OneHot() = default;
+    /// \brief Constructs a one-hot operation.
+    ///
+    /// \param indices   Input tensor containing indices.
+    /// \param depth     Specifies number of classes and the size of one-hot dimension.
+    /// \param on_value  Specifies value that the locations in output tensor represented
+    ///                  by indices in input take.
+    /// \param off_value Specifies value that the locations in output tensor not
+    /// represented
+    ///                  by indices in input take.
+    /// \param axis      Axis along which one-hot representation in added.
+    OneHot(const Output<Node>& indices,
+           const Output<Node>& depth,
+           const Output<Node>& on_value,
+           const Output<Node>& off_value,
+           int64_t axis,
+           NegativeIndicesMode mode = NegativeIndicesMode::IGNORE_NEGATIVE);
+
+    bool visit_attributes(AttributeVisitor& visitor) override;
+    std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& new_args) const override;
+    void validate_and_infer_types() override;
+
+    bool evaluate(TensorVector& outputs, const TensorVector& inputs) const override;
+    bool has_evaluate() const override;
 
-    /// \return The index of the one-hot axis.
-    const int64_t& get_axis() const {
-        return m_axis;
+    /// \brief Sets the negative indices mode.
+    void set_negative_indices_mode(NegativeIndicesMode mode) {
+        m_negative_indices_mode = mode;
+    }
+    /// \return The negative indices mode.
+    NegativeIndicesMode get_negative_indices_mode() const {
+        return m_negative_indices_mode;
     }
-    void set_axis(int64_t axis);
 
 protected:
-    int64_t m_axis;
-
-private:
-    friend void inline resolve_axis(OneHot* op);
+    NegativeIndicesMode m_negative_indices_mode;
 };
-}  // namespace v1
+}  // namespace v16
 }  // namespace op
+
+OPENVINO_API
+std::ostream& operator<<(std::ostream& s, const op::v16::OneHot::NegativeIndicesMode& mode);
+
+template <>
+class OPENVINO_API AttributeAdapter<op::v16::OneHot::NegativeIndicesMode>
+    : public EnumAttributeAdapterBase<op::v16::OneHot::NegativeIndicesMode> {
+public:
+    AttributeAdapter(op::v16::OneHot::NegativeIndicesMode& value)
+        : EnumAttributeAdapterBase<op::v16::OneHot::NegativeIndicesMode>(value) {}
+
+    OPENVINO_RTTI("AttributeAdapter<ov::op::v16::OneHot::NegativeIndicesMode>");
+    ~AttributeAdapter() override;
+};
+
 }  // namespace ov

src/core/include/openvino/op/util/one_hot_base.hpp

@@ -0,0 +1,56 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "openvino/op/op.hpp"
+#include "openvino/op/util/attr_types.hpp"
+
+namespace ov {
+namespace op {
+namespace util {
+class OPENVINO_API OneHotBase : public Op {
+public:
+    OPENVINO_OP("OneHot", "util");
+
+    /// \brief Constructs a one-hot operation.
+    OneHotBase() = default;
+
+    /// \brief Constructs a one-hot operation.
+    ///
+    /// \param indices   Input tensor containing indices.
+    /// \param depth     Specifies number of classes and the size of one-hot dimension.
+    /// \param on_value  Specifies value that the locations in output tensor represented
+    ///                  by indices in input take.
+    /// \param off_value Specifies value that the locations in output tensor not
+    /// represented
+    ///                  by indices in input take.
+    /// \param axis      Axis along which one-hot representation in added.
+    OneHotBase(const Output<Node>& indices,
+               const Output<Node>& depth,
+               const Output<Node>& on_value,
+               const Output<Node>& off_value,
+               int64_t axis);
+
+    bool visit_attributes(AttributeVisitor& visitor) override;
+    void validate_and_infer_types() override;
+
+    /// \return The index of the one-hot axis.
+    const int64_t& get_axis() const {
+        return m_axis;
+    }
+
+    /// @brief Sets the index of the one-hot axis.
+    /// @param axis The index of the one-hot axis.
+    void set_axis(int64_t axis);
+
+protected:
+    int64_t m_axis;
+
+private:
+    friend void inline resolve_axis(OneHotBase* op);
+};
+}  // namespace util
+}  // namespace op
+}  // namespace ov

src/core/include/openvino/opsets/opset16_tbl.hpp

@@ -18,3 +18,4 @@ _OPENVINO_OP_REG(Identity, ov::op::v16)
 _OPENVINO_OP_REG(ISTFT, ov::op::v16)
 _OPENVINO_OP_REG(SegmentMax, ov::op::v16)
 _OPENVINO_OP_REG(SparseFillEmptyRows, ov::op::v16)
+_OPENVINO_OP_REG(OneHot, ov::op::v16)

src/core/reference/include/openvino/reference/one_hot.hpp

@@ -5,6 +5,7 @@
 #pragma once
 
 #include "openvino/core/shape.hpp"
+#include "openvino/op/one_hot.hpp"
 
 namespace ov {
 namespace reference {
@@ -16,7 +17,9 @@ void one_hot(const INPUT_TYPE* indices,
              const size_t depth,
              const int64_t one_hot_axis,
              const char* on_value,
-             const char* off_value) {
+             const char* off_value,
+             const op::v16::OneHot::NegativeIndicesMode mode) {
+    const bool is_mode_normalize = mode == op::v16::OneHot::NegativeIndicesMode::NORMALIZE;
     const size_t num_ind = shape_size(indices_shape);
     // Step 1: Set off_value to the output.
     for (auto p = out; p < out + num_ind * depth * out_elem_size; p += out_elem_size)
@@ -31,11 +34,14 @@ void one_hot(const INPUT_TYPE* indices,
     // Step 2: Write on_value at needed positions
     for (size_t outer_i = 0; outer_i < num_ind; outer_i += inner_block) {
         for (size_t inner_i = 0; inner_i < inner_block; inner_i++) {
-            auto input_val = indices[outer_i + inner_i];
-            // Negative indices are ignored
-            if ((input_val >= 0) && (static_cast<size_t>(input_val) < depth)) {
-                auto oh_index = static_cast<size_t>(input_val);
-                size_t output_offset = out_elem_size * (outer_i * depth + inner_i + oh_index * inner_block);
+            const int64_t input_val = static_cast<int64_t>(indices[outer_i + inner_i]);
+            const int64_t depth_i64 = static_cast<int64_t>(depth);
+            const int64_t actual_index = (input_val < 0 && is_mode_normalize) ? depth_i64 + input_val : input_val;
+            const int64_t max_valid = depth_i64 - 1;
+
+            if (actual_index >= 0 && actual_index <= max_valid) {
+                const size_t output_offset =
+                    out_elem_size * (outer_i * depth + inner_i + static_cast<size_t>(actual_index) * inner_block);
                 std::copy(on_value, on_value + out_elem_size, out + output_offset);
             }
         }

src/core/shape_inference/include/one_hot_shape_inference.hpp

@@ -10,7 +10,6 @@
 namespace ov {
 namespace op {
 namespace util {
-
 template <class T>
 struct GetNotNegative {
     const Node* m_op;
@@ -23,22 +22,21 @@ struct GetNotNegative {
         return static_cast<T>(v);
     }
 };
-}  // namespace util
-namespace v1 {
-void inline resolve_axis(OneHot* op) {
+
+void inline resolve_axis(OneHotBase* op) {
     if (op->get_input_size() < 1) {
         return;
     }
     const auto& indices_shape = op->get_input_partial_shape(0);
     if (indices_shape.rank().is_static()) {
         op->m_axis = ov::util::try_normalize_axis(op->m_axis, indices_shape.rank() + 1, *op);
     }
-}
+}  // namespace util
 
 template <class T, class TRShape = result_shape_t<T>>
-std::vector<TRShape> shape_infer(const OneHot* op,
-                                 const std::vector<T>& input_shapes,
-                                 const ITensorAccessor& ta = make_tensor_accessor()) {
+std::vector<TRShape> shape_infer_base(const OneHotBase* op,
+                                      const std::vector<T>& input_shapes,
+                                      const ITensorAccessor& ta = make_tensor_accessor()) {
     NODE_VALIDATION_CHECK(op, input_shapes.size() == 4);
     using DimType = typename T::value_type;
     const auto& indices_shape = input_shapes[0];
@@ -77,6 +75,25 @@ std::vector<TRShape> shape_infer(const OneHot* op,
     }
     return output_shapes;
 }
+}  // namespace util
+
+namespace v1 {
+template <class TShape, class TRShape = result_shape_t<TShape>>
+std::vector<TRShape> shape_infer(const OneHot* op,
+                                 const std::vector<TShape>& input_shapes,
+                                 const ITensorAccessor& ta = make_tensor_accessor()) {
+    return util::shape_infer_base(op, input_shapes, ta);
+}
 }  // namespace v1
+
+namespace v16 {
+template <class TShape, class TRShape = result_shape_t<TShape>>
+std::vector<TRShape> shape_infer(const OneHot* op,
+                                 const std::vector<TShape>& input_shapes,
+                                 const ITensorAccessor& ta = make_tensor_accessor()) {
+    return util::shape_infer_base(op, input_shapes, ta);
+}
+}  // namespace v16
+
 }  // namespace op
 }  // namespace ov