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

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

@@ -0,0 +1,127 @@
+OneHot
+======
+
+
+.. meta::
+  :description: Learn about OneHot-16 - a sequence processing operation, which
+                can be performed on four required input tensors.
+
+**Versioned name**: *OneHot-16*
+
+**Category**: *Sequence processing*
+
+**Short description**: *OneHot* sets the elements in the output tensor with specified indices to ``on_value`` and fills all other locations with ``off_value``.
+
+**Detailed description**
+
+Taking a tensor with rank ``N`` as the first input ``indices``, OneHot produces a tensor with rank ``N+1`` extending the original
+tensor with a new dimension at the ``axis`` position. The output tensor is populated with two scalar values: ``on_value``
+that comes from the 3rd input and ``off_value`` that comes from the 4nd input. The population is made in the following way:
+
+.. code-block:: cpp
+
+    output[:, ... ,:, i, :, ... ,:] = on_value if (indices[:, ..., :, :, ..., :] == i) else off_value
+
+where ``i`` is at the ``axis`` position in the ``output`` shape and has values from the range ``[0, ..., depth-1]``.
+
+When some elements from the ``indices`` are greater or equal to the ``depth``, it is a well-formed operation. The corresponding output rows are populated with ``off_value`` in this case.
+
+The types of input scalars ``on_value`` and ``off_value`` should match and be equal to any supported type. The output tensor type is derived from the ``on_value`` or the ``off_value``, they all have the same type.
+
+**Attributes**:
+
+* *axis*
+
+  * **Description**: *axis* is a new axis position in the output shape to fill with one-hot values.
+  * **Range of values**: an integer. Negative value means counting dimension from the end.
+  * **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::
+   OneHot-16 with negative_indices_mode set to ignore-negative mode behaves exactly as OneHot-1.
+
+**Inputs**:
+
+* **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.**
+
+**Outputs**:
+
+* **1**: An ``N+1`` rank tensor of type *T2*, where ``N`` is a rank of the input tensor ``indices``. A new axis of the size ``depth`` is inserted at the dimension ``axis``.
+
+**Types**
+
+* *T1*: ``int32`` or ``int64``.
+
+* *T2*: any supported data type.
+
+**Examples**
+
+.. code-block:: xml
+   :force:
+
+    <layer ... type="OneHot" ...>
+        <data axis="-1" negative_indices_mode="normalize"/>
+        <input>
+            <port id="0">    <!-- indices value: [0, -5, -2, 2] -->
+                <dim>4</dim>
+            </port>
+            <port id="1">    <!-- depth value: 3 -->
+            </port>
+            <port id="2">    <!-- on_value 1 -->
+            </port>
+            <port id="3">    <!-- off_value 2 -->
+            </port>
+        </input>
+        <output>
+            <port id="0">    <!-- output value # [[1, 2, 2], [2, 2, 2], [2, 1, 2], [2, 2, 1]] -->
+                <dim>4</dim>
+                <dim>3</dim>
+            </port>
+        </output>
+    </layer>
+
+
+
+.. code-block:: xml
+   :force:
+
+    <layer ... type="OneHot" ...>
+        <data axis="1"/>
+        <input>
+            <port id="0">    <!-- indices value: [[0, 3, 1], [1, 2, 4]] -->
+                <dim>2</dim>
+                <dim>3</dim>
+            </port>
+            <port id="1">    <!-- depth value: 3 -->
+            </port>
+            <port id="2">    <!-- on_value 1 -->
+            </port>
+            <port id="3">    <!-- off_value 0 -->
+            </port>
+        </input>
+        <output>
+            <port id="0">    <!-- output value: [[[1, 0, 0], [0, 0, 1], [0, 0, 0]], -->
+                <dim>2</dim> <!--                [[0, 0, 0], [1, 0, 0], [0, 1, 0]]] -->
+                <dim>3</dim>
+                <dim>3</dim>
+            </port>
+        </output>
+    </layer>
+
+
+

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,57 @@
+// 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;
+    std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& new_args) const 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

@@ -19,3 +19,4 @@ _OPENVINO_OP_REG(ISTFT, ov::op::v16)
 _OPENVINO_OP_REG(SegmentMax, ov::op::v16)
 _OPENVINO_OP_REG(SparseFillEmptyRows, ov::op::v16)
 _OPENVINO_OP_REG(AvgPool, 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);
+        op->m_axis = ov::util::try_normalize_axis(op->get_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