!1044 clean pylint warning in test dir

Merge pull request !1044 from jinyaohui/clean_pylint_test

tests/st/ops/ascend/test_add.py

@@ -20,8 +20,11 @@ import numpy as np
 import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
+
 context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
 context.set_context(enable_task_sink=True)
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -30,8 +33,10 @@ class Net(nn.Cell):
     def construct(self, x, y):
         return self.add(x, y)
 
-x = np.ones([1,3,3,4]).astype(np.float32)
-y = np.ones([1,3,3,4]).astype(np.float32)
+
+x = np.ones([1, 3, 3, 4]).astype(np.float32)
+y = np.ones([1, 3, 3, 4]).astype(np.float32)
+
 
 def test_net():
     add = Net()

tests/st/ops/ascend/test_addn.py

@@ -20,7 +20,10 @@ import numpy as np
 import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
+
 context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -29,6 +32,7 @@ class Net(nn.Cell):
     def construct(self, x, y):
         return self.add((x, y))
 
+
 def test_net():
     x = np.random.randn(1, 3, 3, 4).astype(np.float32)
     y = np.random.randn(1, 3, 3, 4).astype(np.float32)

tests/st/ops/ascend/test_aicpu_ops/test_expand_dims.py

@@ -18,7 +18,10 @@ import mindspore.nn as nn
 from mindspore.common.api import ms_function
 import numpy as np
 import mindspore.context as context
+
 context.set_context(mode=context.PYNATIVE_MODE, device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -33,82 +36,92 @@ def test_net_bool():
     net = Net()
     output = net(Tensor(x), -1)
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.expand_dims(x, -1)))
+    assert (np.all(output.asnumpy() == np.expand_dims(x, -1)))
+
 
 def test_net_int8():
     x = np.random.randn(1, 16, 1, 1).astype(np.int8)
     net = Net()
     output = net(Tensor(x), -1)
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.expand_dims(x, -1)))
+    assert (np.all(output.asnumpy() == np.expand_dims(x, -1)))
+
 
 def test_net_uint8():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint8)
     net = Net()
     output = net(Tensor(x), -1)
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.expand_dims(x, -1)))
+    assert (np.all(output.asnumpy() == np.expand_dims(x, -1)))
+
 
 def test_net_int16():
     x = np.random.randn(1, 16, 1, 1).astype(np.int16)
     net = Net()
     output = net(Tensor(x), -1)
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.expand_dims(x, -1)))
+    assert (np.all(output.asnumpy() == np.expand_dims(x, -1)))
+
 
 def test_net_uint16():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint16)
     net = Net()
     output = net(Tensor(x), -1)
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.expand_dims(x, -1)))
+    assert (np.all(output.asnumpy() == np.expand_dims(x, -1)))
+
 
 def test_net_int32():
     x = np.random.randn(1, 16, 1, 1).astype(np.int32)
     net = Net()
     output = net(Tensor(x), -1)
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.expand_dims(x, -1)))
+    assert (np.all(output.asnumpy() == np.expand_dims(x, -1)))
+
 
 def test_net_uint32():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint32)
     net = Net()
     output = net(Tensor(x), -1)
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.expand_dims(x, -1)))
+    assert (np.all(output.asnumpy() == np.expand_dims(x, -1)))
+
 
 def test_net_int64():
     x = np.random.randn(1, 16, 1, 1).astype(np.int64)
     net = Net()
     output = net(Tensor(x), -1)
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.expand_dims(x, -1)))
+    assert (np.all(output.asnumpy() == np.expand_dims(x, -1)))
+
 
 def test_net_uint64():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint64)
     net = Net()
     output = net(Tensor(x), -1)
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.expand_dims(x, -1)))
+    assert (np.all(output.asnumpy() == np.expand_dims(x, -1)))
+
 
 def test_net_float16():
     x = np.random.randn(1, 16, 1, 1).astype(np.float16)
     net = Net()
     output = net(Tensor(x), -1)
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.expand_dims(x, -1)))
+    assert (np.all(output.asnumpy() == np.expand_dims(x, -1)))
+
 
 def test_net_float32():
     x = np.random.randn(1, 16, 1, 1).astype(np.float32)
     net = Net()
     output = net(Tensor(x), -1)
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.expand_dims(x, -1)))
+    assert (np.all(output.asnumpy() == np.expand_dims(x, -1)))
+
 
 def test_net_float64():
     x = np.random.randn(1, 16, 1, 1).astype(np.float64)
     net = Net()
     output = net(Tensor(x), -1)
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.expand_dims(x, -1)))
-  
+    assert (np.all(output.asnumpy() == np.expand_dims(x, -1)))

