add unique_consecutive_op

Author: firestonelib

paddle/fluid/operators/unique_consecutive_op.cu

@@ -33,10 +33,8 @@ template <typename InT>
 struct BinaryEqual {
   int64_t col;
   const InT* in_trans_data;
-
   BinaryEqual(int64_t _col, const InT* _in_trans_data)
       : col(_col), in_trans_data(_in_trans_data) {}
-
   __device__ bool operator()(int64_t a, int64_t b) const {
     for (int64_t i = 0; i < col; ++i) {
       InT lhs = in_trans_data[i + a * col];
@@ -54,10 +52,8 @@ template <typename InT>
 struct BinaryNotEqual {
   int64_t col;
   const InT* in_trans_data;
-
   BinaryNotEqual(int64_t _col, const InT* _in_trans_data)
       : col(_col), in_trans_data(_in_trans_data) {}
-
   __device__ bool operator()(int64_t a, int64_t b) const {
     for (int64_t i = 0; i < col; ++i) {
       InT lhs = in_trans_data[i + a * col];
@@ -83,23 +79,19 @@ void IndexSelect(const framework::ExecutionContext& context,
   for (auto i = dim + 1; i < input_dim_size; i++) {
     slice_size *= input_dim[i];
   }
-
   auto input_width = slice_size * input_dim[dim];
   auto output_width = slice_size * output_dim[dim];
 
   auto outer_nums = 1;
   for (auto i = 0; i < dim; i++) {
     outer_nums *= input_dim[i];
   }
-
   auto index_size = index.dims()[0];
-
   std::vector<InT> input_vec;
   std::vector<IndexT> index_vec;
   TensorToVector(input, context.device_context(), &input_vec);
   TensorToVector(index, context.device_context(), &index_vec);
   std::vector<InT> out_vec(output->numel());
-
   for (int i = 0; i < index_size; i++) {
     PADDLE_ENFORCE_GE(
         index_vec[i], 0,
@@ -116,7 +108,6 @@ void IndexSelect(const framework::ExecutionContext& context,
             "value.",
             input_dim[dim], index_vec[i]));
   }
-
   for (auto i = 0; i < outer_nums; i++) {
     auto input_start_offset = i * input_width;
     auto output_start_offset = i * output_width;
@@ -144,14 +135,12 @@ static void UniqueConsecutiveFlattendCUDATensor(
   Tensor in_hat;
   framework::TensorCopy(in, context.GetPlace(), &in_hat);
   auto in_data_hat = in_hat.mutable_data<InT>(context.GetPlace());
-
   Tensor sorted_indices;
   sorted_indices.Resize(framework::make_ddim({num_input}));
   auto sorted_indices_data =
       sorted_indices.mutable_data<IndexT>(context.GetPlace());
   thrust::sequence(thrust::device, sorted_indices_data,
                    sorted_indices_data + num_input);
-
   // 1. Calculate op result: 'out'
   Tensor range;
   range.Resize(framework::make_ddim({num_input + 1}));
@@ -166,7 +155,6 @@ static void UniqueConsecutiveFlattendCUDATensor(
                 .first -
             out_data;
   out->Resize(framework::make_ddim({num_out}));
-
   // 2. Calculate inverse index: 'inverse'
   if (return_inverse) {
     Tensor* inverse = context.Output<Tensor>("Index");
@@ -186,7 +174,6 @@ static void UniqueConsecutiveFlattendCUDATensor(
                     inv_loc_data_ptr + num_input, sorted_indices_data,
                     inverse_data);
   }
-
   // 3. Calculate 'counts'
   if (return_counts) {
     Tensor* counts = context.Output<Tensor>("Counts");
@@ -224,7 +211,6 @@ static void ComputeUniqueConsecutiveDims(
                          inv_loc_data_ptr + row, inv_loc_data_ptr);
   thrust::scatter(thrust::device, inv_loc_data_ptr, inv_loc_data_ptr + row,
                   sorted_indices_data, inverse_data);
-
   // 2. sorted indices
   Tensor range;
   range.Resize(framework::make_ddim({row + 1}));

paddle/fluid/operators/unique_consecutive_op.h

@@ -149,7 +149,6 @@ static void UniqueConsecutiveDim(const framework::ExecutionContext& context,
            in_trans_data + static_cast<int64_t>(sorted_indices_vec[i]) * col,
            col * sizeof(InT));
   }
-
   std::vector<framework::Tensor> input_unbind = Unbind(input_sorted);
   std::vector<IndexT> inverse_vec(sorted_indices_vec.size(), 0);
   std::vector<IndexT> counts_vec(sorted_indices_vec.size(), 0);
@@ -172,12 +171,10 @@ static void UniqueConsecutiveDim(const framework::ExecutionContext& context,
   concat_functor(dev_ctx, input_unbind, 0, &out_trans);
   TransCompute<DeviceContext, InT>(out_trans.dims().size(), dev_ctx, out_trans,
                                    out, permute);
-
   if (return_inverse) {
     auto* inverse = context.Output<framework::Tensor>("Index");
     framework::TensorFromVector(inverse_vec, context.device_context(), inverse);
   }
-
   if (return_counts) {
     auto* count = context.Output<framework::Tensor>("Counts");
     framework::TensorFromVector(counts_vec, context.device_context(), count);
@@ -233,7 +230,6 @@ struct UniqueConsecutiveDimFunctor {
         ctx_, in_, out_, return_inverse_, return_counts_, axis_);
   }
 };
-
 template <typename DeviceContext, typename T>
 class UniqueConsecutiveKernel : public framework::OpKernel<T> {
  public:
@@ -251,7 +247,6 @@ class UniqueConsecutiveKernel : public framework::OpKernel<T> {
               "int64.",
               x->numel()));
     }
-
     std::vector<int> axis_vec = context.Attr<std::vector<int>>("axis");
     bool return_inverse = context.Attr<bool>("return_inverse");
     bool return_counts = context.Attr<bool>("return_counts");
@@ -269,6 +264,5 @@ class UniqueConsecutiveKernel : public framework::OpKernel<T> {
     }
   }
 };
-
 }  // namespace operators
 }  // namespace paddle

python/paddle/tensor/manipulation.py

@@ -718,24 +718,20 @@ def unique_consecutive(x,
                        name=None):
     r"""
     Eliminates all but the first element from every consecutive group of equivalent elements.
-
     .. note:: This function is different from :func:`paddle.unique` in the sense that this function
         only eliminates consecutive duplicate values. This semantics is similar to `std::unique`
         in C++.
-
     Args:
         x(Tensor): the input tensor, it's data type should be float32, float64, int32, int64.
         return_inverse(bool, optional): If True, also return the indices for where elements in
             the original input ended up in the returned unique consecutive tensor.
         return_counts(bool, optional): If True, also return the counts for each unique consecutive element.
         axis(int, optional): The axis to apply unique consecutive. If None, the input will be flattened.
             Default: None.
-
     Returns:
         tuple: (out, inverse, counts). `out` is the unique consecutive tensor for `x`.`inverse` is \
            provided only if `return_inverse` is True. `counts` is provided only if `return_counts` \
            is True.
-
     Example:
         .. code-block:: python
 
@@ -774,12 +770,9 @@ def unique_consecutive(x,
             outs.append(inverse)
         if return_counts:
             outs.append(counts)
-
         if len(outs) == 1:
             return outs[0]
-
         return tuple(outs)
-
     check_variable_and_dtype(x, "input",
                              ['float32', 'float64', 'int32', 'int64'],
                              'unique_consecutive')
@@ -788,7 +781,6 @@ def unique_consecutive(x,
     check_dtype(dtype, 'dtype', ['int32', 'int64'], 'unique_consecutive')
     if len(axis) != 0:
         check_type(axis[0], 'axis', int, 'unique_consecutive')
-
     helper = LayerHelper('unique_consecutive', **locals())
     attrs = {
         'dtype': attr_dtype,
@@ -808,16 +800,13 @@ def unique_consecutive(x,
         outs.append(inverse)
     if return_counts:
         outs.append(counts)
-
     helper.append_op(
         type="unique_consecutive",
         inputs={"X": x},
         attrs=attrs,
         outputs=outputs)
-
     if len(outs) == 1:
         return outs[0]
-
     return tuple(outs)