fixing some typos (#17980)

src/bindings/python/tests/test_graph/test_manager.py

@@ -175,7 +175,7 @@ def test_default_version(prepare_ir_paths):
     assert compare_models(model, res_model)
 
 
-def test_default_version_IR_V11_seperate_paths(prepare_ir_paths):
+def test_default_version_IR_V11_separate_paths(prepare_ir_paths):
     core = Core()
 
     xml_path, bin_path = prepare_ir_paths

src/common/transformations/src/transformations/op_conversions/unique_decomposition.cpp

@@ -135,7 +135,7 @@ ov::pass::UniqueDecomposition::UniqueDecomposition() {
         auto unsqueeze_range_1nplus1 = rg.make<Unsqueeze>(range_1nplus1, zero_const);
         // 2. compute a mask with indices counting from one
         auto unique_vs_x_ind = rg.make<Multiply>(unique_vs_x_01, unsqueeze_range_1nplus1);
-        // 3. compute positions of the first occurence for each unique element
+        // 3. compute positions of the first occurrence for each unique element
         // or these are positions of unique elements in the original order
         auto minimum_indices_plus1 = rg.make<ReduceMin>(unique_vs_x_ind, one_const);
         auto minimum_indices = rg.make<Subtract>(minimum_indices_plus1, one_const);

src/common/transformations/tests/op_conversions/unique_decomposition_test.cpp

@@ -86,7 +86,7 @@ shared_ptr<Model> gen_model_ref(PartialShape input_shape, element::Type out_idx)
     auto unsqueeze_range_1nplus1 = make_shared<Unsqueeze>(range_1nplus1, zero_const);
     // 2. compute a mask with indices counting from one
     auto unique_vs_x_ind = make_shared<Multiply>(unique_vs_x_01, unsqueeze_range_1nplus1);
-    // 3. compute positions of the first occurence for each unique element
+    // 3. compute positions of the first occurrence for each unique element
     // or these are positions of unique elements in the original order
     auto minimum_indices_plus1 = make_shared<ReduceMin>(unique_vs_x_ind, one_const);
     auto minimum_indices = make_shared<Subtract>(minimum_indices_plus1, one_const);

src/core/reference/src/runtime/reference/einsum.cpp

@@ -488,7 +488,7 @@ HostTensorPtr build_identity(const HostTensorPtr& input_ptr, const ov::TensorLab
 
     // Identity[k,k,...,k] element is placed in k*p^(n-1) + ... + k*p + k position,
     // where p is a size of one Identity dimension,
-    // n is occurence number for the considered label and k in [0; p).
+    // n is occurrence number for the considered label and k in [0; p).
     // Note that k*p^(n-1) + ... + k*p + k = k * (p^n-1)/(p-1) = k * alpha
     size_t p = repeated_label_dim_size;
     if (p == 1) {

src/core/tests/pass/serialization/const_compression.cpp

@@ -11,7 +11,7 @@
 #include "openvino/pass/serialize.hpp"
 #include "util/test_common.hpp"
 
-class SerializatioConstantCompressionTest : public ov::test::TestsCommon {
+class SerializationConstantCompressionTest : public ov::test::TestsCommon {
 protected:
     std::string m_out_xml_path_1;
     std::string m_out_bin_path_1;
@@ -37,7 +37,7 @@ protected:
     }
 };
 
-TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsI32) {
+TEST_F(SerializationConstantCompressionTest, IdenticalConstantsI32) {
     constexpr int unique_const_count = 1;
     const ov::Shape shape{2, 2, 2};
 
@@ -54,7 +54,7 @@ TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsI32) {
     ASSERT_TRUE(file_size(bin_1) == unique_const_count * ov::shape_size(shape) * sizeof(int32_t));
 }
 
-TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsI64) {
+TEST_F(SerializationConstantCompressionTest, IdenticalConstantsI64) {
     constexpr int unique_const_count = 1;
     const ov::Shape shape{2, 2, 2};
 
@@ -71,7 +71,7 @@ TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsI64) {
     ASSERT_TRUE(file_size(bin_1) == unique_const_count * ov::shape_size(shape) * sizeof(int64_t));
 }
 
-TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsFP16) {
+TEST_F(SerializationConstantCompressionTest, IdenticalConstantsFP16) {
     constexpr int unique_const_count = 1;
     const ov::Shape shape{2, 2, 2};
 
@@ -88,7 +88,7 @@ TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsFP16) {
     ASSERT_TRUE(file_size(bin_1) == unique_const_count * ov::shape_size(shape) * sizeof(ov::float16));
 }
 
-TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsFP32) {
+TEST_F(SerializationConstantCompressionTest, IdenticalConstantsFP32) {
     constexpr int unique_const_count = 1;
     const ov::Shape shape{2, 2, 2};
 
@@ -105,7 +105,7 @@ TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsFP32) {
     ASSERT_TRUE(file_size(bin_1) == unique_const_count * ov::shape_size(shape) * sizeof(float));
 }
 
-TEST_F(SerializatioConstantCompressionTest, NonIdenticalConstantsI64) {
+TEST_F(SerializationConstantCompressionTest, NonIdenticalConstantsI64) {
     constexpr int unique_const_count = 2;
     const ov::Shape shape{2};
 
@@ -123,7 +123,7 @@ TEST_F(SerializatioConstantCompressionTest, NonIdenticalConstantsI64) {
     ASSERT_TRUE(file_size(bin_1) == unique_const_count * ov::shape_size(shape) * sizeof(int64_t));
 }
 
-TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsTimesTwo) {
+TEST_F(SerializationConstantCompressionTest, IdenticalConstantsTimesTwo) {
     constexpr int unique_const_count = 2;
     const ov::Shape shape{2, 2, 2};
 
@@ -142,7 +142,7 @@ TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsTimesTwo) {
     ASSERT_TRUE(file_size(bin_1) == unique_const_count * ov::shape_size(shape) * sizeof(int32_t));
 }
 
-TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsTimesTwoMultipleOccurences) {
+TEST_F(SerializationConstantCompressionTest, IdenticalConstantsTimesTwoMultipleOccurrences) {
     constexpr int unique_const_count = 2;
     const ov::Shape shape{2, 2, 2};
 
@@ -163,7 +163,7 @@ TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsTimesTwoMultipleOc
     ASSERT_TRUE(file_size(bin_1) == unique_const_count * ov::shape_size(shape) * sizeof(int32_t));
 }
 
-TEST_F(SerializatioConstantCompressionTest, NonIdenticalConstants) {
+TEST_F(SerializationConstantCompressionTest, NonIdenticalConstants) {
     constexpr int unique_const_count = 2;
     const ov::Shape shape{2, 2, 2};
 
@@ -180,7 +180,7 @@ TEST_F(SerializatioConstantCompressionTest, NonIdenticalConstants) {
     ASSERT_TRUE(file_size(bin_1) == unique_const_count * ov::shape_size(shape) * sizeof(int32_t));
 }
 
-TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsDifferentTypesI32I64) {
+TEST_F(SerializationConstantCompressionTest, IdenticalConstantsDifferentTypesI32I64) {
     constexpr int unique_const_count = 1;
     const ov::Shape shape{2, 2, 2};
 
@@ -197,7 +197,7 @@ TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsDifferentTypesI32I
     ASSERT_TRUE(file_size(bin_1) == unique_const_count * ov::shape_size(shape) * sizeof(int32_t));
 }
 
-TEST_F(SerializatioConstantCompressionTest, IdenticalConstantsDifferentTypesI32I8) {
+TEST_F(SerializationConstantCompressionTest, IdenticalConstantsDifferentTypesI32I8) {
     constexpr int unique_const_count = 1;
     const ov::Shape shape{1, 1, 2};
 

src/frontends/onnx/frontend/src/core/model.cpp

@@ -19,7 +19,7 @@ std::string get_node_domain(const ONNX_NAMESPACE::NodeProto& node_proto) {
 
 std::int64_t get_opset_version(const ONNX_NAMESPACE::ModelProto& model_proto, const std::string& domain) {
     // copy the opsets and sort them (descending order)
-    // then return the version from the first occurence of a given domain
+    // then return the version from the first occurrence of a given domain
     auto opset_imports = model_proto.opset_import();
     std::sort(std::begin(opset_imports),
               std::end(opset_imports),

src/frontends/onnx/frontend/src/utils/arg_min_max_factory.cpp

@@ -30,15 +30,15 @@ std::shared_ptr<ngraph::Node> ArgMinMaxFactory::make_topk_subgraph(default_opset
 
     if (m_select_last_index == 1) {
         // Example (ArgMin):
-        // The goal is to get the index of the last occurence of the
+        // The goal is to get the index of the last occurrence of the
         // minimum value present in given input tensor.
         //
         // Input:           [1, 2, 1, 3, 4, 4]
         // Expected output: [2]
         //
         // Top-K is always returning the "most-left" result. The trick is to
-        // reverse input to find the "most-right" occurence which is equal to
-        // the last occurence in the original input.
+        // reverse input to find the "most-right" occurrence which is equal to
+        // the last occurrence in the original input.
         // reverse = [4, 4, 3, 1, 2, 1]
         //
         // Run TopK on reversed tensor, in the example output with index values

src/frontends/tensorflow_common/src/op/dynamic_partition.cpp

@@ -33,10 +33,10 @@ OutputVector translate_dynamic_partition_op(const NodeContext& node) {
     auto const_zero = make_shared<Constant>(element::i64, Shape{}, 0);
     auto target_shape = make_shared<Constant>(element::i64, Shape{1}, num_partitions);
     Output<Node> split_legths = make_shared<Broadcast>(const_zero, target_shape);
-    // 2. compute unique partition indices and their occurences
+    // 2. compute unique partition indices and their occurrences
     auto axis = make_shared<Constant>(element::i32, Shape{1}, 0);
     auto unique_partition_inds = make_shared<Unique>(partitions);
-    // 3. update split_lengths with a number of occurences by each partition index
+    // 3. update split_lengths with a number of occurrences by each partition index
     split_legths = make_shared<ScatterUpdate>(split_legths,
                                               unique_partition_inds->output(0),
                                               unique_partition_inds->output(3),

src/plugins/intel_cpu/src/nodes/roi_align.cpp

@@ -526,7 +526,7 @@ private:
 
             uni_vmovups(xmm_weights, ptr[reg_weights]);
             if (jcp_.alg == Algorithm::ROIAlignAvg) {
-                // as vex instruction will zero upper bit for xmm version, store result in seperate xmm_dst_tail
+                // as vex instruction will zero upper bit for xmm version, store result in separate xmm_dst_tail
                 uni_vfmadd231ps(xmm_dst_tail, xmm_src, xmm_weights);
             } else {
                 uni_vmulps(xmm_src, xmm_src, xmm_weights);

src/plugins/intel_gna/legacy/include/legacy/ie_layers.h

@@ -2164,7 +2164,7 @@ public:
      */
     bool return_inverse;
     /**
-     * @brief A flag indicating whether to return a number of occurences for each unique element
+     * @brief A flag indicating whether to return a number of occurrences for each unique element
      */
     bool return_counts;
 

thirdparty/fluid/modules/gapi/src/compiler/passes/intrin.cpp

@@ -254,7 +254,7 @@ void apply(cv::gimpl::GModel::Graph &g) {
 }
 
 // Probably the simplest case: desync makes no sense in the regular
-// compilation process, so just drop all its occurences in the graph,
+// compilation process, so just drop all its occurrences in the graph,
 // reconnecting nodes properly.
 void drop(cv::gimpl::GModel::Graph &g) {
     // FIXME: LOG here that we're dropping the desync operations as