tests/st/ops/ascend/test_aicpu_ops/test_flatten.py

@@ -17,7 +17,10 @@ from mindspore.ops import operations as P
 import mindspore.nn as nn
 import numpy as np
 import mindspore.context as context
+
 context.set_context(mode=context.PYNATIVE_MODE, device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -32,68 +35,76 @@ def test_net_int8():
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.flatten()))
+    assert (np.all(output.asnumpy() == x.flatten()))
+
 
 def test_net_uint8():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint8)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.flatten()))
+    assert (np.all(output.asnumpy() == x.flatten()))
+
 
 def test_net_int16():
     x = np.random.randn(1, 16, 1, 1).astype(np.int16)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.flatten()))
+    assert (np.all(output.asnumpy() == x.flatten()))
+
 
 def test_net_uint16():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint16)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.flatten()))
+    assert (np.all(output.asnumpy() == x.flatten()))
+
 
 def test_net_int32():
     x = np.random.randn(1, 16, 1, 1).astype(np.int32)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.flatten()))
+    assert (np.all(output.asnumpy() == x.flatten()))
+
 
 def test_net_uint32():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint32)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.flatten()))
+    assert (np.all(output.asnumpy() == x.flatten()))
+
 
 def test_net_int64():
     x = np.random.randn(1, 16, 1, 1).astype(np.int64)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.flatten()))
+    assert (np.all(output.asnumpy() == x.flatten()))
+
 
 def test_net_uint64():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint64)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.flatten()))
+    assert (np.all(output.asnumpy() == x.flatten()))
+
 
 def test_net_float16():
     x = np.random.randn(1, 16, 1, 1).astype(np.float16)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.flatten()))
+    assert (np.all(output.asnumpy() == x.flatten()))
+
 
 def test_net_float32():
     x = np.random.randn(1, 16, 1, 1).astype(np.float32)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.flatten()))
-  
+    assert (np.all(output.asnumpy() == x.flatten()))

tests/st/ops/ascend/test_aicpu_ops/test_is_finite.py

@@ -18,7 +18,10 @@ import mindspore.nn as nn
 from mindspore.common.api import ms_function
 import numpy as np
 import mindspore.context as context
+
 context.set_context(mode=context.PYNATIVE_MODE, device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -33,82 +36,92 @@ def test_net_bool():
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.isfinite(x)))
+    assert (np.all(output.asnumpy() == np.isfinite(x)))
+
 
 def test_net_int8():
     x = np.random.randn(1, 16, 1, 1).astype(np.int8)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.isfinite(x)))
+    assert (np.all(output.asnumpy() == np.isfinite(x)))
+
 
 def test_net_uint8():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint8)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.isfinite(x)))
+    assert (np.all(output.asnumpy() == np.isfinite(x)))
+
 
 def test_net_int16():
     x = np.random.randn(1, 16, 1, 1).astype(np.int16)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.isfinite(x)))
+    assert (np.all(output.asnumpy() == np.isfinite(x)))
+
 
 def test_net_uint16():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint16)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.isfinite(x)))
+    assert (np.all(output.asnumpy() == np.isfinite(x)))
+
 
 def test_net_int32():
     x = np.random.randn(1, 16, 1, 1).astype(np.int32)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.isfinite(x)))
+    assert (np.all(output.asnumpy() == np.isfinite(x)))
+
 
 def test_net_uint32():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint32)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.isfinite(x)))
+    assert (np.all(output.asnumpy() == np.isfinite(x)))
+
 
 def test_net_int64():
     x = np.random.randn(1, 16, 1, 1).astype(np.int64)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.isfinite(x)))
+    assert (np.all(output.asnumpy() == np.isfinite(x)))
+
 
 def test_net_uint64():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint64)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.isfinite(x)))
+    assert (np.all(output.asnumpy() == np.isfinite(x)))
+
 
 def test_net_float16():
     x = np.random.randn(1, 16, 1, 1).astype(np.float16)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.isfinite(x)))
+    assert (np.all(output.asnumpy() == np.isfinite(x)))
+
 
 def test_net_float32():
     x = np.random.randn(1, 16, 1, 1).astype(np.float32)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.isfinite(x)))
