Fix typo (batchs -> batches) (#61838)

co63oc · web-flow · commit 5d314d2f78c9 · 2024-02-21T10:42:44.000+08:00
diff --git a/paddle/fluid/imperative/gradient_accumulator.cc b/paddle/fluid/imperative/gradient_accumulator.cc
@@ -635,7 +635,7 @@ void GradientAccumulator::CallReduceHooks() {
                     platform::errors::PreconditionNotMet(
                         "Only can call reduce hooks after the "
                         "gradient accumulation is completed in "
-                        "current batch or across batchs."));
+                        "current batch or across batches."));
   if (var_->HasVoidHook()) {
     for (const auto& hook : var_->GetVoidHooks()) {
       VLOG(3) << "call gradient accumulator backward hooks.";
diff --git a/paddle/fluid/imperative/gradient_accumulator.h b/paddle/fluid/imperative/gradient_accumulator.h
@@ -102,14 +102,14 @@ class GradientAccumulator {
    *
    *    There are two types of gradient accumulation:
    *    1. Gradient accumulation in same batch
-   *    2. Gradient accumulation across batchs
+   *    2. Gradient accumulation across batches
    *    The order of execution between Hooks and gradient accumulation:
 
    *      [ Gradient accumulation in same batch]
    *                        |
    *            [ leaf GradVarBase hooks ]
    *                        |
-   *      [ Gradient accumulation across batchs ]
+   *      [ Gradient accumulation across batches ]
    *                        |
    *          [ Gradient reduce / allreduce hooks ]
 
diff --git a/paddle/fluid/inference/tensorrt/plugin/fused_token_prune_op_plugin.cu b/paddle/fluid/inference/tensorrt/plugin/fused_token_prune_op_plugin.cu
@@ -349,7 +349,7 @@ int FusedTokenPrunePluginDynamic::enqueue(
         static_cast<const int32_t*>(inputs[5]);            // pre pos id
     int32_t* output3 = static_cast<int32_t*>(outputs[3]);  // new pos id
     half* output0 = static_cast<half*>(outputs[0]);
-    const int32_t B = input_desc[1].dims.d[0];  // batchs
+    const int32_t B = input_desc[1].dims.d[0];  // batches
     const int32_t max_sequnce_length =
         input_desc[1].dims.d[1];                     // max sequnce length
     const int32_t length = input_desc[1].dims.d[2];  // hidden size
@@ -447,12 +447,13 @@ int FusedTokenPrunePluginDynamic::enqueue(
     const dim3 num_blocks(
         B,
         max_sequnce_length,
-        length / num_threads);  //  batchs, max_sequnce_length, vector_ength/***
+        length /
+            num_threads);  //  batches, max_sequnce_length, vector_ength/***
     varlen_prune_token_change_order<<<num_blocks, num_threads, 0, stream>>>(
         tokens, output3, padding_token_length, token_index_, output0);
   } else {
     auto input_type = input_desc[0].type;
-    const int32_t B = input_desc[1].dims.d[0];  // batchs
+    const int32_t B = input_desc[1].dims.d[0];  // batches
     const int32_t pre_sequnce_length = input_desc[1].dims.d[1];
     const int32_t new_sequnce_length = input_desc[3].dims.d[2];  // new mask
     const int32_t length = input_desc[1].dims.d[2];              // hidden size
diff --git a/paddle/fluid/inference/tensorrt/plugin/fused_token_prune_op_plugin.h b/paddle/fluid/inference/tensorrt/plugin/fused_token_prune_op_plugin.h
@@ -44,7 +44,7 @@ class FusedTokenPrunePluginDynamic : public DynamicPluginTensorRT {
   nvinfer1::IPluginV2DynamicExt* clone() const TRT_NOEXCEPT override {
     FusedTokenPrunePluginDynamic* ptr = new FusedTokenPrunePluginDynamic(
         with_fp16_, keep_first_token_, keep_order_, flag_varseqlen_);
-    ptr->max_batchs_ = max_batchs_;
+    ptr->max_batches_ = max_batches_;
     ptr->max_token_length_ = max_token_length_;
     ptr->pruned_token_lengths_ = pruned_token_lengths_;
     ptr->token_index_ = token_index_;
@@ -91,7 +91,7 @@ class FusedTokenPrunePluginDynamic : public DynamicPluginTensorRT {
                        int nb_inputs,
                        const nvinfer1::DynamicPluginTensorDesc* out,
                        int nb_outputs) TRT_NOEXCEPT override {
-    max_batchs_ = in[1].max.d[0];
+    max_batches_ = in[1].max.d[0];
     max_token_length_ = in[1].max.d[1];
     int32_t padding_token_length;
     if (max_token_length_ <= 64) {
@@ -113,17 +113,18 @@ class FusedTokenPrunePluginDynamic : public DynamicPluginTensorRT {
     }
     try {
       PADDLE_ENFORCE_GPU_SUCCESS(cudaMalloc(
-          &pruned_token_lengths_, (max_batchs_ + 1) * sizeof(int32_t)));
-      PADDLE_ENFORCE_GPU_SUCCESS(cudaMalloc(
-          &token_index_, max_batchs_ * padding_token_length * sizeof(int32_t)));
+          &pruned_token_lengths_, (max_batches_ + 1) * sizeof(int32_t)));
+      PADDLE_ENFORCE_GPU_SUCCESS(
+          cudaMalloc(&token_index_,
+                     max_batches_ * padding_token_length * sizeof(int32_t)));
       int32_t type_size = 4;
       if (in[0].desc.type == nvinfer1::DataType::kHALF) {
         type_size = 2;
       } else {
         type_size = 4;
       }
       PADDLE_ENFORCE_GPU_SUCCESS(cudaMalloc(
-          &padding_scores_, max_batchs_ * padding_token_length * type_size));
+          &padding_scores_, max_batches_ * padding_token_length * type_size));
     } catch (std::exception& e) {
     }
   }
@@ -153,7 +154,7 @@ class FusedTokenPrunePluginDynamic : public DynamicPluginTensorRT {
   bool flag_varseqlen_;
   int32_t* pruned_token_lengths_;
   int32_t* token_index_;
-  int32_t max_batchs_;
+  int32_t max_batches_;
   int32_t max_token_length_;
   void* padding_scores_;
 };
diff --git a/paddle/fluid/inference/tensorrt/plugin/recover_padding_plugin.cu b/paddle/fluid/inference/tensorrt/plugin/recover_padding_plugin.cu
@@ -148,7 +148,7 @@ int RecoverPaddingPlugin::enqueue(const nvinfer1::PluginTensorDesc* inputDesc,
   const dim3 num_blocks(
       input1_desc.dims.d[0] - 1,
       input2_desc.dims.d[1],
-      vector_length / num_threads);  //  batchs, max sequnce length
+      vector_length / num_threads);  //  batches, max sequnce length
                                      //  (mask_id.dims.d[1]),
                                      //  input.dims.d[1]/***
   RecoverPaddingKernel<<<num_blocks, num_threads, 0, stream>>>(
diff --git a/paddle/fluid/inference/tensorrt/plugin/remove_padding_plugin.cu b/paddle/fluid/inference/tensorrt/plugin/remove_padding_plugin.cu
@@ -141,7 +141,7 @@ int RemovePaddingPlugin::enqueue(const nvinfer1::PluginTensorDesc* inputDesc,
       input0_desc.dims.d[0],
       input0_desc.dims.d[1],
       vector_length /
-          num_threads);  //  batchs, max sequnce length, input0.dims.d[2]/***
+          num_threads);  //  batches, max sequnce length, input0.dims.d[2]/***
 
   RemovePaddingKernel<<<num_blocks, num_threads, 0, stream>>>(
       input0, input1, output);
diff --git a/paddle/fluid/inference/tensorrt/plugin/transformer_input_output_convert_plugin.cu b/paddle/fluid/inference/tensorrt/plugin/transformer_input_output_convert_plugin.cu
@@ -177,7 +177,7 @@ int TransformerInputConvertPlugin::enqueue(
   half* output0 = static_cast<half*>(outputs[0]);        // input(varlen)
   int32_t* output2 = static_cast<int32_t*>(outputs[2]);  // pos_id
   const auto input0_desc = inputDesc[0];
-  const int32_t B = input0_desc.dims.d[0];           // batchs
+  const int32_t B = input0_desc.dims.d[0];           // batches
   const int32_t MaxLength = input0_desc.dims.d[1];   // max token length
   const int32_t HiddenSize = input0_desc.dims.d[2];  // hidden size
 
@@ -222,7 +222,7 @@ int TransformerInputConvertPlugin::enqueue(
       B,
       MaxLength,
       vector_length /
-          num_threads);  //  batchs, max sequnce length, input0.dims.d[2]/*
+          num_threads);  //  batches, max sequnce length, input0.dims.d[2]/*
   remove_padding_kernel<<<num_blocks, num_threads, 0, stream>>>(
       input0, output2, output0);  // input(no_varlen), pos_id, input(varlen)
   return cudaGetLastError() != cudaSuccess;
@@ -311,7 +311,7 @@ int TransformerOutputConvertPlugin::enqueue(
   half* output =
       static_cast<half*>(outputs[0]);  // qkv plugin output(no_varlen)
   const auto input1_desc = inputDesc[1];
-  const int32_t B = input1_desc.dims.d[0];           // batchs
+  const int32_t B = input1_desc.dims.d[0];           // batches
   const int32_t MaxLength = input1_desc.dims.d[1];   // max token length
   const int32_t HiddenSize = input1_desc.dims.d[2];  // hidden size
 
@@ -345,7 +345,7 @@ int TransformerOutputConvertPlugin::enqueue(
   const dim3 num_blocks(
       B,
       MaxLength,
-      vector_length / num_threads);  //  batchs, max sequnce length
+      vector_length / num_threads);  //  batches, max sequnce length
                                      //  (mask_id.dims.d[1]),
                                      //  input.dims.d[1]/*
   recover_padding_kernel<<<num_blocks, num_threads, 0, stream>>>(
diff --git a/paddle/fluid/operators/dlnne/dlnne_engine_op.h b/paddle/fluid/operators/dlnne/dlnne_engine_op.h
@@ -441,7 +441,7 @@ class DlnneEngineOp : public framework::OperatorBase {
             first_batch,
             batch,
             platform::errors::Unavailable(
-                "compute infer_batchs is different from each other"));
+                "compute infer_batches is different from each other"));
       }
       infer_batch = first_batch;
     }
diff --git a/paddle/phi/kernels/fusion/cpu/self_dp_attention_kernel.cc b/paddle/phi/kernels/fusion/cpu/self_dp_attention_kernel.cc
@@ -44,8 +44,8 @@ void arraycpy(T* dst, const Tt* src, int n) {
   }
 }
 
