[GPU] Code cleanup (#14974)

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/binary_buffer.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include <sstream>

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/bind.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include <type_traits>

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/buffer.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include <utility>
 #include <type_traits>

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/cl_kernel_data_serializer.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include <type_traits>

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/helpers.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include <utility>
 #include <type_traits>

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/layout_serializer.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include <vector>

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/loop_serializer.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include <vector>

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/map_serializer.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include <map>

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/polymorphic_serializer.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include <memory>

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/serializer.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 namespace cldnn {

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/set_serializer.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include <set>

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/static_instance.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include <type_traits>

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/string_serializer.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include <string>

src/plugins/intel_gpu/include/intel_gpu/graph/serialization/vector_serializer.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include <vector>

src/plugins/intel_gpu/include/intel_gpu/primitives/activation.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief activation functions
 enum class activation_func {
@@ -130,7 +123,4 @@ protected:
         return {additional_params_input};
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/arg_max_min.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include "openvino/op/util/attr_types.hpp"
@@ -11,12 +10,6 @@
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Finds the index of the k max values of input.
 /// @details Returns indices in f32, because we currently does not support int32 data type.
@@ -61,7 +54,4 @@ struct arg_max_min : public primitive_base<arg_max_min> {
     /// @brief Sets output order: if True than first output contains values and second (optional) - indices.
     bool values_first;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/assign.hpp

@@ -10,12 +10,6 @@
 #include "intel_gpu/runtime/memory.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Sets an input value to the variable_id variable.
 struct assign : public primitive_base<assign> {
@@ -37,7 +31,4 @@ struct assign : public primitive_base<assign> {
     std::string variable_id;
     layout output_layout;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/average_unpooling.hpp

@@ -1,48 +0,0 @@
-// Copyright (C) 2018-2022 Intel Corporation
-// SPDX-License-Identifier: Apache-2.0
-//
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-#pragma once
-#include "primitive.hpp"
-
-namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
-
-/// @brief Performs "average_unpooling" operation.
-/// @details Reverse operation of average pooling.
-/// Each element in every pooling window is filled with output / window size value. In case of window overlap the elements are added.
-struct average_unpooling : public primitive_base<average_unpooling> {
-    CLDNN_DECLARE_PRIMITIVE(average_unpooling)
-
-    /// @brief Constructs average_unpooling primitive.
-    /// @param id This primitive id.
-    /// @param input Input primitive id.
-    /// @param output_size Size of input for average pooling forward.
-    /// @param stride Defines shift in output buffer.
-    /// @param size Pooling kernel size.
-    average_unpooling(
-        const primitive_id& id,
-        const input_info& input,
-        const tensor output_size,
-        const tensor& size,
-        const tensor& stride,
-        const padding& output_padding = padding())
-        : primitive_base(id, {input}, {output_padding}), stride(stride), size(size), output_size(output_size) {}
-
-    /// @brief Defines shift in output buffer.
-    tensor stride;
-    /// @brief Pooling kernel size.
-    tensor size;
-    /// @brief Output size of this primitive.
-    tensor output_size;
-};
-/// @}
-/// @}
-/// @}
-}  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/batch_to_space.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief The BatchToSpace operation reshapes the "batch" dimension 0 into N - 1, N ∈ {4,5,6} dimensions of shape block_shape + [batch]
 /// and interleaves these blocks back into the grid defined by the spatial dimensions [1, ..., N - 1], N ∈ {4,5,6}
@@ -71,7 +64,4 @@ struct batch_to_space : public primitive_base<batch_to_space> {
     tensor crops_end;
     tensor out_size;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/binary_convolution.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include "openvino/core/coordinate_diff.hpp"
@@ -10,12 +9,6 @@
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs forward spatial binary_convolution with weight sharing.
 struct binary_convolution : public primitive_base<binary_convolution> {
@@ -72,8 +65,6 @@ struct binary_convolution : public primitive_base<binary_convolution> {
     /// @brief List of primitive ids containing weights data.
     const primitive_id_arr weights;
 
-    int32_t split() const { return static_cast<int32_t>(weights.size()); }
-
     std::vector<std::reference_wrapper<const primitive_id>> get_dependencies() const override {
         std::vector<std::reference_wrapper<const primitive_id>> ret;
         ret.reserve(weights.size());
@@ -81,7 +72,4 @@ struct binary_convolution : public primitive_base<binary_convolution> {
         return ret;
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/border.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include "openvino/core/coordinate_diff.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Adds border around input.
 ///
@@ -79,7 +72,4 @@ struct border : public primitive_base<border> {
     /// @brief Border value that is used in constant mode.
     float pad_value;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/broadcast.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include "openvino/op/broadcast.hpp"
@@ -11,12 +10,6 @@
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Broadcasts input to defined by @p broadcast_sizes output. @p broadcast_axes are used to
 ///        reinterpret input (reshape) inside algorithm.
@@ -136,7 +129,4 @@ struct broadcast : public primitive_base<broadcast> {
     ///        along which broadcast should happen.
     std::vector<uint16_t> broadcast_axes;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/bucketize.hpp

@@ -6,12 +6,6 @@
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Bucketize operation bucketizes the input based on boundaries.
 struct bucketize : primitive_base<bucketize> {
@@ -33,7 +27,4 @@ struct bucketize : primitive_base<bucketize> {
     bool with_right_bound;
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/concatenation.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @details Concatenation is used to concatenate multiple sources into one destination along specified dimension.
 /// @notes
@@ -66,7 +59,4 @@ struct concatenation : public primitive_base<concatenation> {
     /// @brief Dimension along which concatenation should take place
     int64_t axis;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/condition.hpp

@@ -2,19 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include "intel_gpu/graph/topology.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
+
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 /// @brief Function, which will be used during comparison.
 enum cond_functions : int32_t { EQUAL, GREATER, LESS };
 

src/plugins/intel_gpu/include/intel_gpu/primitives/convert_color.hpp

@@ -7,12 +7,6 @@
 #include "intel_gpu/runtime/memory_caps.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs image conversion from one format to another
 struct convert_color : public primitive_base<convert_color> {
@@ -57,7 +51,4 @@ struct convert_color : public primitive_base<convert_color> {
     memory_type mem_type;
     layout output_layout;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/convolution.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include "openvino/core/strides.hpp"
@@ -10,12 +9,6 @@
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs forward spatial convolution with weight sharing.
 /// Also supports built-in Relu @CLDNN_PRIMITIVE_DESC{activation} available by setting it in arguments.
@@ -770,9 +763,6 @@ struct convolution : public primitive_base<convolution> {
     /// @brief List of primitive ids containing compensation.
     primitive_id_arr compensation;
 
-    /// @brief On how many cards split the computation to.
-    int32_t split() const { return static_cast<int32_t>(weights.size()); }
-
     std::vector<std::reference_wrapper<const primitive_id>> get_dependencies() const override {
         std::vector<std::reference_wrapper<const primitive_id>> ret;
         ret.reserve(weights.size() + bias.size() + weights_zero_points.size() +
@@ -863,9 +853,6 @@ struct deformable_conv : public primitive_base<deformable_conv> {
     /// @brief List of primitive ids containing bias data.
     const primitive_id_arr bias;
 
-    /// @brief On how many cards split the computation to.
-    int32_t split() const { return static_cast<int32_t>(weights.size()); }
-
     std::vector<std::reference_wrapper<const primitive_id>> get_dependencies() const override {
         std::vector<std::reference_wrapper<const primitive_id>> ret;
         ret.reserve(weights.size() + bias.size());
@@ -875,7 +862,4 @@ struct deformable_conv : public primitive_base<deformable_conv> {
     }
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/crop.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Select original ngraph op mode for the @ref crop layer.
 enum class crop_ngraph_op_mode : int32_t {
@@ -132,7 +125,4 @@ struct crop : public primitive_base<crop> {
     /// @brief original ngraph operation type
     crop_ngraph_op_mode op_mode;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/ctc_greedy_decoder.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief CTC greedy decoder primitve
 struct ctc_greedy_decoder : public primitive_base<ctc_greedy_decoder> {
@@ -39,7 +32,4 @@ struct ctc_greedy_decoder : public primitive_base<ctc_greedy_decoder> {
     tensor output_tensor;
     primitive_id second_output;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/ctc_loss.hpp

@@ -8,12 +8,6 @@
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief CTCLoss-4 primitive.
 struct ctc_loss : primitive_base<ctc_loss> {
@@ -41,7 +35,4 @@ struct ctc_loss : primitive_base<ctc_loss> {
     bool unique;
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/cum_sum.hpp

@@ -2,17 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
+
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 struct cum_sum : public primitive_base<cum_sum> {
     CLDNN_DECLARE_PRIMITIVE(cum_sum)
@@ -39,7 +33,4 @@ struct cum_sum : public primitive_base<cum_sum> {
     /// @brief If set to true will perform the sums in reverse direction.
     bool reverse;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/custom_gpu_primitive.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include "intel_gpu/runtime/memory.hpp"
@@ -10,12 +9,6 @@
 #include <string>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief This primitive executes a custom kernel provided by the application
 /// @details The application is required to provide all relevant details for executing the custom kernel
@@ -81,7 +74,4 @@ struct custom_gpu_primitive : public primitive_base<custom_gpu_primitive> {
     /// @brief Source code for the kernel
     const primitive_id_arr kernels_code;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/data.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include "intel_gpu/runtime/memory.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Provides input data to topology.
 /// @details This primitive allows to pass data which is known at topology creation.
@@ -33,7 +26,4 @@ struct data : public primitive_base<data> {
     /// @note If memory is attached by memory::attach(), the attached buffer should be valid till network build.
     memory::ptr mem;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/deconvolution.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
@@ -11,12 +10,6 @@
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs transposed convolution.
 /// Also supports built-in Relu @ref activation available by setting it in arguments.
@@ -280,9 +273,6 @@ struct deconvolution : public primitive_base<deconvolution> {
     /// @brief List of primitive ids containing bias data.
     const primitive_id_arr bias;
 
-    /// @brief On how many cards split the computation to.
-    int32_t split() const { return static_cast<int32_t>(weights.size()); }
-
 protected:
     std::vector<std::reference_wrapper<const primitive_id>> get_dependencies() const override {
         std::vector<std::reference_wrapper<const primitive_id>> ret;
@@ -293,7 +283,4 @@ protected:
         return ret;
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/depth_to_space.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief mode for the @ref depth_to_space primitive.
 enum class depth_to_space_mode : int32_t {
@@ -46,7 +39,4 @@ struct depth_to_space : public primitive_base<depth_to_space> {
     /// @brief depth division mode
     depth_to_space_mode mode;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/detection_output.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include <limits>
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Select method for coding the prior-boxes in the @ref detection output layer.
 enum class prior_box_code_type : int32_t {
@@ -130,7 +123,4 @@ struct detection_output : public primitive_base<detection_output> {
 protected:
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/dft.hpp

@@ -10,12 +10,6 @@
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Direction of DFT operation.
 enum class dft_direction {

src/plugins/intel_gpu/include/intel_gpu/primitives/eltwise.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Select mode for the @ref eltwise layer.
 enum class eltwise_mode : int32_t {
@@ -175,7 +168,4 @@ struct eltwise : public primitive_base<eltwise> {
     /// @brief Define auto broadcast rule specification.
     ov::op::AutoBroadcastSpec broadcast_spec;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/embedding_bag.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Computes sums of "bags" of embeddings, without instantiating the intermediate embeddings.
 /// @details For each index in `indices` this operator gets values from `data` embedding table and sums all values belonging to each bag.
@@ -46,7 +39,4 @@ struct embedding_bag : public primitive_base<embedding_bag> {
     /// @brief Default index
     int32_t default_index;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/experimental_detectron_detection_output.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include <utility>
 #include <vector>
@@ -10,12 +9,6 @@
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief experimental detectron detection output
 struct experimental_detectron_detection_output : public primitive_base<experimental_detectron_detection_output> {
@@ -90,7 +83,4 @@ protected:
         return ret;
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/experimental_detectron_generate_proposals_single_image.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief experimental detectron generate proposals single image
 struct experimental_detectron_generate_proposals_single_image
@@ -63,7 +56,4 @@ protected:
         return ret;
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/experimental_detectron_prior_grid_generator.hpp

@@ -8,12 +8,7 @@
 
 namespace cldnn {
 
-/// @addtogroup cpp_api C++ API
+
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Constructs experimental_detectron_prior_grid_generator primitive.
 struct experimental_detectron_prior_grid_generator

src/plugins/intel_gpu/include/intel_gpu/primitives/experimental_detectron_roi_feature_extractor.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief experimental detectron ROI feature extractor
 struct experimental_detectron_roi_feature_extractor : public primitive_base<experimental_detectron_roi_feature_extractor> {
@@ -49,7 +42,4 @@ struct experimental_detectron_roi_feature_extractor : public primitive_base<expe
     bool aligned = false;
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/experimental_detectron_topk_rois.hpp

@@ -10,12 +10,7 @@
 
 namespace cldnn {
 
-/// @addtogroup cpp_api C++ API
+
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief ExperimentalDetectronTopKROIs-6 primitive
 /// @details

src/plugins/intel_gpu/include/intel_gpu/primitives/extract_image_patches.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief The ExtractImagePatches operation collects patches from the input tensor, as if applying a convolution.
 /// All extracted patches are stacked in the depth dimension of the output.
@@ -62,7 +55,4 @@ struct extract_image_patches : public primitive_base<extract_image_patches> {
     /// @brief Shape of output layout
     tensor output_shape;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/eye.hpp

@@ -1,16 +1,11 @@
 // Copyright (C) 2022 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
+
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief
 /// @details Construct identity matrix or batch fo them
@@ -36,7 +31,4 @@ struct eye : public primitive_base<eye> {
     tensor output_shape;
     int32_t shift;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/fully_connected.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs forward fully connected layer (inner product).
 /// Also supports built-in Relu @CLDNN_PRIMITIVE_DESC{activation} available by setting it in arguments.
@@ -93,7 +86,4 @@ protected:
         return ret;
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/gather.hpp

@@ -2,19 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 #include "openvino/core/shape.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief
 /// @details
@@ -52,7 +45,4 @@ struct gather : public primitive_base<gather> {
     /// @brief Support negative indexes
     bool support_neg_ind;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/gather_elements.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief
 /// @details
@@ -50,7 +43,4 @@ struct gather_elements : public primitive_base<gather_elements> {
     /// @brief Which axis to gather on.
     int64_t axis;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/gather_nd.hpp

@@ -6,12 +6,6 @@
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief
 /// @details
@@ -56,7 +50,4 @@ struct gather_nd : public primitive_base<gather_nd> {
     /// @brief GatherND batch_merged_output
     bool batch_merged_output;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/gather_tree.hpp

@@ -2,21 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-    /// @addtogroup cpp_api C++ API
-    /// @{
-    /// @addtogroup cpp_topology Network Topology
-    /// @{
-    /// @addtogroup cpp_primitives Primitives
-    /// @{
 
-    /// @brief Performs gather tree
+/// @brief Performs gather tree
-    ///
+///
-    /// @details Performs gather tree
+/// @details Performs gather tree
 struct gather_tree : public primitive_base<gather_tree> {
     CLDNN_DECLARE_PRIMITIVE(gather_tree)
 
@@ -38,7 +31,4 @@ struct gather_tree : public primitive_base<gather_tree> {
                     const padding& output_padding = padding())
             : primitive_base(id, { step_input, parent_input, max_seq_len_input, end_token }, {output_padding}) {}
 };
-    /// @}
-    /// @}
-    /// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/gemm.hpp

@@ -2,18 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
+
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 /// @brief Type of gemm that will be added to the input by border layer / primitive.
 
 /// @brief Adds gemm  input.

src/plugins/intel_gpu/include/intel_gpu/primitives/generate_proposals.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief generate proposals
 struct generate_proposals
@@ -76,7 +69,4 @@ protected:
         return ret;
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/grid_sample.hpp

@@ -10,12 +10,7 @@
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
+
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 using GridSampleOp = ov::op::v9::GridSample;
 
@@ -37,7 +32,4 @@ struct grid_sample : primitive_base<grid_sample> {
     GridSampleOp::Attributes attributes;
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/grn.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Global Response Normalization primitive.
 struct grn : public primitive_base<grn> {
@@ -34,7 +27,4 @@ struct grn : public primitive_base<grn> {
     /// @brief Bias value for whole output tensor.
     float bias;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/input_layout.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include "intel_gpu/runtime/memory.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Provides input layout for a data to be passed later to network.
 /// @details This primitive allows to define the layout for input data
@@ -38,7 +31,4 @@ struct input_layout : public primitive_base<input_layout> {
         layout = new_layout;
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/loop.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include <vector>
 #include <functional>
@@ -11,12 +10,7 @@
 
 #define DEFAULT_MAX_NUM_ITERATION 256
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
+
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 ///
 /// @brief Adds primitive which performs recurrent execution of the topology.
 ///
@@ -192,7 +186,4 @@ protected:
     }
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/lrn.hpp

@@ -2,17 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
+
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 typedef enum { /*:int32_t*/
     lrn_norm_region_across_channel,
@@ -67,7 +61,4 @@ struct lrn : public primitive_base<lrn> {
     /// @brief Normalize across or within channel
     lrn_norm_region norm_region;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/lstm.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include "activation.hpp"
@@ -10,12 +9,6 @@
 #include <algorithm>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Weights orders
 /// @details Specifies the order in which the weights are concatenated.
@@ -256,7 +249,4 @@ protected:
     }
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/lstm_dynamic.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs forward Long Short-Term Memory (LSTM_DYNAMIC) layer.
 /// @details The current implementation of LSTM_DYNAMIC is described the following equations.
@@ -112,7 +105,4 @@ protected:
     }
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/lstm_dynamic_input.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "intel_gpu/primitives/primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs forward calcaulations of input gates for dynamic lstm layer.
 /// @details The current implementation of LSTM_DYNAMIC is described the following equations.
@@ -61,7 +54,4 @@ protected:
         return ret;
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/lstm_dynamic_timeloop.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "intel_gpu/primitives/primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs forward calcaulations of input gates for dynamic lstm layer.
 /// @details The current implementation of LSTM_DYNAMIC is described the following equations.
@@ -96,7 +89,4 @@ protected:
         return ret;
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/matrix_nms.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include <vector>
 
@@ -10,12 +9,6 @@
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs matrix nms of input boxes and returns indices of selected boxes.
 struct matrix_nms : public primitive_base<matrix_nms> {
@@ -148,7 +141,4 @@ private:
         }
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/multiclass_nms.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include <utility>
 #include <vector>
@@ -12,12 +11,6 @@
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief multiclass NMS
 struct multiclass_nms : public primitive_base<multiclass_nms> {
@@ -150,7 +143,4 @@ private:
     };
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/mutable_data.hpp

@@ -2,19 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include "intel_gpu/runtime/memory.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Provides mutable data.
 /// @details This primitive allows to pass data which can be written to during training.
@@ -55,7 +48,4 @@ struct mutable_data : public primitive_base<mutable_data> {
     /// @brief Specifies function which will be used to fill weights.
     filler_type fill_type;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/mvn.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Mean Variance Normalization primitive.
 /// @details Normalizes the input to have 0-mean and/or unit (1) variance.
@@ -48,7 +41,4 @@ struct mvn : public primitive_base<mvn> {
     /// @brief Determines if the normalization is done across or within channels.
     bool across_channels;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/non_max_suppression.hpp

@@ -2,19 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs non max supression of input boxes and returns indices of selected boxes.
 /// @detail Filters out boxes that have high intersection-over-union (IOU) with previously
@@ -88,7 +81,4 @@ struct non_max_suppression : public primitive_base<non_max_suppression> {
         return ret;
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/normalize.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Normalizes the input using an L2 norm and multiplies the output with scale value.
 /// The scale can be equal for all channels or one scale per channel.
@@ -65,7 +58,4 @@ struct normalize : public primitive_base<normalize> {
 protected:
     std::vector<std::reference_wrapper<const primitive_id>> get_dependencies() const override { return {scale_input}; }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/one_hot.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Creates a one-hot encoding of the input.
 /// @details Creates a one-hot encoding of the input, putting the new one-hot axis in the position
@@ -95,7 +88,4 @@ struct one_hot : public primitive_base<one_hot> {
     /// @brief all other locations take value this value.
     float off_value;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/permute.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Permutes data in the memory, with respect to provided order.
 /// @details Permute order is set as vector with positions meaning corresponding to tensor.
@@ -39,7 +32,4 @@ struct permute : public primitive_base<permute> {
     /// @brief Array of permuted output order in bfyx format.
     std::vector<uint16_t> permute_order;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/pooling.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
@@ -13,12 +12,6 @@
 #include "openvino/op/util/attr_types.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Select method for the @ref pooling layer.
 enum class pooling_mode : int32_t {
@@ -174,7 +167,4 @@ protected:
         return ret;
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/primitive.hpp

@@ -2,8 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-
 #pragma once
 
 #include "intel_gpu/runtime/compounds.hpp"
@@ -18,11 +16,6 @@
 #include <utility>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-
-/// @addtogroup cpp_topology Network Topology
-/// @{
 
 /// @brief Globally unique primitive's type id
 using primitive_type_id = struct primitive_type *;
@@ -218,6 +211,4 @@ struct prim_map_storage {
 private:
     std::unordered_map<std::string, cldnn::primitive_type_id> map;
 };
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/prior_box.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include "primitive.hpp"
@@ -12,12 +11,6 @@
 #include <limits>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Generates a set of default bounding boxes with different sizes and aspect ratios.
 /// @details The prior-boxes are shared across all the images in a batch (since they have the same width and height).
@@ -217,7 +210,4 @@ private:
         }
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/proposal.hpp

@@ -2,19 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
+
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 #define CLDNN_ROI_VECTOR_SIZE 5
 
@@ -173,7 +167,4 @@ struct proposal : public primitive_base<proposal> {
     bool normalize;
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/pyramid_roi_align.hpp

@@ -10,12 +10,6 @@
 #include <utility>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs RoI Align using image pyramid.
 /// @details Applies RoI Align to layer from the image pyramid.
@@ -65,7 +59,4 @@ struct pyramid_roi_align : public primitive_base<pyramid_roi_align> {
     std::vector<int> pyramid_scales;
     int pyramid_starting_level;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/quantize.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Element-wise linear quantization of floating point input values into a descrete set of floating point values.
 /// @details In general there are four values that specify quantization for each element:
@@ -38,7 +31,4 @@ struct quantize : public primitive_base<quantize> {
     /// @brief levels The number of quantization levels.
     int levels;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/random_uniform.hpp

@@ -10,12 +10,7 @@
 
 namespace cldnn {
 
-/// @addtogroup cpp_api C++ API
+
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief RandomUniform-8 primitive
 /// @details

src/plugins/intel_gpu/include/intel_gpu/primitives/read_value.hpp

@@ -10,12 +10,6 @@
 #include "intel_gpu/runtime/memory.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Returns value of the variable_id variable.
 struct read_value : public primitive_base<read_value> {
@@ -37,7 +31,4 @@ struct read_value : public primitive_base<read_value> {
     std::string variable_id;
     layout output_layout;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/reduce.hpp

@@ -2,19 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Select mode for the @ref reduce layer
 enum class reduce_mode : uint16_t {
@@ -68,7 +61,4 @@ struct reduce : public primitive_base<reduce> {
     /// @brief Keep the reduced dimension or not, 1 mean keep reduced dimension
     bool keep_dims;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/region_yolo.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Normalizes results so they sum to 1.
 /// @details
@@ -49,8 +42,5 @@ struct region_yolo : public primitive_base<region_yolo> {
     uint32_t mask_size;
     bool do_softmax;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn
 #pragma once

src/plugins/intel_gpu/include/intel_gpu/primitives/reorder.hpp

@@ -2,19 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include "intel_gpu/runtime/memory.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief reorder mean operation modes
 enum class reorder_mean_mode {
@@ -164,7 +157,4 @@ protected:
     }
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/reorg_yolo.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Normalizes results so they sum to 1.
 /// @details
@@ -36,8 +29,5 @@ struct reorg_yolo : public primitive_base<reorg_yolo> {
     /// Specific behaviour is determined by these parameters, as follows:
     uint32_t stride;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn
 #pragma once

src/plugins/intel_gpu/include/intel_gpu/primitives/resample.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include "openvino/op/interpolate.hpp"
@@ -10,12 +9,6 @@
 #include <map>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs nearest neighbor/bilinear resample
 /// Also supports built-in Relu @ref activation available by setting it in arguments.
@@ -157,7 +150,4 @@ struct resample : public primitive_base<resample> {
     /// @param round_mode specifies round mode when mode == nearest and is used only when mode == nearest.
     InterpolateOp::NearestMode round_mode;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/reshape.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Changes information about inputs's layout effectively creating new memory which share underlaying buffer
 /// but is interpreted in a different way (different shape).
@@ -88,7 +81,4 @@ struct reshape : public primitive_base<reshape> {
     reshape_mode mode;
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/reverse.hpp

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include "primitive.hpp"

src/plugins/intel_gpu/include/intel_gpu/primitives/reverse_sequence.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief
 /// @details
@@ -59,7 +52,4 @@ struct reverse_sequence : public primitive_base<reverse_sequence> {
     /// @brief The axis along which reversal is performed.
     int32_t batch_axis;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/roi_align.hpp

@@ -1,17 +1,12 @@
 // Copyright (C) 2018-2022 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
+
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief ROIAlign is a pooling layer used over feature maps of
 /// non-uniform input sizes and outputs a feature map of a fixed size.
@@ -65,7 +60,4 @@ struct roi_align : public primitive_base<roi_align> {
     /// @brief Method to coordinate alignment.
     AlignedMode aligned_mode;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/roi_pooling.hpp

@@ -2,19 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "pooling.hpp"
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
+
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 struct roi_pooling : public primitive_base<roi_pooling> {
     CLDNN_DECLARE_PRIMITIVE(roi_pooling)
@@ -88,7 +82,4 @@ struct roi_pooling : public primitive_base<roi_pooling> {
     int spatial_bins_y;
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/roll.hpp

@@ -8,12 +8,6 @@
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Roll-7 primitive.
 struct roll : primitive_base<roll> {
@@ -34,7 +28,4 @@ struct roll : primitive_base<roll> {
     tensor shift;
 };
 
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/scatter_elements_update.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief
 /// @details
@@ -36,7 +29,4 @@ struct scatter_elements_update : public primitive_base<scatter_elements_update>
     /// @brief ScatterElementsUpdate axis
     int64_t axis;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/scatter_nd_update.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief
 /// @details
@@ -36,7 +29,4 @@ struct scatter_nd_update : public primitive_base<scatter_nd_update> {
     /// @brief ScatterNDUpdate indices_rank
     size_t indices_rank;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/scatter_update.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief
 /// @details
@@ -45,7 +38,4 @@ struct scatter_update : public primitive_base<scatter_update> {
     /// @brief ScatterUpdate axis
     int64_t axis;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/select.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs elementwise select operation on two input primitives with selector primitive (mask)
 /// @notes
@@ -48,7 +41,4 @@ struct select : public primitive_base<select> {
     /// @brief Define auto broadcast rule specification.
     ov::op::AutoBroadcastSpec broadcast_spec;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/shape_of.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Returns shape of input primitive.
 struct shape_of : public primitive_base<shape_of> {
@@ -44,7 +37,4 @@ struct shape_of : public primitive_base<shape_of> {
 
     size_t output_rank;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/shuffle_channels.hpp

@@ -2,18 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief
 /// @details
@@ -37,7 +30,4 @@ struct shuffle_channels : public primitive_base<shuffle_channels> {
     /// @brief The index of the channel dimension (default is 1).
     int32_t axis;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/slice.hpp

@@ -1,16 +1,11 @@
 // Copyright (C) 2018-2022 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
+
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief
 /// @details
@@ -30,7 +25,4 @@ struct slice : public primitive_base<slice> {
 
     tensor output_shape;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/softmax.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Normalizes results so they sum to 1.
 /// @details
@@ -46,7 +39,4 @@ struct softmax : public primitive_base<softmax> {
 
     int64_t dimension;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/space_to_batch.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief SpaceToBatch operation divides "spatial" dimensions [1, ..., N - 1], N ∈ {4,5,6} of the data input
 /// into a grid of blocks of shape block_shape, and interleaves these blocks with the batch dimension (0) such that in the output,
@@ -68,7 +61,4 @@ struct space_to_batch : public primitive_base<space_to_batch> {
     tensor pads_end;
     tensor out_size;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/space_to_depth.hpp

@@ -2,17 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief SpaceToDepth operation rearranges data from the spatial dimensions of the input tensor into depth dimension of the output tensor.
 /// @details SpaceToDepth operation permutes element from the input tensor with shape [b, f, y, x]
@@ -72,7 +65,4 @@ struct space_to_depth : public primitive_base<space_to_depth> {
     /// @brief Block size.
     size_t block_size;
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/split.hpp

@@ -2,19 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
 #include "primitive.hpp"
 #include <vector>
 #include <utility>
 
 namespace cldnn {
-/// @addtogroup cpp_api C++ API
-/// @{
-/// @addtogroup cpp_topology Network Topology
-/// @{
-/// @addtogroup cpp_primitives Primitives
-/// @{
 
 /// @brief Performs split operation on input.
 /// @details splits the input data into n parts, for each user provides name and offsets.
@@ -72,7 +65,4 @@ protected:
         return res;
     }
 };
-/// @}
-/// @}
-/// @}
 }  // namespace cldnn