!1532 clean pylint warning in test dir

Merge pull request !1532 from jinyaohui/pylint1

mindspore/ops/_op_impl/_custom_op/matmul_cube_dense_left_impl.py

@@ -244,8 +244,8 @@ def check_supported(input_x1, input_x2, bias=None, output_y={}, trans_a=False, t
 
     return True
 
-
+# pylint: disable=locally-disabled,too-many-arguments, too-many-locals, too-many-statements,
-# pylint: disable=locally-disabled,too-many-arguments, too-many-locals, too-many-statements
+# pylint: disable=inconsistent-return-statements
 # @util.check_input_type(dict, dict, (dict, NoneType), dict, bool, bool, str)
 @op_info_register(matmul_cube_dense_left_op_info)
 def CusMatMulCubeDenseLeft(input_x1, input_x2, bias=None, output_y={}, trans_a=False, trans_b=False,

mindspore/ops/_op_impl/_custom_op/matmul_cube_dense_right_impl.py

@@ -40,6 +40,7 @@ matmul_cube_dense_right_op_info = TBERegOp("CusMatMulCubeDenseRight") \
     .get_op_info()
 
 
+# pylint: disable=inconsistent-return-statements
 @op_info_register(matmul_cube_dense_right_op_info)
 def CusMatMulCubeDenseRight(input_x1, input_x2, input_x3, bias=None, output_y={}, trans_a=False, trans_b=False,
                             kernel_name="matmulcube"):

model_zoo/Transformer/src/transformer_for_train.py

@@ -31,6 +31,8 @@ from .transformer_model import TransformerModel
 GRADIENT_CLIP_TYPE = 1
 GRADIENT_CLIP_VALUE = 5.0
 
+
+# pylint: disable=consider-using-in
 class ClipGradients(nn.Cell):
     """
     Clip gradients.
@@ -48,6 +50,7 @@ class ClipGradients(nn.Cell):
         self.clip_by_norm = nn.ClipByNorm()
         self.cast = P.Cast()
         self.dtype = P.DType()
+
     def construct(self,
                   grads,
                   clip_type,
@@ -217,10 +220,12 @@ class TransformerTrainOneStepCell(nn.Cell):
 grad_scale = C.MultitypeFuncGraph("grad_scale")
 reciprocal = P.Reciprocal()
 
+
 @grad_scale.register("Tensor", "Tensor")
 def tensor_grad_scale(scale, grad):
     return grad * F.cast(reciprocal(scale), F.dtype(grad))
 
+
 class TransformerTrainOneStepWithLossScaleCell(nn.Cell):
     """
     Encapsulation class of Transformer network training.

model_zoo/bert/src/bert_for_pre_training.py

@@ -34,6 +34,9 @@ GRADIENT_CLIP_VALUE = 1.0
 
 _nn_clip_by_norm = nn.ClipByNorm()
 clip_grad = C.MultitypeFuncGraph("clip_grad")
+
+
+# pylint: disable=consider-using-in
 @clip_grad.register("Number", "Number", "Tensor")
 def _clip_grad(clip_type, clip_value, grad):
     """
@@ -57,6 +60,7 @@ def _clip_grad(clip_type, clip_value, grad):
         new_grad = _nn_clip_by_norm(grad, F.cast(F.tuple_to_array((clip_value,)), dt))
     return new_grad
 
+
 class GetMaskedLMOutput(nn.Cell):
     """
     Get masked lm output.
@@ -377,6 +381,7 @@ class BertTrainOneStepWithLossScaleCell(nn.Cell):
             self.loss_scale = Parameter(Tensor(scale_update_cell.get_loss_scale(), dtype=mstype.float32),
                                         name="loss_scale")
         self.add_flags(has_effect=True)
+
     def construct(self,
                   input_ids,
                   input_mask,

tests/mindspore_test_framework/apps/test_bert_parts.py

@@ -15,14 +15,15 @@
 
 """Test bert submodules."""
 
-import numpy as np
 import os
 
-from mindspore import Tensor
+import numpy as np
-from mindspore import nn, context
 from mindspore.model_zoo.Bert_NEZHA import EmbeddingLookup, GetMaskedLMOutput, \
     BertConfig, BertPreTraining, BertNetworkWithLoss
 from mindspore.model_zoo.Bert_NEZHA.bert_model import BertModel
+
+from mindspore import Tensor
+from mindspore import nn, context
 from ..mindspore_test import mindspore_test
 from ..pipeline.forward.compile_forward import pipeline_for_compile_forward_anf_graph_for_case_by_case_config, \
     pipeline_for_compile_forward_ge_graph_for_case_by_case_config

tests/mindspore_test_framework/components/executor/check_exceptions.py

@@ -15,9 +15,10 @@
 
 """Component that Check if the function raises the expected Exception."""
 
-import pytest
 import sys
 
+import pytest
+
 from ...components.icomponent import IExectorComponent
 from ...utils import keyword
 

tests/mindspore_test_framework/utils/check_gradient.py

@@ -16,9 +16,10 @@
 """Implementation of Numerical gradients checking."""
 # pylint: disable=missing-docstring
 
+from typing import Callable, List, Any
+
 import mindspore._c_expression as _c_expression
 import numpy as np
-from typing import Callable, List, Any
 
 from mindspore import ParameterTuple
 from mindspore import Tensor

tests/mindspore_test_framework/utils/dataset_util.py

@@ -15,9 +15,10 @@
 
 """Dataset utils."""
 
-import numpy as np
 import random
 
+import numpy as np
+
 from mindspore import Tensor
 
 

tests/mindspore_test_framework/utils/debug_util.py

@@ -24,8 +24,7 @@ from mindspore.ops import operations as P
 from mindspore.ops._grad.grad_base import bprop_getters
 from mindspore.ops.primitive import prim_attr_register, PrimitiveWithInfer
 
-logging.basicConfig(level=logging.DEBUG, format=
+logging.basicConfig(level=logging.DEBUG, format='[%(levelname)s] %(asctime)s %(pathname)s:%(lineno)d %(message)s')
-'[%(levelname)s] %(asctime)s %(pathname)s:%(lineno)d %(message)s')
 logger = logging.getLogger(__name__)
 
 

tests/mindspore_test_framework/utils/other_util.py

@@ -14,9 +14,8 @@
 # ============================================================================
 
 """Other utils."""
-
-import mindspore._c_expression as _c_expression
 import numpy as np
+import mindspore._c_expression as _c_expression
 
 from mindspore.common.tensor import Tensor
 

tests/st/networks/models/bert/src/bert_for_pre_training.py

@@ -34,6 +34,9 @@ GRADIENT_CLIP_VALUE = 1.0
 
 _nn_clip_by_norm = nn.ClipByNorm()
 clip_grad = C.MultitypeFuncGraph("clip_grad")
+
+
+# pylint: disable=consider-using-in
 @clip_grad.register("Number", "Number", "Tensor")
 def _clip_grad(clip_type, clip_value, grad):
     """
@@ -57,6 +60,7 @@ def _clip_grad(clip_type, clip_value, grad):
         new_grad = _nn_clip_by_norm(grad, F.cast(F.tuple_to_array((clip_value,)), dt))
     return new_grad
 
+
 class GetMaskedLMOutput(nn.Cell):
     """
     Get masked lm output.
@@ -377,6 +381,7 @@ class BertTrainOneStepWithLossScaleCell(nn.Cell):
             self.loss_scale = Parameter(Tensor(scale_update_cell.get_loss_scale(), dtype=mstype.float32),
                                         name="loss_scale")
         self.add_flags(has_effect=True)
+
     def construct(self,
                   input_ids,
                   input_mask,

tests/st/ops/ascend/test_autocast.py

@@ -23,10 +23,12 @@ from mindspore.ops import functional as F, composite as C
 import mindspore.context as context
 import pytest
 
+
 class TensorIntAutoCast(nn.Cell):
     def __init__(self, ):
         super(TensorIntAutoCast, self).__init__()
         self.i = 2
+
     def construct(self, t):
         z = F.tensor_mul(t, self.i)
         return z
@@ -36,6 +38,7 @@ class TensorFPAutoCast(nn.Cell):
     def __init__(self, ):
         super(TensorFPAutoCast, self).__init__()
         self.f = 1.2
+
     def construct(self, t):
         z = F.tensor_mul(t, self.f)
         return z
@@ -45,13 +48,16 @@ class TensorBoolAutoCast(nn.Cell):
     def __init__(self, ):
         super(TensorBoolAutoCast, self).__init__()
         self.f = True
+
     def construct(self, t):
         z = F.tensor_mul(t, self.f)
         return z
 
+
 class TensorAutoCast(nn.Cell):
     def __init__(self, ):
         super(TensorAutoCast, self).__init__()
+
     def construct(self, t1, t2):
         z = F.tensor_mul(t1, t2)
         return z
@@ -210,7 +216,6 @@ def test_tensor_auto_cast():
     with pytest.raises(TypeError):
         net(t_uint64, t_fp64)
 
-
     with pytest.raises(TypeError):
         tfp(t_uint16)
     with pytest.raises(TypeError):

tests/st/ops/ascend/test_ops_infer.py

@@ -21,6 +21,7 @@ import mindspore.common.dtype as mstype
 from mindspore import Tensor
 from mindspore.ops import operations as P
 from mindspore import context
+
 context.set_context(mode=context.GRAPH_MODE, save_graphs=True)
 
 
@@ -29,6 +30,7 @@ def test_cast_op_attr():
         def __init__(self):
             super(CastNet, self).__init__()
             self.cast = P.Cast()
+
         def construct(self, x, t):
             return self.cast(x, t)
 
@@ -37,6 +39,7 @@ def test_cast_op_attr():
             super(CastTypeTest, self).__init__()
             self.net = net
             self.cast = P.Cast()
+
         def construct(self, x, y, z):
             cast_op = self.cast
             t1 = cast_op(x, mstype.float32)
@@ -46,6 +49,7 @@ def test_cast_op_attr():
             t4 = cast_net(y, mstype.int32)
             t5 = cast_net(z, mstype.float16)
             return (t1, t2, t3, t4, t5)
+
     net = CastTypeTest(CastNet())
     t1 = Tensor(np.ones([1, 16, 1, 1918]).astype(np.int32))
     t2 = Tensor(np.ones([1, 16, 1, 3840]).astype(np.float32))

tests/st/ops/cpu/test_transpose_op.py

@@ -142,4 +142,6 @@ def test_transpose():
     assert (output[1].asnumpy() == expect1).all()
     assert (output[2].asnumpy() == expect2).all()
     assert (output[3].asnumpy() == expect3).all()
+
+
 test_transpose()

tests/ut/cpp/python_input/gtest_input/optimizer/opt_test.py

@@ -1043,6 +1043,7 @@ def test_print_tuple_wrapper(tag):
     return fns[tag]
 
 
+# pylint: disable=unnecessary-semicolon
 def test_constant_duplicate_mul(tag):
     fns = FnDict()
     Mul = Primitive('Mul');

tests/ut/python/dtype/test_dictionary.py

@@ -152,7 +152,7 @@ def test_dict_set_item():
 
     x = Tensor(np.ones([2, 2, 3], np.float32))
     net = DictSetNet()
-    out = net(x)
+    _ = net(x)
 
 
 # if the dictionary item does not exist, create a new one
@@ -168,4 +168,4 @@ def test_dict_set_item_create_new():
             return my_dict
     x = Tensor(np.ones([2, 2, 3], np.float32))
     net = DictSetNet()
-    out = net(x)
+    _ = net(x)

tests/ut/python/dtype/test_hypermap.py

@@ -81,31 +81,3 @@ def test_hypermap_func_const():
 
     net = NetMap()
     assert net() == (8, 12, 16)
-
-
-"""
-def test_hypermap_func_variable():
-    class NetMap(Cell):
-        def __init__(self):
-            super(NetMap, self).__init__()
-
-        def double(self, x):
-            return 2 * x
-
-        def triple(self, x):
-            return 3 * x
-
-        def square(self, x):
-            return x * x
-
-        def construct(self, x):
-            _list = [self.double, self.triple, self.square]
-            return map(lambda f: f(x), _list)
-
-    x = Tensor(np.ones([3, 2, 3], np.float32))
-    net = NetMap()
-
-    with pytest.raises(RuntimeError) as ex:
-        net(x)
-    assert "HyperMap don't support Closure with free variable yet" in str(ex.value)
-"""

tests/ut/python/exec/test_AssignAdd.py

@@ -99,4 +99,4 @@ def test_assignadd_scalar_cast():
     net = AssignAddNet()
     x = Tensor(np.ones([1]).astype(np.int64) * 102)
     # _executor.compile(net, 1)
-    result = net(x)
+    _ = net(x)

tests/ut/python/ir/test_tensor.py

@@ -429,9 +429,9 @@ def test_tensor_dtype_np_int64():
 
 def test_tensor_dtype_fp32_to_bool():
     with pytest.raises(RuntimeError):
-        input = np.random.randn(2, 3, 4, 5).astype(np.float32)
+        input_ = np.random.randn(2, 3, 4, 5).astype(np.float32)
-        input = ms.Tensor(input)
+        input_ = ms.Tensor(input_)
-        input_me = ms.Tensor(input, dtype=ms.bool_)
+        _ = ms.Tensor(input_, dtype=ms.bool_)
 
 
 def test_tensor_operation():

tests/ut/python/keep_order/test_keep_order.py

@@ -41,10 +41,10 @@ class Func(nn.Cell):
 
     def construct(self, x, y):
         init = self.alloc_status()
-        sum = add(x, y)
+        sum_ = add(x, y)
         product = mul1(x, y)
         flag = self.get_status(init)
-        out = add2(sum, product)
+        out = add2(sum_, product)
         clear = self.clear_status(flag)
         out = F.depend(out, clear)
         return out
@@ -88,7 +88,7 @@ def test_sens():
     sens = Tensor(np.ones([3, 3]).astype(np.float32))
     net = Net()
     net.add_flags(has_effect=True)
-    out = net(x, y, sens)
+    _ = net(x, y, sens)
 
 
 class Net_hyper(nn.Cell):
@@ -119,7 +119,7 @@ def test_hyper_add():
     sens = Tensor(np.ones([3, 3]).astype(np.float32))
     net = Net_hyper()
     net.add_flags(has_effect=True)
-    out = net(x, y, sens)
+    _ = net(x, y, sens)
 
 
 def test_keep_order_io_effect_exception_return_dtype():

tests/ut/python/model/test_mix_precision.py

@@ -148,9 +148,6 @@ def test_cast():
     _executor.compile(net, x)
 
 
-"""test grad of PReLU, which cause AddN(generated by grad) fail"""
-
-
 class IRBlockZ(nn.Cell):
     def __init__(self, inplanes, planes):
         super(IRBlockZ, self).__init__()

tests/ut/python/nn/test_pooling.py

@@ -46,6 +46,7 @@ class MaxNet(nn.Cell):
                  kernel_size,
                  stride=None,
                  padding=0):
+        _ = padding
         super(MaxNet, self).__init__()
         self.maxpool = nn.MaxPool2d(kernel_size,
                                     stride)
@@ -73,5 +74,5 @@ class Avg1dNet(nn.Cell):
 
 def test_avg1d():
     net = Avg1dNet(6, 1)
-    input = Tensor(np.random.randint(0, 255, [1, 3, 6]).astype(np.float32))
+    input_ = Tensor(np.random.randint(0, 255, [1, 3, 6]).astype(np.float32))
-    _executor.compile(net, input)
+    _executor.compile(net, input_)

tests/ut/python/nn/test_psnr.py

@@ -52,19 +52,19 @@ def test_compile_psnr_grayscale():
 def test_psnr_max_val_negative():
     max_val = -1
     with pytest.raises(ValueError):
-        net = PSNRNet(max_val)
+        _ = PSNRNet(max_val)
 
 
 def test_psnr_max_val_bool():
     max_val = True
     with pytest.raises(TypeError):
-        net = PSNRNet(max_val)
+        _ = PSNRNet(max_val)
 
 
 def test_psnr_max_val_zero():
     max_val = 0
     with pytest.raises(ValueError):
-        net = PSNRNet(max_val)
+        _ = PSNRNet(max_val)
 
 
 def test_psnr_different_shape():

tests/ut/python/nn/test_ssim.py

@@ -51,59 +51,59 @@ def test_compile_grayscale():
 def test_ssim_max_val_negative():
     max_val = -1
     with pytest.raises(ValueError):
-        net = SSIMNet(max_val)
+        _ = SSIMNet(max_val)
 
 
 def test_ssim_max_val_bool():
     max_val = True
     with pytest.raises(TypeError):
-        net = SSIMNet(max_val)
+        _ = SSIMNet(max_val)
 
 
 def test_ssim_max_val_zero():
     max_val = 0
     with pytest.raises(ValueError):
-        net = SSIMNet(max_val)
+        _ = SSIMNet(max_val)
 
 
 def test_ssim_filter_size_float():
     with pytest.raises(TypeError):
-        net = SSIMNet(filter_size=1.1)
+        _ = SSIMNet(filter_size=1.1)
 
 
 def test_ssim_filter_size_zero():
     with pytest.raises(ValueError):
-        net = SSIMNet(filter_size=0)
+        _ = SSIMNet(filter_size=0)
 
 
 def test_ssim_filter_sigma_zero():
     with pytest.raises(ValueError):
-        net = SSIMNet(filter_sigma=0.0)
+        _ = SSIMNet(filter_sigma=0.0)
 
 
 def test_ssim_filter_sigma_negative():
     with pytest.raises(ValueError):
-        net = SSIMNet(filter_sigma=-0.1)
+        _ = SSIMNet(filter_sigma=-0.1)
 
 
 def test_ssim_k1_k2_wrong_value():
     with pytest.raises(ValueError):
-        net = SSIMNet(k1=1.1)
+        _ = SSIMNet(k1=1.1)
     with pytest.raises(ValueError):
-        net = SSIMNet(k1=1.0)
+        _ = SSIMNet(k1=1.0)
     with pytest.raises(ValueError):
-        net = SSIMNet(k1=0.0)
+        _ = SSIMNet(k1=0.0)
     with pytest.raises(ValueError):
-        net = SSIMNet(k1=-1.0)
+        _ = SSIMNet(k1=-1.0)
 
     with pytest.raises(ValueError):
-        net = SSIMNet(k2=1.1)
+        _ = SSIMNet(k2=1.1)
     with pytest.raises(ValueError):
-        net = SSIMNet(k2=1.0)
+        _ = SSIMNet(k2=1.0)
     with pytest.raises(ValueError):
-        net = SSIMNet(k2=0.0)
+        _ = SSIMNet(k2=0.0)
     with pytest.raises(ValueError):
-        net = SSIMNet(k2=-1.0)
+        _ = SSIMNet(k2=-1.0)
 
 
 def test_ssim_different_shape():

tests/ut/python/onnx/test_onnx.py

@@ -64,13 +64,13 @@ class BatchNormTester(nn.Cell):
 
 def test_batchnorm_train_onnx_export():
     "test onnx export interface does not modify trainable flag of a network"
-    input = Tensor(np.ones([1, 3, 32, 32]).astype(np.float32) * 0.01)
+    input_ = Tensor(np.ones([1, 3, 32, 32]).astype(np.float32) * 0.01)
     net = BatchNormTester(3)
     net.set_train()
     if not net.training:
         raise ValueError('netowrk is not in training mode')
     onnx_file = 'batch_norm.onnx'
-    export(net, input, file_name=onnx_file, file_format='ONNX')
+    export(net, input_, file_name=onnx_file, file_format='ONNX')
 
     if not net.training:
         raise ValueError('netowrk is not in training mode')
@@ -172,6 +172,7 @@ net_cfgs = [
 
 
 def get_id(cfg):
+    _ = cfg
     return list(map(lambda x: x[0], net_cfgs))
 
 

tests/ut/python/ops/test_math_ops_check.py

@@ -660,6 +660,7 @@ test_case_math_ops = [
         'skip': ['backward']}),
 ]
 
+
 @mindspore_test(pipeline_for_compile_forward_ge_graph_for_case_by_case_config_exception)
 def test_check_exception():
     return raise_set

tests/ut/python/ops/test_ops_attr_infer.py

@@ -21,12 +21,15 @@ import mindspore.context as context
 from mindspore import Tensor
 from mindspore.ops import functional as F
 from mindspore.ops import prim_attr_register, PrimitiveWithInfer
+
 context.set_context(mode=context.GRAPH_MODE, save_graphs=True)
 
+
 class FakeOp(PrimitiveWithInfer):
     @prim_attr_register
     def __init__(self):
         """"""
+
     def infer_shape(self, x, y):
         self.second_shape = y
         self.add_prim_attr("second_shape", y)
@@ -35,6 +38,7 @@ class FakeOp(PrimitiveWithInfer):
     def infer_dtype(self, x, y):
         return x
 
+
 # test the normal case that should generate independent primitive because of different
 # generated attributes after inference
 def test_conv2d_same_primitive():
@@ -43,15 +47,18 @@ def test_conv2d_same_primitive():
             super(Conv2DSameNet, self).__init__()
             self.conv1 = nn.Conv2d(16, 64, (1, 41), (1, 4), "same", 0, 1, has_bias=True)
             self.conv2 = nn.Conv2d(16, 64, (1, 41), (1, 4), "same", 0, 1, has_bias=True)
+
         def construct(self, x, y):
             r1 = self.conv1(x)
             r2 = self.conv2(y)
             return (r1, r2)
+
     t1 = Tensor(np.ones([1, 16, 1, 1918]).astype(np.float32))
     t2 = Tensor(np.ones([1, 16, 1, 3840]).astype(np.float32))
     net = Conv2DSameNet()
     net(t1, t2)
 
+
 # test cell as high order argument
 # The graph with free variables used as argument is not supported yet
 # because of the limit of inference specialize system
@@ -59,18 +66,22 @@ def Xtest_conv2d_op_with_arg():
     class Conv2dNet(nn.Cell):
         def __init__(self):
             super(Conv2dNet, self).__init__()
+
         def construct(self, op, x):
             return op(x)
+
     class OpsNet(nn.Cell):
         def __init__(self, net):
             super(OpsNet, self).__init__()
             self.opnet = net
             self.conv2 = nn.Conv2d(16, 64, (1, 41), (1, 4), "same", 0, 1, has_bias=True)
+
         def construct(self, x, y):
             conv_op = self.conv2
             a = self.opnet(conv_op, x)
             b = self.opnet(conv_op, y)
             return (a, b)
+
     t1 = Tensor(np.ones([1, 16, 1, 1918]).astype(np.float32))
     t2 = Tensor(np.ones([1, 16, 1, 3840]).astype(np.float32))
     net = OpsNet(Conv2dNet())
@@ -82,23 +93,29 @@ def test_conv2d_op_with_arg():
         def __init__(self):
             super(FackOpNet, self).__init__()
             self.op = FakeOp()
+
         def construct(self, x, y):
             return self.op(x, y)
+
     class OpNet(nn.Cell):
         def __init__(self):
             super(OpNet, self).__init__()
+
         def construct(self, op, x, y):
             return op(x, y)
+
     class OpsNet(nn.Cell):
         def __init__(self, net):
             super(OpsNet, self).__init__()
             self.opnet = net
             self.op = FackOpNet()
+
         def construct(self, x, y):
             op = self.op
             a = self.opnet(op, x, y)
             b = self.opnet(op, y, x)
             return (a, b)
+
     t1 = Tensor(np.ones([1, 16, 1, 1918]).astype(np.float32))
     t2 = Tensor(np.ones([1, 16, 1, 3840]).astype(np.float32))
     net = OpsNet(OpNet())
@@ -110,63 +127,77 @@ def test_conv2d_op_with_arg_same_input():
         def __init__(self):
             super(FackOpNet, self).__init__()
             self.op = FakeOp()
+
         def construct(self, x, y):
             return self.op(x, y)
+
     class OpNet(nn.Cell):
         def __init__(self):
             super(OpNet, self).__init__()
+
         def construct(self, op, x, y):
             return op(x, y)
+
     class OpsNet(nn.Cell):
         def __init__(self, net):
             super(OpsNet, self).__init__()
             self.opnet = net
             self.op = FackOpNet()
+
         def construct(self, x, y):
             op = self.op
             a = self.opnet(op, x, x)
             b = self.opnet(op, y, x)
             return (a, b)
+
     t1 = Tensor(np.ones([1, 16, 1, 1918]).astype(np.float32))
     t2 = Tensor(np.ones([1, 16, 1, 3840]).astype(np.float32))
     net = OpsNet(OpNet())
     net(t1, t2)
 
+
 # test op with partial
 def test_op_as_partial():
     class OpAsPartial(nn.Cell):
         def __init__(self):
             super(OpAsPartial, self).__init__()
             self.op = FakeOp()
+
         def construct(self, x, y, z):
             partial_op = F.partial(self.op, x)
             a = partial_op(y)
             b = partial_op(z)
             return a, b
+
     t1 = Tensor(np.ones([1, 16, 1, 1918]).astype(np.float32))
     t2 = Tensor(np.ones([1, 16, 1, 3840]).astype(np.float32))
     t3 = Tensor(np.ones([1, 16, 1, 1234]).astype(np.float32))
     net = OpAsPartial()
     net(t1, t2, t3)
 
+
 # test op with partial
 def test_op_as_partial_inside():
     class OpAsPartial(nn.Cell):
         def __init__(self):
             super(OpAsPartial, self).__init__()
             self.op = FakeOp()
+
         def construct(self, x, y, z):
             partial_op = F.partial(self.op, x)
             a = partial_op(y)
             b = partial_op(z)
             return a, b
+
     class OuterNet(nn.Cell):
         def __init__(self):
             super(OuterNet, self).__init__()
             self.net = OpAsPartial()
+
         def construct(self, x, y, z):
             a, b = self.net(x, y, z)
             return a, b
+
     t1 = Tensor(np.ones([1, 16, 1, 1918]).astype(np.float32))
     t2 = Tensor(np.ones([1, 16, 1, 3840]).astype(np.float32))
     t3 = Tensor(np.ones([1, 16, 1, 1234]).astype(np.float32))
@@ -180,12 +211,14 @@ def test_op_as_partial_independent():
         def __init__(self):
             super(OpAsPartial, self).__init__()
             self.op = FakeOp()
+
         def construct(self, x, y, z):
             partial_op1 = F.partial(self.op, x)
             a = partial_op1(y)
             partial_op2 = F.partial(self.op, x)
             b = partial_op2(z)
             return a, b
+
     t1 = Tensor(np.ones([1, 16, 1, 1918]).astype(np.float32))
     t2 = Tensor(np.ones([1, 16, 1, 3840]).astype(np.float32))
     t3 = Tensor(np.ones([1, 16, 1, 1234]).astype(np.float32))
@@ -198,6 +231,7 @@ def test_nest_partial():
         def __init__(self):
             super(NestPartial, self).__init__()
             self.op = FakeOp()
+
         def construct(self, x, y, z):
             partial_op1 = F.partial(self.op)
             partial_op2 = F.partial(partial_op1, x)
@@ -206,54 +240,65 @@ def test_nest_partial():
             partial_op4 = F.partial(partial_op3, x)
             b = partial_op4(z)
             return a, b
+
     t1 = Tensor(np.ones([1, 16, 1, 1918]).astype(np.float32))
     t2 = Tensor(np.ones([1, 16, 1, 3840]).astype(np.float32))
     t3 = Tensor(np.ones([1, 16, 1, 1234]).astype(np.float32))
     net = NestPartial()
     net(t1, t2, t3)
 
+
 # high order argument
 # op and op args as network arguments
 def test_op_with_arg_as_input():
     class WithOpArgNet(nn.Cell):
         def __init__(self):
             super(WithOpArgNet, self).__init__()
+
         def construct(self, op, x, y):
             return op(x, y)
+
     class OpsNet(nn.Cell):
         def __init__(self, net):
             super(OpsNet, self).__init__()
             self.opnet = net
             self.op = FakeOp()
+
         def construct(self, x, y, z):
             op = self.op
             a = self.opnet(op, x, z)
             b = self.opnet(op, x, y)
             return (a, b)
+
     t1 = Tensor(np.ones([1, 16, 1, 1918]).astype(np.float32))
     t2 = Tensor(np.ones([1, 16, 1, 3840]).astype(np.float32))
     t3 = Tensor(np.ones([1, 16, 1, 1234]).astype(np.float32))
     net = OpsNet(WithOpArgNet())
     net(t1, t2, t3)
 
+
 # The partial application used as argument is not supported yet
 # because of the limit of inference specialize system
 def Xtest_partial_as_arg():
     class PartialArgNet(nn.Cell):
         def __init__(self):
             super(PartialArgNet, self).__init__()
+
         def construct(self, partial_op, y):
             return partial_op(y)
+
     class OpsNet(nn.Cell):
         def __init__(self, net):
             super(OpsNet, self).__init__()
             self.partial_net = net
             self.op = FakeOp()
+
         def construct(self, x, y, z):
             partial_op = F.partial(self.op, x)
             a = self.partial_net(partial_op, z)
             b = self.partial_net(partial_op, y)
             return (a, b)
+
     t1 = Tensor(np.ones([1, 16, 1, 1918]).astype(np.float32))
     t2 = Tensor(np.ones([1, 16, 1, 3840]).astype(np.float32))
     t3 = Tensor(np.ones([1, 16, 1, 1234]).astype(np.float32))

tests/ut/python/ops/test_ops_check.py

@@ -32,6 +32,7 @@ from ....mindspore_test_framework.pipeline.forward.verify_exception \
 logging.basicConfig(level=logging.WARNING)
 
 
+# pylint: disable=abstract-method
 class NetMissConstruct(nn.Cell):
     """ NetMissConstruct definition """
 
@@ -46,7 +47,6 @@ class NetMissConstruct(nn.Cell):
         self.max_pool2d = nn.MaxPool2d(kernel_size=2)
         self.flatten = P.Flatten()
 
-    # pylint: disable=abstract-method
     # TestCase: Mis-spelled 'construct' to 'construtc'
     def construtc(self, x):
         x = self.max_pool2d(self.relu(self.conv1(x)))

tests/ut/python/optimizer/test_debug_location.py

@@ -44,7 +44,7 @@ class MockNeg(PrimitiveWithInfer):
 
     def infer_dtype(self, input_x):
         raise TypeError("InferError")
-        return input_x
+        # return input_x
 
 
 class MockSub(PrimitiveWithInfer):
@@ -79,8 +79,8 @@ class Net(nn.Cell):
         self.matmul = P.MatMul()
         self.add = P.TensorAdd()
 
-    def construct(self, input):
+    def construct(self, input_):
-        output = self.add(self.matmul(input, self.weight), self.bias)
+        output = self.add(self.matmul(input_, self.weight), self.bias)
         return output
 
 
@@ -93,9 +93,9 @@ class NetFP16(nn.Cell):
         self.add = P.TensorAdd()
         self.cast = P.Cast()
 
-    def construct(self, input):
+    def construct(self, input_):
         output = self.cast(
-            self.add(self.matmul(self.cast(input, mstype.float16), self.cast(self.weight, mstype.float16)),
+            self.add(self.matmul(self.cast(input_, mstype.float16), self.cast(self.weight, mstype.float16)),
                      self.cast(self.bias, mstype.float16)), mstype.float32)
         return output
 

tests/ut/python/optimizer/test_optimize_with_loss_scale.py

@@ -42,10 +42,10 @@ class MindDataSet(MindData):
         if self._size < self._iter_num:
             raise StopIteration
         self._iter_num += 1
-        next = []
+        lst = []
-        for shape, type in zip(self._output_shapes, self._np_types):
+        for shape_, type_ in zip(self._output_shapes, self._np_types):
-            next.append(Tensor(np.ones(shape).astype(type)))
+            lst.append(Tensor(np.ones(shape_).astype(type_)))
-        return tuple(next)
+        return tuple(lst)
 
 
 class Net(nn.Cell):
@@ -56,8 +56,8 @@ class Net(nn.Cell):
         self.matmul = P.MatMul()
         self.add = P.TensorAdd()
 
-    def construct(self, input):
+    def construct(self, input_):
-        output = self.add(self.matmul(input, self.weight), self.bias)
+        output = self.add(self.matmul(input_, self.weight), self.bias)
         return output
 
 
@@ -70,9 +70,9 @@ class NetFP16(nn.Cell):
         self.add = P.TensorAdd()
         self.cast = P.Cast()
 
-    def construct(self, input):
+    def construct(self, input_):
         output = self.cast(
-            self.add(self.matmul(self.cast(input, mstype.float16), self.cast(self.weight, mstype.float16)),
+            self.add(self.matmul(self.cast(input_, mstype.float16), self.cast(self.weight, mstype.float16)),
                      self.cast(self.bias, mstype.float16)), mstype.float32)
         return output
 

tests/ut/python/parallel/test_alltoall.py

@@ -97,8 +97,8 @@ def test_all_to_all():
     print(strategys)
     expect_dict = {'Default/network-_VirtualDatasetCell/_backbone-WithLossCell/_loss_fn-SoftmaxCrossEntropyWithLogits'
                    '/SoftmaxCrossEntropyWithLogits-op3': [[8, 1], [8, 1]],
-                   'Default/network-_VirtualDatasetCell/_backbone-WithLossCell/_loss_fn-SoftmaxCrossEntropyWithLogits/OneHot-op4': [
+                   'Default/network-_VirtualDatasetCell/_backbone-WithLossCell/_loss_fn-SoftmaxCrossEntropyWithLogits/'
-                       [8, 1], [], []],
+                   'OneHot-op4': [[8, 1], [], []],
                    'Default/network-_VirtualDatasetCell/_backbone-WithLossCell/_backbone-AllToAllNet/Transpose-op1': [
                        [8, 1]],
                    'Default/network-_VirtualDatasetCell/_backbone-WithLossCell/_backbone-AllToAllNet/MatMul-op0': [

tests/ut/python/parameter_feature/test_parameter.py

@@ -280,4 +280,4 @@ def test_mixed_precision_const_parameter():
     x = Tensor(np.ones((1, 3, 28, 28), np.float32))
     y = Tensor(np.ones((1, 3, 14, 14), np.float32))
     z = Tensor(np.ones((1, 3, 28, 28), np.float32))
-    out = net(x, y, z)
+    _ = net(x, y, z)

tests/ut/python/parameter_feature/test_var_grad.py

@@ -39,7 +39,7 @@ def test_net_vargs_expand():
     y = Tensor(np.random.normal(0, 1, [3, 4, 5]).astype(np.float32))
     sens = Tensor(np.random.normal(0, 1, [3, 4, 5]).astype(np.float32))
     net = AddNet()
-    out = C.grad_all_with_sens(net, net.trainable_params())(x, y, sens)
+    _ = C.grad_all_with_sens(net, net.trainable_params())(x, y, sens)
 
 
 class VarNet(Cell):
@@ -111,7 +111,7 @@ def test_all_var_args_grad_with_sens():
     sens = Tensor(1.0, dtype=mstype.float32)
     net = VarNet(SecondNet())
     grad_net = GradNet(net)
-    out = grad_net(x, y, sens)
+    _ = grad_net(x, y, sens)
 
 
 def test_grad_list_var_args():
@@ -128,7 +128,7 @@ def test_grad_list_var_args():
     y = Tensor(np.ones([3, 4, 5]), dtype=mstype.float32)
     net = VarNet(SecondNet())
     grad_net = GradNet(net)
-    out = grad_net(x, y)
+    _ = grad_net(x, y)
 
 
 def test_grad_all_var_args():
@@ -145,7 +145,7 @@ def test_grad_all_var_args():
     y = Tensor(np.ones([3, 4, 5]), dtype=mstype.float32)
     net = VarNet(SecondNet())
     grad_net = GradNet(net)
-    out = grad_net(x, y)
+    _ = grad_net(x, y)
 
 
 def test_grad_all_var_args_with_sens():
@@ -163,7 +163,7 @@ def test_grad_all_var_args_with_sens():
     sens = Tensor(1.0, dtype=mstype.float32)
     net = VarNet(SecondNet())
     grad_net = GradNet(net)
-    out = grad_net(x, y, sens)
+    _ = grad_net(x, y, sens)
 
 
 def test_grad_var_args_with_sens():
@@ -181,7 +181,7 @@ def test_grad_var_args_with_sens():
     sens = Tensor(1.0, dtype=mstype.float32)
     net = VarNet(SecondNet())
     grad_net = GradNet(net)
-    out = grad_net(x, y, sens)
+    _ = grad_net(x, y, sens)
 
 
 def test_var_args_grad():
@@ -219,7 +219,7 @@ def test_var_args_grad():
     sens = Tensor(1.0, dtype=mstype.float32)
     net = VarNet(SecondNet())
     grad_net = GradNet(net)
-    out = grad_net(x, y, sens)
+    _ = grad_net(x, y, sens)
 
 
 def test_var_args_positional():
@@ -253,7 +253,7 @@ def test_var_args_positional():
     y = Tensor(np.ones([3, 4, 5]), dtype=mstype.float32)
     net = VarNet(SecondNet())
     grad_net = GradNet(net)
-    out = grad_net(x, y)
+    _ = grad_net(x, y)
 
 
 def test_grad_within_if_else():
@@ -271,7 +271,7 @@ def test_grad_within_if_else():
 
     x = Tensor(np.ones([3, 4, 5]), dtype=mstype.float32)
     y = Tensor(np.ones([3, 4, 5]), dtype=mstype.float32)
-    sens = Tensor(1.0, dtype=mstype.float32)
+    _ = Tensor(1.0, dtype=mstype.float32)
     net = VarNet(SecondNet())
     grad_net = GradNet(net)
     out = grad_net(x, y)
@@ -316,10 +316,10 @@ def test_grad_for_concat():
             net = Concat(axis=self.axis)
             grad_net = GradNet(net)
             grad_net.set_train()
-            input_grad = grad_net(*inputs, Tensor(self.out_grad_np))
+            _ = grad_net(*inputs, Tensor(self.out_grad_np))
 
         def grad_cmp(self):
-            input_grad_mindspore = self.grad_mindspore_impl()
+            self.grad_mindspore_impl()
 
     fact = ConcatFactory(input_shape=(
         (2, 184320, 1), (2, 46080, 1), (2, 11520, 1), (2, 2880, 1), (2, 720, 1)), axis=1)

tests/ut/python/pipeline/parse/test_cont_break.py

@@ -84,7 +84,7 @@ class for_loop_with_cont_break(Cell):
             if i > 5:
                 x *= 3
                 break
-                x *= 2
+                # x *= 2
             x = x * 2
             pass
         return x

tests/ut/python/pynative_mode/test_framstruct.py

@@ -123,6 +123,7 @@ def sub(x, y):
     return x - y
 
 
+# pylint: disable=using-constant-test
 @ms_function
 def if_always_true(x):
     """ if_always_true """
@@ -870,6 +871,7 @@ def test_grad_refactor_14():
     assert C.grad_all(grad_refactor_14)(2, 3) == (3, 9)
 
 
+# pylint: disable=using-constant-test
 class IfDeferInline(nn.Cell):
     def __init__(self, mul_size):
         super().__init__()

tests/ut/python/pynative_mode/test_hook.py

@@ -1,12 +1,10 @@
 import numpy as np
 import mindspore.nn as nn
 import mindspore.ops.operations as P
-from mindspore import context
 from mindspore.ops import composite as C
-from mindspore.common import dtype as mstype
 from mindspore import context, Tensor, ParameterTuple
 from mindspore.common.initializer import TruncatedNormal
-from mindspore.nn import Dense, WithLossCell, SoftmaxCrossEntropyWithLogits, Momentum
+from mindspore.nn import WithLossCell, Momentum
 
 context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU")
 
@@ -18,16 +16,19 @@ def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):
                      kernel_size=kernel_size, stride=stride, padding=padding,
                      weight_init=weight, has_bias=False, pad_mode="valid")
 
+
 def fc_with_initialize(input_channels, out_channels):
     """weight initial for fc layer"""
     weight = weight_variable()
     bias = weight_variable()
     return nn.Dense(input_channels, out_channels, weight, bias)
 
+
 def weight_variable():
     """weight initial"""
     return TruncatedNormal(0.02)
 
+
 def cell_hook_function(cell_id, grad_input, grad_output):
     print(cell_id)
     assert (grad_output[0].asnumpy().shape == (32, 6, 14, 14))
@@ -94,6 +95,7 @@ class GradWrap(nn.Cell):
         weights = self.weights
         return C.GradOperation('get_by_list', get_by_list=True)(self.network, weights)(x, label)
 
+
 def test_hook():
     net = LeNet5()
     optimizer = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.1, 0.9)
@@ -111,8 +113,6 @@ def test_hook():
     print(loss_output.asnumpy().shape)
 
 
-
-
 class MulAdd(nn.Cell):
     def __init__(self):
         super(MulAdd, self).__init__()
@@ -127,6 +127,7 @@ class MulAdd(nn.Cell):
         assert (dout == 1)
         return 3 * dout, 2 * y
 
+
 def test_custom_bprop():
     mul_add = MulAdd()
     mul_add.bprop_debug = True

tests/ut/python/pynative_mode/test_stop_gradient.py

@@ -18,10 +18,9 @@ import pytest
 
 import mindspore.common.dtype as mstype
 import mindspore.nn as nn
-from mindspore import Parameter, ParameterTuple, Tensor
+from mindspore import Parameter, ParameterTuple
 from mindspore import Tensor
 from mindspore import context
-from mindspore import context
 from mindspore.common.api import ms_function
 from mindspore.ops import composite as C
 from mindspore.ops import operations as P

tests/ut/python/train/quant/mobilenetv2.py

@@ -60,6 +60,7 @@ class InvertedResidual(nn.Cell):
 class MobileNetV2(nn.Cell):
     def __init__(self, num_class=1000, input_size=224, width_mul=1.):
         super(MobileNetV2, self).__init__()
+        _ = input_size
         block = InvertedResidual
         input_channel = 32
         last_channel = 1280

tests/ut/python/train/quant/mobilenetv2_combined.py

@@ -68,6 +68,7 @@ class InvertedResidual(nn.Cell):
 class MobileNetV2(nn.Cell):
     def __init__(self, num_class=1000, input_size=224, width_mul=1.):
         super(MobileNetV2, self).__init__()
+        _ = input_size
         block = InvertedResidual
         input_channel = 32
         last_channel = 1280

tests/ut/python/train/quant/test_quant.py

@@ -63,33 +63,3 @@ class LeNet5(nn.Cell):
         x = self.fc2(x)
         x = self.fc3(x)
         return x
-
-"""
-def test_qat_lenet():
-    net = LeNet5()
-    net = qat.convert_quant_network(
-        net, quant_delay=0, bn_fold=False, freeze_bn=10000, weight_bits=8, act_bits=8)
-
-
-def test_qat_mobile():
-    net = MobileNetV2()
-    img = Tensor(np.ones((1, 3, 224, 224)).astype(np.float32))
-    net = qat.convert_quant_network(
-        net, quant_delay=0, bn_fold=False, freeze_bn=10000, weight_bits=8, act_bits=8)
-    net(img)
-
-
-def test_qat_mobile_train():
-    net = MobileNetV2(num_class=10)
-    img = Tensor(np.ones((1, 3, 224, 224)).astype(np.float32))
-    label = Tensor(np.ones((1, 10)).astype(np.float32))
-    net = qat.convert_quant_network(
-        net, quant_delay=0, bn_fold=False, freeze_bn=10000, weight_bits=8, act_bits=8)
-
-    loss = nn.SoftmaxCrossEntropyWithLogits(reduction='mean')
-    optimizer = nn.Momentum(net.trainable_params(),
-                            learning_rate=0.1, momentum=0.9)
-    net = nn.WithLossCell(net, loss)
-    net = nn.TrainOneStepCell(net, optimizer)
-    net(img, label)
-"""

tests/ut/python/train/summary/summary_reader.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 # ============================================================================
 """Summary reader."""
-import mindspore.train.summary_pb2 as summary_pb2
 import struct
 
+import mindspore.train.summary_pb2 as summary_pb2
+
 _HEADER_SIZE = 8
 _HEADER_CRC_SIZE = 4
 _DATA_CRC_SIZE = 4

tests/ut/python/train/test_amp.py

@@ -25,6 +25,7 @@ from ....dataset_mock import MindData
 
 
 def setup_module(module):
+    _ = module
     context.set_context(mode=context.GRAPH_MODE)
 
 
@@ -56,7 +57,7 @@ def test_amp_o0():
 
     optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
     train_network = amp.build_train_network(net, optimizer, level="O0")
-    output = train_network(inputs, label)
+    _ = train_network(inputs, label)
 
 
 def test_amp_o2():
@@ -66,7 +67,7 @@ def test_amp_o2():
 
     optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
     train_network = amp.build_train_network(net, optimizer, level="O2")
-    output = train_network(inputs, label)
+    _ = train_network(inputs, label)
 
 
 def test_amp_o2_loss():
@@ -76,7 +77,7 @@ def test_amp_o2_loss():
     loss = nn.MSELoss()
     optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
     train_network = amp.build_train_network(net, optimizer, loss, level="O2")
-    output = train_network(inputs, label)
+    _ = train_network(inputs, label)
 
 
 def test_amp_o0_loss():
@@ -86,7 +87,7 @@ def test_amp_o0_loss():
     loss = nn.MSELoss()
     optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)
     train_network = amp.build_train_network(net, optimizer, loss)
-    output = train_network(inputs, label)
+    _ = train_network(inputs, label)
 
 
 class MindDataSet(MindData):
@@ -100,10 +101,10 @@ class MindDataSet(MindData):
         if self._size < self._iter_num:
             raise StopIteration
         self._iter_num += 1
-        next = []
+        lst = []
-        for shape, type in zip(self._output_shapes, self._np_types):
+        for shape_, type_ in zip(self._output_shapes, self._np_types):
-            next.append(Tensor(np.ones(shape).astype(type)))
+            lst.append(Tensor(np.ones(shape_).astype(type_)))
-        return tuple(next)
+        return tuple(lst)
 
 
 def test_compile_model_train_O0():

tests/ut/python/train/test_training.py

@@ -151,7 +151,7 @@ def test_eval():
     with pytest.raises(ValueError):
         model2.eval(dataset)
 
-    net3 = LossNet()
+    _ = LossNet()
     model3 = Model(net2, eval_network=net2, metrics={"loss"})
     with pytest.raises(ValueError):
         model3.eval(dataset)

tests/ut/python/utils/test_callback.py

@@ -15,6 +15,7 @@
 """test callback function."""
 import os
 import stat
+
 import numpy as np
 import pytest
 
@@ -283,14 +284,14 @@ def test_build_callbacks():
 
     callbacks = [ck_obj, loss_cb_1, 'Error', None]
     with pytest.raises(TypeError):
-        callback_list = _build_callbacks(callbacks)
+        _ = _build_callbacks(callbacks)
 
 
 def test_RunContext():
     """Test RunContext."""
     context_err = 666
     with pytest.raises(TypeError):
-        context = RunContext(context_err)
+        _ = RunContext(context_err)
 
     cb_params = _InternalCallbackParam()
     cb_params.member1 = 1

tests/vm_impl/nn_ops_vm_impl.py

@@ -223,6 +223,7 @@ def vm_impl_avg_pool_grad(self):
     return vm_impl
 
 
+# pylint: disable=function-redefined
 @vm_impl_getters.register(G.FusedBatchNormGrad)
 def vm_impl_fused_batch_norm_grad(self):
     """Generate vm_impl function for FusedBatchNormGrad"""
@@ -239,6 +240,7 @@ def vm_impl_fused_batch_norm_grad(self):
     return vm_impl
 
 
+# pylint: disable=function-redefined
 @vm_impl_getters.register(G.BatchNormGrad)
 def vm_impl_fused_batch_norm_grad(self):
     """Generate vm_impl function for BatchNormGrad"""