Fix pylint warnings in mindspore st test module

tests/st/auto_parallel/onehot_model_parallel.py

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+# ============================================================================
 
 import os
 import pytest
@@ -26,6 +27,7 @@ device_num = 2
 device_id = int(os.getenv('DEVICE_ID'))
 rank_id = 0
 
+
 def setup_module():
     global device_num
     global rank_id
@@ -42,9 +44,11 @@ def setup_module():
     context.set_auto_parallel_context(device_num=device_num,
                                       global_rank=rank_id)
 
+
 def teardown_module():
     distributedTool.release()
 
+
 class Onehot(Cell):
     def __init__(self, axis=-1, depth=1, on_value=1.0, off_value=0.0, strategy=None):
         super(Onehot, self).__init__()
@@ -56,25 +60,26 @@ class Onehot(Cell):
         self.on_value = Tensor(on_value, ms.float32)
         self.off_value = Tensor(off_value, ms.float32)
         self.transpose = P.Transpose().set_strategy(strategy=trans_stra)
-        self.sub = P.Sub().set_strategy(strategy=((1,1),(1,1)))
+        self.sub = P.Sub().set_strategy(strategy=((1, 1), (1, 1)))
 
     def construct(self, input, indices):
         x = self.onehot(indices, self.depth, self.on_value, self.off_value)
-        x = self.transpose(x, (1,0))
+        x = self.transpose(x, (1, 0))
         x = self.sub(input, x)
         return x
 
+
 class DataGenerator():
     def get_parallel_blocks(self, input_, strategy):
         blocks = [input_]
         i = 0
         for stra in strategy:
             temp = []
-            while len(blocks)>0:
+            while len(blocks) > 0:
                 block = blocks.pop(0)
                 temp.extend(np.split(block, stra, axis=i))
             blocks.extend(temp)
-            i+=1
+            i += 1
         return blocks
 
     def generate_data(self, shape):
@@ -93,32 +98,33 @@ class DataGenerator():
         stra = [1]*len(shape)
         stra[0] = device_num
         datas = self.get_parallel_blocks(data, stra)
-        return Tensor(data),Tensor(datas[rank_id])
+        return Tensor(data), Tensor(datas[rank_id])
+
 
 class OneHotFactory:
     def __init__(self, batch_size, classes, on_value=1.0, off_value=0.0, axis=None, strategy=None):
         dataGen = DataGenerator()
         self.input_full, self.input_part = dataGen.input_data((classes, batch_size))
-        self.label_full, self.label_part = dataGen.label_data((batch_size,),classes)
+        self.label_full, self.label_part = dataGen.label_data((batch_size,), classes)
         self.depth = classes
         self.on_value = on_value
         self.off_value = off_value
         self.axis = axis
         self.strategy = strategy
-    
+
     def forward_mindspore_single_impl(self):
-        net = Onehot(axis=self.axis, 
-                     depth=self.depth, 
-                     on_value=self.on_value, 
+        net = Onehot(axis=self.axis,
+                     depth=self.depth,
+                     on_value=self.on_value,
                      off_value=self.off_value)
         out = net(self.input_full, self.label_full)
         return out
-        
+
     def forward_mindspore_parallel_impl(self):
         context.set_auto_parallel_context(parallel_mode="semi_auto_parallel")
-        net = Onehot(axis=self.axis, 
-                     depth=self.depth, 
-                     on_value=self.on_value, 
+        net = Onehot(axis=self.axis,
+                     depth=self.depth,
+                     on_value=self.on_value,
                      off_value=self.off_value, strategy=self.strategy)
         out = net.compile_and_run(self.input_full, self.label_full)
         return out
@@ -137,7 +143,7 @@ def test_reid_onehot_forward_int32_128_depth1024_model_parallel():
                          on_value=1.000000,
                          off_value=0.000000,
                          axis=-1,
-                         strategy=((1,device_num),(),()))
+                         strategy=((1, device_num), (), ()))
     fact.forward_cmp()
 
 
@@ -147,5 +153,5 @@ def test_reid_onehot_forward_int32_1024_depth128_model_parallel():
                          on_value=1.000000,
                          off_value=0.000000,
                          axis=-1,
-                         strategy=((1,device_num),(),()))
+                         strategy=((1, device_num), (), ()))
     fact.forward_cmp()

tests/st/auto_parallel/soft_entropy_loss_expand_parallel.py

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+# ============================================================================
 
 import os
 import pytest
@@ -31,7 +32,7 @@ from mindspore.nn.optim.momentum import Momentum
 from mindspore.train.callback import Callback
 
 np.set_printoptions(threshold=np.inf)
-device_num=2
+device_num = 2
 device_id = int(os.getenv('DEVICE_ID'))
 rank_id = 0
 embed = 128
@@ -39,6 +40,7 @@ classes = 32
 batch_size = 32*2
 MatmulParamShape = (classes, embed)
 
+
 def setup_module():
     global device_num
     global rank_id
@@ -55,26 +57,28 @@ def setup_module():
     context.set_auto_parallel_context(device_num=device_num,
                                       global_rank=device_id)
 
+
 def teardown_module():
     distributedTool.release()
 
+
 class DataGenerator():
     def get_parallel_blocks(self, input_, strategy):
         blocks = [input_]
         i = 0
         for stra in strategy:
             temp = []
-            while len(blocks)>0:
+            while len(blocks) > 0:
                 block = blocks.pop(0)
                 temp.extend(np.split(block, stra, axis=i))
             blocks.extend(temp)
-            i+=1
+            i += 1
         return blocks
 
     def generate_data(self, shape):
         size = np.cumprod(shape)[-1]
         num_range = min(size, 1000)
-        data = (np.arange(0, size)%num_range)/num_range
+        data = (np.arange(0, size) % num_range)/num_range
         data = np.reshape(data, shape)
         return data
 
@@ -83,14 +87,15 @@ class DataGenerator():
         stra = [1]*len(shape)
         stra[0] = device_num
         datas = self.get_parallel_blocks(data, stra)
-        return Tensor(data), Tensor(datas[rank_id]) 
+        return Tensor(data), Tensor(datas[rank_id])
 
     def label_data(self, shape, embed):
         data = (self.generate_data(shape)*(embed-1)).astype(np.int32)
         stra = [1]*len(shape)
         stra[0] = device_num
         datas = self.get_parallel_blocks(data, stra)
-        return Tensor(data),Tensor(datas[rank_id])
+        return Tensor(data), Tensor(datas[rank_id])
+
 
 class Dataset():
     def __init__(self, predict, label, length=1, input_num=2):
@@ -121,15 +126,18 @@ class Dataset():
     def get_repeat_count(self):
         return self.length
 
+
 class ModelCallback(Callback):
     def __init__(self):
         super(ModelCallback, self).__init__()
         self.loss_list = []
+
     def epoch_end(self, run_context, *args):
         cb_params = run_context.original_args()
         result = cb_params.net_outputs
         self.loss_list.append(result.asnumpy().mean())
 
+
 class SoftmaxCrossEntropyExpand(Cell):
     def __init__(self, sparse=False, stra_list=[]):
         super(SoftmaxCrossEntropyExpand, self).__init__()
@@ -164,22 +172,25 @@ class SoftmaxCrossEntropyExpand(Cell):
         loss = self.reduce_mean(loss, -1)
         return loss
 
+
 class MatmulNet(Cell):
-    def __init__(self, matmul_stra = None, loss_stra_list=[]):
+    def __init__(self, matmul_stra=None, loss_stra_list=[]):
         super(MatmulNet, self).__init__()
         self.matmul = P.MatMul(transpose_b=True).set_strategy(strategy=matmul_stra)
         self.loss = SoftmaxCrossEntropyExpand(sparse=True, stra_list=loss_stra_list)
-        self.weight = Parameter(Tensor(np.ones(MatmulParamShape), dtype=ms.float32), name="weight") 
+        self.weight = Parameter(Tensor(np.ones(MatmulParamShape), dtype=ms.float32), name="weight")
+
     def construct(self, x, label):
         loss_input = self.matmul(x, self.weight)
         out = self.loss(loss_input, label)
         return out
 
+
 class LossFactory():
     def __init__(self):
         dataGen = DataGenerator()
         self.input_full, self.input_part = dataGen.input_data((batch_size, embed))
-        self.label_full, self.label_part = dataGen.label_data((batch_size,),embed)
+        self.label_full, self.label_part = dataGen.label_data((batch_size,), embed)
 
     def single_matmul_trains(self):
         single_callback = ModelCallback()
@@ -196,32 +207,33 @@ class LossFactory():
         parallel_callback = ModelCallback()
         context.set_auto_parallel_context(parallel_mode="semi_auto_parallel")
         net = MatmulNet()
