PaddlePaddle
diff --git a/‎paddle/fluid/operators/fake_quantize_op.cc
Copy file name to clipboard
-215Lines changed: 0 additions & 215 deletions b/‎paddle/fluid/operators/fake_quantize_op.cc
Copy file name to clipboard
-215Lines changed: 0 additions & 215 deletions
diff --git a/‎paddle/fluid/operators/fake_quantize_op.cu
Copy file name to clipboard
-12Lines changed: 0 additions & 12 deletions b/‎paddle/fluid/operators/fake_quantize_op.cu
Copy file name to clipboard
-12Lines changed: 0 additions & 12 deletions
diff --git a/‎paddle/fluid/operators/fake_quantize_op.cu.h
Copy file name to clipboard
-57Lines changed: 0 additions & 57 deletions b/‎paddle/fluid/operators/fake_quantize_op.cu.h
Copy file name to clipboard
-57Lines changed: 0 additions & 57 deletions
@@ -31,197 +31,6 @@ struct Compare {
   bool operator()(const T a, const T b) { return (std::abs(a) < std::abs(b)); }
 };
 
-template <typename T>
-struct ClipAndFakeQuantDequantFunctor<phi::CPUContext, T> {
-  void operator()(const phi::CPUContext &ctx,
-                  const phi::DenseTensor &in,
-                  const phi::DenseTensor &scale,
-                  const int bin_cnt,
-                  const int round_type,
-                  phi::DenseTensor *out) {
-    T s = scale.data<T>()[0];
-    T inv_s = phi::funcs::inverse(s);
-
-    phi::Transform<phi::CPUContext> trans;
-    if (round_type == 0) {
-      trans(ctx,
-            in.data<T>(),
-            in.data<T>() + in.numel(),
-            out->mutable_data<T>(ctx.GetPlace()),
-            phi::funcs::QuantTensorFunctor<T>(static_cast<T>(bin_cnt), inv_s));
-      auto out_e = phi::EigenVector<T>::Flatten(*out);
-      out_e.device(*ctx.eigen_device()) = out_e * s / static_cast<T>(bin_cnt);
-    } else {
-      trans(ctx,
-            in.data<T>(),
-            in.data<T>() + in.numel(),
-            out->mutable_data<T>(ctx.GetPlace()),
-            phi::ClipFunctor<T>(-s, s));
-      auto out_e = phi::EigenVector<T>::Flatten(*out);
-      out_e.device(*ctx.eigen_device()) =
-          (bin_cnt * inv_s * out_e).round() * s / static_cast<T>(bin_cnt);
-    }
-  }
-};
-template struct ClipAndFakeQuantDequantFunctor<phi::CPUContext, float>;
-
-class FakeQuantOrWithDequantAbsMaxOp : public framework::OperatorWithKernel {
- public:
-  FakeQuantOrWithDequantAbsMaxOp(const std::string &type,
-                                 const framework::VariableNameMap &inputs,
-                                 const framework::VariableNameMap &outputs,
-                                 const framework::AttributeMap &attrs)
-      : OperatorWithKernel(type, inputs, outputs, attrs) {}
-
-  void InferShape(framework::InferShapeContext *ctx) const override {
-    OP_INOUT_CHECK(
-        ctx->HasInput("X"), "Input", "X", "FakeQuantOrWithDequantAbsMaxOp");
-    OP_INOUT_CHECK(ctx->HasOutput("Out"),
-                   "Output",
-                   "Out",
-                   "FakeQuantOrWithDequantAbsMaxOp");
-    OP_INOUT_CHECK(ctx->HasOutput("OutScale"),
-                   "Output",
-                   "OutScale",
-                   "FakeQuantOrWithDequantAbsMaxOp");
-    ctx->SetOutputDim("Out", ctx->GetInputDim("X"));
-    ctx->SetOutputDim("OutScale", {1});
-    ctx->ShareLoD("X", /*->*/ "Out");
-  }
-
- protected:
-  phi::KernelKey GetExpectedKernelType(
-      const framework::ExecutionContext &ctx) const override {
-    return phi::KernelKey(OperatorWithKernel::IndicateVarDataType(ctx, "X"),
-                          ctx.device_context().GetPlace());
-  }
-};
-
-class FakeQuantOrWithDequantAbsMaxOpMaker
-    : public framework::OpProtoAndCheckerMaker {
- public:
-  void Make() override {
-    AddInput("X", "(Tensor) Input is float data type.");
-    AddOutput("Out",
-              "(Tensor) Output of quantized low level tensor, "
-              "but also saved as float data type.");
-    AddOutput("OutScale", "(Tensor) Current scale");
-    AddAttr<int>("bit_length", "(int, default 8)")
-        .SetDefault(8)
-        .AddCustomChecker([](const int &bit_length) {
-          PADDLE_ENFORCE_EQ(bit_length >= 1 && bit_length <= 16,
-                            true,
-                            phi::errors::InvalidArgument(
-                                "'bit_length' should be between 1 and 16, but "
-                                "the received is %d",
-                                bit_length));
-        });
-    AddComment(R"DOC(
-This is a Base Op which supports FakeQuantAbsMaxOpMaker and FakeQuantDequantAbsMaxOpMaker.
-FakeQuantAbsMaxOp operator is used in the dynamic quantization.
-
-$$scale = max(abs(X))$$
-$$range = 2^{bit_length - 1} - 1$$
-$$Out = round(X/scale * range)$$
-
-FakeQuantDequantAbsMaxOp operator does the abs_max quantization and then dequantization.
-
-$$scale = max(abs(X))$$
-$$range = 2^{bit\_length - 1} - 1$$
-$$Out = round(X/scale * range) * scale / range$$
-
-)DOC");
-  }
-};
-
-class FakeQuantOrWithDequantMovingAverageAbsMaxOp
-    : public framework::OperatorWithKernel {
- public:
-  FakeQuantOrWithDequantMovingAverageAbsMaxOp(
-      const std::string &type,
-      const framework::VariableNameMap &inputs,
-      const framework::VariableNameMap &outputs,
-      const framework::AttributeMap &attrs)
-      : OperatorWithKernel(type, inputs, outputs, attrs) {}
-
-  void InferShape(framework::InferShapeContext *ctx) const override {
-    OP_INOUT_CHECK(ctx->HasInput("X"),
-                   "Input",
-                   "X",
-                   "FakeQuantOrWithDequantMovingAverageAbsMax");
-    OP_INOUT_CHECK(ctx->HasOutput("Out"),
-                   "Output",
-                   "Out",
-                   "FakeQuantOrWithDequantMovingAverageAbsMax");
-    OP_INOUT_CHECK(ctx->HasOutput("OutScale"),
-                   "Output",
-                   "OutScale",
-                   "FakeQuantOrWithDequantMovingAverageAbsMax");
-    if (ctx->HasOutput("OutState")) {
-      ctx->SetOutputDim("OutState", {1});
-    }
-    if (ctx->HasOutput("OutAccum")) {
-      ctx->SetOutputDim("OutAccum", {1});
-    }
-    ctx->SetOutputDim("Out", ctx->GetInputDim("X"));
-    ctx->SetOutputDim("OutScale", {1});
-    ctx->ShareLoD("X", /*->*/ "Out");
-  }
-
- protected:
-  phi::KernelKey GetExpectedKernelType(
-      const framework::ExecutionContext &ctx) const override {
-    return phi::KernelKey(OperatorWithKernel::IndicateVarDataType(ctx, "X"),
-                          ctx.device_context().GetPlace());
-  }
-};
-
-class FakeQuantOrWithDequantMovingAverageAbsMaxOpMaker
-    : public framework::OpProtoAndCheckerMaker {
- public:
-  void Make() override {
-    AddInput("X", "(Tensor) Input is float data type.");
-    AddInput("InScale", "Last scale.");
-    AddInput("InAccum", "Last accum.").AsDispensable();
-    AddInput("InState", "Last state.").AsDispensable();
-    AddOutput("Out", "(Tensor) Output of quantized low level tensor.");
-    AddOutput("OutScale", " Current scale");
-    AddOutput("OutState", "(Tensor) state buffer.").AsDispensable();
-    AddOutput("OutAccum", "(Tensor) accum buffer.").AsDispensable();
-    AddAttr<float>("moving_rate", "(float, default 0.9) moving rate.")
-        .SetDefault(0.9);
-    AddAttr<int>("bit_length", "(int, default 8), quantization bit number.")
-        .SetDefault(8)
-        .AddCustomChecker([](const int &bit_length) {
-          PADDLE_ENFORCE_EQ(bit_length >= 1 && bit_length <= 16,
-                            true,
-                            phi::errors::InvalidArgument(
-                                "'bit_length' should be between 1 and 16, but "
-                                "the received is %d",
-                                bit_length));
-        });
-    AddAttr<bool>("is_test",
-                  "(bool, default false) Set to true for inference only, false "
-                  "for training. Some layers may run faster when this is true.")
-        .SetDefault(false);
-    AddComment(R"DOC(
-This is a Base Op which supports FakeQuantMovingAverageAbsMaxOp and FakeQuantDequantMovingAverageAbsMaxOp.
-FakeQuantMovingAverageAbsMaxOp operator is used in the static quantization.
-
-$$scale = (moving\_rate*accum+max(abs(x)))/(moving\_rate*state+1)$$
-$$range = 2^{bit\_length - 1} - 1$$
-$$Out = round(X/scale * range)$$
-
-FakeQuantDequantMovingAverageAbsMaxOp operator does the moving_average_abs_max quant and then dequant.
-
-$$scale = (moving\_rate*accum+max(abs(x)))/(moving\_rate*state+1)$$
-$$range = 2^{bit\_length - 1} - 1$$
-$$Out = round(X/scale * range) * scale / range$$
-
-)DOC");
-  }
-};
-
 class MovingAverageAbsMaxScaleOp : public framework::OperatorWithKernel {
  public:
   using framework::OperatorWithKernel::OperatorWithKernel;
@@ -332,30 +141,6 @@ class StraightThroughEstimatorMaker : public framework::SingleGradOpMaker<T> {
 namespace ops = paddle::operators;
 using CPU = phi::CPUContext;
 
-REGISTER_OPERATOR(
-    fake_quantize_dequantize_abs_max,
-    ops::FakeQuantOrWithDequantAbsMaxOp,
-    ops::FakeQuantOrWithDequantAbsMaxOpMaker,
-    ops::StraightThroughEstimatorMaker<paddle::framework::OpDesc>,
-    ops::StraightThroughEstimatorMaker<paddle::imperative::OpBase>);
-PD_REGISTER_STRUCT_KERNEL(fake_quantize_dequantize_abs_max,
-                          CPU,
-                          ALL_LAYOUT,
-                          ops::FakeQuantizeDequantizeAbsMaxKernel,
-                          float) {}
-
-REGISTER_OPERATOR(
-    fake_quantize_dequantize_moving_average_abs_max,
-    ops::FakeQuantOrWithDequantMovingAverageAbsMaxOp,
-    ops::FakeQuantOrWithDequantMovingAverageAbsMaxOpMaker,
-    ops::StraightThroughEstimatorMaker<paddle::framework::OpDesc>,
-    ops::StraightThroughEstimatorMaker<paddle::imperative::OpBase>);
-PD_REGISTER_STRUCT_KERNEL(fake_quantize_dequantize_moving_average_abs_max,
-                          CPU,
-                          ALL_LAYOUT,
-                          ops::FakeQuantizeDequantizeMovingAverageAbsMaxKernel,
-                          float) {}
-
 REGISTER_OPERATOR(
     moving_average_abs_max_scale,
     ops::MovingAverageAbsMaxScaleOp,
 
@@ -18,24 +18,12 @@ limitations under the License. */
 namespace ops = paddle::operators;
 using float16 = phi::dtype::float16;
 
-PD_REGISTER_STRUCT_KERNEL(fake_quantize_dequantize_abs_max,
-                          GPU,
-                          ALL_LAYOUT,
-                          ops::FakeQuantizeDequantizeAbsMaxKernel,
-                          float,
-                          float16) {}
 PD_REGISTER_STRUCT_KERNEL(moving_average_abs_max_scale,
                           GPU,
                           ALL_LAYOUT,
                           ops::MovingAverageAbsMaxScaleKernel,
                           float,
                           float16) {}
-PD_REGISTER_STRUCT_KERNEL(fake_quantize_dequantize_moving_average_abs_max,
-                          GPU,
-                          ALL_LAYOUT,
-                          ops::FakeQuantizeDequantizeMovingAverageAbsMaxKernel,
-                          float,
-                          float16) {}
 PD_REGISTER_STRUCT_KERNEL(straight_through_estimator_grad,
                           GPU,
                           ALL_LAYOUT,
 
@@ -106,62 +106,5 @@ __global__ void ClipAndQuantKernel(const T *in,
   }
 }
 
-template <typename T>
-__global__ void ClipAndQuantDequantKernel(const T *in,
-                                          const T *scale,
-                                          const int bin_cnt,
-                                          const int round_type,
-                                          const int n,
-                                          T *out) {
-  int bid = threadIdx.x + blockIdx.x * blockDim.x;
-  int tid = threadIdx.x;
-
-  using ComputeDataType = typename QuantizeDataType<T>::type;
-
-  ComputeDataType s = static_cast<ComputeDataType>(scale[0]);
-  ComputeDataType inv_s = phi::funcs::inverse(s);
-  ComputeDataType bin_cnt_t = static_cast<ComputeDataType>(bin_cnt);
-
-  for (int i = bid; i < n; i += blockDim.x * gridDim.x) {
-    ComputeDataType x = static_cast<ComputeDataType>(in[i]);
-    if (round_type == 0) {
-      x = bin_cnt_t * inv_s * x;
-      x = phi::funcs::roundWithTiesToEven(x);
-      ComputeDataType max_bound = bin_cnt_t;
-      ComputeDataType min_bound = -bin_cnt_t - static_cast<ComputeDataType>(1);
-      x = x > max_bound ? max_bound : x;
-      x = x < min_bound ? min_bound : x;
-      out[i] = static_cast<T>((x * s) / bin_cnt_t);
-    } else {
-      x = x > s ? s : x;
-      x = x < -s ? -s : x;
-      x = bin_cnt_t * inv_s * x;
-      x = round(x);
-      out[i] = static_cast<T>((x * s) / bin_cnt_t);
-    }
-  }
-}
-
-template <typename T>
-struct ClipAndFakeQuantDequantFunctor<phi::GPUContext, T> {
-  void operator()(const phi::GPUContext &ctx,
-                  const phi::DenseTensor &in,
-                  const phi::DenseTensor &scale,
-                  const int bin_cnt,
-                  const int round_type,
-                  phi::DenseTensor *out) {
-    int num = in.numel();
-    int block = 1024;
-    int grid = (block - 1 + num) / block;
-
-    const T *in_data = in.data<T>();
-    const T *scale_data = scale.data<T>();
-    T *out_data = out->mutable_data<T>(ctx.GetPlace());
-
-    ClipAndQuantDequantKernel<T><<<grid, block, 0, ctx.stream()>>>(
-        in_data, scale_data, bin_cnt, round_type, num, out_data);
-  }
-};
-
 }  // namespace operators
 }  // namespace paddle