[MLU] fix custom_device uts, remove fluid apis (#455)

Author: cifar10

backends/mlu/tests/unittests/test_hard_sigmoid_op_mlu.py

@@ -28,7 +28,7 @@
 
 
 def ref_hardsigmoid(x, slope=0.166666666666667, offset=0.5):
-    return np.maximum(np.minimum(x * slope + offset, 1.), 0.).astype(x.dtype)
+    return np.maximum(np.minimum(x * slope + offset, 1.0), 0.0).astype(x.dtype)
 
 
 class TestMLUHardSigmoid(OpTest):
@@ -42,7 +42,7 @@ def setUp(self):
 
         x = np.random.uniform(-5, 5, [10, 12]).astype(self.dtype)
         lower_threshold = -self.offset / self.slope
-        upper_threshold = (1. - self.offset) / self.slope
+        upper_threshold = (1.0 - self.offset) / self.slope
 
         # Same reason as TestAbs
         delta = 0.005
@@ -51,19 +51,19 @@ def setUp(self):
 
         out = ref_hardsigmoid(x, self.slope, self.offset)
 
-        self.attrs = {'slope': self.slope, 'offset': self.offset}
-        self.inputs = {'X': x}
-        self.outputs = {'Out': out}
+        self.attrs = {"slope": self.slope, "offset": self.offset}
+        self.inputs = {"X": x}
+        self.outputs = {"Out": out}
 
     def test_check_output(self):
         self.check_output_with_place(self.place)
 
     def test_check_grad(self):
-        self.check_grad_with_place(self.place, ['X'], 'Out')
+        self.check_grad_with_place(self.place, ["X"], "Out")
 
     def set_mlu(self):
         self.__class__.use_custom_device = True
-        self.place = paddle.CustomPlace('CustomMLU', 0)
+        self.place = paddle.CustomPlace("CustomMLU", 0)
 
     def init_dtype(self):
         self.dtype = np.float32
@@ -89,13 +89,13 @@ class TestMLUHardSigmoidFp16(unittest.TestCase):
     def setUp(self):
         paddle.disable_static()
 
-        self.place = paddle.CustomPlace('CustomMLU', 0)
+        self.place = paddle.CustomPlace("CustomMLU", 0)
         self.__class__.use_custom_device = True
         self.dtype = np.float32
 
         # float32
         self.float32_x = np.random.uniform(-5, 5, [10, 12]).astype(np.float32)
-        paddle.set_device('cpu')
+        paddle.set_device("cpu")
         data = paddle.to_tensor(self.float32_x, stop_gradient=True)
         self.float32_y = F.hardsigmoid(data)
 
@@ -105,23 +105,27 @@ def setUp(self):
 
     def test_check_output_and_grad_mlu(self):
         # mlu float16
-        paddle.set_device('CustomMLU')
+        paddle.set_device("CustomMLU")
         data = paddle.to_tensor(self.float16_x, stop_gradient=True)
         mlu_float16_y = F.hardsigmoid(data)
 
         cpu_diff_1 = np.divide(
             np.sum(np.abs(self.float32_y.numpy() - self.float16_y)),
-            np.sum(np.abs(self.float32_y.numpy())))
+            np.sum(np.abs(self.float32_y.numpy())),
+        )
         mlu_diff_1 = np.divide(
             np.sum(np.abs(self.float32_y.numpy() - mlu_float16_y.numpy())),
-            np.sum(np.abs(self.float32_y.numpy())))
+            np.sum(np.abs(self.float32_y.numpy())),
+        )
 
         cpu_diff_2 = np.divide(
             np.sum(np.square(self.float32_y.numpy() - self.float16_y)),
-            np.sum(np.square(self.float32_y.numpy())))
+            np.sum(np.square(self.float32_y.numpy())),
+        )
         mlu_diff_2 = np.divide(
             np.sum(np.square(self.float32_y.numpy() - mlu_float16_y.numpy())),
-            np.sum(np.square(self.float32_y.numpy())))
+            np.sum(np.square(self.float32_y.numpy())),
+        )
         assert mlu_diff_1 <= cpu_diff_1
         assert mlu_diff_2 <= cpu_diff_2
 
@@ -130,17 +134,17 @@ class TestHardsigmoidAPI(unittest.TestCase):
     # test paddle.nn.Hardsigmoid, paddle.nn.functional.hardsigmoid
     def setUp(self):
         self.x_np = np.random.uniform(-1, 1, [10, 12]).astype(np.float32)