-        optimizer = Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9) 
+        optimizer = Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
         model = Model(net, optimizer=optimizer)
         epoch_size = 6
         dataset = Dataset(self.input_part, self.label_part)
         model.train(epoch_size, dataset, callbacks=parallel_callback, dataset_sink_mode=False)
         loss_value = np.array(parallel_callback.loss_list)
         return loss_value
-    
+
     def model_parallel_matmul_trains(self):
         parallel_callback = ModelCallback()
-        matmul_stra = ((1,1),(device_num,1))
-        reduce_max_stra = ((1,device_num),)
-        sub_stra = ((1,device_num),(1,1))
-        exp_stra = ((1,device_num),)
-        reduce_sum_stra = ((1,device_num),)
-        div_stra = ((1,device_num),(1,1))
-        log_stra = ((1,device_num),)
-        mul_stra = ((1,device_num),(1,device_num))
-        sum_cross_entropy_stra = ((1,device_num),)
-        mul2_stra = ((),(device_num,))
+        matmul_stra = ((1, 1), (device_num, 1))
+        reduce_max_stra = ((1, device_num),)
+        sub_stra = ((1, device_num), (1, 1))
+        exp_stra = ((1, device_num),)
+        reduce_sum_stra = ((1, device_num),)
+        div_stra = ((1, device_num), (1, 1))
+        log_stra = ((1, device_num),)
+        mul_stra = ((1, device_num), (1, device_num))
+        sum_cross_entropy_stra = ((1, device_num),)
+        mul2_stra = ((), (device_num,))
         reduce_mean_stra = ((device_num,),)
-        onehot_stra = ((1,device_num),(),())
-        loss_stra_list = [exp_stra, reduce_sum_stra, onehot_stra, div_stra, log_stra, sum_cross_entropy_stra, mul_stra, mul2_stra, reduce_mean_stra, reduce_max_stra, sub_stra]
+        onehot_stra = ((1, device_num), (), ())
+        loss_stra_list = [exp_stra, reduce_sum_stra, onehot_stra, div_stra, log_stra,
+                          sum_cross_entropy_stra, mul_stra, mul2_stra, reduce_mean_stra, reduce_max_stra, sub_stra]
         context.set_auto_parallel_context(parallel_mode="auto_parallel")
-        net = MatmulNet(matmul_stra = matmul_stra, loss_stra_list = loss_stra_list)
-        optimizer = Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9) 
+        net = MatmulNet(matmul_stra=matmul_stra, loss_stra_list=loss_stra_list)
+        optimizer = Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
         model = Model(net, optimizer=optimizer)
         epoch_size = 6
         dataset = Dataset(self.input_part, self.label_part)
@@ -231,21 +243,22 @@ class LossFactory():
 
     def mix_parallel_matmul_trains(self):
         parallel_callback = ModelCallback()
-        matmul_stra = ((device_num,1),(1,1))
-        reduce_max_stra = ((1,device_num),)
-        sub_stra = ((device_num,1),(device_num,1))
-        exp_stra = ((1,device_num),)
-        reduce_sum_stra = ((1,device_num),)
-        div_stra = ((1,device_num),(1,1))
-        log_stra = ((1,device_num),)
-        mul_stra = ((1,device_num),(1,device_num))
-        sum_cross_entropy_stra = ((1,device_num),)
-        mul2_stra = ((),(device_num,))
+        matmul_stra = ((device_num, 1), (1, 1))
+        reduce_max_stra = ((1, device_num),)
+        sub_stra = ((device_num, 1), (device_num, 1))
+        exp_stra = ((1, device_num),)
+        reduce_sum_stra = ((1, device_num),)
+        div_stra = ((1, device_num), (1, 1))
+        log_stra = ((1, device_num),)
+        mul_stra = ((1, device_num), (1, device_num))
+        sum_cross_entropy_stra = ((1, device_num),)
+        mul2_stra = ((), (device_num,))
         reduce_mean_stra = ((device_num,),)
-        onehot_stra = ((1,device_num),(),())
-        loss_stra_list = [exp_stra, reduce_sum_stra, onehot_stra, div_stra, log_stra, sum_cross_entropy_stra, mul_stra, mul2_stra, reduce_mean_stra, reduce_max_stra, sub_stra]
+        onehot_stra = ((1, device_num), (), ())
+        loss_stra_list = [exp_stra, reduce_sum_stra, onehot_stra, div_stra, log_stra,
+                          sum_cross_entropy_stra, mul_stra, mul2_stra, reduce_mean_stra, reduce_max_stra, sub_stra]
         context.set_auto_parallel_context(parallel_mode="auto_parallel")
-        net = MatmulNet(matmul_stra = matmul_stra, loss_stra_list = loss_stra_list)
+        net = MatmulNet(matmul_stra=matmul_stra, loss_stra_list=loss_stra_list)
         optimizer = Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
         model = Model(net, optimizer=optimizer)
         epoch_size = 6
@@ -254,6 +267,7 @@ class LossFactory():
         loss_value = np.array(parallel_callback.loss_list)
         return loss_value
 
+
 def test_all_trains():
     loss_factory = LossFactory()
     context.reset_auto_parallel_context()

tests/st/auto_parallel/test_expand_loss.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-
 import os
 import pytest
 
+
 @pytest.mark.level0
 @pytest.mark.platform_x86_ascend_training
 @pytest.mark.platform_arm_ascend_training
@@ -23,4 +23,4 @@ import pytest
 def test_expand_loss():
     sh_path = os.path.split(os.path.realpath(__file__))[0]
     ret = os.system(f"sh {sh_path}/run_auto_parallel_loss_expand.sh")
-    assert(ret==0)
+    assert(ret == 0)

tests/st/auto_parallel/test_model_parallel_onehot.py

@@ -16,6 +16,7 @@
 import os
 import pytest
 
+
 def test_expand_loss():
     ret = os.system("sh run_onehot_model_parallel.sh")
-    assert(ret==0)
+    assert(ret == 0)

tests/st/auto_parallel/test_resnet50_expand_loss_2p.py

@@ -11,10 +11,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+# ============================================================================
 
+import os
 import numpy as np
 import pytest
-from numpy import allclose
+import mindspore.context as context
 import mindspore.nn as nn
 import mindspore.common.dtype as mstype
 from mindspore import Tensor
@@ -22,21 +24,21 @@ from mindspore.ops import operations as P
 from mindspore.nn.optim.momentum import Momentum
 from mindspore.common.initializer import One
 from mindspore.train.model import Model, ParallelMode
-from mindspore import context
-import os
 from mindspore.communication.management import init
 import mindspore.ops.functional as F
 from mindspore.nn.loss.loss import _Loss
 from mindspore.train.callback import Callback
 from mindspore.parallel import set_algo_parameters
+
 context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
 context.set_context(enable_hccl=True)
-context.set_context(enable_task_sink=True,device_id=int(os.getenv('DEVICE_ID')))
+context.set_context(enable_task_sink=True, device_id=int(os.getenv('DEVICE_ID')))
 context.set_context(enable_ir_fusion=True)
 context.set_context(enable_loop_sink=False)
 init()
 context.set_auto_parallel_context(mirror_mean=True, parallel_mode=ParallelMode.AUTO_PARALLEL)
 
+
 def weight_variable(shape, factor=0.1):
     return One()
 
@@ -52,6 +54,7 @@ def _conv1x1(in_channels, out_channels, stride=1, padding=0, pad_mode='same'):
     return nn.Conv2d(in_channels, out_channels,
                      kernel_size=1, stride=stride, padding=padding, pad_mode=pad_mode, weight_init=init_value)
 
+
 def _conv7x7(in_channels, out_channels, stride=1, padding=0, pad_mode='same'):
     init_value = weight_variable((out_channels, in_channels, 7, 7))
     return nn.Conv2d(in_channels, out_channels,
@@ -63,6 +66,7 @@ def _fused_bn(channels, momentum=0.9):
     init_bias = weight_variable((channels,))
     return nn.BatchNorm2d(channels, momentum=momentum)
 
+
 class BasicBlock(nn.Cell):
     expansion = 1
 
@@ -172,7 +176,7 @@ class ResNet(nn.Cell):
                  layer_nums,
                  in_channels,
                  out_channels,
-                 strides=[1,2,2,2],
+                 strides=[1, 2, 2, 2],
                  num_classes=100):
         super(ResNet, self).__init__()
 
@@ -292,17 +296,19 @@ class SoftmaxCrossEntropyExpand(_Loss):
 
 rank_id = int(os.environ["RANK_ID"])
 device_num = int(os.environ["RANK_SIZE"])
+
+
 class DataGenerator():
     def get_parallel_blocks(self, input_, strategy):
         blocks = [input_]
         i = 0
         for stra in strategy:
             temp = []
-            while len(blocks)>0:
+            while len(blocks) > 0:
                 block = blocks.pop(0)
                 temp.extend(np.split(block, stra, axis=i))
             blocks.extend(temp)
