[CodeStyle][UP034] remove (()) cases (#52060)

* add up34

* modify var name in loop

* revert changes in test_slice

* Revert "modify var name in loop"

This reverts commit 6d748e371afb417054ed0c6b36fd11e87959a90d.

* temporarily ignore test_slice.py

* add comment

* empty commit, re-trigger all ci

* fix inc

---------
Co-authored-by: NSigureMo <sigure.qaq@gmail.com>

paddle/fluid/operators/generator/cross_validate.py

@@ -26,7 +26,7 @@ def main(forward_op_yaml_paths, backward_op_yaml_paths):
         with open(op_yaml_path, "rt", encoding="utf-8") as f:
             op_list = yaml.safe_load(f)
             if op_list is not None:
-                ops.update(to_named_dict((op_list)))
+                ops.update(to_named_dict(op_list))
 
     cross_validate(ops)
 

pyproject.toml

@@ -80,7 +80,7 @@ select = [
     # "UP031",
     # "UP032",
     "UP033",
-    # "UP034",
+    "UP034",
     "UP035",
     "UP036",
 
@@ -168,6 +168,11 @@ unfixable = [
 ]
 
 [tool.ruff.per-file-ignores]
+# Ignore unused imports in __init__.py
 "__init__.py" = ["F401"]
+# Temporarily ignore test_slice.py to avoid PR-CI-CINN failure, please fix!
+"python/paddle/fluid/tests/unittests/dygraph_to_static/test_slice.py" = ["UP034"]
+# Ignore version check in setup.py
 "setup.py" = ["UP036"]
+# Ignore unnecessary lambda in dy2st unittest test_lambda
 "python/paddle/fluid/tests/unittests/dygraph_to_static/test_lambda.py" = ["PLC3002"]

python/paddle/distributed/auto_parallel/tuner/profiler.py

@@ -270,7 +270,7 @@ def profiler(args):
             with open(result_path, 'w') as fp:
                 json.dump(result_dict, fp)
 
-        print("profile done! avg speed : {} step / s.".format((avg_tput)))
+        print("profile done! avg speed : {} step / s.".format(avg_tput))
 
     except paddle.framework.core.EOFException:
         data_loader._inner_dataloader.reset()

python/paddle/distributed/fleet/meta_optimizers/ascend/ascend_parser.py

@@ -219,7 +219,7 @@ class AscendParserBase:
         tensor = core.GETensor(tensor_desc)
 
         data = (
-            (value * np.ones((shape)))
+            (value * np.ones(shape))
             .reshape(shape)
             .astype(self.ascend_helper.dtype2np(dtype))
         )
@@ -282,7 +282,7 @@ class AscendParserBase:
         )
         tensor = core.GETensor(tensor_desc)
 
-        data = np.ones((2)).astype("int32").reshape([2])
+        data = np.ones(2).astype("int32").reshape([2])
         data[0] = 64
         buf = data.tobytes()
         data_8 = np.frombuffer(buf, dtype=np.uint8)

python/paddle/distribution/normal.py

@@ -241,7 +241,7 @@ class Normal(distribution.Distribution):
         )
         return paddle.add(
             0.5 + zero_tmp,
-            0.5 * math.log(2 * math.pi) + paddle.log((self.scale + zero_tmp)),
+            0.5 * math.log(2 * math.pi) + paddle.log(self.scale + zero_tmp),
             name=name,
         )
 

python/paddle/fluid/tests/unittests/distribution/test_distribution_transform.py

@@ -1185,7 +1185,7 @@ class TestStickBreakingTransform(unittest.TestCase):
     def test_codomain(self):
         self.assertTrue(isinstance(self._t._codomain, variable.Variable))
 
