paddlepaddle--paddle/paddle/phi/kernels/cpu/kthvalue_kernel.cc

// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "paddle/phi/kernels/kthvalue_kernel.h"

#include "paddle/phi/backends/cpu/cpu_context.h"
#include "paddle/phi/core/kernel_registry.h"
#include "paddle/phi/kernels/full_kernel.h"
#include "paddle/phi/kernels/funcs/eigen/common.h"
#include "paddle/phi/kernels/funcs/math_function.h"
namespace phi {
template <typename T, typename Type>
static void getKthvalue(Type input_height,
                        Type input_width,
                        int input_dim,
                        const DenseTensor* input,
                        T* t_out,
                        Type* t_indices,
                        const int64_t& k) {
  bool partial_sort_flag = (k * 64) < input_width;
#ifdef PADDLE_WITH_MKLML
#pragma omp parallel for
#endif
  for (Type i = 0; i < input_height; ++i) {
    std::vector<std::pair<T, Type>> col_vec;
    col_vec.reserve(input_width);
    if (input_dim == 1) {
      auto e_input = EigenVector<T>::Flatten(*input);
      for (Type j = 0; j < input_width; ++j) {
        col_vec.emplace_back(std::pair<T, Type>(e_input(j), j));
      }
    } else {
      auto e_input = EigenMatrix<T>::Reshape(*input, input_dim - 1);
      for (Type j = 0; j < input_width; ++j) {
        col_vec.emplace_back(std::pair<T, Type>(e_input(i, j), j));
      }
    }
    if (partial_sort_flag) {
      std::partial_sort(
          col_vec.begin(),
          col_vec.begin() + k,
          col_vec.end(),
          [](const std::pair<T, Type>& l, const std::pair<T, Type>& r) {
            return (!std::isnan(static_cast<double>(l.first)) &&
                    std::isnan(static_cast<double>(r.first))) ||
                   (l.first < r.first);
          });
    } else {
      std::nth_element(
          col_vec.begin(),
          col_vec.begin() + k - 1,
          col_vec.end(),
          [](const std::pair<T, Type>& l, const std::pair<T, Type>& r) {
            return (!std::isnan(static_cast<double>(l.first)) &&
                    std::isnan(static_cast<double>(r.first))) ||
                   (l.first < r.first);
          });
    }
    t_out[i] = col_vec[k - 1].first;
    t_indices[i] = col_vec[k - 1].second;
  }
}

template <typename T, typename Context>
void KthvalueKernel(const Context& dev_ctx,
                    const DenseTensor& x,
                    int64_t k,
                    int axis,
                    bool keepdim,
                    DenseTensor* output,
                    DenseTensor* indices) {
  if (x.numel() == 0) {
    Full<T, Context>(dev_ctx, output->dims(), NAN, output);
    Full<int64_t, Context>(dev_ctx, indices->dims(), 0, indices);
    return;
  }
  const auto& in_dims = x.dims();
  if (axis < 0) axis += in_dims.size();

  T* output_data = dev_ctx.template Alloc<T>(output);
  int64_t* indices_data = dev_ctx.template Alloc<int64_t>(indices);
  // For 0D Tensor
  if (in_dims.size() == 0) {
    PADDLE_ENFORCE_EQ(k,
                      1,
                      common::errors::InvalidArgument(
                          "the k in the kthvalue must less equal than the "
                          "elements number of the input X, but received %lld .",
                          k));

    Copy<Context>(dev_ctx, x, dev_ctx.GetPlace(), false, output);
    funcs::set_constant(dev_ctx, indices, static_cast<int64_t>(0));
    return;
  }
  auto out_dims = output->dims();
  if (axis == in_dims.size() - 1) {
    const int64_t& input_height =
        common::product(slice_ddim(in_dims, 0, in_dims.size() - 1));
    const int64_t& input_width = in_dims[in_dims.size() - 1];
    getKthvalue<T, int64_t>(input_height,
                            input_width,
                            in_dims.size(),
                            &x,
                            output_data,
                            indices_data,
                            k);
  } else {
    std::vector<int> trans;
    for (int i = 0; i < axis; i++) {
      trans.emplace_back(i);
    }
    trans.emplace_back(in_dims.size() - 1);
    for (int i = axis + 1; i < in_dims.size() - 1; i++) {
      trans.emplace_back(i);
    }
    trans.emplace_back(axis);
    if (!keepdim) {
      std::vector<int> tmp_out_shape;
      for (int i = 0; i < axis; i++) {
        tmp_out_shape.emplace_back(in_dims[i]);
      }
      tmp_out_shape.emplace_back(1);
      for (int i = axis + 1; i < in_dims.size(); i++) {
        tmp_out_shape.emplace_back(in_dims[i]);
      }
      DDim tmp_out_dims = make_ddim(tmp_out_shape);
      output->Resize(tmp_out_dims);
      indices->Resize(tmp_out_dims);
    }
    DDim trans_dims(in_dims);
    DDim trans_out_dims(in_dims);

    for (int i = 0; i < static_cast<int>(trans.size()); i++) {
      trans_dims[i] = in_dims[trans[i]];
      trans_out_dims[i] = in_dims[trans[i]];
    }
    trans_out_dims[in_dims.size() - 1] = 1;
    DenseTensor trans_inp;
    trans_inp.Resize(trans_dims);
    dev_ctx.template Alloc<T>(&trans_inp);
    int ndims = static_cast<int>(trans.size());
    funcs::TransCompute<CPUContext, T>(ndims, dev_ctx, x, &trans_inp, trans);

    const int64_t input_height =
        common::product(slice_ddim(trans_dims, 0, trans_dims.size() - 1));
    const int64_t input_width = trans_dims[trans_dims.size() - 1];
    DenseTensor tmp_out, tmp_indices;
    tmp_out.Resize(trans_out_dims);
    T* t_out = dev_ctx.template Alloc<T>(&tmp_out);
    tmp_indices.Resize(trans_out_dims);
    int64_t* t_ind = dev_ctx.template Alloc<int64_t>(&tmp_indices);
    getKthvalue<T, int64_t>(
        input_height, input_width, in_dims.size(), &trans_inp, t_out, t_ind, k);
    funcs::TransCompute<CPUContext, int64_t>(
        ndims, dev_ctx, tmp_indices, indices, trans);
    funcs::TransCompute<CPUContext, T>(ndims, dev_ctx, tmp_out, output, trans);
    if (!keepdim) {
      output->Resize(out_dims);
      indices->Resize(out_dims);
    }
  }
}

}  // namespace phi

PD_REGISTER_KERNEL(kthvalue,
                   CPU,
                   ALL_LAYOUT,
                   phi::KthvalueKernel,
                   float,
                   double,
                   int,
                   int64_t) {
  kernel->OutputAt(1).SetDataType(phi::DataType::INT64);
}