+    assert (np.all(output.asnumpy() == np.isfinite(x)))
+
 
 def test_net_float64():
     x = np.random.randn(1, 16, 1, 1).astype(np.float64)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.isfinite(x)))
-  
+    assert (np.all(output.asnumpy() == np.isfinite(x)))

tests/st/ops/ascend/test_aicpu_ops/test_reshape.py

@@ -18,14 +18,17 @@ import mindspore.nn as nn
 from mindspore.common.api import ms_function
 import numpy as np
 import mindspore.context as context
+
 context.set_context(mode=context.PYNATIVE_MODE, device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
         self.reshape = P.Reshape()
 
     def construct(self, tensor):
-    return self.reshape(tensor, (4,4))
+        return self.reshape(tensor, (4, 4))
 
 
 def test_net_bool():
@@ -33,82 +36,92 @@ def test_net_bool():
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.reshape(x, (4,4))))
+    assert (np.all(output.asnumpy() == np.reshape(x, (4, 4))))
+
 
 def test_net_int8():
     x = np.random.randn(1, 16, 1, 1).astype(np.int8)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.reshape(x, (4,4))))
+    assert (np.all(output.asnumpy() == np.reshape(x, (4, 4))))
+
 
 def test_net_uint8():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint8)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.reshape(x, (4,4))))
+    assert (np.all(output.asnumpy() == np.reshape(x, (4, 4))))
+
 
 def test_net_int16():
     x = np.random.randn(1, 16, 1, 1).astype(np.int16)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.reshape(x, (4,4))))
+    assert (np.all(output.asnumpy() == np.reshape(x, (4, 4))))
+
 
 def test_net_uint16():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint16)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.reshape(x, (4,4))))
+    assert (np.all(output.asnumpy() == np.reshape(x, (4, 4))))
+
 
 def test_net_int32():
     x = np.random.randn(1, 16, 1, 1).astype(np.int32)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.reshape(x, (4,4))))
+    assert (np.all(output.asnumpy() == np.reshape(x, (4, 4))))
+
 
 def test_net_uint32():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint32)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.reshape(x, (4,4))))
+    assert (np.all(output.asnumpy() == np.reshape(x, (4, 4))))
+
 
 def test_net_int64():
     x = np.random.randn(1, 16, 1, 1).astype(np.int64)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.reshape(x, (4,4))))
+    assert (np.all(output.asnumpy() == np.reshape(x, (4, 4))))
+
 
 def test_net_uint64():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint64)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.reshape(x, (4,4))))
+    assert (np.all(output.asnumpy() == np.reshape(x, (4, 4))))
+
 
 def test_net_float16():
     x = np.random.randn(1, 16, 1, 1).astype(np.float16)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.reshape(x, (4,4))))
+    assert (np.all(output.asnumpy() == np.reshape(x, (4, 4))))
+
 
 def test_net_float32():
     x = np.random.randn(1, 16, 1, 1).astype(np.float32)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.reshape(x, (4,4))))
+    assert (np.all(output.asnumpy() == np.reshape(x, (4, 4))))
+
 
 def test_net_float64():
     x = np.random.randn(1, 16, 1, 1).astype(np.float64)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == np.reshape(x, (4,4))))
-  
+    assert (np.all(output.asnumpy() == np.reshape(x, (4, 4))))

tests/st/ops/ascend/test_aicpu_ops/test_squeeze.py

@@ -17,7 +17,10 @@ from mindspore.ops import operations as P
 import mindspore.nn as nn
 import numpy as np
 import mindspore.context as context
+
 context.set_context(mode=context.PYNATIVE_MODE, device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -32,82 +35,92 @@ def test_net_bool():
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.squeeze()))
+    assert (np.all(output.asnumpy() == x.squeeze()))
+
 
 def test_net_int8():
     x = np.random.randn(1, 16, 1, 1).astype(np.int8)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.squeeze()))
+    assert (np.all(output.asnumpy() == x.squeeze()))
+
 
 def test_net_uint8():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint8)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.squeeze()))
+    assert (np.all(output.asnumpy() == x.squeeze()))
+
 
 def test_net_int16():
     x = np.random.randn(1, 16, 1, 1).astype(np.int16)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.squeeze()))
+    assert (np.all(output.asnumpy() == x.squeeze()))
+
 
 def test_net_uint16():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint16)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.squeeze()))
