add max functor

Author: Zjq9409

paddle/phi/infermeta/binary.cc

@@ -688,53 +688,4 @@ void SigmoidCrossEntropyWithLogitsInferMeta(const MetaTensor& x,
  out->share_lod(x);
 }
 
-namespace detail {
-static DDim CheckAndGetOutputDim(const DDim& dim_x) {
- auto x_vec = phi::vectorize(dim_x);
- if (x_vec.size() == 2) {
- return phi::make_ddim({1});
- }
- x_vec.erase(x_vec.end() - 2, x_vec.end());
- return phi::make_ddim(x_vec);
-}
-} // namespace detail
-
-// void MatrixRankTolMeta(const MetaTensor& x,
-// const MetaTensor& tol_tensor,
-// bool use_default_tol,
-// bool hermitian,
-// MetaTensor* out){
-// auto dim_x = x.dims();
-// PADDLE_ENFORCE_GE(dim_x.size(), 2,
-// phi::errors::InvalidArgument(
-// "The dims of input must be greater than 2"));
-
-// if (hermitian) {
-// int rows = dim_x[dim_x.size() - 2];
-// int cols = dim_x[dim_x.size() - 1];
-// PADDLE_ENFORCE_EQ(rows, cols,
-// phi::errors::InvalidArgument(
-// "if hermitian == true, matrix should be n*n"));
-// }
-
-// DDim dim_x_batch = detail::CheckAndGetOutputDim(dim_x);
-// auto dim_tol = tol_tensor.dims();
-// if (dim_x_batch == dim_tol) {
-// out->set_dims(dim_x_batch);
-// } else {
-// int max_dim = std::max(dim_x_batch.size(), dim_tol.size());
-// int axis = std::abs(dim_x_batch.size() - dim_tol.size());
-// std::vector<int> x_batch_dims_array(max_dim);
-// std::vector<int> tol_dims_array(max_dim);
-// std::vector<int> out_dims_array(max_dim);
-// funcs::GetBroadcastDimsArrays(dim_x_batch, dim_tol,
-// x_batch_dims_array.data(),
-// tol_dims_array.data(), out_dims_array.data(),
-// max_dim, axis);
-// out->set_dims(phi::make_ddim(out_dims_array));
-// }
-// out->set_dtype(x.dtype());
-// out->share_lod(x);
-// }
-
 } // namespace phi

paddle/phi/infermeta/binary.h

@@ -118,10 +118,4 @@ void SigmoidCrossEntropyWithLogitsInferMeta(const MetaTensor& x,
  MetaTensor* out,
  MetaConfig config = MetaConfig());
 
-void MatrixRankTolMeta(const MetaTensor& x,
- const MetaTensor& tol_tensor,
- bool use_default_tol,
- bool hermitian,
- MetaTensor* out);
-
 } // namespace phi

paddle/phi/infermeta/unary.cc

@@ -1106,43 +1106,6 @@ void TransposeInferMeta(const MetaTensor& x,
  out->set_dtype(x.dtype());
 }
 
-namespace detail {
-static DDim CheckAndGetOutputDim(const DDim& dim_x) {
- auto x_vec = phi::vectorize(dim_x);
- if (x_vec.size() == 2) {
- return phi::make_ddim({1});
- }
- x_vec.erase(x_vec.end() - 2, x_vec.end());
- return phi::make_ddim(x_vec);
-}
-} // namespace detail
-
-void MatrixRankMeta(const MetaTensor& x,
- bool use_default_tol,
- bool hermitian,
- float tol,
- MetaTensor* out) {
- auto dim_x = x.dims();
- PADDLE_ENFORCE_GE(
- dim_x.size(),
- 2,
- phi::errors::InvalidArgument("The dims of input must be greater than 2"));
-
- if (hermitian) {
- int rows = dim_x[dim_x.size() - 2];
- int cols = dim_x[dim_x.size() - 1];
- PADDLE_ENFORCE_EQ(rows,
- cols,
- phi::errors::InvalidArgument(
- "if hermitian == true, matrix should be n*n"));
- }
-
- DDim dim_x_batch = detail::CheckAndGetOutputDim(dim_x);
- out->set_dims(dim_x_batch);
- out->set_dtype(x.dtype());
- out->share_lod(x);
-}
-
 } // namespace phi
 
 PD_REGISTER_INFER_META_FN(copy_to, phi::CopyToInferMeta);

