add gradient test framework

paddle/framework/pybind.cc

@@ -55,6 +55,10 @@ void ExposeOperator(ClassType &m) {
            [](const typename ClassType::type &op) -> std::vector<std::string> {
              return op.outputs_;
            })
+      .def("inputs",
+           [](const typename ClassType::type &op) -> std::vector<std::string> {
+             return op.inputs_;
+           })
       .def("__str__", &ClassType::type::DebugString);
 }
 

python/paddle/v2/framework/tests/op_test_util.py

@@ -68,3 +68,69 @@ def test_all(self):
 
         obj.test_all = test_all
         return obj
+
+
+def create_grad_op(op_type):
+    func = getattr(creation.op_creations, op_type, None)
+    assert (func is not None)
+
+    kwargs = dict()
+    for in_name in func.all_input_args:
+        kwargs[in_name] = in_name
+    for out_name in func.all_output_args:
+        kwargs[out_name] = out_name
+    op = func(**kwargs)
+    backward_op = core.Operator.backward(op, set())
+    return backward_op
+
+
+class GradOpTestMeta(type):
+    """
+    Operator Test ClassMeta.
+
+    It injects `test_all` method into user's OperatorTest class, to make Python
+    unittest module run that method.
+
+    The `test_all` read what value is stored in `self`. It use self's values to
+    create and run a operator, and check whether that op is OK or not.
+
+    See `test_add_two_op` for example usage.
+    """
+
+    def __new__(cls, name, bases, attrs):
+        obj = super(GradOpTestMeta, cls).__new__(cls, name, bases, attrs)
+
+        def test_all(self):
+            backward_op = create_grad_op(self.type)
+
+            scope = core.Scope()
+
+            places = []
+            places.append(core.CPUPlace())
+            if core.is_compile_gpu():
+                places.append(core.GPUPlace(0))
+
+            for place in places:
+                for in_name in backward_op.inputs():
+                    if hasattr(self, in_name):
+                        var = scope.new_var(in_name).get_tensor()
+                        arr = getattr(self, in_name)
+                        var.set_dims(arr.shape)
+                        var.set(arr, place)
+
+                for out_name in backward_op.outputs():
+                    if hasattr(self, out_name):
+                        scope.new_var(out_name).get_tensor()
+
+                backward_op.infer_shape(scope)
+
+                ctx = core.DeviceContext.create(place)
+                backward_op.run(scope, ctx)
+
+                for out_name in backward_op.outputs():
+                    actual = numpy.array(scope.find_var(out_name).get_tensor())
+                    expect = getattr(self, out_name)
+                    numpy.testing.assert_almost_equal(actual, expect, decimal=3)
+
+        obj.test_all = test_all
+        return obj

python/paddle/v2/framework/tests/test_softmax_op.py

@@ -4,7 +4,7 @@
 import paddle.v2.framework.core as core
 import paddle.v2.framework.create_op_creation_methods as creation
 
-from op_test_util import OpTestMeta
+from op_test_util import OpTestMeta, GradOpTestMeta
 
 
 def stable_softmax(x):
@@ -23,6 +23,32 @@ def setUp(self):
         self.Y = np.apply_along_axis(stable_softmax, 1, self.X)
 
 
+class TestSoftmaxGradOp1(unittest.TestCase):
+    __metaclass__ = GradOpTestMeta
+
+    def setUp(self):
+        batch_size = 3
+        class_num = 5
+
+        # Initialize X and add 1e-2 for numerical stability
+        Y = np.random.rand(batch_size, class_num).astype(np.float32)
+        Y = Y + 1e-2
+        dY = np.random.rand(batch_size, class_num).astype(np.float32)
+
+        # Reference implementation of cross entropy with soft labels
+        def label_softmax_grad(Y, dY):
+            dX = Y * 0.0
+            for i in range(batch_size):
+                d = np.dot(Y[i, :], dY[i, :])
+                dX[i, :] = Y[i, :] * (dY[i, :] - d)
+            return dX
+
+        self.type = "softmax"
+        setattr(self, "Y", Y)
+        setattr(self, "Y@GRAD", dY)
+        setattr(self, "X@GRAD", label_softmax_grad(Y, dY))
+
+
 class TestSoftmaxGradOp(unittest.TestCase):
     def test_softmax_grad(self):
         op = creation.op_creations.softmax(X="X", Y="Y")