Fix velocitys velocities (#60991)

co63oc · web-flow · commit 72d51157663e · 2024-01-22T10:57:33.000+08:00
diff --git a/paddle/phi/kernels/impl/merged_momentum_impl.h b/paddle/phi/kernels/impl/merged_momentum_impl.h
@@ -53,7 +53,7 @@ struct MergedMomentumKernelParam
   size_t sizes[N];
   T *PADDLE_RESTRICT params[N];
   const T *PADDLE_RESTRICT grads[N];
-  MT *PADDLE_RESTRICT velocitys[N];
+  MT *PADDLE_RESTRICT velocities[N];
   const MultiPrecisionType<MT> *PADDLE_RESTRICT lr;
   MT mu;
   MT rescale_grad;
@@ -67,7 +67,7 @@ struct MergedMomentumKernelParam
 
       auto param_p = params[idx];
       auto grad_p = grads[idx];
-      auto velocity_p = velocitys[idx];
+      auto velocity_p = velocities[idx];
       auto master_param_p = this->MasterParam(idx);
 
       const MT param =
@@ -90,7 +90,7 @@ void MergedMomentumInnerCompute(
     const Context &ctx,
     const std::vector<const DenseTensor *> &params,
     const std::vector<const DenseTensor *> &grads,
-    const std::vector<const DenseTensor *> &velocitys,
+    const std::vector<const DenseTensor *> &velocities,
     const std::vector<const DenseTensor *> &lrs,
     const paddle::optional<std::vector<const DenseTensor *>> &master_params_opt,
     float mu,
@@ -100,7 +100,7 @@ void MergedMomentumInnerCompute(
     float rescale_grad,
     const bool multi_precision,
     std::vector<DenseTensor *> params_out,
-    std::vector<DenseTensor *> velocitys_out,
+    std::vector<DenseTensor *> velocities_out,
     std::vector<DenseTensor *> master_params_out) {
   size_t n = params.size();
   PADDLE_ENFORCE_EQ(n,
@@ -129,26 +129,26 @@ void MergedMomentumInnerCompute(
           n));
 
   PADDLE_ENFORCE_EQ(n,
-                    velocitys.size(),
+                    velocities.size(),
                     phi::errors::InvalidArgument(
                         "The size of Input(Velocity) must be equal to "
                         "Input(Param), but got the size of Input(Velocity) "
                         "is %d, the size of Input(Param) is %d.",
-                        velocitys.size(),
+                        velocities.size(),
                         n));
 
   PADDLE_ENFORCE_EQ(
       n,
-      velocitys_out.size(),
+      velocities_out.size(),
       phi::errors::InvalidArgument(
           "The size of Output(VelocityOut) must be "
           "equal to Input(Param), but got the size of Output(VelocityOut) is "
           "%d, the size of Input(Param) is %d.",
-          velocitys_out.size(),
+          velocities_out.size(),
           n));
   for (size_t i = 0; i < n; ++i) {
-    PADDLE_ENFORCE_EQ(velocitys[i],
-                      velocitys_out[i],
+    PADDLE_ENFORCE_EQ(velocities[i],
+                      velocities_out[i],
                       phi::errors::InvalidArgument(
                           "Input(Velocity) and Output(VelocityOut) must be "
                           "the same Tensors."));
@@ -231,34 +231,34 @@ void MergedMomentumInnerCompute(
 
   if (lrs.size() == 1 && use_nesterov == false &&
       regularization_methods.size() == 0) {
-#define PADDLE_LAUNCH_MERGED_MOMENTUM_KERNEL(kMultiPrecision)            \
-  MergedMomentumKernelParam<T, MT, kMultiPrecision> kernel_params;       \
-  constexpr auto kMaxMergedNum = decltype(kernel_params)::N;             \
-  size_t kernel_num = (n + kMaxMergedNum - 1) / kMaxMergedNum;           \
-  kernel_params.mu = static_cast<MT>(mu);                                \
-  kernel_params.rescale_grad = static_cast<MT>(rescale_grad);            \
-  kernel_params.lr = lrs[0]->data<MPType>();                             \
-  for (size_t i = 0; i < kernel_num; ++i) {                              \
-    size_t start = i * kMaxMergedNum;                                    \
-    size_t end = std::min((i + 1) * kMaxMergedNum, n);                   \
-    kernel_params.param_num = static_cast<uint32_t>(end - start);        \
-    size_t max_size = 0;                                                 \
-    for (size_t j = 0; j < kernel_params.param_num; ++j) {               \
-      auto size = static_cast<size_t>(params_out[j + start]->numel());   \
-      max_size = std::max(max_size, size);                               \
-      kernel_params.sizes[j] = size;                                     \
-      kernel_params.params[j] = params_out[j + start]->data<T>();        \
-      kernel_params.grads[j] = grads[j + start]->data<T>();              \
-      kernel_params.velocitys[j] = velocitys_out[j + start]->data<MT>(); \
-      kernel_params.SetMasterParam(                                      \
-          j,                                                             \
-          kMultiPrecision ? master_params_out[j + start]->data<MT>()     \
-                          : nullptr);                                    \
-    }                                                                    \
-    phi::funcs::ForRange<Context> for_range(ctx, max_size);              \
-    for_range(kernel_params);                                            \
-    VLOG(10) << "Launch MergedMomentum kernel " << i << " "              \
-             << kernel_params.param_num;                                 \
+#define PADDLE_LAUNCH_MERGED_MOMENTUM_KERNEL(kMultiPrecision)              \
+  MergedMomentumKernelParam<T, MT, kMultiPrecision> kernel_params;         \
+  constexpr auto kMaxMergedNum = decltype(kernel_params)::N;               \
+  size_t kernel_num = (n + kMaxMergedNum - 1) / kMaxMergedNum;             \
+  kernel_params.mu = static_cast<MT>(mu);                                  \
+  kernel_params.rescale_grad = static_cast<MT>(rescale_grad);              \
+  kernel_params.lr = lrs[0]->data<MPType>();                               \
+  for (size_t i = 0; i < kernel_num; ++i) {                                \
+    size_t start = i * kMaxMergedNum;                                      \
+    size_t end = std::min((i + 1) * kMaxMergedNum, n);                     \
+    kernel_params.param_num = static_cast<uint32_t>(end - start);          \
+    size_t max_size = 0;                                                   \
+    for (size_t j = 0; j < kernel_params.param_num; ++j) {                 \
+      auto size = static_cast<size_t>(params_out[j + start]->numel());     \
+      max_size = std::max(max_size, size);                                 \
+      kernel_params.sizes[j] = size;                                       \
+      kernel_params.params[j] = params_out[j + start]->data<T>();          \
+      kernel_params.grads[j] = grads[j + start]->data<T>();                \
+      kernel_params.velocities[j] = velocities_out[j + start]->data<MT>(); \
+      kernel_params.SetMasterParam(                                        \
+          j,                                                               \
+          kMultiPrecision ? master_params_out[j + start]->data<MT>()       \
+                          : nullptr);                                      \
+    }                                                                      \
+    phi::funcs::ForRange<Context> for_range(ctx, max_size);                \
+    for_range(kernel_params);                                              \
+    VLOG(10) << "Launch MergedMomentum kernel " << i << " "                \
+             << kernel_params.param_num;                                   \
   }
     if (multi_precision) {
       PADDLE_LAUNCH_MERGED_MOMENTUM_KERNEL(true);
@@ -288,14 +288,14 @@ void MergedMomentumInnerCompute(
         phi::CPUDenseMomentumFunctor<MT> functor;
         functor(params[idx],
                 grads[idx],
-                velocitys[idx],
+                velocities[idx],
                 lr_temp,
                 static_cast<MT>(mu),
                 use_nesterov,
                 regularization_flag,
                 regularization_coeff,
                 params_out[idx],
-                velocitys_out[idx]);
+                velocities_out[idx]);
         VLOG(10) << "Launch MergedMomentum cpu kernel.";
       } else if (ctx.GetPlace().GetType() == phi::AllocationType::GPU) {
         phi::funcs::ForRange<Context> for_range(
@@ -306,30 +306,30 @@ void MergedMomentumInnerCompute(
     DenseMomentumFunctor<T, float, MT, __reg_type, __nesterov> functor( \
         params[idx]->data<T>(),                                         \
         grads[idx]->data<float>(),                                      \
-        velocitys[idx]->data<MT>(),                                     \
+        velocities[idx]->data<MT>(),                                    \
         lr_temp->data<MPType>(),                                        \
         master_in_data,                                                 \
         static_cast<MT>(mu),                                            \
         static_cast<MT>(rescale_grad),                                  \
         params[idx]->numel(),                                           \
         regularization_coeff,                                           \
         params_out[idx]->data<T>(),                                     \
-        velocitys_out[idx]->data<MT>(),                                 \
+        velocities_out[idx]->data<MT>(),                                \
         master_out_data);                                               \
     for_range(functor);                                                 \
   } else {                                                              \
     DenseMomentumFunctor<T, T, MT, __reg_type, __nesterov> functor(     \
         params[idx]->data<T>(),                                         \
         grads[idx]->data<T>(),                                          \
-        velocitys[idx]->data<MT>(),                                     \
+        velocities[idx]->data<MT>(),                                    \
         lr_temp->data<MPType>(),                                        \
         master_in_data,                                                 \
         static_cast<MT>(mu),                                            \
         static_cast<MT>(rescale_grad),                                  \
         params[idx]->numel(),                                           \
         regularization_coeff,                                           \
         params_out[idx]->data<T>(),                                     \
-        velocitys_out[idx]->data<MT>(),                                 \
+        velocities_out[idx]->data<MT>(),                                \
         master_out_data);                                               \
     for_range(functor);                                                 \
   }
diff --git a/paddle/phi/kernels/impl/multi_dot_kernel_impl.h b/paddle/phi/kernels/impl/multi_dot_kernel_impl.h
@@ -69,7 +69,7 @@ inline DenseTensor MatMul(const Context& ctx,
  * ins_dims: the shape of ins after reshape
  * order: the optimal order
  * i: the left of sub chain
- * j: the righe of sub chain
+ * j: the right of sub chain
  * save_result: set true by backward
  * results: save the intermediate result during backward
  */
@@ -272,8 +272,8 @@ void CalcGrad(const Context& ctx,
  * ins_dims: the shape of ins after reshape
  * order: the optimal order
  * i: the left of sub chain
- * j: the righe of sub chain
- * results: the intermediate result of farward
+ * j: the right of sub chain
+ * results: the intermediate result of forward
  */
 template <typename Context, typename T>
 void MatChainMulGrad(const Context& ctx,
diff --git a/paddle/phi/kernels/impl/set_value_grad_kernel_impl.h b/paddle/phi/kernels/impl/set_value_grad_kernel_impl.h
@@ -170,7 +170,7 @@ void SetValueGradImpl(const Context& dev_ctx,
       auto value_grad_dims = value_grad->dims();
       auto fake_value_grad_dims = out_dims;
 
-      // Create an extented shape according to the rules of broadcast.
+      // Create an extended shape according to the rules of broadcast.
       auto value_grad_dims_size = value_grad_dims.size();
 
       int num_decrease = 0;
diff --git a/paddle/phi/kernels/impl/set_value_kernel_impl.h b/paddle/phi/kernels/impl/set_value_kernel_impl.h
@@ -273,13 +273,13 @@ void SetValueKernel(const Context& dev_ctx,
                     const std::vector<int64_t>& shape,
                     const std::vector<Scalar>& values,
                     DenseTensor* out) {
-  std::vector<T> assgin_values;
-  assgin_values.reserve(values.size());
+  std::vector<T> assign_values;
+  assign_values.reserve(values.size());
   for (const auto& val : values) {
-    assgin_values.push_back(val.to<T>());
+    assign_values.push_back(val.to<T>());
   }
   DenseTensor value_tensor = Empty<T>(dev_ctx, shape);
-  phi::TensorFromVector(assgin_values, dev_ctx, &value_tensor);
+  phi::TensorFromVector(assign_values, dev_ctx, &value_tensor);
   value_tensor.Resize(common::make_ddim(shape));
 
   SetTensorValueKernel<T, Context>(dev_ctx,
diff --git a/paddle/phi/kernels/impl/slice_grad_kernel_impl.h b/paddle/phi/kernels/impl/slice_grad_kernel_impl.h
@@ -135,7 +135,7 @@ void EigenPaddingCompute(
         // first dimension is the padding dimension
         in_tore_shape[0] = in_dims[pad_dim];
         out_tore_shape[0] = out_dims[pad_dim];
-        // sencond dimension is the accumulate of succeeding dimension
+        // second dimension is the accumulate of succeeding dimension
         for (size_t i = pad_dim + 1; i < D; i++) {
           in_tore_shape[1] *= in_dims[i];
           out_tore_shape[1] *= out_dims[i];