paddle/phi/infermeta/unary.h

@@ -161,10 +161,4 @@ void TransposeInferMeta(const MetaTensor& x,
  const std::vector<int>& axis,
  MetaTensor* out);
 
-void MatrixRankMeta(const MetaTensor& x,
- bool use_default_tol,
- bool hermitian,
- float tol,
- MetaTensor* out);
-
 } // namespace phi

paddle/phi/kernels/cpu/matrix_rank_kernel.cc

@@ -21,9 +21,9 @@ namespace phi {
 template <typename T, typename Context>
 void MatrixRankKernel(const Context& dev_ctx,
  const DenseTensor& x,
- bool hermitian,
- bool use_default_tol,
  float tol,
+ bool use_default_tol,
+ bool hermitian,
  DenseTensor* out) {
  DenseTensor atol_tensor;
  if (use_default_tol) {
@@ -34,7 +34,7 @@ void MatrixRankKernel(const Context& dev_ctx,
  std::vector<T>{tol}, dev_ctx, &atol_tensor);
  }
  MatrixRankTolKernel<T, Context>(
- dev_ctx, x, atol_tensor, hermitian, use_default_tol, out);
+ dev_ctx, x, atol_tensor, use_default_tol, hermitian, out);
 }
 
 } // namespace phi

paddle/phi/kernels/cpu/matrix_rank_tol_kernel.cc

