Delete grad Op

Author: From00

paddle/fluid/operators/eigvals_op.cc

@@ -73,63 +73,17 @@ class EigvalsOpVarTypeInference : public framework::VarTypeInference {
     ctx->SetOutputDataType("Out", output_dtype);
   }
 };
-
-class EigvalsGradOp : public framework::OperatorWithKernel {
- public:
-  using framework::OperatorWithKernel::OperatorWithKernel;
-  void InferShape(framework::InferShapeContext* ctx) const override {
-    OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "EigvalsGrad");
-    OP_INOUT_CHECK(ctx->HasInput(framework::GradVarName("Out")), "Input",
-                   "Out@Grad", "EigvalsGrad");
-    OP_INOUT_CHECK(ctx->HasOutput(framework::GradVarName("X")), "Output",
-                   "X@Grad", "EigvalsGrad");
-    ctx->SetOutputDim(framework::GradVarName("X"), ctx->GetInputDim("X"));
-  }
-
- protected:
-  framework::OpKernelType GetExpectedKernelType(
-      const framework::ExecutionContext& ctx) const override {
-    return framework::OpKernelType(
-        OperatorWithKernel::IndicateVarDataType(ctx, "X"), ctx.GetPlace());
-  }
-};
-
-template <typename T>
-class EigvalsGradOpMaker : public framework::SingleGradOpMaker<T> {
- public:
-  using framework::SingleGradOpMaker<T>::SingleGradOpMaker;
-
- protected:
-  void Apply(GradOpPtr<T> retv) const override {
-    retv->SetType("eigvals_grad");
-    retv->SetInput("X", this->Input("X"));
-    retv->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out"));
-    retv->SetOutput(framework::GradVarName("X"), this->InputGrad("X"));
-  }
-};
 }  // namespace operators
 }  // namespace paddle
 namespace ops = paddle::operators;
 namespace plat = paddle::platform;
 
 REGISTER_OPERATOR(eigvals, ops::EigvalsOp, ops::EigvalsOpMaker,
-                  ops::EigvalsOpVarTypeInference,
-                  ops::EigvalsGradOpMaker<paddle::framework::OpDesc>,
-                  ops::EigvalsGradOpMaker<paddle::imperative::OpBase>);
-REGISTER_OPERATOR(eigvals_grad, ops::EigvalsGradOp);
+                  ops::EigvalsOpVarTypeInference);
 REGISTER_OP_CPU_KERNEL(eigvals,
                        ops::EigvalsKernel<plat::CPUDeviceContext, float>,
                        ops::EigvalsKernel<plat::CPUDeviceContext, double>,
                        ops::EigvalsKernel<plat::CPUDeviceContext,
                                           paddle::platform::complex<float>>,
                        ops::EigvalsKernel<plat::CPUDeviceContext,
                                           paddle::platform::complex<double>>);
-
-// TODO(Ruibiao): Support gradient kernel for Eigvals OP
-// REGISTER_OP_CPU_KERNEL(eigvals_grad,
-// ops::EigvalsGradKernel<plat::CPUDeviceContext, float>,
-// ops::EigvalsGradKernel<plat::CPUDeviceContext, double>,
-// ops::EigvalsGradKernel<plat::CPUDeviceContext,
-// paddle::platform::complex<float>>,
-// ops::EigvalsGradKernel<plat::CPUDeviceContext,
-// paddle::platform::complex<double>>);

python/paddle/fluid/tests/unittests/test_eigvals_op.py

@@ -32,26 +32,6 @@ def np_eigvals(a):
     return res
 
 
-''' Keep it for testing gradient kernel in the future.
-def np_eigvals_grad(a, out_grad):
-    l, v = np.linalg.eig(a)
-    print("l:")
-    print(l)
-    print("v:")
-    print(v)
-    vh = v.conj().T
-    print("vh:")
-    print(vh)
-    print("out_grad:")
-    print(out_grad)
-    a_grad = np.linalg.solve(vh, np.diagflat(out_grad, 0) * vh)
-    print("a_grad")
-    print(a_grad)
-
-    return a_grad.astype(a.dtype)
-'''
-
-
 class TestEigvalsOp(OpTest):
     def setUp(self):
         np.random.seed(0)
@@ -86,26 +66,6 @@ def test_check_output(self):
         self.check_output_with_place_customized(
             checker=self.verify_output, place=core.CPUPlace())
 
-    ''' The gradient kernel of this operator does not yet develop.
-    def test_check_grad_normal(self):
-        self.grad_dtype = self.dtype
-        if self.dtype == np.float32:
-            self.grad_dtype = np.complex64
-        elif self.dtype == np.float64:
-            self.grad_dtype = np.complex128
-
-        self.out_grad = (np.random.random(self.input_dims[-1:]) + 
-            np.random.random(self.input_dims[-1:]) * 1j).astype(self.grad_dtype)
-        self.x_grad = np_eigvals_grad(self.input_data, self.out_grad)
-
-        print("np_eigvals_grad:\n")
-        print(self.x_grad)
-
-        self.check_grad(['X'], 'Out', 
-            user_defined_grads=[self.x_grad],
-            user_defined_grad_outputs=[self.out_grad])
-    '''
-
     def verify_output(self, outs):
         actual_outs = np.sort(np.array(outs[0]))
         expect_outs = np.sort(np.array(self.outputs['Out']))