-            i+=1
+            i += 1
         return blocks
 
     def generate_data(self, shape):
@@ -321,7 +327,7 @@ class DataGenerator():
         stra = [1]*len(shape)
         stra[0] = device_num
         datas = self.get_parallel_blocks(data, stra)
-        return Tensor(data),Tensor(datas[rank_id])
+        return Tensor(data), Tensor(datas[rank_id])
 
 
 class Dataset():
@@ -359,6 +365,7 @@ class ModelCallback(Callback):
     def __init__(self):
         super(ModelCallback, self).__init__()
         self.loss_list = []
+
     def epoch_end(self, run_context, *args):
         cb_params = run_context.original_args()
         result = cb_params.net_outputs
@@ -382,7 +389,7 @@ def test_train_feed(num_classes=8192):
     model.train(5, dataset, dataset_sink_mode=False, callbacks=parallel_callback)
     loss_value = np.array(parallel_callback.loss_list)
     expect_out = [9.010913, 8.855984, 8.56246, 8.146317, 7.624489]
-    assert allclose(loss_value, expect_out, 0.0001, 0.0001)
+    assert np.allclose(loss_value, expect_out, 0.0001, 0.0001)
 
 
 @pytest.mark.level0
@@ -402,4 +409,4 @@ def test_train_feed2(num_classes=1001):
     model.train(5, dataset, dataset_sink_mode=False, callbacks=parallel_callback)
     loss_value = np.array(parallel_callback.loss_list)
     expect_out = [6.908755, 6.8358116, 6.6986914, 6.506859, 6.2708097]
-    assert allclose(loss_value, expect_out, 0.0001, 0.0001)
+    assert np.allclose(loss_value, expect_out, 0.0001, 0.0001)

tests/st/control/test_while.py

@@ -13,12 +13,12 @@
 # limitations under the License.
 # ============================================================================
 import numpy as np
-from mindspore.common.tensor import Tensor
-from mindspore.common import dtype as mstype
 import mindspore.context as context
-from mindspore.ops import operations as P
 import mindspore.nn as nn
-from mindspore.common import ms_function
+from mindspore import Tensor, ms_function
+from mindspore.common import dtype as mstype
+from mindspore.ops import operations as P
+
 
 @ms_function
 def t1_while(x, y, z):
@@ -28,8 +28,9 @@ def t1_while(x, y, z):
     x = x + 3
     return x
 
+
 def test_net():
-    context.set_context(mode=context.GRAPH_MODE,device_target="Ascend")
+    context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
     context.set_context(enable_task_sink=True)
     c1 = Tensor([2], mstype.int32)
     c2 = Tensor([14], mstype.int32)
@@ -38,5 +39,6 @@ def test_net():
     ret = t1_while(c1, c2, c3)
     assert (ret == expect)
 
+
 if __name__ == "__main__":
-    test_net()
+    test_net()

tests/st/fusion/test_add_relu_buffer_fusion.py

@@ -12,17 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-from mindspore import Tensor
-from mindspore.ops import operations as P
-import mindspore.nn as nn
-from mindspore.common.api import ms_function
-import mindspore.common.dtype as mstype
 import numpy as np
 import mindspore.context as context
-from mindspore.common.initializer import initializer
-from mindspore.common.parameter import Parameter
+import mindspore.nn as nn
+import mindspore.common.dtype as mstype
+from mindspore import Tensor, ms_function
+from mindspore.ops import operations as P
+
 context.set_context(mode=context.GRAPH_MODE, device_id=5, device_target="Ascend")
-#context.set_context(enable_task_sink=True)
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -35,17 +34,14 @@ class Net(nn.Cell):
     def construct(self, x, y):
         x = self.cast(x, mstype.float16)
         y = self.cast(y, mstype.float16)
-        #x = self.softmax(x)
         x = self.add(x, y)
-        #x = self.relu(x)
         x = self.relu(x)
-        #x = self.softmax(x)
         x = self.reduce_mean(x)
         return x
 
+
 def test_net():
     x = np.random.randn(32, 10).astype(np.float32)
     relu = Net()
     output = relu(Tensor(x), Tensor(x))
-    print(x)
     print(output.asnumpy())

tests/st/fusion/test_conv_bn1_fusion.py

@@ -13,15 +13,13 @@
 # limitations under the License.
 # ============================================================================
 import numpy as np
+import mindspore.context as context
 import mindspore.nn as nn
+from mindspore import Tensor, Parameter, Model, ms_function
 from mindspore.ops import operations as P
 from mindspore.common.initializer import initializer
-from mindspore import Tensor, Parameter, Model
 from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits
 from mindspore.nn.optim import Momentum
-from mindspore.common.api import ms_function
-import mindspore.nn as wrap
-import mindspore.context as context
 
 context.set_context(device_target="Ascend", enable_task_sink=True)
 
@@ -35,6 +33,7 @@ class MsWrapper(nn.Cell):
     def __init__(self, network):
         super(MsWrapper, self).__init__(auto_prefix=False)
         self._network = network
+
     @ms_function
     def construct(self, *args):
         return self._network(*args)
@@ -42,16 +41,16 @@ class MsWrapper(nn.Cell):
 
 def me_train_tensor(net, input_np, label_np, epoch_size=2):
     loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True)
-    opt = nn.Momentum(Tensor(np.array([0.1])), Tensor(np.array([0.9])), filter(lambda x: x.requires_grad, net.get_parameters()))
+    opt = nn.Momentum(Tensor(np.array([0.1])), Tensor(np.array([0.9])),
+                      filter(lambda x: x.requires_grad, net.get_parameters()))
     context.set_context(mode=context.GRAPH_MODE)
     Model(net, loss, opt)
-    _network = wrap.WithLossCell(net, loss)
-    _train_net = MsWrapper(wrap.TrainOneStepCell(_network, opt))
+    _network = nn.WithLossCell(net, loss)
+    _train_net = MsWrapper(nn.TrainOneStepCell(_network, opt))
     _train_net.set_train()
     for epoch in range(0, epoch_size):
-        print(f"epoch %d"%(epoch))
+        print(f"epoch %d" % (epoch))
         output = _train_net(Tensor(input_np), Tensor(label_np))
-        print("********output***********")
         print(output.asnumpy())
 
 
@@ -60,9 +59,9 @@ def test_conv_bn_add_relu_fusion():
         def __init__(self):
             super(Net, self).__init__()
             self.conv = nn.Conv2d(input_channel, output_channel,
-                  kernel_size=1, stride=1, padding=0, has_bias=False, pad_mode="same")
+                                  kernel_size=1, stride=1, padding=0, has_bias=False, pad_mode="same")
             self.conv1 = nn.Conv2d(input_channel, output_channel,
-                  kernel_size=1, stride=1, padding=0, has_bias=False, pad_mode="same")
+                                   kernel_size=1, stride=1, padding=0, has_bias=False, pad_mode="same")
             self.bn = nn.BatchNorm2d(output_channel, momentum=0.1, eps=0.0001)
             self.add = P.TensorAdd()
             self.relu = P.ReLU()
@@ -91,7 +90,7 @@ def test_conv_bn_relu_fusion():
         def __init__(self):
             super(Net, self).__init__()
             self.conv = nn.Conv2d(input_channel, output_channel,
-                  kernel_size=1, stride=1, padding=0, has_bias=False, pad_mode="same")
+                                  kernel_size=1, stride=1, padding=0, has_bias=False, pad_mode="same")
             self.bn = nn.BatchNorm2d(output_channel, momentum=0.1, eps=0.0001)
             self.relu = P.ReLU()
             self.mean = P.ReduceMean(keep_dims=True)
@@ -118,7 +117,7 @@ def test_conv_bn_fusion():
         def __init__(self):
             super(Net, self).__init__()
             self.conv = nn.Conv2d(input_channel, output_channel,
-                  kernel_size=1, stride=1, padding=0, has_bias=False, pad_mode="same")
+                                  kernel_size=1, stride=1, padding=0, has_bias=False, pad_mode="same")
             self.bn = nn.BatchNorm2d(output_channel, momentum=0.1, eps=0.0001)
             self.mean = P.ReduceMean(keep_dims=True)
             self.reshape = P.Reshape()

tests/st/fusion/test_tbe_eltwise_fusion_1.py

@@ -13,16 +13,15 @@
 # limitations under the License.
 # ============================================================================
 import pytest
-from mindspore import Tensor
-from mindspore.ops import operations as P
-import mindspore.nn as nn
-from mindspore.common.api import ms_function
-import mindspore.common.dtype as mstype
 import numpy as np
 import mindspore.context as context
-from mindspore.common.initializer import initializer
-from mindspore.common.parameter import Parameter
+import mindspore.nn as nn
+from mindspore import Tensor
+from mindspore.ops import operations as P
+
 context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -35,6 +34,7 @@ class Net(nn.Cell):
         x = self.relu(x)
         return x
 
