【Hackathon 6th No.55】move dequantize_log to phi - part (#63638)

zeroRains · web-flow · commit aba200b32f0c · 2024-04-22T12:51:53.000+08:00
* move dequantize_log to phi

* fix typo

* save the dequantize_log_op.cc

* add the config in pir ops.yaml
diff --git a/paddle/fluid/operators/dequantize_log_op.cc b/paddle/fluid/operators/dequantize_log_op.cc
@@ -1,20 +1,23 @@
 /* Copyright (c) 2020 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
-
     https://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/fluid/operators/dequantize_log_op.h"
-
 #include <string>
+#include <vector>
+
+#include "paddle/common/ddim.h"
+#include "paddle/fluid/framework/op_registry.h"
+
+#include "paddle/fluid/framework/infershape_utils.h"
+#include "paddle/phi/core/infermeta_utils.h"
+#include "paddle/phi/infermeta/binary.h"
 
 namespace paddle {
 namespace framework {
@@ -31,28 +34,6 @@ class OpBase;
 namespace paddle {
 namespace operators {
 
-template <typename T>
-struct DequantizeFunctor<phi::CPUContext, T> {
-  void operator()(const phi::CPUContext& dev_ctx,
-                  const phi::DenseTensor* in,
-                  const phi::DenseTensor* dict,
-                  phi::DenseTensor* out) {
-    const float* dict_data = dict->data<float>();
-    const T* input_data = in->data<T>();
-    float* output_data = out->mutable_data<float>(dev_ctx.GetPlace());
-    int ind = static_cast<int>(in->numel());
-    for (size_t i = 0; i < (unsigned)ind; i++) {
-      if (input_data[i] < 0) {
-        output_data[i] = -dict_data[input_data[i] + 128];
-      } else {
-        output_data[i] = dict_data[input_data[i]];
-      }
-    }
-  }
-};
-
-template struct DequantizeFunctor<phi::CPUContext, int8_t>;
-
 class DequantizeLogOp : public framework::OperatorWithKernel {
  public:
   DequantizeLogOp(const std::string& type,
@@ -61,20 +42,6 @@ class DequantizeLogOp : public framework::OperatorWithKernel {
                   const framework::AttributeMap& attrs)
       : OperatorWithKernel(type, inputs, outputs, attrs) {}
 
-  void InferShape(framework::InferShapeContext* ctx) const override {
-    PADDLE_ENFORCE_EQ(
-        ctx->HasInput("X"),
-        true,
-        phi::errors::NotFound("Input(X) of DequantizeLogOp is not found."));
-    PADDLE_ENFORCE_EQ(
-        ctx->HasOutput("Out"),
-        true,
-        phi::errors::NotFound("Output(Out) of DequantizeLogOp is not found."));
-
-    ctx->ShareDim("X", /*->*/ "Out");
-    ctx->ShareLoD("X", /*->*/ "Out");
-  }
-
   phi::KernelKey GetExpectedKernelType(
       const framework::ExecutionContext& ctx) const override {
     auto data_type = OperatorWithKernel::IndicateVarDataType(ctx, "X");
@@ -94,11 +61,7 @@ class DequantizeLogOpMaker : public framework::OpProtoAndCheckerMaker {
               "precision tensor.");
     AddComment(R"DOC(
 DequantizeLogOp operator.
-
 This calculation is an opposite operation of QuantizeLogOp:
-
-
-
 )DOC");
   }
 };
@@ -108,12 +71,14 @@ This calculation is an opposite operation of QuantizeLogOp:
 
 namespace ops = paddle::operators;
 
+DECLARE_INFER_SHAPE_FUNCTOR(dequantize_log,
+                            DequantizeLogInferShapeFunctor,
+                            PD_INFER_META(phi::DequantizeLogInferMeta));
+
 REGISTER_OPERATOR(
     dequantize_log,
     ops::DequantizeLogOp,
     ops::DequantizeLogOpMaker,
     paddle::framework::EmptyGradOpMaker<paddle::framework::OpDesc>,
-    paddle::framework::EmptyGradOpMaker<paddle::imperative::OpBase>);
-
-PD_REGISTER_STRUCT_KERNEL(
-    dequantize_log, CPU, ALL_LAYOUT, ops::DequantizeLogKernel, int8_t) {}
+    paddle::framework::EmptyGradOpMaker<paddle::imperative::OpBase>,
+    DequantizeLogInferShapeFunctor);
diff --git a/paddle/fluid/operators/dequantize_log_op.cu b/paddle/fluid/operators/dequantize_log_op.cu
diff --git a/paddle/fluid/operators/dequantize_log_op.h b/paddle/fluid/operators/dequantize_log_op.h
diff --git a/paddle/fluid/operators/ops_signature/dequantize_log_sig.cc b/paddle/fluid/operators/ops_signature/dequantize_log_sig.cc
@@ -0,0 +1,25 @@
+// Copyright (c) 2024 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
+//
+//     https://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/core/compat/op_utils.h"
+
+namespace phi {
+
+KernelSignature DequantizeLogOpArgumentMapping(
+    const ArgumentMappingContext& ctx) {
+  return KernelSignature("dequantize_log", {"X", "Dict"}, {}, {"Out"});
+}
+
+}  // namespace phi
+
+PD_REGISTER_ARG_MAPPING_FN(dequantize_log, phi::DequantizeLogOpArgumentMapping);
diff --git a/paddle/fluid/pir/dialect/operator/ir/ops.yaml b/paddle/fluid/pir/dialect/operator/ir/ops.yaml
@@ -478,6 +478,15 @@
   optional : in_accum, in_state, out_scale, out_accum, out_state
   inplace : (scale -> out_scale, in_accum -> out_accum, in_state -> out_state)
 