-        self.place = paddle.CustomPlace('CustomMLU', 0)
+        self.place = paddle.CustomPlace("CustomMLU", 0)
         self.__class__.use_custom_device = True
 
     def test_static_api(self):
         with paddle.static.program_guard(paddle.static.Program()):
-            x = paddle.static.data('X', self.x_np.shape, self.x_np.dtype)
+            x = paddle.static.data("X", self.x_np.shape, self.x_np.dtype)
             out1 = F.hardsigmoid(x)
             m = paddle.nn.Hardsigmoid()
             out2 = m(x)
             exe = paddle.static.Executor(self.place)
-            res = exe.run(feed={'X': self.x_np}, fetch_list=[out1, out2])
+            res = exe.run(feed={"X": self.x_np}, fetch_list=[out1, out2])
         out_ref = ref_hardsigmoid(self.x_np)
         for r in res:
             np.testing.assert_allclose(out_ref, r, rtol=1e-6)
@@ -159,16 +163,16 @@ def test_dygraph_api(self):
     def test_fluid_api(self):
         paddle.enable_static()
         with fluid.program_guard(fluid.Program()):
-            x = fluid.data('X', self.x_np.shape, self.x_np.dtype)
-            out = fluid.layers.hard_sigmoid(x)
+            x = fluid.data("X", self.x_np.shape, self.x_np.dtype)
+            out = paddle.nn.functional.hardsigmoid(x, slope=0.2)
             exe = fluid.Executor(self.place)
-            res = exe.run(feed={'X': self.x_np}, fetch_list=[out])
+            res = exe.run(feed={"X": self.x_np}, fetch_list=[out])
         out_ref = ref_hardsigmoid(self.x_np, 0.2, 0.5)
         np.testing.assert_allclose(out_ref, res[0])
 
         paddle.disable_static(self.place)
         x = paddle.to_tensor(self.x_np)
-        out = paddle.fluid.layers.hard_sigmoid(x)
+        out = paddle.nn.functional.hardsigmoid(x, slope=0.2)
         np.testing.assert_allclose(out_ref, out.numpy())
         paddle.enable_static()
 
@@ -177,14 +181,12 @@ def test_errors(self):
             # The input type must be Variable.
             self.assertRaises(TypeError, F.hardsigmoid, 1)
             # The input dtype must be float16, float32, float64.
-            x_int32 = paddle.fluid.data(
-                name='x_int32', shape=[12, 10], dtype='int32')
+            x_int32 = paddle.fluid.data(name="x_int32", shape=[12, 10], dtype="int32")
             self.assertRaises(TypeError, F.hardsigmoid, x_int32)
             # support the input dtype is float16
-            x_fp16 = paddle.fluid.data(
-                name='x_fp16', shape=[12, 10], dtype='float16')
+            x_fp16 = paddle.fluid.data(name="x_fp16", shape=[12, 10], dtype="float16")
             F.hardsigmoid(x_fp16)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

backends/mlu/tests/unittests/test_huber_loss_op_mlu.py

@@ -19,7 +19,7 @@
 from tests.op_test import OpTest
 import paddle
 import paddle.fluid as fluid
-from paddle.fluid import compiler, Program, program_guard
+from paddle.fluid import Program, program_guard
 
 paddle.enable_static()
 
@@ -33,31 +33,29 @@ def huber_loss_forward(val, delta):
 
 
 class TestHuberLossOp(OpTest):
-
     def setUp(self):
-        self.op_type = 'huber_loss'
+        self.op_type = "huber_loss"
         self.set_mlu()
-        self.python_api = paddle.fluid.layers.huber_loss
+        self.python_api = paddle.nn.functional.smooth_l1_loss
         self.python_out_sig = ["Out"]
         self.delta = 1.0
         self.init_input()
         shape = self.set_shape()