+
 @pytest.mark.level0
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
@@ -43,5 +43,4 @@ def test_net():
     x = np.random.randn(32, 10).astype(np.float32)
     relu_relu = Net()
     output = relu_relu(Tensor(x))
-    print(x)
     print(output.asnumpy())

tests/st/fusion/test_tbe_eltwise_fusion_2.py

@@ -13,16 +13,15 @@
 # limitations under the License.
 # ============================================================================
 import pytest
-from mindspore import Tensor
-from mindspore.ops import operations as P
-import mindspore.nn as nn
-from mindspore.common.api import ms_function
-import mindspore.common.dtype as mstype
 import numpy as np
 import mindspore.context as context
-from mindspore.common.initializer import initializer
-from mindspore.common.parameter import Parameter
+import mindspore.nn as nn
+from mindspore import Tensor
+from mindspore.ops import operations as P
+
 context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
+
+
 class Net(nn.Cell):
     def __init__(self):
         super(Net, self).__init__()
@@ -41,6 +40,7 @@ class Net(nn.Cell):
         x = self.relu(x)
         return x
 
+
 @pytest.mark.level0
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
@@ -50,5 +50,4 @@ def test_net():
     y = np.random.randn(10).astype(np.float32)
     net = Net()
     output = net(Tensor(x), Tensor(y))
-    print(x)
-    print(output.asnumpy())
+    print(output.asnumpy())

tests/st/fusion/test_tbe_multi_inout_eltwise_fusion.py

@@ -12,15 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-from mindspore import Tensor
-from mindspore.ops import operations as P
-import mindspore.nn as nn
-import mindspore.common.dtype as mstype
 import numpy as np
 import mindspore.context as context
-from mindspore.common.parameter import Parameter
+import mindspore.nn as nn
+from mindspore import Tensor
+from mindspore.ops import operations as P
+
 context.set_context(mode=context.GRAPH_MODE, device_id=4, device_target="Ascend")
-#context.set_context(enable_task_sink=True)
+
 
 class Net(nn.Cell):
     def __init__(self):
@@ -39,6 +38,7 @@ class Net(nn.Cell):
         z = self.add(z1, z2)
         return z
 
+
 def test_net():
     x = np.random.randn(32, 10).astype(np.float32)
     y = np.random.randn(32, 10).astype(np.float32)
@@ -46,6 +46,4 @@ def test_net():
     h = np.random.randn(10).astype(np.float32)
     relu_relu = Net()
     output = relu_relu(Tensor(x), Tensor(y), Tensor(k), Tensor(h))
-    print(x)
     print(output.asnumpy())
-

tests/st/fusion/test_tbe_reduce_eltwise_fusion.py

@@ -13,17 +13,16 @@
 # limitations under the License.
 # ============================================================================
 import pytest
+import numpy as np
+import mindspore.context as context
+import mindspore.nn as nn
 from mindspore import Tensor
 from mindspore.ops import operations as P
 from mindspore.ops.operations import _grad_ops as G
-import mindspore.nn as nn
-from mindspore.common.api import ms_function
-import mindspore.common.dtype as mstype
-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__()
@@ -41,6 +40,7 @@ class Net(nn.Cell):
         x = self.relu(x)
         return x
 
+
 @pytest.mark.level0
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
@@ -49,5 +49,4 @@ def test_net():
     x = np.random.randn(32, 10).astype(np.float32)
     net = Net()
     output = net(Tensor(x))
-    print(x)
-    print(output.asnumpy())
+    print(output.asnumpy())

tests/st/mem_reuse/check_file.py

@@ -14,6 +14,7 @@
 # ============================================================================
 import os
 import filecmp
+
 curr_path = os.path.abspath(os.curdir)
 file_memreuse = curr_path + "/mem_reuse_check/memreuse.ir"
 file_normal = curr_path + "/mem_reuse_check/normal_mem.ir"
@@ -23,5 +24,3 @@ checker = os.path.exists(file_normal)
 assert (checker, True)
 checker = filecmp.cmp(file_memreuse, file_normal)
 assert (checker, True)
-
-

tests/st/mem_reuse/resnet.py

@@ -19,6 +19,7 @@ from mindspore.ops import operations as P
 from mindspore.common.initializer import initializer
 from mindspore.common import dtype as mstype
 
+
 def weight_variable(shape):
     return initializer('XavierUniform', shape=shape, dtype=mstype.float32)
 
@@ -297,4 +298,3 @@ class ResNet(nn.Cell):
 
 def resnet50(batch_size, num_classes):
     return ResNet(ResidualBlock, [3, 4, 6, 3], num_classes, batch_size)
-

tests/st/mem_reuse/resnet_cifar_memreuse.py

@@ -12,16 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
+import argparse
+import os
+import numpy as np
+import mindspore.context as context
 import mindspore.nn as nn
+import mindspore.common.dtype as mstype
 from mindspore import Tensor
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.nn.optim.momentum import Momentum
 from mindspore.train.model import Model, ParallelMode
-from mindspore import context
-import mindspore.common.dtype as mstype
-import os
-import numpy as np
-import mindspore.ops.functional as F
 from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor
 from mindspore.train.serialization import load_checkpoint, load_param_into_net
 import mindspore.dataset as de
@@ -30,11 +31,11 @@ import mindspore.dataset.transforms.vision.c_transforms as vision
 from mindspore.communication.management import init
 from resnet import resnet50
 import random
+
 random.seed(1)
 np.random.seed(1)
 de.config.set_seed(1)
 
-import argparse
 parser = argparse.ArgumentParser(description='Image classification')
 parser.add_argument('--run_distribute', type=bool, default=False, help='Run distribute')
 parser.add_argument('--device_num', type=int, default=1, help='Device num.')
