[CodeStyle][Typos][I[3-5],K-1,M[1-5]] Fix typo(indx,instrance,intergral,keywards,mian,Marices,memorys,momemts,Momemtum) (PaddlePaddle#76129)

Author: enkilee

paddle/ap/include/axpr/anf_expr_util.h

@@ -458,7 +458,7 @@ struct ParseJsonToAnfExprHelperInt64 {
     if (!j_obj.is_number_integer()) {
       return JsonParseMismatch(j_obj,
                                "ParseJsonToAnfExpr<int64_t>: json object "
-                               "should be a intergral number.");
+                               "should be a integral number.");
     }
     auto c = j_obj.get<Json::number_integer_t>();
     return AnfExpr{AnfExprBuilder().Int64(c)};

paddle/ap/include/axpr/data_value_util.h

@@ -69,7 +69,7 @@ struct ArithmeticBinaryOpHelper<ArithmeticMod> {
       return ArithmeticMod::Call(lhs, rhs);
     } else {
       return adt::errors::TypeError{
-          std::string() + "'%' only support intergral type, but receive: '" +
+          std::string() + "'%' only support integral type, but receive: '" +
           CppDataType<decltype(lhs)>{}.Name() + "' and '" +
           CppDataType<decltype(rhs)>{}.Name() + "'."};
     }

paddle/fluid/inference/tensorrt/engine.h

@@ -702,19 +702,19 @@ class PADDLE_API TRTEngineManager {
                          const phi::Stream& stream) {
     std::lock_guard<std::mutex> lock(mutex_);
     static auto alignment = GetAlignmentSize(place);
-    if (context_memorys_.count(predictor_id) == 0) {
+    if (context_memories_.count(predictor_id) == 0) {
       auto context_memory =
           memory::Alloc(place, max_ctx_mem_size_ + alignment, stream);
-      context_memorys_[predictor_id] = std::move(context_memory);
+      context_memories_[predictor_id] = std::move(context_memory);
     }
-    return GetAlignedMemory(context_memorys_[predictor_id]->ptr(), alignment);
+    return GetAlignedMemory(context_memories_[predictor_id]->ptr(), alignment);
   }
 
   void ReleaseContextMemory(PredictorID predictor_id) {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (context_memorys_.count(predictor_id)) {
-      context_memorys_[predictor_id].reset(nullptr);
-      context_memorys_.erase(predictor_id);
+    if (context_memories_.count(predictor_id)) {
+      context_memories_[predictor_id].reset(nullptr);
+      context_memories_.erase(predictor_id);
     }
   }
 
@@ -730,7 +730,7 @@ class PADDLE_API TRTEngineManager {
 
   mutable std::mutex mutex_;
   size_t max_ctx_mem_size_{0};
-  std::unordered_map<PredictorID, AllocationPtr> context_memorys_;
+  std::unordered_map<PredictorID, AllocationPtr> context_memories_;
   std::unordered_map<std::string, std::unique_ptr<TensorRTEngine>> engines_;
   infer_ptr<nvinfer1::IBuilder> holder_;
 };

paddle/fluid/platform/tensorrt/engine.h

@@ -640,19 +640,19 @@ class TRTEngineManager {
                          const phi::Stream& stream) {
     std::lock_guard<std::mutex> lock(mutex_);
     static auto alignment = GetAlignmentSize(place);
-    if (context_memorys_.count(predictor_id) == 0) {
+    if (context_memories_.count(predictor_id) == 0) {
       auto context_memory =
           memory::Alloc(place, max_ctx_mem_size_ + alignment, stream);
-      context_memorys_[predictor_id] = std::move(context_memory);
+      context_memories_[predictor_id] = std::move(context_memory);
     }
-    return GetAlignedMemory(context_memorys_[predictor_id]->ptr(), alignment);
+    return GetAlignedMemory(context_memories_[predictor_id]->ptr(), alignment);
   }
 
   void ReleaseContextMemory(PredictorID predictor_id) {
     std::lock_guard<std::mutex> lock(mutex_);
-    if (context_memorys_.count(predictor_id)) {
-      context_memorys_[predictor_id].reset(nullptr);
-      context_memorys_.erase(predictor_id);
+    if (context_memories_.count(predictor_id)) {
+      context_memories_[predictor_id].reset(nullptr);
+      context_memories_.erase(predictor_id);
     }
   }
 
@@ -668,7 +668,7 @@ class TRTEngineManager {
 
   mutable std::mutex mutex_;
   size_t max_ctx_mem_size_{0};
-  std::unordered_map<PredictorID, AllocationPtr> context_memorys_;
+  std::unordered_map<PredictorID, AllocationPtr> context_memories_;
   std::unordered_map<std::string, std::unique_ptr<TensorRTEngine>> engines_;
   infer_ptr<nvinfer1::IBuilder> holder_;
 };

paddle/phi/kernels/funcs/multi_tensor_apply.h

@@ -75,7 +75,7 @@ void LaunchMultiTensorApplyKernel(
       InputNum - 1,
       errors::InvalidArgument(
           "input_vector.size() != InputNum - 1, the input vector's size is "
-          "unequal to InputNum - 1, please cheack grads, params, momemts1, "
+          "unequal to InputNum - 1, please cheack grads, params, moments1, "
           "moments2, moments2_max(if use amsgrad), and, master_params."));
   size_t length = input_vector[0].size();
   PADDLE_ENFORCE_GT(

python/paddle/dataset/common.py

@@ -174,16 +174,16 @@ def split(reader, line_count, suffix="%05d.pickle", dumper=pickle.dump):
     if not callable(dumper):
         raise TypeError("dumper should be callable.")
     lines = []
-    indx_f = 0
+    index_f = 0
     for i, d in enumerate(reader()):
         lines.append(d)
         if i >= line_count and i % line_count == 0:
-            with open(suffix % indx_f, "w") as f:
+            with open(suffix % index_f, "w") as f:
                 dumper(lines, f)
                 lines = []
-                indx_f += 1
+                index_f += 1
     if lines:
-        with open(suffix % indx_f, "w") as f:
+        with open(suffix % index_f, "w") as f:
             dumper(lines, f)
 
 

python/paddle/nn/layer/common.py

@@ -398,7 +398,7 @@ class Upsample(Layer):
                                corner pixels.
                                Default: False
         align_mode(int)  :  An optional for linear/bilinear/trilinear interpolation. Refer to the formula in the example above,
-                            it can be \'0\' for src_idx = scale_factor*(dst_indx+0.5)-0.5 , can be \'1\' for
+                            it can be \'0\' for src_idx = scale_factor*(dst_index+0.5)-0.5 , can be \'1\' for
                             src_idx = scale_factor*dst_index.
         data_format (str|None, optional): Specify the data format of the input, and the data format of
              the output will be consistent with that of the input. An optional string from:`"NCW"`,

python/paddle/profiler/statistic_helper.py

@@ -25,18 +25,20 @@ def merge_self_ranges(src_ranges, is_sorted=False):
     if len(src_ranges) > 0:
         if not is_sorted:
             src_ranges.sort(key=lambda x: x[0])
-        cur_indx = 0
-        merged_ranges.append((src_ranges[cur_indx][0], src_ranges[cur_indx][1]))
-        for cur_indx in range(1, len(src_ranges)):
-            if src_ranges[cur_indx][1] > merged_ranges[-1][1]:
-                if src_ranges[cur_indx][0] <= merged_ranges[-1][1]:
+        cur_index = 0
+        merged_ranges.append(
+            (src_ranges[cur_index][0], src_ranges[cur_index][1])
+        )
+        for cur_index in range(1, len(src_ranges)):
+            if src_ranges[cur_index][1] > merged_ranges[-1][1]:
+                if src_ranges[cur_index][0] <= merged_ranges[-1][1]:
                     merged_ranges[-1] = (
                         merged_ranges[-1][0],
-                        src_ranges[cur_indx][1],
+                        src_ranges[cur_index][1],
                     )
                 else:
                     merged_ranges.append(
-                        (src_ranges[cur_indx][0], src_ranges[cur_indx][1])
+                        (src_ranges[cur_index][0], src_ranges[cur_index][1])
                     )
     return merged_ranges
 
@@ -55,58 +57,58 @@ def merge_ranges(range_list1, range_list2, is_sorted=False):
     elif len2 == 0:
         return range_list1
     else:
-        indx1 = 0
-        indx2 = 0
-        range1 = range_list1[indx1]
-        range2 = range_list2[indx2]
+        index1 = 0
+        index2 = 0
+        range1 = range_list1[index1]
+        range2 = range_list2[index2]
         if range1[0] < range2[0]:
             merged_ranges.append(range1)
-            indx1 += 1
+            index1 += 1
         else:
             merged_ranges.append(range2)
-            indx2 += 1
-        while indx1 < len1 and indx2 < len2:
-            range1 = range_list1[indx1]
-            range2 = range_list2[indx2]
+            index2 += 1
+        while index1 < len1 and index2 < len2:
+            range1 = range_list1[index1]
+            range2 = range_list2[index2]
             if range1[0] < range2[0]:
                 if range1[1] > merged_ranges[-1][1]:
                     if range1[0] <= merged_ranges[-1][1]:
                         merged_ranges[-1] = (merged_ranges[-1][0], range1[1])
                     else:
                         merged_ranges.append((range1[0], range1[1]))
-                    indx1 += 1
+                    index1 += 1
                 else:
-                    indx1 += 1
+                    index1 += 1
             else:
                 if range2[1] > merged_ranges[-1][1]:
                     if range2[0] <= merged_ranges[-1][1]:
                         merged_ranges[-1] = (merged_ranges[-1][0], range2[1])
                     else:
                         merged_ranges.append((range2[0], range2[1]))
-                    indx2 += 1
+                    index2 += 1
                 else:
-                    indx2 += 1
+                    index2 += 1
 
-        while indx1 < len1:
-            range1 = range_list1[indx1]
+        while index1 < len1:
+            range1 = range_list1[index1]
             if range1[1] > merged_ranges[-1][1]:
                 if range1[0] <= merged_ranges[-1][1]:
                     merged_ranges[-1] = (merged_ranges[-1][0], range1[1])
                 else:
                     merged_ranges.append((range1[0], range1[1]))
-                indx1 += 1
+                index1 += 1
             else:
-                indx1 += 1
-        while indx2 < len2:
-            range2 = range_list2[indx2]
+                index1 += 1
+        while index2 < len2:
+            range2 = range_list2[index2]
             if range2[1] > merged_ranges[-1][1]:
                 if range2[0] <= merged_ranges[-1][1]:
                     merged_ranges[-1] = (merged_ranges[-1][0], range2[1])
                 else:
                     merged_ranges.append((range2[0], range2[1]))
-                indx2 += 1
+                index2 += 1
             else:
-                indx2 += 1
+                index2 += 1
     return merged_ranges
 
 
@@ -120,59 +122,59 @@ def intersection_ranges(range_list1, range_list2, is_sorted=False):
 
     len1 = len(range_list1)
     len2 = len(range_list2)
-    indx1 = 0
-    indx2 = 0
-    range1 = range_list1[indx1]
-    range2 = range_list2[indx2]
-    while indx1 < len1 and indx2 < len2:
+    index1 = 0
+    index2 = 0
+    range1 = range_list1[index1]
+    range2 = range_list2[index2]
+    while index1 < len1 and index2 < len2:
         if range2[1] <= range1[0]:
-            indx2 += 1
-            if indx2 == len2:
+            index2 += 1
+            if index2 == len2:
                 break
-            range2 = range_list2[indx2]
+            range2 = range_list2[index2]
 
         elif range2[0] <= range1[0] and range2[1] < range1[1]:
             assert range2[1] > range1[0]
             result_range.append((range1[0], range2[1]))
             range1 = (range2[1], range1[1])
-            indx2 += 1
-            if indx2 == len2:
+            index2 += 1
+            if index2 == len2:
                 break
-            range2 = range_list2[indx2]
+            range2 = range_list2[index2]
 
         elif range2[0] <= range1[0]:
             assert range2[1] >= range1[1]
             result_range.append(range1)
             range2 = (range1[1], range2[1])
-            indx1 += 1
-            if indx1 == len1:
+            index1 += 1
+            if index1 == len1:
                 break
-            range1 = range_list1[indx1]
+            range1 = range_list1[index1]
 
         elif range2[1] < range1[1]:
             assert range2[0] > range1[0]
             result_range.append(range2)
             range1 = (range2[1], range1[1])
-            indx2 += 1
-            if indx2 == len2:
+            index2 += 1
+            if index2 == len2:
                 break
-            range2 = range_list2[indx2]
+            range2 = range_list2[index2]
 
         elif range2[0] < range1[1]:
             assert range2[1] >= range1[1]
             result_range.append((range2[0], range1[1]))
             range2 = (range1[1], range2[1])
-            indx1 += 1
-            if indx1 == len1:
+            index1 += 1
+            if index1 == len1:
                 break
-            range1 = range_list1[indx1]
+            range1 = range_list1[index1]
 
         else:
             assert range2[0] >= range1[1]
-            indx1 += 1
-            if indx1 == len1:
+            index1 += 1
+            if index1 == len1:
                 break
-            range1 = range_list1[indx1]
+            range1 = range_list1[index1]
     return result_range
 
 
@@ -188,41 +190,41 @@ def subtract_ranges(range_list1, range_list2, is_sorted=False):
 
     len1 = len(range_list1)
     len2 = len(range_list2)
-    indx1 = 0
-    indx2 = 0
-    range1 = range_list1[indx1]
-    range2 = range_list2[indx2]
+    index1 = 0
+    index2 = 0
+    range1 = range_list1[index1]
+    range2 = range_list2[index2]
 
-    while indx1 < len(range_list1):
-        if indx2 == len(range_list2):
+    while index1 < len(range_list1):
+        if index2 == len(range_list2):
             result_range.append(range1)
-            indx1 += 1
-            if indx1 == len1:
+            index1 += 1
+            if index1 == len1:
                 break
-            range1 = range_list1[indx1]
+            range1 = range_list1[index1]
         elif range2[1] <= range1[0]:
-            indx2 += 1
-            if indx2 != len2:
-                range2 = range_list2[indx2]
+            index2 += 1
+            if index2 != len2:
+                range2 = range_list2[index2]
         elif range2[0] <= range1[0] and range2[1] < range1[1]:
             range1 = (range2[1], range1[1])
-            indx2 += 1
-            if indx2 != len2:
-                range2 = range_list2[indx2]
+            index2 += 1
+            if index2 != len2:
+                range2 = range_list2[index2]
         elif range2[0] <= range1[0]:
             assert range2[1] >= range1[1]
             range2 = (range1[1], range2[1])
-            indx1 += 1
-            if indx1 != len1:
-                range1 = range_list1[indx1]
+            index1 += 1
+            if index1 != len1:
+                range1 = range_list1[index1]
         elif range2[0] < range1[1]:
             assert range2[0] > range1[0]
             result_range.append((range1[0], range2[0]))
             range1 = (range2[0], range1[1])
         else:
             assert range2[0] >= range1[1]
             result_range.append(range1)
-            indx1 += 1
-            if indx1 != len1:
-                range1 = range_list1[indx1]
+            index1 += 1
+            if index1 != len1:
+                range1 = range_list1[index1]
     return result_range

python/paddle/static/nn/common.py

@@ -2715,7 +2715,7 @@ def batch_norm(
         "use_global_stats": use_global_stats,
     }
     if isinstance(momentum, paddle.static.Variable):
-        inputs['MomemtumTensor'] = momentum
+        inputs['MomentumTensor'] = momentum
     else:
         attrs['momentum'] = momentum
 

test/ir/pir/translator/test_dgc_momentum_translator.py

@@ -22,7 +22,7 @@
 paddle.pir_utils._switch_to_old_ir_()
 
 
-class TestDgcMomemtumOpTranslator(test_op_translator.TestOpTranslator):
+class TestDgcMomentumOpTranslator(test_op_translator.TestOpTranslator):
     def append_op(self):
         self.op_type = "dgc_momentum"