+- op : dequantize_log
+  args: (Tensor x, Tensor dict)
+  output: Tensor(out)
+  infer_meta:
+    func: DequantizeLogInferMeta
+  kernel:
+    func: dequantize_log
+    data_type: x
+
 - op : dgc
   args : (Tensor u, Tensor v, Tensor grad, Tensor param, Tensor current_step, Tensor nranks, float[] sparsity, float m=0.9, bool use_nesterov=true, float rampup_begin_step=0.0, float rampup_step=0.0, float regular_coeff=0.0, int regular_type=0)
   output : Tensor(u_out), Tensor(v_out), Tensor(encode_grad), Tensor(grad_out), Tensor(k), Tensor(gather_buff)
diff --git a/paddle/phi/api/yaml/legacy_ops.yaml b/paddle/phi/api/yaml/legacy_ops.yaml
@@ -323,6 +323,15 @@
     data_type : x
   backward : depthwise_conv2d_transpose_grad
 
+- op : dequantize_log
+  args: (Tensor x, Tensor dict)
+  output: Tensor(out)
+  infer_meta:
+    func: DequantizeLogInferMeta
+  kernel:
+    func: dequantize_log
+    data_type: x
+
 - op : disable_check_model_nan_inf
   args: (Tensor x, int flag = 0)
   output: Tensor(out)
diff --git a/paddle/phi/infermeta/binary.cc b/paddle/phi/infermeta/binary.cc
@@ -1084,6 +1084,14 @@ void DepthwiseConvInferMeta(const MetaTensor& input,
                 config);
 }
 
+void DequantizeLogInferMeta(const MetaTensor& x,
+                            const MetaTensor& dict,
+                            MetaTensor* out) {
+  out->set_dtype(x.dtype());
+  out->share_dims(x);
+  out->share_lod(x);
+}
+
 void DistInferMeta(const MetaTensor& x,
                    const MetaTensor& y,
                    float p,
diff --git a/paddle/phi/infermeta/binary.h b/paddle/phi/infermeta/binary.h
@@ -181,6 +181,10 @@ void DepthwiseConvInferMeta(const MetaTensor& input,
                             MetaTensor* out,
                             MetaConfig config = MetaConfig());
 
+void DequantizeLogInferMeta(const MetaTensor& x,
+                            const MetaTensor& dict,
+                            MetaTensor* out);
+
 void DistInferMeta(const MetaTensor& x,
                    const MetaTensor& y,
                    float p,
diff --git a/paddle/phi/kernels/cpu/dequantize_log_kernel.cc b/paddle/phi/kernels/cpu/dequantize_log_kernel.cc
@@ -0,0 +1,42 @@
+// Copyright (c) 2024 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
+//
+//     https://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/dequantize_log_kernel.h"
+
+#include "paddle/phi/backends/cpu/cpu_context.h"
+#include "paddle/phi/core/kernel_registry.h"
+
+namespace phi {
+
+template <typename T, typename Context>
+void DequantizeLogKernel(const Context& dev_ctx,
+                         const DenseTensor& x,
+                         const DenseTensor& dict,
+                         DenseTensor* out) {
+  const float* dict_data = dict.data<float>();
+  const T* input_data = x.data<T>();
+  float* output_data = dev_ctx.template Alloc<float>(out);
+  int ind = static_cast<int>(x.numel());
+  for (size_t i = 0; i < (unsigned)ind; i++) {
+    if (input_data[i] < 0) {
+      output_data[i] = -dict_data[input_data[i] + 128];
+    } else {
+      output_data[i] = dict_data[input_data[i]];
+    }
+  }
+}
+}  // namespace phi
+
+PD_REGISTER_KERNEL(
+    dequantize_log, CPU, ALL_LAYOUT, phi::DequantizeLogKernel, int8_t) {}
diff --git a/paddle/phi/kernels/dequantize_log_kernel.h b/paddle/phi/kernels/dequantize_log_kernel.h
@@ -0,0 +1,28 @@
+// Copyright (c) 2024 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
+//
+//     https://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.
+
+#pragma once
+
+#include "paddle/phi/backends/all_context.h"
+#include "paddle/phi/core/dense_tensor.h"
+
+namespace phi {
+
+template <typename T, typename Context>
+void DequantizeLogKernel(const Context& dev_ctx,
+                         const DenseTensor& x,
+                         const DenseTensor& dict,
+                         DenseTensor* out);
+
+}  // namespace phi
diff --git a/paddle/phi/kernels/gpu/dequantize_log_kernel.cu b/paddle/phi/kernels/gpu/dequantize_log_kernel.cu
diff --git a/test/legacy_test/test_dequantize_log_op.py b/test/legacy_test/test_dequantize_log_op.py