-// batchs x tokens x 3 x head x heads ->  3 x batchs x head x tokens x heads (2
-// 0 3 1 4)
+// batches x tokens x 3 x head x heads ->  3 x batches x head x tokens x heads
+// (2 0 3 1 4)
 template <typename T, typename Tt>
 void transpose_before_bmm1(const T* qkvBuffer,
                            Tt* qkvTransBuffer,
@@ -108,7 +108,7 @@ void transpose_before_bmm1(const T* qkvBuffer,
   }
 }
 
-// batchs x head x tokens x heads -> batchs x tokens x head x heads (0 2 1 3)
+// batches x head x tokens x heads -> batches x tokens x head x heads (0 2 1 3)
 template <typename T, typename Tt>
 void transpose_after_bmm2(T* Buffer,
                           Tt* TransBuffer,
diff --git a/paddle/phi/kernels/sparse/cpu/sparse_utils_kernel.cc b/paddle/phi/kernels/sparse/cpu/sparse_utils_kernel.cc
@@ -182,10 +182,10 @@ void CooToCsrCPUKernel(const CPUContext& dev_ctx,
                         "SparseCsrTensor only support 2-D or 3-D matrix"));
   const int64_t non_zero_num = x.nnz();
 
-  int batchs = static_cast<int>(x_dims.size() == 2 ? 1 : x_dims[0]);
+  int batches = static_cast<int>(x_dims.size() == 2 ? 1 : x_dims[0]);
   int rows = static_cast<int>(x_dims.size() == 2 ? x_dims[0] : x_dims[1]);
 