@@ -47,9 +48,9 @@ parser.add_argument('--checkpoint_path', type=str, default=None, help='Checkpoin
 parser.add_argument('--dataset_path', type=str, default="/var/log/npu/datasets/cifar", help='Dataset path')
 args_opt = parser.parse_args()
 
-device_id=int(os.getenv('DEVICE_ID'))
+device_id = int(os.getenv('DEVICE_ID'))
 
-data_home=args_opt.dataset_path
+data_home = args_opt.dataset_path
 
 context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
 context.set_context(enable_task_sink=True, device_id=device_id)
@@ -64,8 +65,8 @@ def create_dataset(repeat_num=1, training=True):
     ds = de.Cifar10Dataset(data_dir)
 
     if args_opt.run_distribute:
-        rank_id=int(os.getenv('RANK_ID'))
-        rank_size=int(os.getenv('RANK_SIZE'))
+        rank_id = int(os.getenv('RANK_ID'))
+        rank_size = int(os.getenv('RANK_SIZE'))
         ds = de.Cifar10Dataset(data_dir, num_shards=rank_size, shard_id=rank_id)
 
     resize_height = 224
@@ -74,9 +75,9 @@ def create_dataset(repeat_num=1, training=True):
     shift = 0.0
 
     # define map operations
-    random_crop_op = vision.RandomCrop((32, 32), (4, 4, 4, 4)) # padding_mode default CONSTANT
+    random_crop_op = vision.RandomCrop((32, 32), (4, 4, 4, 4))  # padding_mode default CONSTANT
     random_horizontal_op = vision.RandomHorizontalFlip()
-    resize_op = vision.Resize((resize_height, resize_width)) # interpolation default BILINEAR
+    resize_op = vision.Resize((resize_height, resize_width))  # interpolation default BILINEAR
     rescale_op = vision.Rescale(rescale, shift)
     normalize_op = vision.Normalize((0.4465, 0.4822, 0.4914), (0.2010, 0.1994, 0.2023))
     changeswap_op = vision.HWC2CHW()

tests/st/mem_reuse/resnet_cifar_normal.py

@@ -12,16 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
+import argparse
+import os
+import numpy as np
+import mindspore.context as context
 import mindspore.nn as nn
+import mindspore.common.dtype as mstype
 from mindspore import Tensor
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.nn.optim.momentum import Momentum
 from mindspore.train.model import Model, ParallelMode
-from mindspore import context
-import mindspore.common.dtype as mstype
-import os
-import numpy as np
-import mindspore.ops.functional as F
 from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor
 from mindspore.train.serialization import load_checkpoint, load_param_into_net
 import mindspore.dataset as de
@@ -35,7 +36,6 @@ random.seed(1)
 np.random.seed(1)
 de.config.set_seed(1)
 
-import argparse
 
 parser = argparse.ArgumentParser(description='Image classification')
 parser.add_argument('--run_distribute', type=bool, default=False, help='Run distribute')

tests/st/nccl/test_nccl_all.py

@@ -15,6 +15,7 @@
 import os
 import pytest
 
+
 @pytest.mark.level0
 @pytest.mark.platform_x86_gpu_training
 @pytest.mark.env_single
@@ -22,6 +23,7 @@ def test_nccl_lenet():
     return_code = os.system("mpirun -n 8 pytest -s test_nccl_lenet.py")
     assert(return_code == 0)
 
+
 @pytest.mark.level0
 @pytest.mark.platform_x86_gpu_training
 @pytest.mark.env_single
@@ -29,6 +31,7 @@ def test_nccl_all_reduce_op():
     return_code = os.system("mpirun -n 8 pytest -s test_nccl_all_reduce_op.py")
     assert(return_code == 0)
 
+
 @pytest.mark.level0
 @pytest.mark.platform_x86_gpu_training
 @pytest.mark.env_single
@@ -36,6 +39,7 @@ def test_nccl_all_gather_op():
     return_code = os.system("mpirun -n 8 pytest -s test_nccl_all_gather_op.py")
     assert(return_code == 0)
 
+
 @pytest.mark.level0
 @pytest.mark.platform_x86_gpu_training
 @pytest.mark.env_single

tests/st/nccl/test_nccl_all_gather_op.py

@@ -12,23 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-from mindspore import Tensor
-from mindspore.ops import operations as P
-import mindspore.nn as nn
 import numpy as np
 import mindspore.context as context
+import mindspore.nn as nn
+from mindspore import Tensor
+from mindspore.ops import operations as P
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
 from mindspore.communication.management import init, NCCL_WORLD_COMM_GROUP, get_rank, get_group_size
+
 context.set_context(mode=context.GRAPH_MODE, device_target='GPU')
 
 init('nccl')
 rank = get_rank()
 size = get_group_size()
-x = np.ones([1,1,3,3]).astype(np.float32) * 0.01 * (rank + 1)
+x = np.ones([1, 1, 3, 3]).astype(np.float32) * 0.01 * (rank + 1)
+
 
 class Net(nn.Cell):
-    def __init__( self):
+    def __init__(self):
         super(Net, self).__init__()
         self.all_gather = P.AllGather(group=NCCL_WORLD_COMM_GROUP)
         self.x = Parameter(initializer(Tensor(x), x.shape), name='x')
@@ -36,6 +38,7 @@ class Net(nn.Cell):
     def construct(self):
         return self.all_gather(self.x)
 
+
 def test_AllGather():
     all_gather = Net()
     output = all_gather()

tests/st/nccl/test_nccl_all_reduce_op.py

@@ -12,23 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-from mindspore import Tensor
-from mindspore.ops import operations as P
-import mindspore.nn as nn
 import numpy as np
 import mindspore.context as context
+import mindspore.nn as nn
+from mindspore import Tensor
+from mindspore.ops import operations as P
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
 from mindspore.communication.management import init, NCCL_WORLD_COMM_GROUP, get_rank, get_group_size
+
 context.set_context(mode=context.GRAPH_MODE, device_target='GPU')
 
 init('nccl')
 rank = get_rank()
 size = get_group_size()
-x = np.ones([3,1,3,3]).astype(np.float32) * 0.01 * (rank + 1)
+x = np.ones([3, 1, 3, 3]).astype(np.float32) * 0.01 * (rank + 1)
+
 
 class Net(nn.Cell):
-    def __init__( self):
+    def __init__(self):
         super(Net, self).__init__()
         self.x1 = Parameter(initializer(Tensor(x), x.shape), name='x1')
         self.x2 = Parameter(initializer(Tensor(x), x.shape), name='x2')
@@ -47,6 +49,7 @@ class Net(nn.Cell):
                 self.all_reduce2(self.x2),
                 self.all_reduce3(self.x3))
 
+
 def test_AllReduce():
     all_reduce = Net()
     output = all_reduce()
@@ -58,16 +61,16 @@ def test_AllReduce():
     diff0 = output[0].asnumpy() - expect0
     error0 = np.ones(shape=expect0.shape) * 1.0e-5
     assert np.all(diff0 < error0)
-    assert (output[0].shape() == expect0.shape)
+    assert output[0].shape() == expect0.shape
 
     expect1 = expect0
     diff1 = output[1].asnumpy() - expect1
     error1 = np.ones(shape=expect1.shape) * 1.0e-5
     assert np.all(diff1 < error1)
-    assert (output[1].shape() == expect1.shape)
+    assert output[1].shape() == expect1.shape
 
     expect2 = expect1
     diff2 = output[2].asnumpy() - expect2
     error2 = np.ones(shape=expect2.shape) * 1.0e-5
     assert np.all(diff2 < error2)
-    assert (output[2].shape() == expect2.shape)
+    assert output[2].shape() == expect2.shape

tests/st/nccl/test_nccl_lenet.py

@@ -12,16 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-import numpy as np
-from mindspore.nn import Dense
-import mindspore.nn as nn
 import datetime
+import numpy as np
 import mindspore.context as context
-from mindspore.communication.management import init, NCCL_WORLD_COMM_GROUP, get_rank, get_group_size
+import mindspore.nn as nn
+from mindspore import Tensor
 from mindspore.nn.optim import Momentum
 from mindspore.nn import TrainOneStepCell, WithLossCell
 from mindspore.ops import operations as P
-from mindspore.common.tensor import Tensor
+from mindspore.communication.management import init, get_rank, get_group_size
 
 context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
 init('nccl')
@@ -31,6 +30,7 @@ total = 5000
 batch_size = 32
 mini_batch = total // batch_size
 
+
 class LeNet(nn.Cell):
     def __init__(self):
         super(LeNet, self).__init__()
@@ -43,15 +43,15 @@ class LeNet(nn.Cell):
         self.conv2 = nn.Conv2d(6, 16, (5, 5), weight_init=weight2, pad_mode='valid', stride=1, padding=0)
         self.pool = nn.MaxPool2d(kernel_size=2, stride=2, pad_mode="valid")
         self.reshape = P.Reshape()
-        
+
         weight1 = Tensor(np.ones([120, 400]).astype(np.float32) * 0.01)
-        self.fc1 = Dense(400, 120, weight_init=weight1)
-        
+        self.fc1 = nn.Dense(400, 120, weight_init=weight1)
+
         weight2 = Tensor(np.ones([84, 120]).astype(np.float32) * 0.01)
-        self.fc2 = Dense(120, 84, weight_init=weight2)
-        
+        self.fc2 = nn.Dense(120, 84, weight_init=weight2)
+
         weight3 = Tensor(np.ones([10, 84]).astype(np.float32) * 0.01)
-        self.fc3 = Dense(84, 10, weight_init=weight3)
+        self.fc3 = nn.Dense(84, 10, weight_init=weight3)
 
     def construct(self, input_x):
         output = self.conv1(input_x)
@@ -66,6 +66,7 @@ class LeNet(nn.Cell):
         output = self.fc3(output)
         return output
 
+
 def test_lenet_nccl():
     net = LeNet()
     net.set_train()

tests/st/nccl/test_nccl_reduce_scatter_op.py

@@ -12,11 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-from mindspore import Tensor
-from mindspore.ops import operations as P
-import mindspore.nn as nn
 import numpy as np
 import mindspore.context as context
+import mindspore.nn as nn
+from mindspore import Tensor
+from mindspore.ops import operations as P
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
 from mindspore.communication.management import init, NCCL_WORLD_COMM_GROUP, get_rank, get_group_size
@@ -27,8 +27,9 @@ rank = get_rank()
 size = get_group_size()
 x = np.ones([size, 1, 3, 3]).astype(np.float32) * 0.01 * (rank + 1)
 
+
 class Net(nn.Cell):
-    def __init__( self):
+    def __init__(self):
         super(Net, self).__init__()
         self.x = Parameter(initializer(Tensor(x), x.shape), name='x')
 
@@ -46,6 +47,7 @@ class Net(nn.Cell):
                 self.reduce_scatter2(self.x),
                 self.reduce_scatter3(self.x))
 
+
 def test_ReduceScatter():
     reduce_scatter = Net()
     output = reduce_scatter()
@@ -53,7 +55,7 @@ def test_ReduceScatter():
     sum = np.ones([size, 1, 3, 3]).astype(np.float32) * 0
     for i in range(size):
         sum += np.ones([size, 1, 3, 3]).astype(np.float32) * 0.01 * (i + 1)
-    expect0 = sum[rank : rank + 1]
+    expect0 = sum[rank: rank + 1]
     diff0 = output[0].asnumpy() - expect0
     error0 = np.ones(shape=expect0.shape) * 1.0e-5
     assert np.all(diff0 < error0)

tests/st/networks/models/alexnet.py

@@ -16,6 +16,7 @@ import mindspore.nn as nn
 from mindspore.ops import operations as P
 from mindspore.nn import Dense
 
+
 class AlexNet(nn.Cell):
     def __init__(self, num_classes=10):
         super(AlexNet, self).__init__()

