Fix formated_axis formatted_axis, etc (#62308)

co63oc · web-flow · commit abf2116a4a9b · 2024-03-04T15:55:42.000+08:00
diff --git a/paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/infer_sym_utils.cc b/paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/infer_sym_utils.cc
@@ -35,18 +35,18 @@ bool ReduceInferDim(pir::Operation *op,
   auto x = op->operand_source(0);
   int x_rank = x.type().dyn_cast<pir::DenseTensorType>().dims().size();
 
-  const std::vector<int64_t> formated_axis = [&] {
-    std::vector<int64_t> formated_axis = axis;
+  const std::vector<int64_t> formatted_axis = [&] {
+    std::vector<int64_t> formatted_axis = axis;
     for (size_t i = 0; i < axis.size(); ++i) {
       if (axis[i] < 0) {
-        formated_axis[i] = axis[i] + x_rank;
+        formatted_axis[i] = axis[i] + x_rank;
       }
     }
-    return formated_axis;
+    return formatted_axis;
   }();
 
   bool full_dim = true;
-  std::set<int64_t> dims_set(formated_axis.begin(), formated_axis.end());
+  std::set<int64_t> dims_set(formatted_axis.begin(), formatted_axis.end());
   for (int64_t i = 0; i < x_rank; ++i) {
     if (dims_set.find(i) == dims_set.end()) {
       full_dim = false;
diff --git a/paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/paddle_op_infer_sym.cc b/paddle/fluid/pir/dialect/operator/interface/infer_symbolic_shape/paddle_op_infer_sym.cc
@@ -848,7 +848,7 @@ bool TransposeOpInferSymbolicShape(
 
   int x_rank = x_dims.size();
 
-  const std::vector<int32_t> formated_axis = [op, x_rank, &perm] {
+  const std::vector<int32_t> formatted_axis = [op, x_rank, &perm] {
     std::vector<int32_t> out(perm.size(), 0);
     std::transform(perm.begin(),
                    perm.end(),
@@ -866,11 +866,11 @@ bool TransposeOpInferSymbolicShape(
     return out;
   }();
 
-  int axis_size = static_cast<int>(formated_axis.size());
+  int axis_size = static_cast<int>(formatted_axis.size());
 
   std::vector<symbol::DimExpr> out_dims(x_dims);
   for (int i = 0; i < axis_size; ++i) {
-    out_dims[i] = x_dims[formated_axis[i]];
+    out_dims[i] = x_dims[formatted_axis[i]];
   }
 
   shape_analysis->SetShapeOrDataForValue(op->result(0),
diff --git a/paddle/phi/infermeta/backward.cc b/paddle/phi/infermeta/backward.cc
@@ -1180,16 +1180,16 @@ void TransposeGradInferMeta(const MetaTensor& x,
                             const std::vector<int>& axis,
                             MetaTensor* out) {
   size_t x_rank = x.dims().size();
-  std::vector<int> formated_axis = axis;
+  std::vector<int> formatted_axis = axis;
   for (size_t i = 0; i < axis.size(); i++) {
     if (axis[i] < 0) {
-      formated_axis[i] = static_cast<int>(axis[i] + x_rank);
+      formatted_axis[i] = static_cast<int>(axis[i] + x_rank);
     }
   }
 
   std::vector<int> reversed_axis(axis);
-  for (int i = 0; i < static_cast<int>(formated_axis.size()); i++) {
-    reversed_axis[formated_axis[i]] = i;
+  for (int i = 0; i < static_cast<int>(formatted_axis.size()); i++) {
+    reversed_axis[formatted_axis[i]] = i;
   }
 
   TransposeInferMeta(x, reversed_axis, out);
diff --git a/paddle/phi/infermeta/unary.cc b/paddle/phi/infermeta/unary.cc
@@ -2584,7 +2584,7 @@ void NanmedianInferMeta(const MetaTensor& x,
       }
     }
   } else {
-    std::vector<int64_t> formated_axis;
+    std::vector<int64_t> formatted_axis;
     for (auto& axis : axis_list) {
       if (x_rank == 0) {
         PADDLE_ENFORCE_EQ(axis == 0 || axis == -1,
@@ -2612,17 +2612,17 @@ void NanmedianInferMeta(const MetaTensor& x,
       }
       if (axis < 0) axis += x_rank;
       PADDLE_ENFORCE_EQ(
-          std::find(formated_axis.begin(), formated_axis.end(), axis),
-          formated_axis.end(),
+          std::find(formatted_axis.begin(), formatted_axis.end(), axis),
+          formatted_axis.end(),
           errors::InvalidArgument("Attr(axes) has duplicated elements: %d.",
                                   static_cast<int>(axis)));
 
-      formated_axis.push_back(axis);
+      formatted_axis.push_back(axis);
     }
 
     for (int64_t i = 0; i < x_rank; i++) {
-      if (std::find(formated_axis.begin(), formated_axis.end(), i) ==
-          formated_axis.end()) {
+      if (std::find(formatted_axis.begin(), formatted_axis.end(), i) ==
+          formatted_axis.end()) {
         out_dim.push_back(x_dim[i]);  // NOLINT
       } else if (keep_dim) {
         out_dim.push_back(1);
@@ -3382,7 +3382,7 @@ DDim ReduceInferDim(const MetaTensor& x,
                     bool reduce_all) {
   int x_rank = x.dims().size();
 
-  std::vector<int64_t> formated_axis = axis;
+  std::vector<int64_t> formatted_axis = axis;
   for (size_t i = 0; i < axis.size(); ++i) {
     if (x_rank == 0) {
       PADDLE_ENFORCE_EQ(
@@ -3414,12 +3414,12 @@ DDim ReduceInferDim(const MetaTensor& x,
     }
 
     if (axis[i] < 0) {
-      formated_axis[i] = axis[i] + x_rank;
+      formatted_axis[i] = axis[i] + x_rank;
     }
   }
 
   bool full_dim = true;
-  std::set<int64_t> dims_set(formated_axis.begin(), formated_axis.end());
+  std::set<int64_t> dims_set(formatted_axis.begin(), formatted_axis.end());
   for (int64_t i = 0; i < x_rank; ++i) {
     if (dims_set.find(i) == dims_set.end()) {
       full_dim = false;
@@ -4148,7 +4148,7 @@ void SplitWithNumInferMeta(const MetaTensor& x,
     }
   } else {
     auto input_axis_dim = x.dims().at(axis_value);
-    // step1: get formated sections
+    // step1: get formatted sections
     std::vector<int64_t> sections_vec;
     PADDLE_ENFORCE_NE(
         num,
@@ -4757,7 +4757,7 @@ void TransposeInferMeta(const MetaTensor& x,
                         x_rank,
                         axis_size));
 
-  std::vector<int> formated_axis = axis;
+  std::vector<int> formatted_axis = axis;
   std::vector<int> count(axis_size, 0);
   for (int i = 0; i < axis_size; i++) {
     PADDLE_ENFORCE_LT(axis[i],
@@ -4780,10 +4780,10 @@ void TransposeInferMeta(const MetaTensor& x,
                           axis[i]));
 
     if (axis[i] < 0) {
-      formated_axis[i] = axis[i] + x_rank;
+      formatted_axis[i] = axis[i] + x_rank;
     }
     PADDLE_ENFORCE_EQ(
-        ++count[formated_axis[i]],
+        ++count[formatted_axis[i]],
         1,
         errors::InvalidArgument("Each element of axis should be unique. but "
                                 "axis[%d] is %d appear not only once",
@@ -4793,7 +4793,7 @@ void TransposeInferMeta(const MetaTensor& x,
 
   phi::DDim out_dims(x_dims);
   for (int i = 0; i < axis_size; ++i) {
-    out_dims[i] = x_dims[formated_axis[i]];
+    out_dims[i] = x_dims[formatted_axis[i]];
   }
 
   out->set_dims(out_dims);
diff --git a/paddle/phi/kernels/cpu/transpose_kernel.cc b/paddle/phi/kernels/cpu/transpose_kernel.cc
@@ -29,50 +29,50 @@ void TransposeKernel(const Context& ctx,
                      const std::vector<int>& axis,
                      DenseTensor* out) {
   size_t x_rank = x.dims().size();
-  std::vector<int> formated_axis = axis;
+  std::vector<int> formatted_axis = axis;
   for (size_t i = 0; i < axis.size(); i++) {
     if (axis[i] < 0) {
-      formated_axis[i] = static_cast<int>(axis[i] + x_rank);
+      formatted_axis[i] = static_cast<int>(axis[i] + x_rank);
     }
   }
 
   ctx.template Alloc<T>(out);
   if (out->numel() == 0) {
     return;
   }
-  int rank = static_cast<int>(formated_axis.size());
+  int rank = static_cast<int>(formatted_axis.size());
   switch (rank) {
     case 0:
       phi::Copy<Context>(ctx, x, ctx.GetPlace(), false, out);
       break;
     case 1:
       funcs::Transpose<Context, T, 1> trans1;
-      trans1(ctx, x, out, formated_axis);
+      trans1(ctx, x, out, formatted_axis);
       break;
     case 2:
       funcs::Transpose<Context, T, 2> trans2;
-      trans2(ctx, x, out, formated_axis);
+      trans2(ctx, x, out, formatted_axis);
       break;
     case 3:
       funcs::Transpose<Context, T, 3> trans3;
-      trans3(ctx, x, out, formated_axis);
+      trans3(ctx, x, out, formatted_axis);
       break;
     case 4:
       funcs::Transpose<Context, T, 4> trans4;
-      trans4(ctx, x, out, formated_axis);
+      trans4(ctx, x, out, formatted_axis);
       break;
     case 5:
       funcs::Transpose<Context, T, 5> trans5;
-      trans5(ctx, x, out, formated_axis);
+      trans5(ctx, x, out, formatted_axis);
       break;
     case 6:
       funcs::Transpose<Context, T, 6> trans6;
-      trans6(ctx, x, out, formated_axis);
+      trans6(ctx, x, out, formatted_axis);
       break;
     default:
       // for rank >= 7 situation
       funcs::TransposeNormal<Context, T> trans_normal;
-      trans_normal(ctx, x, out, formated_axis);
+      trans_normal(ctx, x, out, formatted_axis);
   }
 }
 
diff --git a/paddle/phi/kernels/fusion/onednn/fused_transpose_kernel.cc b/paddle/phi/kernels/fusion/onednn/fused_transpose_kernel.cc
@@ -69,11 +69,11 @@ void FusedTransposeKernel(const Context& dev_ctx,
       (phi::OneDNNContext::tls().get_cur_paddle_data_layout() ==
        phi::DataLayout::kNHWC)) {
     int axis_size = static_cast<int>(axis.size());
-    std::vector<int> formated_axis = axis;
+    std::vector<int> formatted_axis = axis;
     std::vector<int> count(axis_size, 0);
     for (int i = 0; i < axis_size; i++) {
       if (axis[i] < 0) {
-        formated_axis[i] = axis[i] + axis_size;
+        formatted_axis[i] = axis[i] + axis_size;
       }
     }
     auto dims = common::vectorize<int>(x_dims);
@@ -85,7 +85,7 @@ void FusedTransposeKernel(const Context& dev_ctx,
 
     phi::DDim out_dims(x_dims);
     for (size_t i = 0; i < axis.size(); i++) {
-      out_dims[i] = x_dims[formated_axis[i]];  // NOLINT
+      out_dims[i] = x_dims[formatted_axis[i]];  // NOLINT
     }
     out->Resize(out_dims);
   }
diff --git a/paddle/phi/kernels/gpu/transpose_kernel.cu b/paddle/phi/kernels/gpu/transpose_kernel.cu
@@ -31,22 +31,22 @@ void TransposeKernel(const Context& ctx,
                      const std::vector<int>& axis,
                      DenseTensor* out) {
   size_t x_rank = x.dims().size();
-  std::vector<int> formated_axis = axis;
+  std::vector<int> formatted_axis = axis;
   for (size_t i = 0; i < axis.size(); i++) {
     if (axis[i] < 0) {
-      formated_axis[i] = axis[i] + x_rank;
+      formatted_axis[i] = axis[i] + x_rank;
     }
   }
 
   ctx.template Alloc<T>(out);
   if (out->numel() == 0) {
     return;
   }
-  if (formated_axis.size() == 0) {
+  if (formatted_axis.size() == 0) {
     phi::Copy<Context>(ctx, x, ctx.GetPlace(), false, out);
     return;
   }
-  phi::funcs::TransposeGPUKernelDriver<T>(ctx, x, formated_axis, out);
+  phi::funcs::TransposeGPUKernelDriver<T>(ctx, x, formatted_axis, out);
 }
 
 }  // namespace phi
diff --git a/paddle/phi/kernels/impl/transpose_grad_kernel_impl.h b/paddle/phi/kernels/impl/transpose_grad_kernel_impl.h
@@ -26,17 +26,17 @@ void TransposeGradKernel(const Context& dev_ctx,
                          const std::vector<int>& axis,
                          DenseTensor* x_grad) {
   size_t axis_size = axis.size();
-  std::vector<int> formated_axis = axis;
+  std::vector<int> formatted_axis = axis;
   for (size_t i = 0; i < axis_size; i++) {
     if (axis[i] < 0) {
-      formated_axis[i] = axis[i] + axis_size;
+      formatted_axis[i] = axis[i] + axis_size;
     }
   }
 
   std::vector<int> reversed_axis(axis);
   dev_ctx.template Alloc<T>(x_grad);
   for (size_t i = 0; i < axis_size; i++) {
-    reversed_axis[formated_axis[i]] = i;
+    reversed_axis[formatted_axis[i]] = i;
   }
 
   TransposeKernel<T, Context>(dev_ctx, out_grad, reversed_axis, x_grad);
diff --git a/paddle/phi/kernels/onednn/transpose_kernel.cc b/paddle/phi/kernels/onednn/transpose_kernel.cc
@@ -33,11 +33,11 @@ void TransposeKernel(const Context& dev_ctx,
       (phi::OneDNNContext::tls().get_cur_paddle_data_layout() ==
        phi::DataLayout::kNHWC)) {
     int axis_size = static_cast<int>(axis.size());
-    std::vector<int> formated_axis = axis;
+    std::vector<int> formatted_axis = axis;
     std::vector<int> count(axis_size, 0);
     for (int i = 0; i < axis_size; i++) {
       if (axis[i] < 0) {
-        formated_axis[i] = axis[i] + axis_size;
+        formatted_axis[i] = axis[i] + axis_size;
       }
     }
     auto dims = common::vectorize<int>(x_dims);
@@ -49,7 +49,7 @@ void TransposeKernel(const Context& dev_ctx,
 
     phi::DDim out_dims(x_dims);
     for (size_t i = 0; i < axis.size(); i++) {
-      out_dims[i] = x_dims[formated_axis[i]];  // NOLINT
+      out_dims[i] = x_dims[formatted_axis[i]];  // NOLINT
     }
     out->Resize(out_dims);
   }
diff --git a/paddle/phi/kernels/stride/transpose_grad_kernel.cc b/paddle/phi/kernels/stride/transpose_grad_kernel.cc
@@ -25,16 +25,16 @@ void TransposeGradStridedKernel(const Context& dev_ctx,
                                 const std::vector<int>& axis,
                                 DenseTensor* x_grad) {
   size_t axis_size = axis.size();
-  std::vector<int> formated_axis = axis;
+  std::vector<int> formatted_axis = axis;
   for (size_t i = 0; i < axis_size; i++) {
     if (axis[i] < 0) {
-      formated_axis[i] = static_cast<int>(axis[i] + axis_size);
+      formatted_axis[i] = static_cast<int>(axis[i] + axis_size);
     }
   }
 
   std::vector<int> reversed_axis(axis);
   for (int i = 0; i < static_cast<int>(axis_size); i++) {
-    reversed_axis[formated_axis[i]] = i;
+    reversed_axis[formatted_axis[i]] = i;
   }
 
   TransposeStridedKernel<Context>(dev_ctx, out_grad, reversed_axis, x_grad);
diff --git a/paddle/phi/kernels/stride/transpose_kernel.cc b/paddle/phi/kernels/stride/transpose_kernel.cc
@@ -24,18 +24,18 @@ void TransposeStridedKernel(const Context& ctx,
                             const std::vector<int>& axis,
                             DenseTensor* out) {
   size_t x_rank = x.dims().size();
-  std::vector<int> formated_axis = axis;
+  std::vector<int> formatted_axis = axis;
   for (size_t i = 0; i < axis.size(); i++) {
     if (axis[i] < 0) {
-      formated_axis[i] = static_cast<int>(axis[i] + x_rank);
+      formatted_axis[i] = static_cast<int>(axis[i] + x_rank);
     }
   }
 
   auto meta = out->meta();
   auto in_stride = x.strides();
   meta.strides = in_stride;
-  for (int i = 0; i < static_cast<int>(formated_axis.size()); i++) {
-    meta.strides[i] = in_stride[formated_axis[i]];
+  for (int i = 0; i < static_cast<int>(formatted_axis.size()); i++) {
+    meta.strides[i] = in_stride[formatted_axis[i]];
   }
   meta.offset = x.offset();
 
diff --git a/paddle/phi/kernels/xpu/flip_kernel.cc b/paddle/phi/kernels/xpu/flip_kernel.cc
@@ -26,17 +26,17 @@ void FlipKernel(const Context& dev_ctx,
                 DenseTensor* out) {
   using XPUInTDType = typename XPUTypeTrait<T>::Type;
   int x_rank = x.dims().size();
-  std::vector<int64_t> formated_axis(std::begin(axis), std::end(axis));
+  std::vector<int64_t> formatted_axis(std::begin(axis), std::end(axis));
   for (size_t i = 0; i < axis.size(); i++) {
     if (axis[i] < 0) {
-      formated_axis[i] = static_cast<int64_t>(axis[i] + x_rank);
+      formatted_axis[i] = static_cast<int64_t>(axis[i] + x_rank);
     }
   }
   dev_ctx.template Alloc<T>(out);
   if (out->numel() == 0) {
     return;
   }
-  if (formated_axis.size() == 0) {
+  if (formatted_axis.size() == 0) {
     phi::Copy<Context>(dev_ctx, x, dev_ctx.GetPlace(), false, out);
     return;
   }
@@ -52,7 +52,7 @@ void FlipKernel(const Context& dev_ctx,
       /* const T* x */ x_data,
       /* T* y */ out_data,
       /* const std::vector<int64_t>& xshape */ x_shape,
-      /* const std::vector<int64_t>& axis */ formated_axis);
+      /* const std::vector<int64_t>& axis */ formatted_axis);
   PADDLE_ENFORCE_XDNN_SUCCESS(r, "flip");
 }
 
diff --git a/paddle/phi/kernels/xpu/transpose_grad_kernel.cc b/paddle/phi/kernels/xpu/transpose_grad_kernel.cc
diff --git a/paddle/phi/kernels/xpu/transpose_kernel.cc b/paddle/phi/kernels/xpu/transpose_kernel.cc
diff --git a/python/paddle/jit/dy2static/error.py b/python/paddle/jit/dy2static/error.py
diff --git a/python/paddle/jit/dy2static/origin_info.py b/python/paddle/jit/dy2static/origin_info.py

Original file line number	Diff line number	Diff line change
`@@ -1180,16 +1180,16 @@ void TransposeGradInferMeta(const MetaTensor& x,`
`1180`	`1180`	`const std::vector<int>& axis,`
`1181`	`1181`	`MetaTensor* out) {`
`1182`	`1182`	`size_t x_rank = x.dims().size();`
`1183`		`- std::vector<int> formated_axis = axis;`
	`1183`	`+ std::vector<int> formatted_axis = axis;`
`1184`	`1184`	`for (size_t i = 0; i < axis.size(); i++) {`
`1185`	`1185`	`if (axis[i] < 0) {`
`1186`		`- formated_axis[i] = static_cast<int>(axis[i] + x_rank);`
	`1186`	`+ formatted_axis[i] = static_cast<int>(axis[i] + x_rank);`
`1187`	`1187`	`}`
`1188`	`1188`	`}`
`1189`	`1189`
`1190`	`1190`	`std::vector<int> reversed_axis(axis);`
`1191`		`- for (int i = 0; i < static_cast<int>(formated_axis.size()); i++) {`
`1192`		`- reversed_axis[formated_axis[i]] = i;`
	`1191`	`+ for (int i = 0; i < static_cast<int>(formatted_axis.size()); i++) {`
	`1192`	`+ reversed_axis[formatted_axis[i]] = i;`
`1193`	`1193`	`}`
`1194`	`1194`
`1195`	`1195`	`TransposeInferMeta(x, reversed_axis, out);`
Original file line number	Diff line number	Diff line change
`@@ -69,11 +69,11 @@ void FusedTransposeKernel(const Context& dev_ctx,`
`69`	`69`	`(phi::OneDNNContext::tls().get_cur_paddle_data_layout() ==`
`70`	`70`	`phi::DataLayout::kNHWC)) {`
`71`	`71`	`int axis_size = static_cast<int>(axis.size());`
`72`		`- std::vector<int> formated_axis = axis;`
	`72`	`+ std::vector<int> formatted_axis = axis;`
`73`	`73`	`std::vector<int> count(axis_size, 0);`
`74`	`74`	`for (int i = 0; i < axis_size; i++) {`
`75`	`75`	`if (axis[i] < 0) {`
`76`		`- formated_axis[i] = axis[i] + axis_size;`
	`76`	`+ formatted_axis[i] = axis[i] + axis_size;`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`	`auto dims = common::vectorize<int>(x_dims);`
`@@ -85,7 +85,7 @@ void FusedTransposeKernel(const Context& dev_ctx,`
`85`	`85`
`86`	`86`	`phi::DDim out_dims(x_dims);`
`87`	`87`	`for (size_t i = 0; i < axis.size(); i++) {`
`88`		`- out_dims[i] = x_dims[formated_axis[i]]; // NOLINT`
	`88`	`+ out_dims[i] = x_dims[formatted_axis[i]]; // NOLINT`
`89`	`89`	`}`
`90`	`90`	`out->Resize(out_dims);`
`91`	`91`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,22 +31,22 @@ void TransposeKernel(const Context& ctx,`
`31`	`31`	`const std::vector<int>& axis,`
`32`	`32`	`DenseTensor* out) {`
`33`	`33`	`size_t x_rank = x.dims().size();`
`34`		`- std::vector<int> formated_axis = axis;`
	`34`	`+ std::vector<int> formatted_axis = axis;`
`35`	`35`	`for (size_t i = 0; i < axis.size(); i++) {`
`36`	`36`	`if (axis[i] < 0) {`
`37`		`- formated_axis[i] = axis[i] + x_rank;`
	`37`	`+ formatted_axis[i] = axis[i] + x_rank;`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`ctx.template Alloc<T>(out);`
`42`	`42`	`if (out->numel() == 0) {`
`43`	`43`	`return;`
`44`	`44`	`}`
`45`		`- if (formated_axis.size() == 0) {`
	`45`	`+ if (formatted_axis.size() == 0) {`
`46`	`46`	`phi::Copy<Context>(ctx, x, ctx.GetPlace(), false, out);`
`47`	`47`	`return;`
`48`	`48`	`}`
`49`		`- phi::funcs::TransposeGPUKernelDriver<T>(ctx, x, formated_axis, out);`
	`49`	`+ phi::funcs::TransposeGPUKernelDriver<T>(ctx, x, formatted_axis, out);`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`} // namespace phi`
Original file line number	Diff line number	Diff line change
`@@ -26,17 +26,17 @@ void TransposeGradKernel(const Context& dev_ctx,`
`26`	`26`	`const std::vector<int>& axis,`
`27`	`27`	`DenseTensor* x_grad) {`
`28`	`28`	`size_t axis_size = axis.size();`
`29`		`- std::vector<int> formated_axis = axis;`
	`29`	`+ std::vector<int> formatted_axis = axis;`
`30`	`30`	`for (size_t i = 0; i < axis_size; i++) {`
`31`	`31`	`if (axis[i] < 0) {`
`32`		`- formated_axis[i] = axis[i] + axis_size;`
	`32`	`+ formatted_axis[i] = axis[i] + axis_size;`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`std::vector<int> reversed_axis(axis);`
`37`	`37`	`dev_ctx.template Alloc<T>(x_grad);`
`38`	`38`	`for (size_t i = 0; i < axis_size; i++) {`
`39`		`- reversed_axis[formated_axis[i]] = i;`
	`39`	`+ reversed_axis[formatted_axis[i]] = i;`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`TransposeKernel<T, Context>(dev_ctx, out_grad, reversed_axis, x_grad);`
Original file line number	Diff line number	Diff line change
`@@ -33,11 +33,11 @@ void TransposeKernel(const Context& dev_ctx,`
`33`	`33`	`(phi::OneDNNContext::tls().get_cur_paddle_data_layout() ==`
`34`	`34`	`phi::DataLayout::kNHWC)) {`
`35`	`35`	`int axis_size = static_cast<int>(axis.size());`
`36`		`- std::vector<int> formated_axis = axis;`
	`36`	`+ std::vector<int> formatted_axis = axis;`
`37`	`37`	`std::vector<int> count(axis_size, 0);`
`38`	`38`	`for (int i = 0; i < axis_size; i++) {`
`39`	`39`	`if (axis[i] < 0) {`
`40`		`- formated_axis[i] = axis[i] + axis_size;`
	`40`	`+ formatted_axis[i] = axis[i] + axis_size;`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`	`auto dims = common::vectorize<int>(x_dims);`
`@@ -49,7 +49,7 @@ void TransposeKernel(const Context& dev_ctx,`
`49`	`49`
`50`	`50`	`phi::DDim out_dims(x_dims);`
`51`	`51`	`for (size_t i = 0; i < axis.size(); i++) {`
`52`		`- out_dims[i] = x_dims[formated_axis[i]]; // NOLINT`
	`52`	`+ out_dims[i] = x_dims[formatted_axis[i]]; // NOLINT`
`53`	`53`	`}`
`54`	`54`	`out->Resize(out_dims);`
`55`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,16 +25,16 @@ void TransposeGradStridedKernel(const Context& dev_ctx,`
`25`	`25`	`const std::vector<int>& axis,`
`26`	`26`	`DenseTensor* x_grad) {`
`27`	`27`	`size_t axis_size = axis.size();`
`28`		`- std::vector<int> formated_axis = axis;`
	`28`	`+ std::vector<int> formatted_axis = axis;`
`29`	`29`	`for (size_t i = 0; i < axis_size; i++) {`
`30`	`30`	`if (axis[i] < 0) {`
`31`		`- formated_axis[i] = static_cast<int>(axis[i] + axis_size);`
	`31`	`+ formatted_axis[i] = static_cast<int>(axis[i] + axis_size);`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`std::vector<int> reversed_axis(axis);`
`36`	`36`	`for (int i = 0; i < static_cast<int>(axis_size); i++) {`
`37`		`- reversed_axis[formated_axis[i]] = i;`
	`37`	`+ reversed_axis[formatted_axis[i]] = i;`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`TransposeStridedKernel<Context>(dev_ctx, out_grad, reversed_axis, x_grad);`