-  phi::DenseTensor crows = phi::Empty<IntT>(dev_ctx, {batchs * (rows + 1)});
+  phi::DenseTensor crows = phi::Empty<IntT>(dev_ctx, {batches * (rows + 1)});
   phi::DenseTensor cols = phi::Empty<IntT>(dev_ctx, {non_zero_num});
   phi::DenseTensor values = phi::EmptyLike<T, CPUContext>(dev_ctx, x.values());
   if (non_zero_num <= 0) {
@@ -198,18 +198,18 @@ void CooToCsrCPUKernel(const CPUContext& dev_ctx,
 
   const auto& coo_indices = x.indices();
   const auto& coo_values = x.values();
-  const IntT* batchs_ptr = coo_indices.data<IntT>();
+  const IntT* batches_ptr = coo_indices.data<IntT>();
   const IntT* coo_rows_data =
-      x_dims.size() == 2 ? batchs_ptr : batchs_ptr + non_zero_num;
+      x_dims.size() == 2 ? batches_ptr : batches_ptr + non_zero_num;
   const IntT* coo_cols_data = coo_rows_data + non_zero_num;
   const T* coo_values_data = coo_values.data<T>();
 
-  std::vector<int64_t> offsets(batchs, 0);
-  if (batchs > 1) {
+  std::vector<int64_t> offsets(batches, 0);
+  if (batches > 1) {
     for (int i = 0; i < non_zero_num; i++) {
-      if (i == non_zero_num - 1 || batchs_ptr[i] != batchs_ptr[i + 1]) {
-        const int start = batchs_ptr[i];
-        const int end = i == non_zero_num - 1 ? batchs : batchs_ptr[i + 1];
+      if (i == non_zero_num - 1 || batches_ptr[i] != batches_ptr[i + 1]) {
+        const int start = batches_ptr[i];
+        const int end = i == non_zero_num - 1 ? batches : batches_ptr[i + 1];
         for (int j = start; j < end; j++) {
           offsets[j] = i + 1;
         }
@@ -219,7 +219,7 @@ void CooToCsrCPUKernel(const CPUContext& dev_ctx,
     offsets[0] = non_zero_num;
   }
 
-  for (int b = 0; b < batchs; b++) {
+  for (int b = 0; b < batches; b++) {
     int batch_start = 0;
     int batch_non_zero_num = static_cast<int>(offsets[b]);
     if (b > 0) {
diff --git a/paddle/phi/kernels/sparse/gpu/sparse_utils_kernel.cu b/paddle/phi/kernels/sparse/gpu/sparse_utils_kernel.cu
@@ -185,10 +185,10 @@ void DenseToCooKernel(const Context& dev_ctx,
 template <typename IntT>
 __global__ void GetBatchSizes(const IntT* crows,
                               const int rows,
-                              const int batchs,
+                              const int batches,
                               IntT* batch_sizes) {
   const int tid = threadIdx.x + blockIdx.x * blockDim.x;
-  if (tid < batchs) {
+  if (tid < batches) {
     batch_sizes[tid] = crows[tid * (rows + 1) + rows];
   }
 }
@@ -339,35 +339,35 @@ void CsrToCooKernel(const Context& dev_ctx,
 }
 
 template <typename IntT>
-__global__ void GetBatchsOffset(const IntT* batchs_ptr,
-                                const int batchs,
-                                const int non_zero_num,
-                                int* batchs_offset) {
+__global__ void GetBatchesOffset(const IntT* batches_ptr,
+                                 const int batches,
+                                 const int non_zero_num,
+                                 int* batches_offset) {
   int tid = threadIdx.x + blockIdx.x * blockDim.x;
   for (int i = tid; i < non_zero_num; i += gridDim.x * blockDim.x) {
-    if (i == non_zero_num - 1 || batchs_ptr[i] != batchs_ptr[i + 1]) {
-      const int start = batchs_ptr[i];
-      const int end = i == non_zero_num - 1 ? batchs : batchs_ptr[i + 1];
+    if (i == non_zero_num - 1 || batches_ptr[i] != batches_ptr[i + 1]) {
+      const int start = batches_ptr[i];
+      const int end = i == non_zero_num - 1 ? batches : batches_ptr[i + 1];
       for (int j = start; j < end; j++) {
-        batchs_offset[j] = i + 1;
+        batches_offset[j] = i + 1;
       }
     }
   }
 }
 
 template <typename IntT>
 __global__ void ConvertCooRowsToCsrCrows(
-    const int* batchs_offset,  // can be null if batchs = 1
+    const int* batches_offset,  // can be null if batches = 1
     const IntT* coo_rows_data,
     IntT* csr_crows_data,
     const int rows,
     const int64_t non_zero_num) {
   const int b = blockIdx.y;
   int batch_non_zero_num =
-      batchs_offset == nullptr ? non_zero_num : batchs_offset[b];
+      batches_offset == nullptr ? non_zero_num : batches_offset[b];
   IntT batch_start = 0;
   if (b > 0) {
-    batch_start = batchs_offset[b - 1];
+    batch_start = batches_offset[b - 1];
     batch_non_zero_num -= batch_start;
   }
 
@@ -409,10 +409,10 @@ void CooToCsrGPUKernel(const GPUContext& dev_ctx,
                         "SparseCsrTensor only support 2-D or 3-D matrix"));
   const int64_t non_zero_num = x.nnz();
 
-  int batchs = x_dims.size() == 2 ? 1 : x_dims[0];
+  int batches = x_dims.size() == 2 ? 1 : x_dims[0];
   int rows = x_dims.size() == 2 ? x_dims[0] : x_dims[1];
 
-  phi::DenseTensor crows = phi::Empty<IntT>(dev_ctx, {batchs * (rows + 1)});
+  phi::DenseTensor crows = phi::Empty<IntT>(dev_ctx, {batches * (rows + 1)});
   phi::DenseTensor cols = phi::Empty<IntT>(dev_ctx, {non_zero_num});
   phi::DenseTensor values = phi::EmptyLike<T, GPUContext>(dev_ctx, x.values());
   if (non_zero_num <= 0) {
@@ -425,33 +425,33 @@ void CooToCsrGPUKernel(const GPUContext& dev_ctx,
 
   const auto& coo_indices = x.indices();
   const auto& coo_values = x.values();
-  const IntT* batchs_ptr = coo_indices.data<IntT>();
+  const IntT* batches_ptr = coo_indices.data<IntT>();
   const IntT* coo_rows_data =
-      x_dims.size() == 2 ? batchs_ptr : batchs_ptr + non_zero_num;
+      x_dims.size() == 2 ? batches_ptr : batches_ptr + non_zero_num;
   const IntT* coo_cols_data = coo_rows_data + non_zero_num;
   const T* coo_values_data = coo_values.data<T>();
 
-  auto config = phi::backends::gpu::GetGpuLaunchConfig1D(dev_ctx, batchs, 1);
-  if (batchs > 1) {
+  auto config = phi::backends::gpu::GetGpuLaunchConfig1D(dev_ctx, batches, 1);
+  if (batches > 1) {
     auto config =
         phi::backends::gpu::GetGpuLaunchConfig1D(dev_ctx, non_zero_num, 1);
-    phi::DenseTensor batchs_offset = phi::Empty<int>(dev_ctx, {batchs});
-    int* batchs_offset_ptr = batchs_offset.data<int>();
+    phi::DenseTensor batches_offset = phi::Empty<int>(dev_ctx, {batches});
+    int* batches_offset_ptr = batches_offset.data<int>();
     phi::funcs::SetConstant<GPUContext, int> set_zero;
-    // set zero if the nnz=0 of batchs[0]
-    set_zero(dev_ctx, &batchs_offset, static_cast<IntT>(0));
-    GetBatchsOffset<IntT><<<config.block_per_grid.x,
-                            config.thread_per_block.x,
-                            0,
-                            dev_ctx.stream()>>>(
-        batchs_ptr, batchs, non_zero_num, batchs_offset_ptr);
-
-    config.block_per_grid.y = batchs;
+    // set zero if the nnz=0 of batches[0]
+    set_zero(dev_ctx, &batches_offset, static_cast<IntT>(0));
+    GetBatchesOffset<IntT><<<config.block_per_grid.x,
+                             config.thread_per_block.x,
+                             0,
+                             dev_ctx.stream()>>>(
+        batches_ptr, batches, non_zero_num, batches_offset_ptr);
+
+    config.block_per_grid.y = batches;
     ConvertCooRowsToCsrCrows<IntT><<<config.block_per_grid,
                                      config.thread_per_block.x,
                                      0,
                                      dev_ctx.stream()>>>(
-        batchs_offset_ptr, coo_rows_data, csr_crows_data, rows, non_zero_num);
+        batches_offset_ptr, coo_rows_data, csr_crows_data, rows, non_zero_num);
   } else {
     ConvertCooRowsToCsrCrows<IntT><<<config.block_per_grid.x,
                                      config.thread_per_block.x,
diff --git a/test/amp/test_amp_master_grad.py b/test/amp/test_amp_master_grad.py
diff --git a/test/collective/fleet/hybrid_parallel_mp_model.py b/test/collective/fleet/hybrid_parallel_mp_model.py
diff --git a/test/collective/fleet/hybrid_parallel_mp_model_with_sequence_parallel.py b/test/collective/fleet/hybrid_parallel_mp_model_with_sequence_parallel.py
diff --git a/test/legacy_test/test_sparse_utils_op.py b/test/legacy_test/test_sparse_utils_op.py

Original file line number	Diff line number	Diff line change
`@@ -441,7 +441,7 @@ class DlnneEngineOp : public framework::OperatorBase {`
`441`	`441`	`first_batch,`
`442`	`442`	`batch,`
`443`	`443`	`platform::errors::Unavailable(`
`444`		`- "compute infer_batchs is different from each other"));`
	`444`	`+ "compute infer_batches is different from each other"));`
`445`	`445`	`}`
`446`	`446`	`infer_batch = first_batch;`
`447`	`447`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,8 +44,8 @@ void arraycpy(T* dst, const Tt* src, int n) {`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`47`		`-// batchs x tokens x 3 x head x heads -> 3 x batchs x head x tokens x heads (2`
`48`		`-// 0 3 1 4)`
	`47`	`+// batches x tokens x 3 x head x heads -> 3 x batches x head x tokens x heads`
	`48`	`+// (2 0 3 1 4)`
`49`	`49`	`template <typename T, typename Tt>`
`50`	`50`	`void transpose_before_bmm1(const T* qkvBuffer,`
`51`	`51`	`Tt* qkvTransBuffer,`
`@@ -108,7 +108,7 @@ void transpose_before_bmm1(const T* qkvBuffer,`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`111`		`-// batchs x head x tokens x heads -> batchs x tokens x head x heads (0 2 1 3)`
	`111`	`+// batches x head x tokens x heads -> batches x tokens x head x heads (0 2 1 3)`
`112`	`112`	`template <typename T, typename Tt>`
`113`	`113`	`void transpose_after_bmm2(T* Buffer,`
`114`	`114`	`Tt* TransBuffer,`