tests/st/networks/models/bert/bert_tdt_no_lossscale.py

@@ -18,21 +18,22 @@
 import os
 import pytest
 import numpy as np
-from numpy import allclose
+import mindspore.context as context
 import mindspore.common.dtype as mstype
 import mindspore.dataset.engine.datasets as de
 import mindspore.dataset.transforms.c_transforms as C
-from mindspore import context
-from mindspore.common.tensor import Tensor
+from mindspore import Tensor
 from mindspore.train.model import Model
 from mindspore.train.callback import Callback
 from mindspore.model_zoo.Bert_NEZHA import BertConfig, BertNetworkWithLoss, BertTrainOneStepCell
 from mindspore.nn.optim import Momentum
 from mindspore import log as logger
+
 _current_dir = os.path.dirname(os.path.realpath(__file__))
 DATA_DIR = ["/home/workspace/mindspore_dataset/bert/example/examples.tfrecord"]
 SCHEMA_DIR = "/home/workspace/mindspore_dataset/bert/example/datasetSchema.json"
 
+
 def get_config(version='base', batch_size=1):
     """get config"""
     if version == 'base':
@@ -99,13 +100,14 @@ def get_config(version='base', batch_size=1):
         bert_config = BertConfig(batch_size=batch_size)
     return bert_config
 
+
 def me_de_train_dataset():
     """test me de train dataset"""
     # apply repeat operations
     repeat_count = 1
     ds = de.TFRecordDataset(DATA_DIR, SCHEMA_DIR, columns_list=["input_ids", "input_mask", "segment_ids",
-                                                               "next_sentence_labels", "masked_lm_positions",
-                                                               "masked_lm_ids", "masked_lm_weights"], shuffle=False)
+                                                                "next_sentence_labels", "masked_lm_positions",
+                                                                "masked_lm_ids", "masked_lm_weights"], shuffle=False)
     type_cast_op = C.TypeCast(mstype.int32)
     ds = ds.map(input_columns="masked_lm_ids", operations=type_cast_op)
     ds = ds.map(input_columns="masked_lm_positions", operations=type_cast_op)
@@ -137,6 +139,7 @@ class ModelCallback(Callback):
         self.loss_list.append(cb_params.net_outputs.asnumpy()[0])
         logger.info("epoch: {}, outputs are {}".format(cb_params.cur_epoch_num, str(cb_params.net_outputs)))
 
+
 @pytest.mark.level0
 @pytest.mark.platform_arm_ascend_training
 @pytest.mark.platform_x86_ascend_training
@@ -180,7 +183,8 @@ def test_bert_tdt():
     expect_out = [12.19179, 11.965041, 11.969687, 11.97815, 11.969171, 12.603289, 12.165594,
                   12.824818, 12.38842, 12.604046]
     logger.info("expected loss value output: {}".format(expect_out))
-    assert allclose(loss_value, expect_out, 0.00001, 0.00001)
+    assert np.allclose(loss_value, expect_out, 0.00001, 0.00001)
+
 
 if __name__ == '__main__':
     test_bert_tdt()

tests/st/networks/models/lenet.py

@@ -14,9 +14,10 @@
 # ============================================================================
 import numpy as np
 import mindspore.nn as nn
+from mindspore import Tensor
 from mindspore.ops import operations as P
 from mindspore.nn import Dense
-from mindspore import Tensor
+
 
 class LeNet(nn.Cell):
     def __init__(self):

tests/st/networks/models/resnetv1_5.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 # ============================================================================
 import numpy as np
-from mindspore.common.tensor import Tensor
 import mindspore.nn as nn
-import mindspore.ops.operations as P
+from mindspore import Tensor
+from mindspore.ops import operations as P
+
 
 def weight_variable(shape):
     ones = np.ones(shape).astype(np.float32)
@@ -37,7 +38,7 @@ def conv3x3(in_channels, out_channels, stride=1, padding=0):
     weight_shape = (out_channels, in_channels, 3, 3)
     weight = weight_variable(weight_shape)
     return nn.Conv2d(in_channels, out_channels,
-                  kernel_size=3, stride=stride, padding=padding, weight_init=weight, has_bias=False, pad_mode="same")
+                     kernel_size=3, stride=stride, padding=padding, weight_init=weight, has_bias=False, pad_mode="same")
 
 
 def conv1x1(in_channels, out_channels, stride=1, padding=0):
@@ -45,7 +46,7 @@ def conv1x1(in_channels, out_channels, stride=1, padding=0):
     weight_shape = (out_channels, in_channels, 1, 1)
     weight = weight_variable(weight_shape)
     return nn.Conv2d(in_channels, out_channels,
-                  kernel_size=1, stride=stride, padding=padding, weight_init=weight, has_bias=False, pad_mode="same")
+                     kernel_size=1, stride=stride, padding=padding, weight_init=weight, has_bias=False, pad_mode="same")
 
 
 def conv7x7(in_channels, out_channels, stride=1, padding=0):
@@ -53,7 +54,7 @@ def conv7x7(in_channels, out_channels, stride=1, padding=0):
     weight_shape = (out_channels, in_channels, 7, 7)
     weight = weight_variable(weight_shape)
     return nn.Conv2d(in_channels, out_channels,
-                  kernel_size=7, stride=stride, padding=padding, weight_init=weight, has_bias=False, pad_mode="same")
+                     kernel_size=7, stride=stride, padding=padding, weight_init=weight, has_bias=False, pad_mode="same")
 
 
 def bn_with_initialize(out_channels):
@@ -63,7 +64,7 @@ def bn_with_initialize(out_channels):
     beta = weight_variable_0(shape)
     gamma = weight_variable_1(shape)
     bn = nn.BatchNorm2d(out_channels, momentum=0.1, eps=0.0001, gamma_init=gamma,
-                     beta_init=beta, moving_mean_init=mean, moving_var_init=var)
+                        beta_init=beta, moving_mean_init=mean, moving_var_init=var)
     return bn
 
 
@@ -74,7 +75,7 @@ def bn_with_initialize_last(out_channels):
     beta = weight_variable_0(shape)
     gamma = weight_variable_0(shape)
     bn = nn.BatchNorm2d(out_channels, momentum=0.1, eps=0.0001, gamma_init=gamma,
-                     beta_init=beta, moving_mean_init=mean, moving_var_init=var)
+                        beta_init=beta, moving_mean_init=mean, moving_var_init=var)
     return bn
 
 
@@ -294,6 +295,6 @@ class ResNet(nn.Cell):
         x = self.fc(x)
         return x
 
+
 def resnet50(batch_size, num_classes):
     return ResNet(ResidualBlock, [3, 4, 6, 3], num_classes, batch_size)
-

tests/st/networks/test_cpu_lenet.py

@@ -13,13 +13,15 @@
 # limitations under the License.
 # ============================================================================
 import pytest
-from mindspore.nn import TrainOneStepCell, WithLossCell
-import mindspore.context as context
-from mindspore.nn.optim import Momentum
 import numpy as np
+import mindspore.context as context
 import mindspore.nn as nn
-from mindspore.ops import operations as P
 from mindspore import Tensor
+from mindspore.nn import TrainOneStepCell, WithLossCell
+from mindspore.nn.optim import Momentum
+from mindspore.ops import operations as P
+
+context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
 
 
 class LeNet(nn.Cell):
@@ -52,9 +54,6 @@ class LeNet(nn.Cell):
         return output
 
 
-context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
-
-
 def train(net, data, label):
     learning_rate = 0.01
     momentum = 0.9

tests/st/networks/test_gpu_alexnet.py

@@ -19,15 +19,17 @@ from __future__ import print_function
 
 import pytest
 import numpy as np
+import mindspore.context as context
 import mindspore.nn as nn
+from mindspore import Tensor
 from mindspore.nn.optim import Momentum
 from mindspore.ops import operations as P
 from mindspore.nn import TrainOneStepCell, WithLossCell
-from mindspore import Tensor
 from mindspore.common.initializer import initializer
-import mindspore.context as context
+
 context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
 
+
 class AlexNet(nn.Cell):
     def __init__(self, num_classes=10):
         super(AlexNet, self).__init__()
@@ -66,6 +68,7 @@ class AlexNet(nn.Cell):
         x = self.fc3(x)
         return x
 
+
 @pytest.mark.level0
 @pytest.mark.platform_x86_gpu_training
 @pytest.mark.env_onecard
@@ -73,14 +76,14 @@ def test_trainTensor(num_classes=10, epoch=15, batch_size=32):
     net = AlexNet(num_classes)
     lr = 0.1
     momentum = 0.9
-    optimizer = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), lr, momentum, weight_decay = 0.0001)
+    optimizer = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), lr, momentum, weight_decay=0.0001)
     criterion = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True)
     net_with_criterion = WithLossCell(net, criterion)
     train_network = TrainOneStepCell(net_with_criterion, optimizer)
     train_network.set_train()