@@ -84,15 +84,11 @@ template <typename T, typename Context>
 void MatrixRankTolKernel(const Context& dev_ctx,
  const DenseTensor& x,
  const DenseTensor& atol_tensor,
- bool hermitian,
  bool use_default_tol,
+ bool hermitian,
  DenseTensor* out) {
- // const Tensor* x = context.Input<Tensor>("X");
  auto* x_data = x.data<T>();
- // auto* out = context.Output<Tensor>("Out");
  dev_ctx.template Alloc<int64_t>(out);
- // out->mutable_data<int64_t>(context.GetPlace());
- // bool hermitian = context.Attr<bool>("hermitian");
 
  auto dim_x = x.dims();
  auto dim_out = out->dims();
@@ -103,47 +99,43 @@ void MatrixRankTolKernel(const Context& dev_ctx,
  int batches = numel / (rows * cols);
 
  T rtol_T = 0;
- // DenseTensor atol_dense_tensor;
- // DenseTensor temp_tensor;
+
  if (use_default_tol) {
- // atol_tensor = temp_tensor;
  rtol_T = std::numeric_limits<T>::epsilon() * std::max(rows, cols);
  }
 
  DenseTensor eigenvalue_tensor;
- // auto* eigenvalue_data = eigenvalue_tensor.mutable_data<T>(
- // detail::GetEigenvalueDim(dim_x, k), context.GetPlace());
  eigenvalue_tensor.Resize(detail::GetEigenvalueDim(dim_x, k));
  auto* eigenvalue_data = dev_ctx.template Alloc<T>(&eigenvalue_tensor);
+
  if (hermitian) {
  BatchEigenvalues<T>(x_data, eigenvalue_data, batches, rows, cols, k);
  } else {
  BatchSVD<T>(x_data, eigenvalue_data, batches, rows, cols, k);
  }
 
- // auto dito_T = math::DeviceIndependenceTensorOperations<
- // paddle::platform::CPUDeviceContext,
- // T>(context);
- std::vector<int> max_eigenvalue_shape =
- phi::vectorize<int>(detail::RemoveLastDim(eigenvalue_tensor.dims()));
  DenseTensor max_eigenvalue_tensor;
- // =
- // dito_T.ReduceMax(eigenvalue_tensor, max_eigenvalue_shape);
+ max_eigenvalue_tensor.Resize(detail::RemoveLastDim(eigenvalue_tensor.dims()));
+ dev_ctx.template Alloc<T>(&max_eigenvalue_tensor);
 
+ ReduceKernelImpl<Context, T, T, phi::funcs::MaxFunctor>(
+ dev_ctx,
+ eigenvalue_tensor,
+ &max_eigenvalue_tensor,
+ std::vector<int64_t>{-1},
+ false,
+ false);
  DenseTensor temp_rtol_tensor;
  paddle::framework::TensorFromVector<T>(std::vector<T>{rtol_T},
  &temp_rtol_tensor);
-
+ std::cout << "\n1111111111111\n";
  DenseTensor rtol_tensor =
  phi::Multiply<T>(dev_ctx, temp_rtol_tensor, max_eigenvalue_tensor);
- // DenseTensor rtol_tensor = dito_T.Mul(temp_rtol_tensor,
- // max_eigenvalue_tensor);
 
  DenseTensor tol_tensor;
  tol_tensor.Resize(detail::NewAxisDim(dim_out, k));
  dev_ctx.template Alloc<T>(&tol_tensor);
- // tol_tensor.mutable_data<T>(dim_out, context.GetPlace());
-
+ std::cout << "\n1111111111112\n";
  funcs::ElementwiseCompute<GreaterElementFunctor<T>, T, T>(
  dev_ctx,
  atol_tensor,
@@ -156,10 +148,8 @@ void MatrixRankTolKernel(const Context& dev_ctx,
 
  DenseTensor compare_result;
  compare_result.Resize(detail::NewAxisDim(dim_out, k));
- dev_ctx.template Alloc<T>(&compare_result);
- // compare_result.mutable_data<int64_t>(detail::NewAxisDim(dim_out, k),
- // context.GetPlace());
-
+ dev_ctx.template Alloc<int64_t>(&compare_result);
+ std::cout << "\n1111111111113\n";
  int axis = -1;
  if (eigenvalue_tensor.dims().size() >= tol_tensor.dims().size()) {
  funcs::ElementwiseCompute<funcs::GreaterThanFunctor<T, int64_t>, T, int>(
@@ -177,13 +167,29 @@ void MatrixRankTolKernel(const Context& dev_ctx,
  axis,
  funcs::LessThanFunctor<T, int64_t>(),
  &compare_result);
-
- std::vector<int64_t> result_shape = phi::vectorize<int64_t>(dim_out);
- DenseTensor result;
- ReduceKernelImpl<Context, T, T, phi::funcs::SumFunctor>(
- dev_ctx, compare_result, &result, result_shape, true, false);
- // DenseTensor result = dito_int.ReduceSum(compare_result, result_shape);
+ std::cout << "\n1111111111144414\n";
+ // DenseTensor result;
+ // result.Resize(dim_out);
+ // dev_ctx.template Alloc<T>(&result);
+ std::cout << "\n1111111111144416677\n";
+ std::cout << "compare_result: " << compare_result << "\n";
+ DenseTensor result = phi::Sum<T>(dev_ctx,
+ compare_result,
+ std::vector<int64_t>{-1},
+ compare_result.dtype(),
+ false);
+ // SumKernel<T, Context>(dev_ctx, compare_result, std::vector<int64_t>{-1},
+ // compare_result.type(), );
+ // ReduceKernelImpl<Context, T, T, phi::funcs::SumFunctor>(
+ // dev_ctx,
+ // compare_result,
+ // &result,
+ // std::vector<int64_t>{-1},
+ // true,
+ // false);
+ std::cout << "\n1111111111116\n";
  out->ShareDataWith(result);
+ std::cout << "\n1111111111115\n";
  }
 }
 } // namespace phi

paddle/phi/kernels/funcs/reduce_functor.h

@@ -41,5 +41,13 @@ struct ProdFunctor {
  }
 };
 
+//////// Max Functor ///////
+struct MaxFunctor {
+ template <typename DeviceContext, typename X, typename Y, typename Dim>
+ void operator()(const DeviceContext& place, X* x, Y* y, const Dim& dim) {
+ y->device(place) = x->maximum(dim);
+ }
+};
+
 } // namespace funcs
 } // namespace phi

paddle/phi/kernels/gpu/matrix_rank_kernel.cu

@@ -24,9 +24,9 @@ namespace phi {
 template <typename T, typename Context>
 void MatrixRankKernel(const Context& dev_ctx,
  const DenseTensor& x,
- bool hermitian,
- bool use_default_tol,
  float tol,
+ bool use_default_tol,
+ bool hermitian,
  DenseTensor* out) {
  DenseTensor atol_tensor;
  if (use_default_tol) {
@@ -37,7 +37,7 @@ void MatrixRankKernel(const Context& dev_ctx,
  std::vector<T>{tol}, dev_ctx, &atol_tensor);
  }
  MatrixRankTolKernel<T, Context>(
- dev_ctx, x, atol_tensor, hermitian, use_default_tol, out);
+ dev_ctx, x, atol_tensor, use_default_tol, hermitian, out);
 }
 
 } // namespace phi