+    assert (np.all(output.asnumpy() == x.squeeze()))
+
 
 def test_net_int32():
     x = np.random.randn(1, 16, 1, 1).astype(np.int32)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.squeeze()))
+    assert (np.all(output.asnumpy() == x.squeeze()))
+
 
 def test_net_uint32():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint32)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.squeeze()))
+    assert (np.all(output.asnumpy() == x.squeeze()))
+
 
 def test_net_int64():
     x = np.random.randn(1, 16, 1, 1).astype(np.int64)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.squeeze()))
+    assert (np.all(output.asnumpy() == x.squeeze()))
+
 
 def test_net_uint64():
     x = np.random.randn(1, 16, 1, 1).astype(np.uint64)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.squeeze()))
+    assert (np.all(output.asnumpy() == x.squeeze()))
+
 
 def test_net_float16():
     x = np.random.randn(1, 16, 1, 1).astype(np.float16)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.squeeze()))
+    assert (np.all(output.asnumpy() == x.squeeze()))
+
 
 def test_net_float32():
     x = np.random.randn(1, 16, 1, 1).astype(np.float32)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.squeeze()))
+    assert (np.all(output.asnumpy() == x.squeeze()))
+
 
 def test_net_float64():
     x = np.random.randn(1, 16, 1, 1).astype(np.float64)
     net = Net()
     output = net(Tensor(x))
     print(output.asnumpy())
-  assert(np.all(output.asnumpy() == x.squeeze()))
-  
+    assert (np.all(output.asnumpy() == x.squeeze()))

tests/st/ops/ascend/test_apply_momentum.py

@@ -20,7 +20,10 @@ import numpy as np
 import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
+
 context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -35,9 +38,11 @@ class Net(nn.Cell):
             'normal', [2, 3, 3, 4]), name='gradient')
         self.momentum = Parameter(initializer(
             'normal', [1, ]), name='momentum')
+
     def construct(self):
         return self.apply_momentum(self.variable, self.accumulation, self.learning_rate, self.gradient, self.momentum)
 
+
 def test_net():
     apply_momentum = Net()
     output = apply_momentum()

tests/st/ops/ascend/test_biasAddGrad.py

@@ -21,22 +21,25 @@ import numpy as np
 import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
