fix bug

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

@@ -97,12 +97,15 @@ def init_dtype(self):
 
 class TestRemainderOp(unittest.TestCase):
 
+    def _executed_api(self, x, y, name=None):
+        return paddle.remainder(x, y, name)
+
     def test_name(self):
         with fluid.program_guard(fluid.Program()):
             x = fluid.data(name="x", shape=[2, 3], dtype="int64")
             y = fluid.data(name='y', shape=[2, 3], dtype='int64')
 
-            y_1 = paddle.remainder(x, y, name='div_res')
+            y_1 = self._executed_api(x, y, name='div_res')
             self.assertEqual(('div_res' in y_1.name), True)
 
     def test_dygraph(self):
@@ -111,7 +114,7 @@ def test_dygraph(self):
             np_y = np.array([1, 5, 3, 3]).astype('int64')
             x = paddle.to_tensor(np_x)
             y = paddle.to_tensor(np_y)
-            z = paddle.remainder(x, y)
+            z = self._executed_api(x, y)
             np_z = z.numpy()
             z_expected = np.array([0, 3, 2, 1])
             self.assertEqual((np_z == z_expected).all(), True)
@@ -135,40 +138,41 @@ def test_dygraph(self):
 
 class TestRemainderInplaceOp(unittest.TestCase):
 
-    def test_name(self):
-        with fluid.program_guard(fluid.Program()):
-            x = fluid.data(name="x", shape=[2, 3], dtype="int64")
-            y = fluid.data(name='y', shape=[2, 3], dtype='int64')
+    def _executed_api(self, x, y, name=None):
+        return x.subtract_(y, name)
 
-            y_1 = paddle.remainder_(x, y, name='div_res')
-            self.assertEqual(('div_res' in y_1.name), True)
 
-    def test_dygraph(self):
-        with fluid.dygraph.guard():
-            np_x = np.array([2, 3, 8, 7]).astype('int64')
-            np_y = np.array([1, 5, 3, 3]).astype('int64')
-            x = paddle.to_tensor(np_x)
-            y = paddle.to_tensor(np_y)
-            z = paddle.remainder_(x, y)
-            np_z = z.numpy()
-            z_expected = np.array([0, 3, 2, 1])
-            self.assertEqual((np_z == z_expected).all(), True)
+class TestRemainderInplaceBroadcastSuccess(unittest.TestCase):
 
-            np_x = np.array([-3.3, 11.5, -2, 3.5])
-            np_y = np.array([-1.2, 2., 3.3, -2.3])
-            x = paddle.to_tensor(np_x)
-            y = paddle.to_tensor(np_y)
-            z = x % y
-            z_expected = np.array([-0.9, 1.5, 1.3, -1.1])
-            np.testing.assert_allclose(z_expected, z.numpy(), rtol=1e-05)
+    def init_data(self):
+        self.x_numpy = np.random.rand(2, 3, 4).astype('float')
+        self.y_numpy = np.random.rand(3, 4).astype('float')
 
-            np_x = np.array([-3, 11, -2, 3])
-            np_y = np.array([-1, 2, 3, -2])
-            x = paddle.to_tensor(np_x, dtype="int64")
-            y = paddle.to_tensor(np_y, dtype="int64")
-            z = x % y
-            z_expected = np.array([0, 1, 1, -1])
-            np.testing.assert_allclose(z_expected, z.numpy(), rtol=1e-05)
+    def test_broadcast_success(self):
+        paddle.disable_static()
+        self.init_data()
+        x = paddle.to_tensor(self.x_numpy)
+        y = paddle.to_tensor(self.y_numpy)
+        inplace_result = x.remainder_(y)
+        numpy_result = self.x_numpy % self.y_numpy
+        self.assertEqual((inplace_result.numpy() == numpy_result).all(), True)
+        paddle.enable_static()
+
+
+class TestRemainderInplaceBroadcastSuccess2(TestRemainderInplaceBroadcastSuccess
+                                            ):
+
+    def init_data(self):
+        self.x_numpy = np.random.rand(1, 2, 3, 1).astype('float')
+        self.y_numpy = np.random.rand(3, 1).astype('float')
+
+
+class TestRemainderInplaceBroadcastSuccess3(TestRemainderInplaceBroadcastSuccess
+                                            ):
+
+    def init_data(self):
+        self.x_numpy = np.random.rand(2, 3, 1, 5).astype('float')
+        self.y_numpy = np.random.rand(1, 3, 1, 5).astype('float')
 
 
 if __name__ == '__main__':

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

@@ -485,15 +485,6 @@ def inplace_api_processing(self, var):
 
 class TestDygraphInplaceRemainder(unittest.TestCase):
 
-    def setUp(self):
-        self.init_data()
-        self.set_np_compare_func()
-
-    def init_data(self):
-        self.input_var_numpy = np.random.rand(2, 3, 4)
-        self.dtype = "float32"
-        self.input_var_numpy_2 = np.random.rand(2, 3, 4).astype(self.dtype)
-
     def non_inplace_api_processing(self, var):
         input_var_2 = paddle.to_tensor(self.input_var_numpy_2)
         return var.remainder(input_var_2)
@@ -502,40 +493,17 @@ def inplace_api_processing(self, var):
         input_var_2 = paddle.to_tensor(self.input_var_numpy_2)
         return var.remainder_(input_var_2)
 
-    def set_np_compare_func(self):
-        self.np_compare = np.array_equal
-
-    def func_test_inplace_api(self):
-        var = paddle.to_tensor(self.input_var_numpy).astype(self.dtype)
-        inplace_var = self.inplace_api_processing(var)
-        self.assertTrue(id(var) == id(inplace_var))
-
-        inplace_var[0] = 2.
-        np.testing.assert_array_equal(var.numpy(), inplace_var.numpy())
-
-    def test_inplace_api(self):
-        with _test_eager_guard():
-            self.func_test_inplace_api()
-        self.func_test_inplace_api()
-
-    def func_test_forward_version(self):
-        with paddle.fluid.dygraph.guard():
-            var = paddle.to_tensor(self.input_var_numpy).astype(self.dtype)
-            self.assertEqual(var.inplace_version, 0)
-
-            inplace_var = self.inplace_api_processing(var)
-            self.assertEqual(var.inplace_version, 1)
+    def test_leaf_inplace_var_error(self):
+        pass
 
-            inplace_var[0] = 2.
-            self.assertEqual(var.inplace_version, 2)
+    def test_backward_error(self):
+        pass
 
-            inplace_var = self.inplace_api_processing(inplace_var)
-            self.assertEqual(var.inplace_version, 3)
+    def test_backward_success_1(self):
+        pass
 
-    def test_forward_version(self):
-        with _test_eager_guard():
-            self.func_test_forward_version()
-        self.func_test_forward_version()
+    def test_backward_success_2(self):
+        pass
 
 
 class TestLossIsInplaceVar(unittest.TestCase):