-    @param.param_func(((np.random.random((10)),),))
+    @param.param_func(((np.random.random(10),),))
     def test_forward(self, input):
         np.testing.assert_allclose(
             self._t.inverse(self._t.forward(paddle.to_tensor(input))),
@@ -1202,7 +1202,7 @@ class TestStickBreakingTransform(unittest.TestCase):
     def test_inverse_shape(self, shape, expected_shape):
         self.assertEqual(self._t.inverse_shape(shape), expected_shape)
 
-    @param.param_func(((np.random.random((10)),),))
+    @param.param_func(((np.random.random(10),),))
     def test_forward_log_det_jacobian(self, x):
         self.assertEqual(
             self._t.forward_log_det_jacobian(paddle.to_tensor(x)).shape, [1]

python/paddle/fluid/tests/unittests/dygraph_to_static/test_basic_api_transformation.py

@@ -456,7 +456,7 @@ def _dygraph_fn():
     x = np.random.random((1, 3)).astype('float32')
     with fluid.dygraph.guard():
         fluid.dygraph.to_variable(x)
-        np.random.random((1))
+        np.random.random(1)
 
 
 class TestDygraphApiRecognition(unittest.TestCase):

python/paddle/fluid/tests/unittests/dygraph_to_static/test_break_continue.py

@@ -204,7 +204,7 @@ def test_optim_break_in_while(x):
 
 class TestContinueInFor(unittest.TestCase):
     def setUp(self):
-        self.input = np.zeros((1)).astype('int64')
+        self.input = np.zeros(1).astype('int64')
         self.place = (
             fluid.CUDAPlace(0)
             if fluid.is_compiled_with_cuda()

python/paddle/fluid/tests/unittests/dygraph_to_static/test_cache_program.py

@@ -138,7 +138,7 @@ class TestConvertWithCache(unittest.TestCase):
 
 @to_static
 def sum_even_until_limit(max_len, limit):
-    ret_sum = fluid.dygraph.to_variable(np.zeros((1)).astype('int32'))
+    ret_sum = fluid.dygraph.to_variable(np.zeros(1).astype('int32'))
     for i in range(max_len):
         if i % 2 > 0:
             continue
@@ -150,8 +150,8 @@ def sum_even_until_limit(max_len, limit):
 
 
 def sum_under_while(limit):
-    i = fluid.dygraph.to_variable(np.zeros((1)).astype('int32'))
-    ret_sum = fluid.dygraph.to_variable(np.zeros((1)).astype('int32'))
+    i = fluid.dygraph.to_variable(np.zeros(1).astype('int32'))
+    ret_sum = fluid.dygraph.to_variable(np.zeros(1).astype('int32'))
     while i <= limit:
         ret_sum += i
         i += 1

python/paddle/fluid/tests/unittests/dygraph_to_static/test_dict.py

@@ -171,7 +171,7 @@ def test_dic_pop_2(x):
 
 class TestDictPop(unittest.TestCase):
     def setUp(self):
-        self.input = np.random.random((3)).astype('int32')
+        self.input = np.random.random(3).astype('int32')
         self.place = (
             paddle.CUDAPlace(0)
             if paddle.is_compiled_with_cuda()

python/paddle/fluid/tests/unittests/dygraph_to_static/test_list.py

@@ -219,7 +219,7 @@ class TestListWithoutControlFlow(unittest.TestCase):
         self.init_dygraph_func()
 
     def init_data(self):
-        self.input = np.random.random((3)).astype('int32')
+        self.input = np.random.random(3).astype('int32')
 
     def init_dygraph_func(self):
         self.all_dygraph_funcs = [
@@ -275,7 +275,7 @@ class TestListInIf(TestListWithoutControlFlow):
 
 class TestListInWhileLoop(TestListWithoutControlFlow):
     def init_data(self):
-        self.input = np.random.random((3)).astype('int32')
+        self.input = np.random.random(3).astype('int32')
         self.iter_num = 3
 
     def init_dygraph_func(self):

python/paddle/fluid/tests/unittests/dygraph_to_static/test_return.py

@@ -265,7 +265,7 @@ def test_return_nested(x):
 
 class TestReturnBase(unittest.TestCase):
     def setUp(self):
-        self.input = np.ones((1)).astype('int32')
+        self.input = np.ones(1).astype('int32')
         self.place = (
             fluid.CUDAPlace(0)
             if fluid.is_compiled_with_cuda()

python/paddle/fluid/tests/unittests/dygraph_to_static/test_transformer.py

@@ -108,7 +108,7 @@ def train_static(args, batch_generator):
             # the best cross-entropy value with label smoothing
             loss_normalizer = -(
                 (1.0 - args.label_smooth_eps)
-                * np.log((1.0 - args.label_smooth_eps))
+                * np.log(1.0 - args.label_smooth_eps)
                 + args.label_smooth_eps
                 * np.log(
                     args.label_smooth_eps / (args.trg_vocab_size - 1) + 1e-20
@@ -221,8 +221,7 @@ def train_dygraph(args, batch_generator):
         )
         # the best cross-entropy value with label smoothing
         loss_normalizer = -(
-            (1.0 - args.label_smooth_eps)
-            * np.log((1.0 - args.label_smooth_eps))
+            (1.0 - args.label_smooth_eps) * np.log(1.0 - args.label_smooth_eps)
             + args.label_smooth_eps
             * np.log(args.label_smooth_eps / (args.trg_vocab_size - 1) + 1e-20)
         )

python/paddle/fluid/tests/unittests/ipu/test_modelruntime_ipu.py

@@ -123,10 +123,8 @@ class TestBase(IPUOpTest):
                 pad_batch = self.batch_size - dy_batch
                 for k, v in feed.items():
                     pad_size = tuple(
-                        (
-                            (0, 0 if i != 0 else pad_batch)
-                            for i in range(len(v.shape))
-                        )
+                        (0, 0 if i != 0 else pad_batch)
+                        for i in range(len(v.shape))
                     )
                     feed[k] = np.pad(v, pad_size, 'constant', constant_values=0)
 

python/paddle/fluid/tests/unittests/ir/inference/test_conv_elementwise_add2_act_fuse_pass.py

@@ -62,24 +62,20 @@ class TestConvElementwiseAdd2ActPass(PassAutoScanTest):
             if (
                 int(
                     (
-                        (
-                            input_shape[2]
-                            - (dilations[0] * (filter_shape[2] - 1) + 1)
-                        )
-                        / strides[0]
-                        + 1
+                        input_shape[2]
+                        - (dilations[0] * (filter_shape[2] - 1) + 1)
                     )
+                    / strides[0]
+                    + 1
                 )
                 <= 0
                 or int(
                     (
-                        (
-                            input_shape[3]
-                            - (dilations[1] * (filter_shape[3] - 1) + 1)
-                        )
-                        / strides[1]
-                        + 1
+                        input_shape[3]
+                        - (dilations[1] * (filter_shape[3] - 1) + 1)
                     )
+                    / strides[1]
+                    + 1
                 )
                 <= 0
             ):
@@ -88,28 +84,24 @@ class TestConvElementwiseAdd2ActPass(PassAutoScanTest):
             if (
                 int(
                     (
-                        (
-                            input_shape[2]
-                            + paddings[0]
-                            + paddings[1]
-                            - (dilations[0] * (filter_shape[2] - 1) + 1)
-                        )
-                        / strides[0]
-                        + 1
+                        input_shape[2]
+                        + paddings[0]
+                        + paddings[1]
+                        - (dilations[0] * (filter_shape[2] - 1) + 1)
                     )
+                    / strides[0]
+                    + 1
                 )
                 <= 0
                 or int(
                     (
-                        (
-                            input_shape[3]
-                            + paddings[2]
-                            + paddings[3]
-                            - (dilations[1] * (filter_shape[3] - 1) + 1)
-                        )
-                        / strides[1]
-                        + 1
+                        input_shape[3]
+                        + paddings[2]
+                        + paddings[3]
+                        - (dilations[1] * (filter_shape[3] - 1) + 1)
                     )
+                    / strides[1]
+                    + 1
                 )
                 <= 0
             ):
@@ -206,27 +198,23 @@ class TestConvElementwiseAdd2ActPass(PassAutoScanTest):
                 f_shape[0],
                 int(
                     (
-                        (
-                            x_shape[2]
-                            + padding[0]
-                            + padding[1]
-                            - (dilations[0] * (f_shape[2] - 1) + 1)
-                        )
-                        / strides[0]
-                        + 1
+                        x_shape[2]
+                        + padding[0]
+                        + padding[1]
+                        - (dilations[0] * (f_shape[2] - 1) + 1)
                     )
+                    / strides[0]
+                    + 1
                 ),
                 int(
                     (
-                        (
-                            x_shape[3]
-                            + padding[2]
-                            + padding[3]
-                            - (dilations[1] * (f_shape[3] - 1) + 1)
-                        )
-                        / strides[1]
-                        + 1
+                        x_shape[3]
+                        + padding[2]
+                        + padding[3]
+                        - (dilations[1] * (f_shape[3] - 1) + 1)
                     )
+                    / strides[1]
+                    + 1
                 ),
             ]
 
@@ -241,18 +229,14 @@ class TestConvElementwiseAdd2ActPass(PassAutoScanTest):
                 x_shape[0],
                 f_shape[0],
                 int(
-                    (
-                        (x_shape[2] - (dilations[0] * (f_shape[2] - 1) + 1))
-                        / strides[0]
-                        + 1
-                    )
+                    (x_shape[2] - (dilations[0] * (f_shape[2] - 1) + 1))
+                    / strides[0]
+                    + 1
                 ),
                 int(
-                    (
-                        (x_shape[3] - (dilations[1] * (f_shape[3] - 1) + 1))
-                        / strides[1]
-                        + 1
-                    )
+                    (x_shape[3] - (dilations[1] * (f_shape[3] - 1) + 1))
+                    / strides[1]
+                    + 1
                 ),
             ]
             bias_index = 1

python/paddle/fluid/tests/unittests/ir/inference/test_mkldnn_prelu_op.py

@@ -42,7 +42,7 @@ class TestMkldnnPreluOp(MkldnnAutoScanTest):
             elif kwargs["mode"] == "channel":
                 if len(kwargs['in_shape']) <= 1:
                     # not valid case, just return 0
-                    return np.zeros((1)).astype(np.float32)
+                    return np.zeros(1).astype(np.float32)
                 if kwargs['data_format'] == 'NCHW':
                     return np.random.random(kwargs['in_shape'][1]).astype(
                         np.float32
@@ -54,7 +54,7 @@ class TestMkldnnPreluOp(MkldnnAutoScanTest):
             else:
                 if len(kwargs['in_shape']) <= 1:
                     # not valid case, just return 0
-                    return np.zeros((1)).astype(np.float32)
+                    return np.zeros(1).astype(np.float32)
                 return np.random.random(kwargs['in_shape']).astype(np.float32)
 
         prelu_op = OpConfig(

python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_where.py

@@ -35,7 +35,7 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest):
 
         def generate_input1(dims, batch):
             if dims == 1:
-                return np.zeros((batch)).astype(np.float32)
+                return np.zeros(batch).astype(np.float32)
             elif dims == 2:
                 return np.ones((batch, 4)).astype(np.float32)
             elif dims == 3:
@@ -45,7 +45,7 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest):
 
         def generate_input2(dims, batch):
             if dims == 1:
-                return np.zeros((batch)).astype(np.float32)
+                return np.zeros(batch).astype(np.float32)
             elif dims == 2:
                 return np.ones((batch, 4)).astype(np.float32)
             elif dims == 3:
@@ -55,7 +55,7 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest):
 
         def generate_input3(dims, batch):
             if dims == 1:
-                return np.zeros((batch)).astype(np.float32)
+                return np.zeros(batch).astype(np.float32)
             elif dims == 2:
                 return np.ones((batch, 4)).astype(np.float32)
             elif dims == 3:

python/paddle/fluid/tests/unittests/mkldnn/test_expand_v2_mkldnn_op.py

@@ -90,7 +90,7 @@ class TestExpandV2ExpandShapesTensor1OneDNNOp(TestExpandV2OneDNNOp):
         self.expand_shapes_tensor = []
         for index, ele in enumerate(self.expand_shape):
             self.expand_shapes_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
     def set_additional_inputs(self):

python/paddle/fluid/tests/unittests/mkldnn/test_fc_int8_mkldnn_op.py

@@ -64,7 +64,7 @@ class TestFCINT8OneDNNOp(OpTest):
 
         self.out_float = np.dot(self.x_float, self.y_float)
         if self.use_bias:
-            self.bias = np.random.random((10)).astype("float32") * 10
+            self.bias = np.random.random(10).astype("float32") * 10
             self.out_float += self.bias
 
         self.out_scale, self.out = self.quantize(self.out_float)

python/paddle/fluid/tests/unittests/mkldnn/test_fill_constant_mkldnn_op.py

@@ -78,7 +78,7 @@ class TestFillZerosLike4DShapeTensorListPriorityOneDNNOp(
         self.shape_tensor_list = []
         for index, elem in enumerate(shape):
             self.shape_tensor_list.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * elem)
+                ("x" + str(index), np.ones(1).astype('int32') * elem)
             )
 
         self.inputs = {'ShapeTensorList': self.shape_tensor_list}

python/paddle/fluid/tests/unittests/mkldnn/test_matmul_mkldnn_op.py

@@ -119,17 +119,17 @@ class TestDnnlMatMulOpMixedDimsXWiderTransposeX(TestDnnlMatMulWithGradOp):
 
 class TestDnnlMatMulOpVectorMultiply(TestDnnlMatMulWithGradOp):
     def generate_data(self):
-        self.x = np.random.random((5)).astype("float32")
-        self.y = np.random.random((5)).astype("float32")
+        self.x = np.random.random(5).astype("float32")
+        self.y = np.random.random(5).astype("float32")
         self.out = np.matmul(self.x, self.y)
 
 
 class TestDnnlMatMulOpVectorMultiplyTranspose(TestDnnlMatMulWithGradOp):
     def generate_data(self):
-        self.x = np.random.random((5)).astype("float32")
+        self.x = np.random.random(5).astype("float32")
         x_resized = np.copy(self.x)
         x_resized = np.expand_dims(x_resized, 1)
-        self.y = np.random.random((6)).astype("float32")
+        self.y = np.random.random(6).astype("float32")
         y_resized = np.copy(self.y)
         y_resized = np.expand_dims(y_resized, 0)
         self.out = np.matmul(x_resized, y_resized)

python/paddle/fluid/tests/unittests/mkldnn/test_prelu_mkldnn_op.py

@@ -103,14 +103,14 @@ class TestPReluModeChannelAlpha1DOneDNNOp(TestPReluModeChannelOneDNNOp):
     def init_attrs(self):
         self.mode = "channel"
         self.x = np.random.random((1, 100, 1)).astype("float32")
-        self.alpha = np.random.random((100)).astype("float32")
+        self.alpha = np.random.random(100).astype("float32")
 
 
 class TestPReluModeAllAlpha1DOneDNNOp(TestPReluModeAllOneDNNOp):
     def init_attrs(self):
         self.mode = "channel"
         self.x = np.random.random((1, 1, 100)).astype("float32")
-        self.alpha = np.random.random((1)).astype("float32")
+        self.alpha = np.random.random(1).astype("float32")
 
 
 #   BF16 TESTS

python/paddle/fluid/tests/unittests/mkldnn/test_reshape_mkldnn_op.py

@@ -119,7 +119,7 @@ class TestReshape2OneDNNOpDimInfer1_attr_ShapeTensor(TestReshape2OneDNNOp):
         shape_tensor = []
         for index, ele in enumerate(self.new_shape):
             shape_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs["ShapeTensor"] = shape_tensor
@@ -138,7 +138,7 @@ class TestReshape2OneDNNOpDimInfer1_attr_ShapeTensorAndShape(
         shape_tensor = []
         for index, ele in enumerate(self.new_shape):
             shape_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs["Shape"] = np.array((1, 2, 3, 4), dtype="int32")

python/paddle/fluid/tests/unittests/mkldnn/test_slice_mkldnn_op.py

@@ -160,7 +160,7 @@ class TestSliceOneDNNOp_decs_dim_starts_ListTensor(
     def set_inputs(self):
         starts_tensor = []
         for index, ele in enumerate(self.starts):
-            starts_tensor.append(("x1", np.ones((1)).astype('int32') * 2))
+            starts_tensor.append(("x1", np.ones(1).astype('int32') * 2))
         self.inputs = {'Input': self.input, 'StartsTensorList': starts_tensor}
 
     def config(self):

python/paddle/fluid/tests/unittests/mkldnn/test_split_bf16_mkldnn_op.py

@@ -96,7 +96,7 @@ class TestSplitSectionsTensorBF16OneDNNOp(TestSplitSectionsBF16OneDNNOp):
         self.sections_tensor_list = []
         for index, ele in enumerate(self.sections):
             self.sections_tensor_list.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
         self.sections = [-1, -1, -1]
         indices_or_sections = [2, 3]  # sections

python/paddle/fluid/tests/unittests/mkldnn/test_split_mkldnn_op.py

@@ -114,7 +114,7 @@ class TestSplitSectionsTensorOneDNNOp(TestSplitSectionsOneDNNOp):
         self.sections_tensor_list = []
         for index, ele in enumerate(self.sections):
             self.sections_tensor_list.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
         self.sections = [-1, -1, -1]
         indices_or_sections = [2, 3]  # sections

python/paddle/fluid/tests/unittests/sequence/test_sequence_pad_op.py

@@ -70,7 +70,7 @@ class TestSequencePadOp(OpTest):
             start_idx = end_idx
 
         out_data = np.array(padded_sequences)
-        length = np.array(self.x_len_lod[0]).reshape((-1))
+        length = np.array(self.x_len_lod[0]).reshape(-1)
         self.outputs = {'Out': out_data, 'Length': length}
 
     def setUp(self):
@@ -90,7 +90,7 @@ class TestSequencePadOp2(TestSequencePadOp):
     def set_attr(self):
         self.x_shape = [12, 10]
         self.x_len_lod = [[2, 3, 4, 3]]
-        self.pad_value = np.random.random((10))
+        self.pad_value = np.random.random(10)
         self.padded_length = -1
         self.dtype = 'float64'
 
@@ -108,7 +108,7 @@ class TestSequencePadOp4(TestSequencePadOp):
     def set_attr(self):
         self.x_shape = [12, 10]
         self.x_len_lod = [[2, 3, 4, 3]]
-        self.pad_value = np.random.random((10))
+        self.pad_value = np.random.random(10)
         self.padded_length = 7
         self.dtype = 'float64'
 

python/paddle/fluid/tests/unittests/sequence/test_sequence_unpad_op.py

@@ -98,7 +98,7 @@ class TestSequenceUnpadOpError(unittest.TestCase):
 
         def test_length_variable():
             x1 = paddle.static.data(name='x1', shape=[10, 5], dtype='float32')
-            len1 = np.random.random((10)).astype("int64")
+            len1 = np.random.random(10).astype("int64")
             paddle.static.nn.sequence_lod.sequence_pad(x=x1, length=len1)
 
         self.assertRaises(TypeError, test_length_variable)

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

@@ -2444,7 +2444,7 @@ class TestSoftRelu(TestActivation):
         t = np.copy(x)
         t[t < -threshold] = -threshold
         t[t > threshold] = threshold
-        out = np.log((np.exp(t) + 1))
+        out = np.log(np.exp(t) + 1)
 
         self.inputs = {'X': OpTest.np_dtype_to_fluid_dtype(x)}
         self.attrs = {'threshold': threshold}

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

@@ -794,14 +794,14 @@ class TestAdamWOpLayerwiseLR(TestAdamWOp):
                 out = linear1(x)
                 out = linear2(out)
 
-                fc1_w_mon1 = np.zeros((linear1.weight.shape)).astype("float32")
-                fc1_w_mon2 = np.zeros((linear1.weight.shape)).astype("float32")
-                fc1_b_mon1 = np.zeros((linear1.bias.shape)).astype("float32")
-                fc1_b_mon2 = np.zeros((linear1.bias.shape)).astype("float32")
-                fc2_w_mon1 = np.zeros((linear2.weight.shape)).astype("float32")
-                fc2_w_mon2 = np.zeros((linear2.weight.shape)).astype("float32")
-                fc2_b_mon1 = np.zeros((linear2.bias.shape)).astype("float32")
-                fc2_b_mon2 = np.zeros((linear2.bias.shape)).astype("float32")
+                fc1_w_mon1 = np.zeros(linear1.weight.shape).astype("float32")
+                fc1_w_mon2 = np.zeros(linear1.weight.shape).astype("float32")
+                fc1_b_mon1 = np.zeros(linear1.bias.shape).astype("float32")
+                fc1_b_mon2 = np.zeros(linear1.bias.shape).astype("float32")
+                fc2_w_mon1 = np.zeros(linear2.weight.shape).astype("float32")
+                fc2_w_mon2 = np.zeros(linear2.weight.shape).astype("float32")
+                fc2_b_mon1 = np.zeros(linear2.bias.shape).astype("float32")
+                fc2_b_mon2 = np.zeros(linear2.bias.shape).astype("float32")
 
                 cost = paddle.nn.functional.square_error_cost(
                     input=out, label=y

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

@@ -230,7 +230,7 @@ class TestAddMMOp4(OpTest):
         self.dtype = np.float64
         self.init_dtype_type()
         self.inputs = {
-            'Input': np.random.random((100)).astype(self.dtype),
+            'Input': np.random.random(100).astype(self.dtype),
             'X': np.random.random((20, 10)).astype(self.dtype),
             'Y': np.random.random((10, 100)).astype(self.dtype),
         }
@@ -296,7 +296,7 @@ class TestAddMMAPI(unittest.TestCase):
         self.assertRaises(ValueError, test_error1)
 
         def test_error2():
-            data_x_wrong = np.ones((2)).astype(np.float32)
+            data_x_wrong = np.ones(2).astype(np.float32)
             x = paddle.to_tensor(data_x_wrong)
             y = paddle.to_tensor(data_y)
             input = paddle.to_tensor(data_input)
@@ -318,7 +318,7 @@ class TestAddMMAPI(unittest.TestCase):
         self.assertRaises(ValueError, test_error3)
 
         def test_error4():
-            data_input_wrong = np.ones((5)).astype(np.float32)
+            data_input_wrong = np.ones(5).astype(np.float32)
             x = paddle.to_tensor(data_x)
             y = paddle.to_tensor(data_y)
             input = paddle.to_tensor(data_input_wrong)
@@ -358,7 +358,7 @@ class TestAddMMAPI(unittest.TestCase):
     def test_api_normal_2(self):
         data_x = np.ones((3, 10)).astype(np.float32)
         data_y = np.ones((10, 3)).astype(np.float32)
-        data_input = np.ones((3)).astype(np.float32)
+        data_input = np.ones(3).astype(np.float32)
         data_alpha = 0.1
         data_beta = 1.0
 
@@ -383,7 +383,7 @@ class TestAddMMAPI(unittest.TestCase):
     def test_api_normal_3(self):
         data_x = np.ones((3, 10)).astype(np.float32)
         data_y = np.ones((10, 3)).astype(np.float32)
-        data_input = np.ones((1)).astype(np.float32)
+        data_input = np.ones(1).astype(np.float32)
         data_alpha = 0.1
         data_beta = 1.0
 

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

@@ -32,7 +32,7 @@ class TestCheckFiniteAndUnscaleOp(OpTest):
         self.python_out_sig = ["out0", "FoundInfinite"]
         self.init_dtype()
         x = np.random.random((1024, 1024)).astype(self.dtype)
-        scale = np.random.random((1)).astype(self.dtype)
+        scale = np.random.random(1).astype(self.dtype)
 
         self.inputs = {'X': [('x0', x)], 'Scale': scale}
         self.outputs = {
@@ -55,7 +55,7 @@ class TestCheckFiniteAndUnscaleOpWithNan(OpTest):
         self.python_out_sig = ["out0", "FoundInfinite"]
         x = np.random.random((1024, 1024)).astype(self.dtype)
         x[128][128] = np.nan
-        scale = np.random.random((1)).astype(self.dtype)
+        scale = np.random.random(1).astype(self.dtype)
 
         self.inputs = {'X': [('x0', x)], 'Scale': scale}
         self.outputs = {
@@ -80,7 +80,7 @@ class TestCheckFiniteAndUnscaleOpWithInf(OpTest):
         self.python_out_sig = ["out0", "FoundInfinite"]
         x = np.random.random((1024, 1024)).astype(self.dtype)
         x[128][128] = np.inf
-        scale = np.random.random((1)).astype(self.dtype)
+        scale = np.random.random(1).astype(self.dtype)
 
         self.inputs = {'X': [('x0', x)], 'Scale': scale}
         self.outputs = {

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

@@ -24,7 +24,7 @@ def output_hist(out):
     hist, _ = np.histogram(out, bins=2)
     hist = hist.astype("float32")
     hist /= float(out.size)
-    prob = 0.5 * np.ones((2))
+    prob = 0.5 * np.ones(2)
     return hist, prob
 
 

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

@@ -446,7 +446,7 @@ class TestBilinearInterpOp_attr_tensor(OpTest):
             size_tensor = []
             for index, ele in enumerate(self.out_size):
                 size_tensor.append(
-                    ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                    ("x" + str(index), np.ones(1).astype('int32') * ele)
                 )
             self.inputs['SizeTensor'] = size_tensor
 

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

@@ -798,7 +798,7 @@ class TestBilinearInterpOp_attr_tensor(OpTest):
             size_tensor = []
             for index, ele in enumerate(self.out_size):
                 size_tensor.append(
-                    ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                    ("x" + str(index), np.ones(1).astype('int32') * ele)
                 )
             self.inputs['SizeTensor'] = size_tensor
 

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

@@ -293,7 +293,7 @@ class TestBoxCoderOpWithVariance(OpTest):
         self.python_api = wrapper_box_coder
         lod = [[1, 1, 1, 1, 1]]
         prior_box = np.random.random((30, 4)).astype('float32')
-        prior_box_var = np.random.random((4)).astype('float32')
+        prior_box_var = np.random.random(4).astype('float32')
         target_box = np.random.random((30, 81, 4)).astype('float32')
         code_type = "DecodeCenterSize"
         box_normalized = False
@@ -325,7 +325,7 @@ class TestBoxCoderOpWithVarianceDygraphAPI(unittest.TestCase):
     def setUp(self):
         self.lod = [[1, 1, 1, 1, 1]]
         self.prior_box = np.random.random((30, 4)).astype('float32')
-        self.prior_box_var = np.random.random((4)).astype('float32')
+        self.prior_box_var = np.random.random(4).astype('float32')
         self.target_box = np.random.random((30, 81, 4)).astype('float32')
         self.code_type = "DecodeCenterSize"
         self.box_normalized = False

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

@@ -106,7 +106,7 @@ class TestAllocContinuousSpace(OpTest):
 
         coalesce_tensor_var = np.concatenate([input for input in inputs])
         if set_constant:
-            coalesce_tensor_var = np.ones((len(coalesce_tensor_var))) * constant
+            coalesce_tensor_var = np.ones(len(coalesce_tensor_var)) * constant
             outputs = [
                 (out[0], np.ones(out[1].shape).astype(self.dtype) * constant)
                 for out in outputs

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

@@ -332,7 +332,7 @@ def create_paddle_case(op_type, callback):
                 op = eval("paddle.%s" % (self.op_type))
                 out = op(x, y)
                 exe = paddle.static.Executor(self.place)
-                input_x = np.arange(0, 5).reshape((5)).astype(np.int32)
+                input_x = np.arange(0, 5).reshape(5).astype(np.int32)
                 input_y = np.array([5, 3, 2]).reshape((3, 1)).astype(np.int32)
                 real_result = callback(input_x, input_y)
                 (res,) = exe.run(

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

@@ -110,8 +110,8 @@ class TestComplexMatMulLayer(unittest.TestCase):
             x = np.random.random((2, 1, 100)).astype(
                 dtype
             ) + 1j * np.random.random((2, 1, 100)).astype(dtype)
-            y = np.random.random((100)).astype(dtype) + 1j * np.random.random(
-                (100)
+            y = np.random.random(100).astype(dtype) + 1j * np.random.random(
+                100
             ).astype(dtype)
 
             np_result = np.matmul(x, y)

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

@@ -147,7 +147,7 @@ class TestCropTensorOpTensorAttr(OpTest):
             shape_tensor = []
             for index, ele in enumerate(self.crop_shape):
                 shape_tensor.append(
-                    ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                    ("x" + str(index), np.ones(1).astype('int32') * ele)
                 )
             self.inputs = {
                 'X': np.random.random(self.x_shape).astype("float64"),
@@ -159,7 +159,7 @@ class TestCropTensorOpTensorAttr(OpTest):
             offsets_tensor = []
             for index, ele in enumerate(self.offsets):
                 offsets_tensor.append(
-                    ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                    ("x" + str(index), np.ones(1).astype('int32') * ele)
                 )
             self.inputs = {
                 'X': np.random.random(self.x_shape).astype("float64"),

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

@@ -860,7 +860,7 @@ class CrossEntropyLoss(unittest.TestCase):
         N = 100
         C = 200
         input_np = np.random.random([N, C]).astype(self.dtype)
-        label_np = -np.ones((N)).astype(np.int64)
+        label_np = -np.ones(N).astype(np.int64)
         paddle.enable_static()
         prog = fluid.Program()
         startup_prog = fluid.Program()

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

@@ -186,7 +186,7 @@ class TestSumOp6(TestSumOp1):
 
 class TestSumOp7(TestSumOp1):
     def set_attrs_input_output(self):
-        self.x = np.random.random((100)).astype(self.dtype_)
+        self.x = np.random.random(100).astype(self.dtype_)
         self.out = self.x.cumsum(axis=0)
 
 

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

@@ -73,7 +73,7 @@ class TestCumulativeTrapezoidWithOutDxX(TestCumulativeTrapezoidAPI):
 class TestCumulativeTrapezoidBroadcast(TestCumulativeTrapezoidAPI):
     def set_args(self):
         self.y = np.random.random((3, 3, 4)).astype('float32')
-        self.x = np.random.random((3)).astype('float32')
+        self.x = np.random.random(3).astype('float32')
         self.dx = None
         self.axis = 1
 

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

@@ -96,7 +96,7 @@ class TestDropoutOpInput1d(OpTest):
         self.attrs = {'dropout_prob': 0.0, 'fix_seed': True, 'is_test': False}
         self.outputs = {
             'Out': self.inputs['X'],
-            'Mask': np.ones((2000)).astype('uint8'),
+            'Mask': np.ones(2000).astype('uint8'),
         }
         # Because prim op compare res with dygraph
         # when p = 0 dropout api return x,in dygraph mode x_grad = out_grad,

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

@@ -348,7 +348,7 @@ class TestEigWrongDimsError(unittest.TestCase):
     def test_error(self):
         paddle.device.set_device("cpu")
         paddle.disable_static()
-        a = np.random.random((3)).astype('float32')
+        a = np.random.random(3).astype('float32')
         x = paddle.to_tensor(a)
         self.assertRaises(ValueError, paddle.linalg.eig, x)
 

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

@@ -106,7 +106,7 @@ class TestElementWiseAddOp(unittest.TestCase):
     def test_check_forward_backward_with_scale_and_bias(self):
         np.random.seed(123)
         self.x = np.random.random((4, 32, 220, 220)).astype(np.float32)
-        self.y = np.random.random((32)).astype(np.float32)
+        self.y = np.random.random(32).astype(np.float32)
         self.out = self.x + self.y.reshape(1, 32, 1, 1)
         self.axis = 1
         self.check_forward_backward()

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

@@ -160,7 +160,7 @@ class TestEmptyOp_ShapeTensorList(OpTest):
         shape_tensor_list = []
         for index, ele in enumerate(self.shape):
             shape_tensor_list.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs = {"ShapeTensorList": shape_tensor_list}

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

@@ -87,7 +87,7 @@ class TestExpandOpRank1_tensor_attr(OpTest):
         expand_times_tensor = []
         for index, ele in enumerate(self.expand_times):
             expand_times_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs = {

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

@@ -89,7 +89,7 @@ class TestExpandV2OpRank1_tensor_attr(OpTest):
         expand_shapes_tensor = []
         for index, ele in enumerate(self.expand_shape):
             expand_shapes_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs = {

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

@@ -51,7 +51,7 @@ class MatrixGenerate:
         if bias_dims == 2:
             self.bias = np.random.random((1, oc)).astype("float32")
         else:
-            self.bias = np.random.random((oc)).astype("float32")
+            self.bias = np.random.random(oc).astype("float32")
 
 
 class TestFCOp(OpTest):

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

@@ -155,7 +155,7 @@ class TestFillConstantOp1_ShapeTensorList(OpTest):
         shape_tensor_list = []
         for index, ele in enumerate(self.shape):
             shape_tensor_list.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs = {"ShapeTensorList": shape_tensor_list}
@@ -180,7 +180,7 @@ class TestFillConstantOp2_ShapeTensorList(OpTest):
         shape_tensor_list = []
         for index, ele in enumerate(self.shape):
             shape_tensor_list.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs = {"ShapeTensorList": shape_tensor_list}

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

@@ -68,7 +68,7 @@ class TestFullOp(unittest.TestCase):
         paddle.disable_static()
         input = paddle.arange(6, 10, dtype='float32')
         out = paddle.full_like(input, fill_value=888.88, dtype='float32')
-        out_numpy = np.random.random((4)).astype("float32")
+        out_numpy = np.random.random(4).astype("float32")
         out_numpy.fill(888.88)
         self.assertTrue((out.numpy() == out_numpy).all(), True)
         paddle.enable_static()
@@ -77,7 +77,7 @@ class TestFullOp(unittest.TestCase):
         paddle.disable_static()
         input = paddle.arange(6, 10, dtype='float32')
         out = paddle.full_like(input, fill_value=float('inf'))
-        out_numpy = np.random.random((4)).astype("float32")
+        out_numpy = np.random.random(4).astype("float32")
         out_numpy.fill(float('inf'))
         self.assertTrue((out.numpy() == out_numpy).all(), True)
         paddle.enable_static()

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

@@ -275,16 +275,16 @@ class APITestStaticFusedFFN(unittest.TestCase):
         linear1_weight_data = np.random.random(
             (d_model, dim_feedforward)
         ).astype(dtype)
-        linear1_bias_data = np.zeros((dim_feedforward)).astype(dtype)
+        linear1_bias_data = np.zeros(dim_feedforward).astype(dtype)
         linear2_weight_data = np.random.random(
             (dim_feedforward, d_model)
         ).astype(dtype)
-        linear2_bias_data = np.zeros((d_model)).astype(dtype)
+        linear2_bias_data = np.zeros(d_model).astype(dtype)
 
-        ln1_scale_data = np.ones((d_model)).astype(layer_norm_dtype)
-        ln1_bias_data = np.zeros((d_model)).astype(layer_norm_dtype)
-        ln2_scale_data = np.ones((d_model)).astype(layer_norm_dtype)
-        ln2_bias_data = np.zeros((d_model)).astype(layer_norm_dtype)
+        ln1_scale_data = np.ones(d_model).astype(layer_norm_dtype)
+        ln1_bias_data = np.zeros(d_model).astype(layer_norm_dtype)
+        ln2_scale_data = np.ones(d_model).astype(layer_norm_dtype)
+        ln2_bias_data = np.zeros(d_model).astype(layer_norm_dtype)
 
         res_list = [fused_out, ln_out]
         real_res = []

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

@@ -100,7 +100,7 @@ class TestFusedGateAttentionOp(OpTest):
             self.gating_b = _random((self.num_heads, self.head_dim))
 
         self.output_w = _random((self.num_heads, self.head_dim, self.out_dim))
-        self.output_b = _random((self.out_dim))
+        self.output_b = _random(self.out_dim)
 
         self.dout = _random(
             (self.batch_size, self.msa_len, self.res_len, self.q_dim)

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

@@ -123,7 +123,7 @@ class TestGaussianRandomOp_ShapeTensorList(TestGaussianRandomOp):
         shape_tensor_list = []
         for index, ele in enumerate(self.shape):
             shape_tensor_list.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.attrs = {

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

@@ -136,7 +136,7 @@ class TestGRUOp(OpTest):
             (self.num_layers * self.direction_num, batch_size, self.hidden_size)
         ).astype(self.dtype)
 
-        state_out = np.ndarray((300)).astype("uint8")
+        state_out = np.ndarray(300).astype("uint8")
 
         self.inputs = {
             'Input': input,
@@ -162,7 +162,7 @@ class TestGRUOp(OpTest):
         self.outputs = {
             'Out': output,
             'State': [('last_hidden', last_hidden)],
-            'Reserve': np.ndarray((400)).astype("uint8"),
+            'Reserve': np.ndarray(400).astype("uint8"),
             'DropoutState': state_out,
         }
 

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

@@ -186,7 +186,7 @@ class TestGumbelSoftmaxOpSampleDistribution(OpTest):
         # Construct statistics z for samples and
         # z is approximately N(0,1) for unbiased count
         expected = self.probs * self.shape[0]
-        z = (self.counts - expected) / np.sqrt((expected * (1 - self.probs)))
+        z = (self.counts - expected) / np.sqrt(expected * (1 - self.probs))
         # A (lazy) approximate 99% two-sided test:
         # occurs with prob alpha~>=0.01 if unbiased
         self.assertLess(np.max(np.abs(z)).item(), 2.58)

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

@@ -64,7 +64,7 @@ class TestDygraphFramework(unittest.TestCase):
                     "backward should not be usable in static graph mode"
                 )
             except AssertionError as e:
-                self.assertTrue((e is not None))
+                self.assertTrue(e is not None)
 
     def test_dygraph_to_string(self):
         np_inp = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)

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

@@ -38,7 +38,7 @@ def output_hist(out):
     hist, _ = np.histogram(out, range=(-1, 1))
     hist = hist.astype("float32")
     hist /= float(out.size)
-    prob = 0.1 * np.ones((10))
+    prob = 0.1 * np.ones(10)
     return hist, prob
 
 
@@ -632,7 +632,7 @@ class TestNumpyArrayInitializer(unittest.TestCase):
 
         program = framework.Program()
         block = program.global_block()
-        np_array = numpy.random.random((10000)).astype(dtype)
+        np_array = numpy.random.random(10000).astype(dtype)
         for _ in range(2):
             block.create_parameter(
                 dtype=np_array.dtype,

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

@@ -644,7 +644,7 @@ class TestAssign(unittest.TestCase):
 
         program = framework.Program()
         block = program.global_block()
-        np_array = numpy.random.random((10000)).astype(dtype)
+        np_array = numpy.random.random(10000).astype(dtype)
         for _ in range(2):
             block.create_parameter(
                 dtype=np_array.dtype,

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

@@ -1102,7 +1102,7 @@ class TestJitSaveLoadEmptyLayer(unittest.TestCase):
 
     def test_save_load_empty_layer(self):
         layer = EmptyLayer()
-        x = paddle.to_tensor(np.random.random((10)).astype('float32'))
+        x = paddle.to_tensor(np.random.random(10).astype('float32'))
         out = layer(x)
         paddle.jit.save(layer, self.model_path)
         load_layer = paddle.jit.load(self.model_path)
@@ -1124,8 +1124,8 @@ class TestJitSaveLoadNoParamLayer(unittest.TestCase):
 
     def test_save_load_no_param_layer(self):
         layer = NoParamLayer()
-        x = paddle.to_tensor(np.random.random((5)).astype('float32'))
-        y = paddle.to_tensor(np.random.random((5)).astype('float32'))
+        x = paddle.to_tensor(np.random.random(5).astype('float32'))
+        y = paddle.to_tensor(np.random.random(5).astype('float32'))
         out = layer(x, y)
         paddle.jit.save(layer, self.model_path)
         load_layer = paddle.jit.load(self.model_path)
@@ -1433,7 +1433,7 @@ class TestJitSaveLoadFinetuneLoad(unittest.TestCase):
         result_11 = layer_finetune(inps1)
 
         self.assertTrue(float((result_00 - result_10).abs().max()) < 1e-5)
-        self.assertTrue(float(((result_01 - result_11)).abs().max()) < 1e-5)
+        self.assertTrue(float((result_01 - result_11).abs().max()) < 1e-5)
 
 
 # NOTE(weixin): When there are multiple test functions in an

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

@@ -27,7 +27,7 @@ class LinearTestCase(unittest.TestCase):
         self.dtype = 'float32'
         self.input = np.ones((3, 1, 2)).astype(self.dtype)
         self.weight = np.ones((2, 2)).astype(self.dtype)
-        self.bias = np.ones((2)).astype(self.dtype)
+        self.bias = np.ones(2).astype(self.dtype)
         self.place = (
             paddle.CUDAPlace(0)
             if core.is_compiled_with_cuda()

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

@@ -227,7 +227,7 @@ class TestLinearInterpOpSizeTensor(TestLinearInterpOp):
             size_tensor = []
             for index, ele in enumerate(self.out_size):
                 size_tensor.append(
-                    ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                    ("x" + str(index), np.ones(1).astype('int32') * ele)
                 )
             self.inputs['SizeTensor'] = size_tensor
 

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

@@ -295,7 +295,7 @@ class TestLinearInterpOpSizeTensor(TestLinearInterpOp):
             size_tensor = []
             for index, ele in enumerate(self.out_size):
                 size_tensor.append(
-                    ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                    ("x" + str(index), np.ones(1).astype('int32') * ele)
                 )
             self.inputs['SizeTensor'] = size_tensor
 

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

@@ -474,7 +474,7 @@ class TestCUDNNLstmOp(OpTest):
         init_c = np.zeros((self.num_layers, batch_size, hidden_size)).astype(
             self.dtype
         )
-        state_out = np.ndarray((300)).astype("uint8")
+        state_out = np.ndarray(300).astype("uint8")
 
         if core.is_compiled_with_rocm():
             for i in range(len(flat_w)):
@@ -508,7 +508,7 @@ class TestCUDNNLstmOp(OpTest):
             'Out': output,
             "LastH": last_hidden,
             'LastC': last_cell,
-            'Reserve': np.ndarray((400)).astype("uint8"),
+            'Reserve': np.ndarray(400).astype("uint8"),
             'StateOut': state_out,
         }
 

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

@@ -268,7 +268,7 @@ class TestMeshGrid_ZeroDim(TestMeshgridOp):
         self.shape = self.get_x_shape()
         ins = []
         outs = []
-        ins.append(np.random.random(([])).astype(self.dtype))
+        ins.append(np.random.random([]).astype(self.dtype))
         ins.append(np.random.random([2]).astype(self.dtype))
         ins.append(np.random.random([3]).astype(self.dtype))
         for i in range(len(self.shape)):

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

@@ -104,7 +104,7 @@ class TestMultiDotOp4Mat(TestMultiDotOp):
 
 class TestMultiDotOpFirst1D(TestMultiDotOp):
     def get_inputs_and_outputs(self):
-        self.A = np.random.random((4)).astype(self.dtype)
+        self.A = np.random.random(4).astype(self.dtype)
         self.B = np.random.random((4, 3)).astype(self.dtype)
         self.inputs = {'X': [('x0', self.A), ('x1', self.B)]}
         self.outputs = {'Out': multi_dot([self.A, self.B])}
@@ -112,7 +112,7 @@ class TestMultiDotOpFirst1D(TestMultiDotOp):
 
 class TestMultiDotOp3MatFirst1D(TestMultiDotOp3Mat):
     def get_inputs_and_outputs(self):
-        self.A = np.random.random((4)).astype(self.dtype)
+        self.A = np.random.random(4).astype(self.dtype)
         self.B = np.random.random((4, 3)).astype(self.dtype)
         self.C = np.random.random((3, 3)).astype(self.dtype)
         self.inputs = {'X': [('x0', self.A), ('x1', self.B), ('x2', self.C)]}
@@ -121,7 +121,7 @@ class TestMultiDotOp3MatFirst1D(TestMultiDotOp3Mat):
 
 class TestMultiDotOp4MatFirst1D(TestMultiDotOp4Mat):
     def get_inputs_and_outputs(self):
-        self.A = np.random.random((4)).astype(self.dtype)
+        self.A = np.random.random(4).astype(self.dtype)
         self.B = np.random.random((4, 3)).astype(self.dtype)
         self.C = np.random.random((3, 4)).astype(self.dtype)
         self.D = np.random.random((4, 5)).astype(self.dtype)
@@ -139,7 +139,7 @@ class TestMultiDotOp4MatFirst1D(TestMultiDotOp4Mat):
 class TestMultiDotOpLast1D(TestMultiDotOp):
     def get_inputs_and_outputs(self):
         self.A = np.random.random((3, 6)).astype(self.dtype)
-        self.B = np.random.random((6)).astype(self.dtype)
+        self.B = np.random.random(6).astype(self.dtype)
         self.inputs = {'X': [('x0', self.A), ('x1', self.B)]}
         self.outputs = {'Out': multi_dot([self.A, self.B])}
 
@@ -148,7 +148,7 @@ class TestMultiDotOp3MatLast1D(TestMultiDotOp3Mat):
     def get_inputs_and_outputs(self):
         self.A = np.random.random((2, 4)).astype(self.dtype)
         self.B = np.random.random((4, 3)).astype(self.dtype)
-        self.C = np.random.random((3)).astype(self.dtype)
+        self.C = np.random.random(3).astype(self.dtype)
         self.inputs = {'X': [('x0', self.A), ('x1', self.B), ('x2', self.C)]}
         self.outputs = {'Out': multi_dot([self.A, self.B, self.C])}
 
@@ -163,7 +163,7 @@ class TestMultiDotOp4MatLast1D(TestMultiDotOp4Mat):
         self.A = np.random.random((2, 3)).astype(self.dtype)
         self.B = np.random.random((3, 2)).astype(self.dtype)
         self.C = np.random.random((2, 3)).astype(self.dtype)
-        self.D = np.random.random((3)).astype(self.dtype)
+        self.D = np.random.random(3).astype(self.dtype)
         self.inputs = {
             'X': [
                 ('x0', self.A),
@@ -178,7 +178,7 @@ class TestMultiDotOp4MatLast1D(TestMultiDotOp4Mat):
 class TestMultiDotOpFirstAndLast1D(TestMultiDotOp):
     def get_inputs_and_outputs(self):
         self.A = np.random.random((4,)).astype(self.dtype)
-        self.B = np.random.random((4)).astype(self.dtype)
+        self.B = np.random.random(4).astype(self.dtype)
         self.inputs = {'X': [('x0', self.A), ('x1', self.B)]}
         self.outputs = {'Out': multi_dot([self.A, self.B])}
 
@@ -187,7 +187,7 @@ class TestMultiDotOp3MatFirstAndLast1D(TestMultiDotOp3Mat):
     def get_inputs_and_outputs(self):
         self.A = np.random.random((6,)).astype(self.dtype)
         self.B = np.random.random((6, 4)).astype(self.dtype)
-        self.C = np.random.random((4)).astype(self.dtype)
+        self.C = np.random.random(4).astype(self.dtype)
         self.inputs = {'X': [('x0', self.A), ('x1', self.B), ('x2', self.C)]}
         self.outputs = {'Out': multi_dot([self.A, self.B, self.C])}
 
@@ -197,7 +197,7 @@ class TestMultiDotOp4MatFirstAndLast1D(TestMultiDotOp4Mat):
         self.A = np.random.random((3,)).astype(self.dtype)
         self.B = np.random.random((3, 4)).astype(self.dtype)
         self.C = np.random.random((4, 2)).astype(self.dtype)
-        self.D = np.random.random((2)).astype(self.dtype)
+        self.D = np.random.random(2).astype(self.dtype)
         self.inputs = {
             'X': [
                 ('x0', self.A),

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

@@ -37,7 +37,7 @@ class TestMVOp(OpTest):
 
     def init_config(self):
         self.x = np.random.random((2, 100)).astype("float64")
-        self.vec = np.random.random((100)).astype("float64")
+        self.vec = np.random.random(100).astype("float64")
 
 
 class TestMVAPI(unittest.TestCase):
@@ -46,7 +46,7 @@ class TestMVAPI(unittest.TestCase):
 
         self.x_data = np.random.random((5, 100)).astype("float64")
         self.x = paddle.to_tensor(self.x_data)
-        self.vec_data = np.random.random((100)).astype("float64")
+        self.vec_data = np.random.random(100).astype("float64")
         self.vec = paddle.to_tensor(self.vec_data)
         z = paddle.mv(self.x, self.vec)
         np_z = z.numpy()

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

@@ -189,7 +189,7 @@ class TestNanmedian(unittest.TestCase):
         x_np[2, 3:] = np.nan
         x_np_sorted = np.sort(x_np)
         nan_counts = np.count_nonzero(np.isnan(x_np).astype(np.int32), axis=1)
-        np_grad = np.zeros((shape))
+        np_grad = np.zeros(shape)
         for i in range(shape[0]):
             valid_cnts = shape[1] - nan_counts[i]
             if valid_cnts == 0:

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

@@ -374,7 +374,7 @@ class TestNearestInterpOp_attr_tensor(OpTest):
             size_tensor = []
             for index, ele in enumerate(self.out_size):
                 size_tensor.append(
-                    ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                    ("x" + str(index), np.ones(1).astype('int32') * ele)
                 )
             self.inputs['SizeTensor'] = size_tensor
 

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

@@ -874,7 +874,7 @@ class TestNearestInterpOp_attr_tensor(OpTest):
             size_tensor = []
             for index, ele in enumerate(self.out_size):
                 size_tensor.append(
-                    ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                    ("x" + str(index), np.ones(1).astype('int32') * ele)
                 )
             self.inputs['SizeTensor'] = size_tensor
 

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

@@ -128,7 +128,7 @@ class TestNpairLossOpError(unittest.TestCase):
         with program_guard(Program(), Program()):
             anchor_np = np.random.random((2, 4)).astype("float32")
             positive_np = np.random.random((2, 4)).astype("float32")
-            labels_np = np.random.random((2)).astype("float32")
+            labels_np = np.random.random(2).astype("float32")
             anchor_data = paddle.static.data(
                 name='anchor', shape=[2, 4], dtype='float32'
             )

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

@@ -27,7 +27,7 @@ class TestNumelOp(OpTest):
         self.op_type = "size"
         self.python_api = paddle.numel
         self.init()
-        x = np.random.random((self.shape)).astype(self.dtype)
+        x = np.random.random(self.shape).astype(self.dtype)
         self.inputs = {
             'Input': x,
         }
@@ -82,7 +82,7 @@ class TestNumelOpBF16(OpTest):
         self.python_api = paddle.numel
         self.dtype = np.uint16
         self.init()
-        x = np.random.random((self.shape)).astype(np.float32)
+        x = np.random.random(self.shape).astype(np.float32)
         self.inputs = {'Input': convert_float_to_uint16(x)}
         self.outputs = {'Out': np.array([np.size(x)])}
 

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

@@ -778,7 +778,7 @@ class TestCase4_AsyPadding(TestCase4):
         self.shape = [2, 3, 7, 7]
 
 
-class TestCase5_AsyPadding((TestCase5)):
+class TestCase5_AsyPadding(TestCase5):
     def init_test_case(self):
         self.ksize = [3, 3]
         self.strides = [1, 1]

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

@@ -55,7 +55,7 @@ class TestPyLayer(unittest.TestCase):
         z2.mean().backward()
 
         self.assertTrue(
-            np.max(np.abs((input1.grad.numpy() - input2.grad.numpy()))) < 1e-10
+            np.max(np.abs(input1.grad.numpy() - input2.grad.numpy())) < 1e-10
         )
 
     def test_simple_pylayer_return_none_with_no_grad(self):
@@ -91,7 +91,7 @@ class TestPyLayer(unittest.TestCase):
         z2.mean().backward()
 
         self.assertTrue(
-            np.max(np.abs((input1.grad.numpy() - input2.grad.numpy()))) < 1e-10
+            np.max(np.abs(input1.grad.numpy() - input2.grad.numpy())) < 1e-10
         )
 
     def test_simple_pylayer_single_output(self):
@@ -119,7 +119,7 @@ class TestPyLayer(unittest.TestCase):
         z2.mean().backward()
 
         self.assertTrue(
-            np.max(np.abs((input1.grad.numpy() - input2.grad.numpy()))) < 1e-10
+            np.max(np.abs(input1.grad.numpy() - input2.grad.numpy())) < 1e-10
         )
 
     def test_simple_pylayer_multi_output(self):
@@ -149,7 +149,7 @@ class TestPyLayer(unittest.TestCase):
         z2.mean().backward()
 
         self.assertTrue(
-            np.max(np.abs((input1.grad.numpy() - input2.grad.numpy()))) < 1e-10
+            np.max(np.abs(input1.grad.numpy() - input2.grad.numpy())) < 1e-10
         )
 
     def test_pylayer_num_output_match(self):

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

@@ -29,7 +29,7 @@ def output_hist(out):
     hist, _ = np.histogram(out, range=(-10, 10))
     hist = hist.astype("float32")
     hist /= float(out.size)
-    prob = 0.1 * np.ones((10))
+    prob = 0.1 * np.ones(10)
     return hist, prob
 
 
@@ -74,7 +74,7 @@ class TestRandintOp_attr_tensorlist(OpTest):
         shape_tensor = []
         for index, ele in enumerate(self.new_shape):
             shape_tensor.append(
-                ("x" + str(index), np.ones((1)).astype("int64") * ele)
+                ("x" + str(index), np.ones(1).astype("int64") * ele)
             )
         self.inputs = {'ShapeTensorList': shape_tensor}
         self.init_attrs()
@@ -160,7 +160,7 @@ class TestRandintImperative(unittest.TestCase):
         x3 = paddle.tensor.random.randint(n)
         for i in [x1, x2, x3]:
             for j in i.numpy().tolist():
-                self.assertTrue((j >= 0 and j < n))
+                self.assertTrue(j >= 0 and j < n)
         paddle.enable_static()
 
 

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

@@ -63,7 +63,7 @@ class TestRandpermOp(OpTest):
         self.dtype = "int64"
 
         self.inputs = {}
-        self.outputs = {"Out": np.zeros((self.n)).astype(self.dtype)}
+        self.outputs = {"Out": np.zeros(self.n).astype(self.dtype)}
         self.init_attrs()
         self.attrs = {
             "n": self.n,

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

@@ -24,7 +24,7 @@ from paddle.fluid import core
 def gen_input_help(input, rank_offset, max_rank, max_size):
     input_row, input_col = input.shape
     max_ins = np.max((max_size, input_row))
-    input_help = np.zeros((max_ins * max_rank * input_col))
+    input_help = np.zeros(max_ins * max_rank * input_col)
     ins_rank = np.zeros((max_ins, 1))
     ins_rank.fill(-1)
 

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

@@ -174,7 +174,7 @@ class TestReshapeOp_attr_ShapeTensor(OpTest):
         shape_tensor = []
         for index, ele in enumerate(self.new_shape):
             shape_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs = {

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

@@ -120,7 +120,7 @@ class TestRnnError(unittest.TestCase):
             self.assertRaises(TypeError, test_initial_states_type)
 
             def test_sequence_length_type():
-                np_sequence_length = np.random.random((batch_size)).astype(
+                np_sequence_length = np.random.random(batch_size).astype(
                     "float32"
                 )
                 dynamic_rnn(

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

@@ -137,7 +137,7 @@ class TestRNNOp(OpTest):
         init_c = np.zeros(
             (self.num_layers * self.direction_num, batch_size, hidden_size)
         ).astype(self.dtype)
-        state_out = np.ndarray((300)).astype("uint8")
+        state_out = np.ndarray(300).astype("uint8")
 
         self.inputs = {
             'Input': input,
@@ -163,7 +163,7 @@ class TestRNNOp(OpTest):
         self.outputs = {
             'Out': output,
             "State": [('last_hidden', last_hidden), ('last_cell', last_cell)],
-            'Reserve': np.ndarray((400)).astype("uint8"),
+            'Reserve': np.ndarray(400).astype("uint8"),
             'DropoutState': state_out,
         }
 

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

@@ -28,7 +28,7 @@ class TestSeedOpFixSeed(OpTest):
         self.op_type = "seed"
         self.inputs = {}
         self.attrs = {"seed": 123}
-        self.outputs = {"Out": np.asarray((123)).astype('int')}
+        self.outputs = {"Out": np.asarray(123).astype('int')}
 
     def test_check_output(self):
         self.check_output()
@@ -39,7 +39,7 @@ class TestSeedOpDiffSeed(OpTest):
         self.op_type = "seed"
         self.inputs = {}
         self.attrs = {"seed": 0}
-        self.outputs = {"Out": np.asarray((123)).astype('int')}
+        self.outputs = {"Out": np.asarray(123).astype('int')}
 
     def test_check_output(self):
         self.check_output(no_check_set=["Out"])

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

@@ -36,8 +36,8 @@ def sigmoid_focal_loss_forward(
         a = int(idx / num_classes)
         d = int(idx % num_classes)
         label = label_data[a]
-        c_pos = float((int(label) == int(d + 1)))
-        c_neg = float(((int(label) != -1) & (int(label) != (d + 1))))
+        c_pos = float(int(label) == int(d + 1))
+        c_neg = float((int(label) != -1) & (int(label) != (d + 1)))
         fg_num = max(fg_num_data, 1)
         z_neg = (1.0 - alpha) / fg_num
         z_pos = alpha / fg_num

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

@@ -128,7 +128,7 @@ class TestSimpleRNNOp(OpTest):
             (self.num_layers * self.direction_num, batch_size, hidden_size)
         ).astype(self.dtype)
 
-        state_out = np.ndarray((300)).astype("uint8")
+        state_out = np.ndarray(300).astype("uint8")
 
         self.inputs = {
             'Input': input,
@@ -154,7 +154,7 @@ class TestSimpleRNNOp(OpTest):
         self.outputs = {
             'Out': output,
             'State': [('last_hidden', last_hidden)],
-            'Reserve': np.ndarray((400)).astype("uint8"),
+            'Reserve': np.ndarray(400).astype("uint8"),
             'DropoutState': state_out,
         }
 

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

@@ -172,7 +172,7 @@ class TestSliceOp_starts_ListTensor(OpTest):
         starts_tensor = []
         for index, ele in enumerate(self.starts):
             starts_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int64') * ele)
+                ("x" + str(index), np.ones(1).astype('int64') * ele)
             )
 
         self.inputs = {'Input': self.input, 'StartsTensorList': starts_tensor}
@@ -212,7 +212,7 @@ class TestSliceOp_decs_dim_starts_ListTensor(OpTest):
         starts_tensor = []
         for index, ele in enumerate(self.starts):
             starts_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs = {'Input': self.input, 'StartsTensorList': starts_tensor}
@@ -379,7 +379,7 @@ class TestSliceOp_starts_OneTensor_ends_ListTensor(OpTest):
         ends_tensor = []
         for index, ele in enumerate(self.ends):
             ends_tensor.append(
-                ("y" + str(index), np.ones((1)).astype('int32') * ele)
+                ("y" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs = {

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

@@ -154,7 +154,7 @@ class TestSplitOp_SectionsTensor(OpTest):
         sections_tensor = []
         for index, ele in enumerate(self.sections):
             sections_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs['SectionsTensorList'] = sections_tensor

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

@@ -324,7 +324,7 @@ class TestStridedSliceOp_starts_ListTensor(OpTest):
         starts_tensor = []
         for index, ele in enumerate(self.starts):
             starts_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs = {'Input': self.input, 'StartsTensorList': starts_tensor}
@@ -366,7 +366,7 @@ class TestStridedSliceOp_ends_ListTensor(OpTest):
         ends_tensor = []
         for index, ele in enumerate(self.ends):
             ends_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs = {'Input': self.input, 'EndsTensorList': ends_tensor}
@@ -477,7 +477,7 @@ class TestStridedSliceOp_listTensor_Tensor(OpTest):
         ends_tensor = []
         for index, ele in enumerate(self.ends):
             ends_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
         self.op_type = "strided_slice"
         self.python_api = paddle.strided_slice

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

@@ -111,7 +111,7 @@ class TestTileOpRank1_tensor_attr(OpTest):
         repeat_times_tensor = []
         for index, ele in enumerate(self.repeat_times):
             repeat_times_tensor.append(
-                ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                ("x" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs = {

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

@@ -148,7 +148,7 @@ class TestTrapezoidWithOutDxX(TestTrapezoidAPI):
 class TestTrapezoidBroadcast(TestTrapezoidAPI):
     def set_args(self):
         self.y = np.random.random((3, 3, 4)).astype('float32')
-        self.x = np.random.random((3)).astype('float32')
+        self.x = np.random.random(3).astype('float32')
         self.dx = None
         self.axis = 1
 

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

@@ -528,7 +528,7 @@ class TestTrilinearInterpOp_attr_tensor(OpTest):
             size_tensor = []
             for index, ele in enumerate(self.out_size):
                 size_tensor.append(
-                    ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                    ("x" + str(index), np.ones(1).astype('int32') * ele)
                 )
             self.inputs['SizeTensor'] = size_tensor
 

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

@@ -888,7 +888,7 @@ class TestTrilinearInterpOp_attr_tensor(OpTest):
             size_tensor = []
             for index, ele in enumerate(self.out_size):
                 size_tensor.append(
-                    ("x" + str(index), np.ones((1)).astype('int32') * ele)
+                    ("x" + str(index), np.ones(1).astype('int32') * ele)
                 )
             self.inputs['SizeTensor'] = size_tensor
 

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

@@ -70,7 +70,7 @@ class TestUniformRandomOpBF16AttrTensorList(TestUniformRandomOpBF16):
         shape_tensor = []
         for index, ele in enumerate(self.new_shape):
             shape_tensor.append(
-                ("x" + str(index), np.ones((1)).astype("int64") * ele)
+                ("x" + str(index), np.ones(1).astype("int64") * ele)
             )
         self.inputs = {'ShapeTensorList': shape_tensor}
         self.init_attrs()

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

@@ -33,7 +33,7 @@ def output_hist(out):
     hist, _ = np.histogram(out, range=(-5, 10))
     hist = hist.astype("float32")
     hist /= float(out.size)
-    prob = 0.1 * np.ones((10))
+    prob = 0.1 * np.ones(10)
     return hist, prob
 
 
@@ -46,7 +46,7 @@ def output_hist_diag(out):
     hist, _ = np.histogram(out, range=(-5, 10))
     hist = hist.astype("float32")
     hist /= float(out.size)
-    prob = 0.1 * np.ones((10))
+    prob = 0.1 * np.ones(10)
     return hist, prob
 
 
@@ -58,7 +58,7 @@ class TestUniformRandomOp_attr_tensorlist(OpTest):
         shape_tensor = []
         for index, ele in enumerate(self.new_shape):
             shape_tensor.append(
-                ("x" + str(index), np.ones((1)).astype("int64") * ele)
+                ("x" + str(index), np.ones(1).astype("int64") * ele)
             )
         self.inputs = {'ShapeTensorList': shape_tensor}
         self.init_attrs()
@@ -90,7 +90,7 @@ class TestUniformRandomOp_attr_tensorlist_int32(OpTest):
         shape_tensor = []
         for index, ele in enumerate(self.new_shape):
             shape_tensor.append(
-                ("x" + str(index), np.ones((1)).astype("int32") * ele)
+                ("x" + str(index), np.ones(1).astype("int32") * ele)
             )
         self.inputs = {'ShapeTensorList': shape_tensor}
         self.init_attrs()
@@ -471,7 +471,7 @@ class TestUniformRandomDygraphMode(unittest.TestCase):
             x = paddle.uniform([10], dtype="float32", min=0.0, max=1.0)
             x_np = x.numpy()
             for i in range(10):
-                self.assertTrue((x_np[i] > 0 and x_np[i] < 1.0))
+                self.assertTrue(x_np[i] > 0 and x_np[i] < 1.0)
 
 
 class TestUniformRandomBatchSizeLikeOpError(unittest.TestCase):
@@ -562,7 +562,7 @@ class TestUniformDygraphMode(unittest.TestCase):
             )
             x_np = x.numpy()
             for i in range(10):
-                self.assertTrue((x_np[i] > 0 and x_np[i] < 1.0))
+                self.assertTrue(x_np[i] > 0 and x_np[i] < 1.0)
 
 
 class TestUniformDtype(unittest.TestCase):

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

@@ -120,7 +120,7 @@ class TestUnsqueezeOp_AxesTensorList(OpTest):
         axes_tensor_list = []
         for index, ele in enumerate(self.axes):
             axes_tensor_list.append(
-                ("axes" + str(index), np.ones((1)).astype('int32') * ele)
+                ("axes" + str(index), np.ones(1).astype('int32') * ele)
             )
 
         self.inputs = {

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

@@ -173,7 +173,7 @@ class TestVariable(unittest.TestCase):
             y_1 = y[:, 0]
             feeder = fluid.DataFeeder(place=place, feed_list=[x])
             data = []
-            data.append((np.random.randint(10, size=[13]).astype('float32')))
+            data.append(np.random.randint(10, size=[13]).astype('float32'))
             exe.run(fluid.default_startup_program())
 
             local_out = exe.run(

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

@@ -21,13 +21,13 @@ import paddle
 
 
 def sigmoid(x):
-    return 1.0 / (1.0 + np.exp(((-1.0) * x)))
+    return 1.0 / (1.0 + np.exp((-1.0) * x))
 
 
 def YoloBox(x, img_size, attrs):
     (n, c, h, w) = x.shape
     anchors = attrs['anchors']
-    an_num = int((len(anchors) // 2))
+    an_num = int(len(anchors) // 2)
     class_num = attrs['class_num']
     conf_thresh = attrs['conf_thresh']
     downsample = attrs['downsample_ratio']
@@ -145,7 +145,7 @@ class TestYoloBoxOp(OpTest):
 
     def initTestCase(self):
         self.anchors = [10, 13, 16, 30, 33, 23]
-        an_num = int((len(self.anchors) // 2))
+        an_num = int(len(self.anchors) // 2)
         self.batch_size = 32
         self.class_num = 2
         self.conf_thresh = 0.5
@@ -166,7 +166,7 @@ class TestYoloBoxOp(OpTest):
 class TestYoloBoxOpNoClipBbox(TestYoloBoxOp):
     def initTestCase(self):
         self.anchors = [10, 13, 16, 30, 33, 23]
-        an_num = int((len(self.anchors) // 2))
+        an_num = int(len(self.anchors) // 2)
         self.batch_size = 32
         self.class_num = 2
         self.conf_thresh = 0.5
@@ -187,7 +187,7 @@ class TestYoloBoxOpNoClipBbox(TestYoloBoxOp):
 class TestYoloBoxOpScaleXY(TestYoloBoxOp):
     def initTestCase(self):
         self.anchors = [10, 13, 16, 30, 33, 23]
-        an_num = int((len(self.anchors) // 2))
+        an_num = int(len(self.anchors) // 2)
         self.batch_size = 32
         self.class_num = 2
         self.conf_thresh = 0.5
@@ -208,7 +208,7 @@ class TestYoloBoxOpScaleXY(TestYoloBoxOp):
 class TestYoloBoxOpIoUAware(TestYoloBoxOp):
     def initTestCase(self):
         self.anchors = [10, 13, 16, 30, 33, 23]
-        an_num = int((len(self.anchors) // 2))
+        an_num = int(len(self.anchors) // 2)
         self.batch_size = 32
         self.class_num = 2
         self.conf_thresh = 0.5
@@ -295,7 +295,7 @@ class TestYoloBoxStatic(unittest.TestCase):
 class TestYoloBoxOpHW(TestYoloBoxOp):
     def initTestCase(self):
         self.anchors = [10, 13, 16, 30, 33, 23]
-        an_num = int((len(self.anchors) // 2))
+        an_num = int(len(self.anchors) // 2)
         self.batch_size = 32
         self.class_num = 2
         self.conf_thresh = 0.5

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

@@ -81,7 +81,7 @@ def YOLOv3Loss(x, gtbox, gtlabel, gtscore, attrs):
     bias_x_y = -0.5 * (scale_x_y - 1.0)
     input_size = downsample_ratio * h
     x = x.reshape((n, mask_num, 5 + class_num, h, w)).transpose((0, 1, 3, 4, 2))
-    loss = np.zeros((n)).astype('float64')
+    loss = np.zeros(n).astype('float64')
 
     smooth_weight = min(1.0 / class_num, 1.0 / 40)
     label_pos = 1.0 - smooth_weight if use_label_smooth else 1.0

python/paddle/fluid/tests/unittests/xpu/test_activation_op_xpu.py

@@ -1011,7 +1011,7 @@ class XPUTestSoftReluOP(XPUOpTestWrapper):
             t = np.copy(x)
             t[t < -threshold] = -threshold
             t[t > threshold] = threshold
-            out = np.log((np.exp(t) + 1))
+            out = np.log(np.exp(t) + 1)
 
             self.inputs = {'X': x}
             self.outputs = {'Out': out}

python/paddle/fluid/tests/unittests/xpu/test_adamw_op_xpu.py

@@ -484,30 +484,22 @@ class XPUTestAdamwOp2(XPUOpTestWrapper):
                     out = linear1(x)
                     out = linear2(out)
 
-                    fc1_w_mon1 = np.zeros((linear1.weight.shape)).astype(
+                    fc1_w_mon1 = np.zeros(linear1.weight.shape).astype(
                         "float32"
                     )
-                    fc1_w_mon2 = np.zeros((linear1.weight.shape)).astype(
+                    fc1_w_mon2 = np.zeros(linear1.weight.shape).astype(
                         "float32"
                     )
-                    fc1_b_mon1 = np.zeros((linear1.bias.shape)).astype(
+                    fc1_b_mon1 = np.zeros(linear1.bias.shape).astype("float32")
+                    fc1_b_mon2 = np.zeros(linear1.bias.shape).astype("float32")
+                    fc2_w_mon1 = np.zeros(linear2.weight.shape).astype(
                         "float32"
                     )
-                    fc1_b_mon2 = np.zeros((linear1.bias.shape)).astype(
-                        "float32"
-                    )
-                    fc2_w_mon1 = np.zeros((linear2.weight.shape)).astype(
-                        "float32"
-                    )
-                    fc2_w_mon2 = np.zeros((linear2.weight.shape)).astype(
-                        "float32"
-                    )
-                    fc2_b_mon1 = np.zeros((linear2.bias.shape)).astype(
-                        "float32"
-                    )
-                    fc2_b_mon2 = np.zeros((linear2.bias.shape)).astype(
+                    fc2_w_mon2 = np.zeros(linear2.weight.shape).astype(
                         "float32"
                     )
+                    fc2_b_mon1 = np.zeros(linear2.bias.shape).astype("float32")
+                    fc2_b_mon2 = np.zeros(linear2.bias.shape).astype("float32")
 
                     cost = paddle.nn.functional.square_error_cost(
                         input=out, label=y

python/paddle/fluid/tests/unittests/xpu/test_amp_check_finite_and_scale_op_xpu.py

@@ -40,7 +40,7 @@ class XPUTestCheckFiniteAndUnscaleOp(XPUOpTestWrapper):
             self.op_type = "check_finite_and_unscale"
             self.init_dtype()
             x = np.random.random((8, 8)).astype(self.dtype)
-            scale = np.random.random((1)).astype(np.float32)
+            scale = np.random.random(1).astype(np.float32)
             self.inputs = {'X': [('x0', x)], 'Scale': scale}
             self.outputs = {
                 'FoundInfinite': np.array([0]),
@@ -64,7 +64,7 @@ class XPUTestCheckFiniteAndUnscaleOp(XPUOpTestWrapper):
             idx2 = np.random.randint(255)
             x[idx1][idx2] = np.nan
             x[idx2][idx1] = np.nan
-            scale = np.random.random((1)).astype(np.float32)
+            scale = np.random.random(1).astype(np.float32)
 
             self.inputs = {'X': [('x0', x)], 'Scale': scale}
             self.outputs = {
@@ -91,7 +91,7 @@ class XPUTestCheckFiniteAndUnscaleOp(XPUOpTestWrapper):
             idx2 = np.random.randint(255)
             x[idx1][idx2] = np.nan
             x[idx2][idx1] = np.nan
-            scale = np.random.random((1)).astype(np.float32)
+            scale = np.random.random(1).astype(np.float32)
             myscale = np.array([0.05]).astype(self.dtype)
             self.inputs = {'X': [('x0', x)], 'Scale': scale}
             self.outputs = {
@@ -118,7 +118,7 @@ class XPUTestCheckFiniteAndUnscaleOp(XPUOpTestWrapper):
             idx2 = np.random.randint(255)
             x[idx1][idx2] = np.inf
             x[idx2][idx1] = np.nan
-            scale = np.random.random((1)).astype(np.float32)
+            scale = np.random.random(1).astype(np.float32)
             myscale = np.array([0.05]).astype(self.dtype)
             self.inputs = {'X': [('x0', x)], 'Scale': scale}
             self.outputs = {