-    losses=[]
+    losses = []
     for i in range(0, epoch):
-        data = Tensor(np.ones([batch_size, 3 ,227, 227]).astype(np.float32) * 0.01)
+        data = Tensor(np.ones([batch_size, 3, 227, 227]).astype(np.float32) * 0.01)
         label = Tensor(np.ones([batch_size]).astype(np.int32))
         loss = train_network(data, label)
         losses.append(loss)

tests/st/networks/test_gpu_lenet.py

@@ -16,16 +16,19 @@
 import pytest
 import numpy as np
 import mindspore.nn as nn
+import mindspore.context as context
+from mindspore import Tensor
 from mindspore.nn.optim import Momentum
 from mindspore.ops import operations as P
 from mindspore.nn import TrainOneStepCell, WithLossCell
 from mindspore.nn import Dense
-from mindspore import Tensor
 from mindspore.common.initializer import initializer
 from mindspore.common import dtype as mstype
-import mindspore.context as context
+
 
 context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
+
+
 class LeNet(nn.Cell):
     def __init__(self):
         super(LeNet, self).__init__()
@@ -65,6 +68,7 @@ def multisteplr(total_steps, gap, base_lr=0.9, gamma=0.1, dtype=mstype.float32):
         lr.append(lr_)
     return Tensor(np.array(lr), dtype)
 
+
 @pytest.mark.level0
 @pytest.mark.platform_x86_gpu_training
 @pytest.mark.env_onecard
@@ -81,7 +85,7 @@ def test_train_lenet():
     train_network.set_train()
     losses = []
     for i in range(epoch):
-        data = Tensor(np.ones([net.batch_size, 3 ,32, 32]).astype(np.float32) * 0.01)
+        data = Tensor(np.ones([net.batch_size, 3, 32, 32]).astype(np.float32) * 0.01)
         label = Tensor(np.ones([net.batch_size]).astype(np.int32))
         loss = train_network(data, label)
         losses.append(loss)

tests/st/networks/test_gpu_lstm.py

@@ -15,18 +15,20 @@
 
 import pytest
 import numpy as np
+import mindspore.context as context
+import mindspore.nn as nn
+from mindspore import Tensor
 from mindspore.nn.optim import Momentum
 from mindspore.ops import operations as P
 from mindspore.nn import TrainOneStepCell, WithLossCell
 from mindspore.nn import Dense
-from mindspore import Tensor
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter
-import mindspore.context as context
-import mindspore.nn as nn
+
 
 context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
 
+
 def InitialLstmWeight(input_size, hidden_size, num_layers, bidirectional, has_bias=False):
     num_directions = 1
     if bidirectional:
@@ -56,6 +58,7 @@ def InitialLstmWeight(input_size, hidden_size, num_layers, bidirectional, has_bi
 
     return h, c, w
 
+
 class SentimentNet(nn.Cell):
     def __init__(self, vocab_size, embed_size, num_hiddens, num_layers,
                  bidirectional, weight, labels, batch_size):
@@ -99,6 +102,7 @@ class SentimentNet(nn.Cell):
         outputs = self.decoder(encoding)
         return outputs
 
+
 batch_size = 64
 @pytest.mark.level0
 @pytest.mark.platform_x86_gpu_training
@@ -130,7 +134,7 @@ def test_LSTM():
     train_network.set_train()
 
     train_features = Tensor(np.ones([64, max_len]).astype(np.int32))
-    train_labels = Tensor(np.ones([64,]).astype(np.int32)[0:64])
+    train_labels = Tensor(np.ones([64, ]).astype(np.int32)[0:64])
     losses = []
     for epoch in range(num_epochs):
         loss = train_network(train_features, train_labels)

tests/st/networks/test_gpu_resnet.py

@@ -19,36 +19,34 @@ from __future__ import print_function
 
 import pytest
 import numpy as np
-
+import mindspore.context as context
+import mindspore.nn as nn
+from mindspore import Tensor
 from mindspore.nn.cell import Cell
 from mindspore.nn.layer.conv import Conv2d
 from mindspore.nn.layer.basic import Flatten
 from mindspore.nn.layer.normalization import BatchNorm2d
 from mindspore.nn.layer.pooling import MaxPool2d
 from mindspore.ops.operations import TensorAdd
-import mindspore.nn as nn
-
 from mindspore.nn.optim import Momentum
 from mindspore.ops import operations as P
 from mindspore.nn import TrainOneStepCell, WithLossCell
 from mindspore.nn import Dense
-from mindspore import Tensor
 from mindspore.common.initializer import initializer
 
-import mindspore.context as context
-
 context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
 
+
 def random_normal_init(shape, mean=0.0, stddev=0.01, seed=None):
     init_value = np.ones(shape).astype(np.float32) * 0.01
     return Tensor(init_value)
 
+
 def variance_scaling_raw(shape):
     variance_scaling_value = np.ones(shape).astype(np.float32) * 0.01
     return Tensor(variance_scaling_value)
 
 
-
 def weight_variable_0(shape):
     zeros = np.zeros(shape).astype(np.float32)
     return Tensor(zeros)
@@ -323,6 +321,7 @@ class ResNet(Cell):
 def resnet50(num_classes):
     return ResNet(ResidualBlock, [3, 4, 6, 3], num_classes)
 
+
 @pytest.mark.level0
 @pytest.mark.platform_x86_gpu_training
 @pytest.mark.env_onecard
@@ -335,9 +334,9 @@ def test_trainTensor(num_classes=10, epoch=8, batch_size=1):
     net_with_criterion = WithLossCell(net, criterion)
     train_network = TrainOneStepCell(net_with_criterion, optimizer)  # optimizer
     train_network.set_train()
-    losses=[]
+    losses = []
     for i in range(0, epoch):
-        data = Tensor(np.ones([batch_size, 3 ,224, 224]).astype(np.float32) * 0.01)
+        data = Tensor(np.ones([batch_size, 3, 224, 224]).astype(np.float32) * 0.01)
         label = Tensor(np.ones([batch_size]).astype(np.int32))
         loss = train_network(data, label)
         losses.append(loss)

tests/st/networks/test_network_main.py

@@ -13,25 +13,27 @@
 # limitations under the License.
 # ============================================================================
 """
-Function: 
+Function:
     test network
-Usage: 
+Usage:
     python test_network_main.py --net lenet --target Ascend
 """
 import os
 import time
 import numpy as np
 import argparse
+import mindspore.context as context
 import mindspore.nn as nn
-from mindspore.common.tensor import Tensor
+from mindspore import Tensor
 from mindspore.nn import TrainOneStepCell, WithLossCell
-import mindspore.context as context
 from mindspore.nn.optim import Momentum
 from models.lenet import LeNet
 from models.resnetv1_5 import resnet50
 from models.alexnet import AlexNet
+
 context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
 
+
 def train(net, data, label):
     learning_rate = 0.01
     momentum = 0.9
@@ -42,29 +44,31 @@ def train(net, data, label):
     train_network = TrainOneStepCell(net_with_criterion, optimizer)  # optimizer
     train_network.set_train()
     res = train_network(data, label)
-    print("+++++++++Loss+++++++++++++")
     print(res)
-    print("+++++++++++++++++++++++++++")
     assert res
 
+
 def test_resnet50():
-    data = Tensor(np.ones([32, 3 ,224, 224]).astype(np.float32) * 0.01)
+    data = Tensor(np.ones([32, 3, 224, 224]).astype(np.float32) * 0.01)
     label = Tensor(np.ones([32]).astype(np.int32))
     net = resnet50(32, 10)
     train(net, data, label)
 
+
 def test_lenet():
-    data = Tensor(np.ones([32, 1 ,32, 32]).astype(np.float32) * 0.01)
+    data = Tensor(np.ones([32, 1, 32, 32]).astype(np.float32) * 0.01)
     label = Tensor(np.ones([32]).astype(np.int32))
     net = LeNet()
     train(net, data, label)
 
+
 def test_alexnet():
-    data = Tensor(np.ones([32, 3 ,227, 227]).astype(np.float32) * 0.01)
+    data = Tensor(np.ones([32, 3, 227, 227]).astype(np.float32) * 0.01)
     label = Tensor(np.ones([32]).astype(np.int32))
     net = AlexNet()
     train(net, data, label)
 
+
 parser = argparse.ArgumentParser(description='MindSpore Testing Network')
 parser.add_argument('--net', default='resnet50', type=str, help='net name')
 parser.add_argument('--device', default='Ascend', type=str, help='device target')

tests/st/pynative/test_ascend_lenet.py

@@ -14,7 +14,8 @@
 # ============================================================================
 import pytest
 import numpy as np
-import time, math
+import time
+import math
 import mindspore.nn as nn
 from mindspore import context, Tensor, ParameterTuple
 from mindspore.ops import operations as P
@@ -28,6 +29,7 @@ from mindspore.nn.optim import Momentum
 
 np.random.seed(1)
 
+
 def weight_variable():
     """weight initial"""
     return TruncatedNormal(0.02)
@@ -58,6 +60,7 @@ class LeNet(nn.Cell):
     Examples:
         >>> LeNet(num_class=10)
     """
+
     def __init__(self, num_class=10):
         super(LeNet, self).__init__()
         self.num_class = num_class
@@ -91,6 +94,7 @@ class CrossEntropyLoss(nn.Cell):
     """
     Define loss for network
     """
+
     def __init__(self):
         super(CrossEntropyLoss, self).__init__()
         self.cross_entropy = P.SoftmaxCrossEntropyWithLogits()
@@ -111,6 +115,7 @@ class GradWrap(nn.Cell):
     """
     GradWrap definition
     """
+
     def __init__(self, network):
         super(GradWrap, self).__init__()
         self.network = network
@@ -154,4 +159,3 @@ def test_ascend_pynative_lenet():
 
         print("======epoch: ", epoch, " loss: ", loss_output.asnumpy(), " cost time: ", cost_time)
     assert(loss_output.asnumpy() < 0.1)
-    

tests/st/summary/test_davinci_summary.py

@@ -33,10 +33,12 @@ SUMMARY_DIR = CUR_DIR + "/test_temp_summary_event_file/"
 
 context.set_context(device_target="Ascend")
 
+
 class MsWrapper(nn.Cell):
     def __init__(self, network):
         super(MsWrapper, self).__init__(auto_prefix=False)
         self._network = network
+
     @ms_function
     def construct(self, *args):
         return self._network(*args)
@@ -45,14 +47,15 @@ class MsWrapper(nn.Cell):
 def me_train_tensor(net, input_np, label_np, epoch_size=2):
     context.set_context(mode=context.GRAPH_MODE)
     loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True)
-    opt = ApplyMomentum(Tensor(np.array([0.1])), Tensor(np.array([0.9])), filter(lambda x: x.requires_grad, net.get_parameters()))
+    opt = ApplyMomentum(Tensor(np.array([0.1])), Tensor(np.array([0.9])),
+                        filter(lambda x: x.requires_grad, net.get_parameters()))
     Model(net, loss, opt)
     _network = wrap.WithLossCell(net, loss)
     _train_net = MsWrapper(wrap.TrainOneStepCell(_network, opt))
     _train_net.set_train()
     summary_writer = SummaryRecord(SUMMARY_DIR, file_suffix="_MS_GRAPH", network=_train_net)
     for epoch in range(0, epoch_size):
-        print(f"epoch %d"%(epoch))
+        print(f"epoch %d" % (epoch))
         output = _train_net(Tensor(input_np), Tensor(label_np))
         summary_writer.record(i)
         print("********output***********")

tests/st/summary/test_gpu_summary.py

@@ -108,6 +108,6 @@ def me_scalar_summary(steps, tag=None, value=None):
 def test_scalarsummary_scalar1_step10_summaryrecord1():
     clean_environment_file(SUMMARY_DIR_ME_TEMP)
     output_dict = me_scalar_summary(10)
-    print("test_scalarsummary_scalar1_step10_summaryrecord1 \n",output_dict)
+    print("test_scalarsummary_scalar1_step10_summaryrecord1 \n", output_dict)
     save_summary_events_file(SUMMARY_DIR_ME_TEMP, SUMMARY_DIR_ME)
     clean_environment_file(SUMMARY_DIR_ME)

tests/st/tbe_networks/export_geir.py

@@ -24,12 +24,13 @@ import mindspore.nn as nn
 from mindspore import context
 
 from mindspore.train.serialization import save, load, save_checkpoint, load_checkpoint,\
-                                          load_param_into_net, _exec_save_checkpoint,\
-                                          _check_filedir_or_create, _chg_model_file_name_if_same_exist, \
-                                          _read_file_last_line, context, export
+    load_param_into_net, _exec_save_checkpoint,\
+    _check_filedir_or_create, _chg_model_file_name_if_same_exist, \
+    _read_file_last_line, context, export
+
+context.set_context(mode=context.GRAPH_MODE, device_target="Ascend",
+                    enable_task_sink=True, enable_loop_sink=True, enable_ir_fusion=True)
 
-context.set_context(mode=context.GRAPH_MODE, device_target="Ascend", 
-enable_task_sink=True,enable_loop_sink=True,enable_ir_fusion=True)
 
 def test_resnet50_export(batch_size=1, num_classes=5):
     context.set_context(enable_ir_fusion=False)

tests/st/tbe_networks/resnet.py

@@ -19,6 +19,7 @@ from mindspore.ops import operations as P
 from mindspore.common.initializer import initializer
 from mindspore.common import dtype as mstype
 
+
 def weight_variable(shape):
     return initializer('XavierUniform', shape=shape, dtype=mstype.float32)
 
@@ -297,4 +298,3 @@ class ResNet(nn.Cell):
 
 def resnet50(batch_size, num_classes):
     return ResNet(ResidualBlock, [3, 4, 6, 3], num_classes, batch_size)
-

tests/st/tbe_networks/resnet_cifar.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
+import argparse
 import mindspore.nn as nn
 from mindspore import Tensor
 from mindspore.ops import operations as P
@@ -35,7 +36,6 @@ random.seed(1)
 np.random.seed(1)
 ds.config.set_seed(1)
 
-import argparse
 parser = argparse.ArgumentParser(description='Image classification')
 parser.add_argument('--run_distribute', type=bool, default=False, help='Run distribute')
 parser.add_argument('--device_num', type=int, default=1, help='Device num.')
@@ -48,15 +48,16 @@ parser.add_argument('--checkpoint_path', type=str, default=None, help='Checkpoin
 parser.add_argument('--dataset_path', type=str, default="/var/log/npu/datasets/cifar", help='Dataset path')
 args_opt = parser.parse_args()
 
-device_id=int(os.getenv('DEVICE_ID'))
+device_id = int(os.getenv('DEVICE_ID'))
 
-data_home=args_opt.dataset_path
+data_home = args_opt.dataset_path
 
 context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
 context.set_context(enable_task_sink=True, device_id=device_id)
 context.set_context(enable_loop_sink=True)
 context.set_context(enable_mem_reuse=True)
 
+
 def create_dataset(repeat_num=1, training=True):
     data_dir = data_home + "/cifar-10-batches-bin"
     if not training:
@@ -64,8 +65,8 @@ def create_dataset(repeat_num=1, training=True):
     data_set = ds.Cifar10Dataset(data_dir)
 
     if args_opt.run_distribute:
-        rank_id=int(os.getenv('RANK_ID'))
-        rank_size=int(os.getenv('RANK_SIZE'))
+        rank_id = int(os.getenv('RANK_ID'))
+        rank_size = int(os.getenv('RANK_SIZE'))
         data_set = ds.Cifar10Dataset(data_dir, num_shards=rank_size, shard_id=rank_id)
 
     resize_height = 224
@@ -74,9 +75,9 @@ def create_dataset(repeat_num=1, training=True):
     shift = 0.0
 
     # define map operations
-    random_crop_op = vision.RandomCrop((32, 32), (4, 4, 4, 4)) # padding_mode default CONSTANT
+    random_crop_op = vision.RandomCrop((32, 32), (4, 4, 4, 4))  # padding_mode default CONSTANT
     random_horizontal_op = vision.RandomHorizontalFlip()
-    resize_op = vision.Resize((resize_height, resize_width)) # interpolation default BILINEAR
+    resize_op = vision.Resize((resize_height, resize_width))  # interpolation default BILINEAR
     rescale_op = vision.Rescale(rescale, shift)
     normalize_op = vision.Normalize((0.4465, 0.4822, 0.4914), (0.2010, 0.1994, 0.2023))
     changeswap_op = vision.HWC2CHW()
@@ -103,6 +104,7 @@ def create_dataset(repeat_num=1, training=True):
 
     return data_set
 
+
 class CrossEntropyLoss(nn.Cell):
     def __init__(self):
         super(CrossEntropyLoss, self).__init__()

tests/st/tbe_networks/test_resnet_cifar_8p.py

@@ -112,6 +112,7 @@ class CrossEntropyLoss(nn.Cell):
         loss = self.mean(loss, (-1,))
         return loss
 
+
 class LossGet(Callback):
     def __init__(self, per_print_times=1):
         super(LossGet, self).__init__()
@@ -143,6 +144,7 @@ class LossGet(Callback):
     def get_loss(self):
         return self._loss
 
+
 def train_process(q, device_id, epoch_size, num_classes, device_num, batch_size, enable_hccl):
     os.system("mkdir " + str(device_id))
     os.chdir(str(device_id))