+
 context.set_context(device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
         self.bias_add_grad = G.BiasAddGrad()
-    #self.dout = Parameter(initializer(
-                #'normal', [2, 3, 3, 4]), name='dout')
-
+        # self.dout = Parameter(initializer(
+        # 'normal', [2, 3, 3, 4]), name='dout')
 
     @ms_function
     def construct(self, dout):
         return self.bias_add_grad(dout)
 
-dout = np.ones([2,3,4,4]).astype(np.float32)
+
+dout = np.ones([2, 3, 4, 4]).astype(np.float32)
 bias_add_grad = Net()
 output = bias_add_grad(Tensor(dout))
-expect_output = np.array([32.,32.,32.]).astype(np.float32)
-assert np.all(output.asnumpy()==expect_output), "bias_add_grad execute failed, please check current code commit"
+expect_output = np.array([32., 32., 32.]).astype(np.float32)
+assert np.all(output.asnumpy() == expect_output), "bias_add_grad execute failed, please check current code commit"
 print(output.asnumpy())

tests/st/ops/ascend/test_bias_add_grad.py

@@ -21,17 +21,20 @@ import numpy as np
 import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
+
 context.set_context(device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
         self.bias_add_grad = G.BiasAddGrad()
 
-
     @ms_function
     def construct(self, dout):
         return self.bias_add_grad(dout)
 
+
 def test_net():
     dout = np.random.rand(1, 1001).astype(np.float32)
     bias_add_grad = Net()

tests/st/ops/ascend/test_conv.py

@@ -20,7 +20,10 @@ import numpy as np
 import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
+
 context.set_context(device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -37,15 +40,13 @@ class Net(nn.Cell):
         self.w = Parameter(initializer(
             'normal', [64, 3, 7, 7]), name='w')
 
-
     @ms_function
     def construct(self, x):
         return self.conv(x, self.w)
 
 
-
 def test_net():
-    x = np.random.randn(32,3,224,224).astype(np.float32)
+    x = np.random.randn(32, 3, 224, 224).astype(np.float32)
     conv = Net()
     output = conv(Tensor(x))
     print(output.asnumpy())

tests/st/ops/ascend/test_conv2dGradFilter.py

@@ -21,12 +21,14 @@ import numpy as np
 import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
+
 context.set_context(device_target="Ascend")
 
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
-    self.conv2d_grad = G.Conv2DBackpropFilter(4,1)
+        self.conv2d_grad = G.Conv2DBackpropFilter(4, 1)
         yt = Tensor(np.array([[[[1, 0, -1], [1, 0, -1], [1, 0, -1]]]]).astype(np.float32))
         self.y = Parameter(yt, name='y')
         self.get_shape = P.Shape()
@@ -35,6 +37,7 @@ class Net(nn.Cell):
     def construct(self, x, out):
         return self.conv2d_grad(out, x, self.get_shape(self.y))
 
+
 x = Tensor(np.array([[[
     [3, 0, 1, 2, 7, 4],
     [1, 5, 8, 9, 3, 1],
@@ -44,14 +47,14 @@ x = Tensor(np.array([[[
     [2, 4, 5, 2, 3, 9]]]]).astype(np.float32))
 
 out = Tensor(np.array([[[
-        [ -5,  -4,   0,   8],
+    [-5, -4, 0, 8],
     [-10, -2, 2, 3],
-        [  0,  -2,  -4,  -7],
-        [ -3,  -2,  -3, -16]]]]).astype(np.float32))
+    [0, -2, -4, -7],
+    [-3, -2, -3, -16]]]]).astype(np.float32))
 
 operator = Net()
 output = operator(x, out)
-expect_out = np.array([[[[ -60., -142., -265.],[-104., -211., -322.],[-102., -144., -248.]]]]).astype(np.float32)
+expect_out = np.array([[[[-60., -142., -265.], [-104., -211., -322.], [-102., -144., -248.]]]]).astype(np.float32)
 print(output.asnumpy())
 print(expect_out)
-assert np.all(output.asnumpy()==expect_out), "conv2d_grad execute failed, please check current code commit"
+assert np.all(output.asnumpy() == expect_out), "conv2d_grad execute failed, please check current code commit"

tests/st/ops/ascend/test_conv_grad.py

@@ -21,8 +21,10 @@ import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
 from mindspore.ops.composite import GradOperation
+
 context.set_context(device_target="Ascend")
 
+
 class Grad(nn.Cell):
     def __init__(self, network):
         super(Grad, self).__init__()
@@ -33,6 +35,7 @@ class Grad(nn.Cell):
     def construct(self, input, output_grad):
         return self.grad(self.network)(input, output_grad)
 
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -53,6 +56,7 @@ class Net(nn.Cell):
     def construct(self, x):
         return self.conv(x, self.w)
 
+
 def test_net():
     x = np.ones([32, 2048, 7, 7]).astype(np.float32)
     sens = np.ones([32, 512, 7, 7]).astype(np.float32)

tests/st/ops/ascend/test_dense.py

@@ -20,7 +20,10 @@ import numpy as np
 import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
+
 context.set_context(device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -30,6 +33,7 @@ class Net(nn.Cell):
     def construct(self, x):
         return self.dense(x)
 
+
 def test_net():
     x = np.random.randn(32, 2048).astype(np.float32)
     net = Net()

tests/st/ops/ascend/test_dense_grad.py

@@ -21,8 +21,10 @@ import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
 from mindspore.ops.composite import GradOperation
+
 context.set_context(device_target="Ascend")
 
+
 class Grad(nn.Cell):
     def __init__(self, network):
         super(Grad, self).__init__()
@@ -33,6 +35,7 @@ class Grad(nn.Cell):
     def construct(self, input, output_grad):
         return self.grad(self.network)(input, output_grad)
 
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -41,6 +44,7 @@ class Net(nn.Cell):
     def construct(self, x):
         return self.dense(x)
 
+
 def test_net():
     x = np.random.randn(32, 2048).astype(np.float32)
     sens = np.random.randn(32, 1001).astype(np.float32)

tests/st/ops/ascend/test_drop_out_gen_mask.py

@@ -17,6 +17,7 @@ from mindspore.ops import operations as P
 import mindspore.nn as nn
 import numpy as np
 import mindspore.context as context
+
 context.set_context(mode=context.GRAPH_MODE,
                     device_target="Ascend")
 

tests/st/ops/ascend/test_full_connection.py

@@ -21,6 +21,7 @@ import mindspore.context as context
 
 context.set_context(device_target="Ascend")
 
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()

tests/st/ops/ascend/test_fused_batchnorm.py

@@ -20,7 +20,10 @@ import numpy as np
 import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
+
 context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -35,7 +38,7 @@ class Net(nn.Cell):
 
 
 def test_net():
-    x = np.random.randn(1,64,112,112).astype(np.float32)
+    x = np.random.randn(1, 64, 112, 112).astype(np.float32)
     # mean = np.random.randn(1,16,1,1).astype(np.float32)
     # variance = np.random.randn(1,16,1,1).astype(np.float32)
     fusedBn = Net()
@@ -45,4 +48,3 @@ def test_net():
 
     print("***********output y*********")
     print(output.asnumpy())
-

tests/st/ops/ascend/test_fused_batchnorm_grad.py

@@ -21,8 +21,11 @@ import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
 from mindspore.ops.composite import GradOperation
-#context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
+
+# context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
 context.set_context(device_target="Ascend")
+
+
 class Grad(nn.Cell):
     def __init__(self, network):
         super(Grad, self).__init__()
@@ -33,6 +36,7 @@ class Grad(nn.Cell):
     def construct(self, input, output_grad):
         return self.grad(self.network)(input, output_grad)
 
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -47,8 +51,8 @@ class Net(nn.Cell):
 
 
 def test_net():
-    x = np.random.randn(1,64,112,112).astype(np.float32)
-    sens = np.random.randn(1,64,112,112).astype(np.float32)
+    x = np.random.randn(1, 64, 112, 112).astype(np.float32)
+    sens = np.random.randn(1, 64, 112, 112).astype(np.float32)
     net = Grad(Net())
     output = net(Tensor(x), Tensor(sens))
     print("***********x*********")

tests/st/ops/ascend/test_image_gradients.py

@@ -20,6 +20,8 @@ from mindspore import Tensor
 from mindspore.common.api import ms_function
 
 context.set_context(device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -31,32 +33,32 @@ class Net(nn.Cell):
 
 
 def test_image_gradients():
-    image = Tensor(np.array([[[[1,2],[3,4]]]]), dtype=mstype.int32)
-    expected_dy = np.array([[[[2,2],[0,0]]]]).astype(np.int32)
-    expected_dx = np.array([[[[1,0],[1,0]]]]).astype(np.int32)
+    image = Tensor(np.array([[[[1, 2], [3, 4]]]]), dtype=mstype.int32)
+    expected_dy = np.array([[[[2, 2], [0, 0]]]]).astype(np.int32)
+    expected_dx = np.array([[[[1, 0], [1, 0]]]]).astype(np.int32)
     net = Net()
     dy, dx = net(image)
-    assert np.any(dx.asnumpy()-expected_dx) == False
-    assert np.any(dy.asnumpy()-expected_dy) == False
+    assert np.any(dx.asnumpy() - expected_dx) == False
+    assert np.any(dy.asnumpy() - expected_dy) == False
 
 
 def test_image_gradients_multi_channel_depth():
     # 4 x 2 x 2 x 2
     dtype = mstype.int32
-    image = Tensor(np.array([[[[1,2],[3,4]], [[5,6],[7,8]]],
-                             [[[3,5],[7,9]], [[11,13],[15,17]]],
-                             [[[5,10],[15,20]], [[25,30],[35,40]]],
-                             [[[10,20],[30,40]], [[50,60],[70,80]]]]), dtype=dtype)
-    expected_dy = Tensor(np.array([[[[2,2],[0,0]], [[2,2],[0,0]]],
-                                   [[[4,4],[0,0]], [[4,4],[0,0]]],
-                                   [[[10,10],[0,0]], [[10,10],[0,0]]],
-                                   [[[20,20],[0,0]], [[20,20],[0,0]]]]), dtype=dtype)
-    expected_dx = Tensor(np.array([[[[1,0],[1,0]], [[1,0],[1,0]]],
-                                   [[[2,0],[2,0]], [[2,0],[2,0]]],
-                                   [[[5,0],[5,0]], [[5,0],[5,0]]],
-                                   [[[10,0],[10,0]], [[10,0],[10,0]]]]), dtype=dtype)
+    image = Tensor(np.array([[[[1, 2], [3, 4]], [[5, 6], [7, 8]]],
+                             [[[3, 5], [7, 9]], [[11, 13], [15, 17]]],
+                             [[[5, 10], [15, 20]], [[25, 30], [35, 40]]],
+                             [[[10, 20], [30, 40]], [[50, 60], [70, 80]]]]), dtype=dtype)
+    expected_dy = Tensor(np.array([[[[2, 2], [0, 0]], [[2, 2], [0, 0]]],
+                                   [[[4, 4], [0, 0]], [[4, 4], [0, 0]]],
+                                   [[[10, 10], [0, 0]], [[10, 10], [0, 0]]],
+                                   [[[20, 20], [0, 0]], [[20, 20], [0, 0]]]]), dtype=dtype)
+    expected_dx = Tensor(np.array([[[[1, 0], [1, 0]], [[1, 0], [1, 0]]],
+                                   [[[2, 0], [2, 0]], [[2, 0], [2, 0]]],
+                                   [[[5, 0], [5, 0]], [[5, 0], [5, 0]]],
+                                   [[[10, 0], [10, 0]], [[10, 0], [10, 0]]]]), dtype=dtype)
     net = Net()
     dy, dx = net(image)
 
-    assert np.any(dx.asnumpy()-expected_dx.asnumpy()) == False
-    assert np.any(dy.asnumpy()-expected_dy.asnumpy()) == False
+    assert np.any(dx.asnumpy() - expected_dx.asnumpy()) == False
+    assert np.any(dy.asnumpy() - expected_dy.asnumpy()) == False

tests/st/ops/ascend/test_matmul.py

@@ -20,7 +20,10 @@ import numpy as np
 import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
+
 context.set_context(device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -30,8 +33,10 @@ class Net(nn.Cell):
     def construct(self, x1, x2):
         return self.matmul(x1, x2)
 
-x1 = np.random.randn(1,3).astype(np.float32)
-x2 = np.random.randn(3,4).astype(np.float32)
+
+x1 = np.random.randn(1, 3).astype(np.float32)
+x2 = np.random.randn(3, 4).astype(np.float32)
+
 
 def test_net():
     matmul = Net()

tests/st/ops/ascend/test_maxpool.py

@@ -20,12 +20,13 @@ import numpy as np
 import mindspore.context as context
 
 context.set_context(device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
         self.maxpool = P.MaxPool(pad_mode="SAME", window=3, stride=2)
 
-
     @ms_function
     def construct(self, x):
         output = self.maxpool(x)
@@ -33,7 +34,7 @@ class Net(nn.Cell):
 
 
 def test_net():
-    x = np.random.randn(32,64,112,112).astype(np.float32)
+    x = np.random.randn(32, 64, 112, 112).astype(np.float32)
     maxpool = Net()
     output = maxpool(Tensor(x))
     print(output.asnumpy())

tests/st/ops/ascend/test_maxpool_grad.py

@@ -19,6 +19,7 @@ from mindspore.common.api import ms_function
 import numpy as np
 import mindspore.context as context
 from mindspore.ops.composite import GradOperation
+
 context.set_context(device_target="Ascend")
 
 

tests/st/ops/ascend/test_maxpool_with_argmax_grad.py

@@ -21,8 +21,10 @@ import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
 from mindspore.ops.composite import GradOperation
+
 context.set_context(device_target="Ascend")
 
+
 class Grad(nn.Cell):
     def __init__(self, network):
         super(Grad, self).__init__()
@@ -33,6 +35,7 @@ class Grad(nn.Cell):
     def construct(self, input, output_grad):
         return self.grad(self.network)(input, output_grad)
 
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -46,6 +49,7 @@ class Net(nn.Cell):
         output = self.maxpool(x)
         return output[0]
 
+
 def test_net():
     x = np.random.randn(32, 64, 112, 112).astype(np.float32)
     sens = np.random.randn(32, 64, 56, 56).astype(np.float32)

tests/st/ops/ascend/test_relu.py

@@ -20,7 +20,10 @@ import numpy as np
 import mindspore.context as context
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
+
 context.set_context(device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -30,8 +33,9 @@ class Net(nn.Cell):
     def construct(self, x):
         return self.relu(x)
 
+
 def test_net():
-    x = np.random.randn(2,3,3,4).astype(np.float32)
+    x = np.random.randn(2, 3, 3, 4).astype(np.float32)
     relu = Net()
     output = relu(Tensor(x))
     print(x)