-        residual = self.inputs['Y'] - self.inputs['X']
-        loss = np.vectorize(huber_loss_forward)(residual,
-                                                self.delta).astype('float32')
-        self.attrs = {'delta': self.delta}
-        self.outputs = {'Residual': residual, 'Out': loss.reshape(shape)}
+        residual = self.inputs["Y"] - self.inputs["X"]
+        loss = np.vectorize(huber_loss_forward)(residual, self.delta).astype("float32")
+        self.attrs = {"delta": self.delta}
+        self.outputs = {"Residual": residual, "Out": loss.reshape(shape)}
 
     def init_input(self):
         shape = self.set_shape()
         self.inputs = {
-            'X': np.random.uniform(0, 1., shape).astype('float32'),
-            'Y': np.random.uniform(0, 1., shape).astype('float32'),
+            "X": np.random.uniform(0, 1.0, shape).astype("float32"),
+            "Y": np.random.uniform(0, 1.0, shape).astype("float32"),
         }
 
     def set_mlu(self):
         self.__class__.use_custom_device = True
-        self.place = paddle.CustomPlace('CustomMLU', 0)
+        self.place = paddle.CustomPlace("CustomMLU", 0)
 
     def set_shape(self):
         return (100, 1)
@@ -66,60 +64,68 @@ def test_check_output(self):
         self.check_output_with_place(self.place, atol=1e-3)
 
     def test_check_grad_normal(self):
-        self.check_grad_with_place(self.place, ['X', 'Y'], 'Out')
+        self.check_grad_with_place(self.place, ["X", "Y"], "Out")
 
     def test_check_grad_ingore_x(self):
-        self.check_grad_with_place(self.place, ['Y'],
-                                   'Out',
-                                   max_relative_error=0.008,
-                                   no_grad_set=set("residual"))
+        self.check_grad_with_place(
+            self.place,
+            ["Y"],
+            "Out",
+            max_relative_error=0.008,
+            no_grad_set=set("residual"),
+        )
 
     def test_check_grad_ingore_y(self):
-        self.check_grad_with_place(self.place, ['X'],
-                                   'Out',
-                                   max_relative_error=0.008,
-                                   no_grad_set=set('residual'))
+        self.check_grad_with_place(
+            self.place,
+            ["X"],
+            "Out",
+            max_relative_error=0.008,
+            no_grad_set=set("residual"),
+        )
 
 
 def TestHuberLossOp1(TestHuberLossOp):
-
     def set_shape(self):
-        return (64)
+        return 64
 
 
 def TestHuberLossOp2(TestHuberLossOp):
-
     def set_shape(self):
         return (6, 6)
 
 
 def TestHuberLossOp3(TestHuberLossOp):
-
     def set_shape(self):
         return (6, 6, 1)
 
 
 class TestHuberLossOpError(unittest.TestCase):
-
     def test_errors(self):
         with program_guard(Program(), Program()):
             # the input and label must be Variable
             xw = np.random.random((6, 6)).astype("float32")
-            xr = fluid.data(name='xr', shape=[None, 6], dtype="float32")
+            xr = fluid.data(name="xr", shape=[None, 6], dtype="float32")
             lw = np.random.random((6, 6)).astype("float32")
-            lr = fluid.data(name='lr', shape=[None, 6], dtype="float32")
+            lr = fluid.data(name="lr", shape=[None, 6], dtype="float32")
             delta = 1.0
-            self.assertRaises(TypeError, fluid.layers.huber_loss, xr, lw, delta)
-            self.assertRaises(TypeError, fluid.layers.huber_loss, xw, lr, delta)
+            self.assertRaises(
+                TypeError, paddle.nn.functional.smooth_l1_loss, xr, lw, delta
+            )
+            self.assertRaises(
+                TypeError, paddle.nn.functional.smooth_l1_loss, xw, lr, delta
+            )
 
             # the dtype of input and label must be float32 or float64
-            xw2 = fluid.data(name='xw2', shape=[None, 6], dtype="int32")
-            lw2 = fluid.data(name='lw2', shape=[None, 6], dtype="int32")
-            self.assertRaises(TypeError, fluid.layers.huber_loss, xw2, lr,
-                              delta)
-            self.assertRaises(TypeError, fluid.layers.huber_loss, xr, lw2,
-                              delta)
-
-
-if __name__ == '__main__':
-    unittest.main()
+            xw2 = fluid.data(name="xw2", shape=[None, 6], dtype="int32")
+            lw2 = fluid.data(name="lw2", shape=[None, 6], dtype="int32")
+            self.assertRaises(
+                TypeError, paddle.nn.functional.smooth_l1_loss, xw2, lr, delta
+            )
+            self.assertRaises(
+                TypeError, paddle.nn.functional.smooth_l1_loss, xr, lw2, delta
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()