switch positon of the codes for second_order

example/resnet101_imagenet2012_THOR/config_imagenet.py

@@ -16,6 +16,7 @@
 network config setting, will be used in train.py and eval.py
 """
 from easydict import EasyDict as ed
+
 config = ed({
     "class_num": 1000,
     "batch_size": 32,

example/resnet101_imagenet2012_THOR/crossentropy.py

@@ -13,24 +13,26 @@
 # limitations under the License.
 # ============================================================================
 
-from mindspore.nn.loss.loss import _Loss
+import mindspore.nn as nn
-from mindspore.ops import operations as P
-from mindspore.ops import functional as F
 from mindspore import Tensor
 from mindspore.common import dtype as mstype
-import mindspore.nn as nn
+from mindspore.nn.loss.loss import _Loss
+from mindspore.ops import functional as F
+from mindspore.ops import operations as P
+
 
 class CrossEntropy(_Loss):
     def __init__(self, smooth_factor=0., num_classes=1000):
         super(CrossEntropy, self).__init__()
         self.onehot = P.OneHot()
         self.on_value = Tensor(1.0 - smooth_factor, mstype.float32)
-        self.off_value = Tensor(1.0 * smooth_factor / (num_classes -1), mstype.float32)
+        self.off_value = Tensor(1.0 * smooth_factor / (num_classes - 1), mstype.float32)
-        #self.cast = P.Cast()
+        # self.cast = P.Cast()
         self.ce = nn.SoftmaxCrossEntropyWithLogits()
         self.mean = P.ReduceMean(False)
+
     def construct(self, logit, label):
-        #one_hot_label = self.onehot(self.cast(label, mstype.int32),
+        # one_hot_label = self.onehot(self.cast(label, mstype.int32),
         #                F.shape(logit)[1], self.on_value, self.off_value)、
         one_hot_label = self.onehot(label, F.shape(logit)[1], self.on_value, self.off_value)
         loss = self.ce(logit, one_hot_label)

example/resnet101_imagenet2012_THOR/cus_ops/batch_matmul_impl.py

@@ -12,10 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-from te import tik
-from topi.cce import util
 from mindspore.ops.op_info_register import op_info_register
 
+
 @op_info_register("""{
     "op_name": "CusBatchMatMul",
     "imply_type": "TBE",
@@ -71,11 +70,5 @@ from mindspore.ops.op_info_register import op_info_register
         }
     ]
 }""")
-
- 
-
- 
-
 def CusBatchMatMul(input_x1, input_x2, output, transpose_a=False, transpose_b=True, kernel_name="batchmatmul"):
-
     return

example/resnet101_imagenet2012_THOR/cus_ops/cholesky_trsm.py

@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-from te import tik
-from topi.cce import util
 from mindspore.ops.op_info_register import op_info_register
+
+
 @op_info_register("""{
     "op_name": "CusCholeskyTrsm",
     "imply_type": "TBE",
@@ -58,7 +58,5 @@ from mindspore.ops.op_info_register import op_info_register
         }
    ]
 }""")
- 
+def CusCholeskyTrsm(input_x, output, kernel_name):
- 
-def CusCholeskyTrsm(input_x,output, kernel_name):
     return

example/resnet101_imagenet2012_THOR/cus_ops/cus_batch_matmul.py

@@ -12,42 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-import numpy as np
 from mindspore.ops import prim_attr_register, PrimitiveWithInfer
-from mindspore import Tensor
-import mindspore as ms
 from mindspore.ops.composite import multitype_ops as C
+
+
 # y = x^2
 class CusBatchMatMul(PrimitiveWithInfer):
     """CusMatMulCube definition"""
+
     @prim_attr_register
     def __init__(self):
         """init CusMatMulCube"""
         self.init_prim_io_names(inputs=['x1', 'x2'], outputs=['y'])
-        # self.transpose_a = transpose_a
+
-        # self.transpose_b = transpose_b
-        from .batch_matmul_impl import CusBatchMatMul
- 
     def get_bprop(self):
         def bprop(x1, x2, out, dout):
-            return (C.zeros_like(x1),C.zeros_like(x2))
+            return (C.zeros_like(x1), C.zeros_like(x2))
+
         return bprop
- 
+
     def infer_shape(self, data1_shape, data2_shape):
-        #shape = [1, data1_shape[1], data2_shape[2], 16, 16]
-        #return shape
-        # if self.transpose_a == True:
-        #     k1, m = data1_shape
-        # else:
-        #     m, k1 = data1_shape
-        # if self.transpose_b == True:
-        #     n, k2 = data2_shape
-        # else:
-        #     k2, n = data2_shape
-        # assert k1==k2
-        # shape = [m, n]
         return data1_shape
- 
+
     def infer_dtype(self, data1_dtype, data2_dtype):
-        return data1_dtype
+        return data1_dtype
-        # return ms.common.dtype.tensor_type(getattr(ms, "float32"))

example/resnet101_imagenet2012_THOR/cus_ops/cus_cholesky_trsm.py

@@ -12,24 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-import numpy as np
 from mindspore.ops import prim_attr_register, PrimitiveWithInfer
-from mindspore import Tensor
+
- 
+
 class CusCholeskyTrsm(PrimitiveWithInfer):
     """CusCholeskyTrsm definition"""
+
     @prim_attr_register
     def __init__(self):
         """init CusCholeskyTrsm"""
         self.init_prim_io_names(inputs=['x1'], outputs=['y'])
-        from .cholesky_trsm import CusCholeskyTrsm
+
- 
     def infer_shape(self, data1_shape):
-        m,n = data1_shape
+        m, n = data1_shape
         if m >= 128:
-            return [m//128,128,128]
+            return [m // 128, 128, 128]
         else:
-            return [1,64,64]
+            return [1, 64, 64]
- 
+
     def infer_dtype(self, data1_dtype):
-        return data1_dtype
+        return data1_dtype

example/resnet101_imagenet2012_THOR/cus_ops/cus_fused_abs_max1.py

@@ -12,31 +12,30 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-import numpy as np
 from mindspore.ops import prim_attr_register, PrimitiveWithInfer
-from mindspore import Tensor
 from mindspore.ops.composite import multitype_ops as C
- 
+
+
 class CusFusedAbsMax1(PrimitiveWithInfer):
     """CusCholeskyTrsm definition"""
+
     @prim_attr_register
-    def __init__(self, origin_shape = [-1,-1]):
+    def __init__(self, origin_shape=[-1, -1]):
         """init CusCholeskyTrsm"""
         self.init_prim_io_names(inputs=['x1'], outputs=['y'])
-        from .fused_abs_max1 import CusFusedAbsMax1
         self.origin_shape = origin_shape
- 
+
     def get_bprop(self):
         def bprop(x, out, dout):
             return (C.zeros_like(x),)
+
         return bprop
- 
+
     def infer_shape(self, data1_shape):
         if len(data1_shape) == 2:
-            return [1,]
+            return [1, ]
         else:
             return [32, 64]
-        # return [128,128]
+
- 
     def infer_dtype(self, data1_dtype):
         return data1_dtype

example/resnet101_imagenet2012_THOR/cus_ops/cus_img2col.py

@@ -13,26 +13,26 @@
 # limitations under the License.
 # ============================================================================
 
-import numpy as np
 from mindspore.ops import prim_attr_register, PrimitiveWithInfer
-from mindspore import Tensor
 from mindspore.ops.composite import multitype_ops as C
 
+
 class CusImg2Col(PrimitiveWithInfer):
     """CusImg2Col definition"""
+
     @prim_attr_register
-    def __init__(self, ksizes, strides, dilates = (1, 1, 1, 1), mode="NC1HWC0"):
+    def __init__(self, ksizes, strides, dilates=(1, 1, 1, 1), mode="NC1HWC0"):
         """init CusImg2Col"""
         self.init_prim_io_names(inputs=['x1'], outputs=['y'])
         self.ksizes = ksizes
         self.strides = strides
         self.dilates = dilates
         self.mode = mode
-        from .img2col_impl import CusImg2Col
 
     def get_bprop(self):
         def bprop(x, out, dout):
             return (C.zeros_like(x),)
+
         return bprop
 
     def infer_shape(self, data1_shape):

example/resnet101_imagenet2012_THOR/cus_ops/cus_matmul_cube.py

@@ -12,30 +12,31 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-import numpy as np
-from mindspore.ops import prim_attr_register, PrimitiveWithInfer
-from mindspore import Tensor
 import mindspore as ms
+from mindspore.ops import prim_attr_register, PrimitiveWithInfer
 from mindspore.ops.composite import multitype_ops as C
+
+
 # y = x^2
 class CusMatMulCube(PrimitiveWithInfer):
     """CusMatMulCube definition"""
+
     @prim_attr_register
     def __init__(self, transpose_a=False, transpose_b=False):
         """init CusMatMulCube"""
         self.init_prim_io_names(inputs=['x1', 'x2'], outputs=['y'])
         self.transpose_a = transpose_a
         self.transpose_b = transpose_b
-        from .matmul_cube_impl import CusMatMulCube
+
- 
     def get_bprop(self):
         def bprop(x1, x2, out, dout):
-            return (C.zeros_like(x1),C.zeros_like(x2))
+            return (C.zeros_like(x1), C.zeros_like(x2))
+
         return bprop
- 
+
     def infer_shape(self, data1_shape, data2_shape):
-        #shape = [1, data1_shape[1], data2_shape[2], 16, 16]
+        # shape = [1, data1_shape[1], data2_shape[2], 16, 16]
-        #return shape
+        # return shape
         if self.transpose_a == True:
             k1, m = data1_shape
         else:
@@ -44,9 +45,9 @@ class CusMatMulCube(PrimitiveWithInfer):
             n, k2 = data2_shape
         else:
             k2, n = data2_shape
-        assert k1==k2
+        assert k1 == k2
         shape = [m, n]
         return shape
- 
+
     def infer_dtype(self, data1_dtype, data2_dtype):
         return ms.common.dtype.tensor_type(getattr(ms, "float32"))

example/resnet101_imagenet2012_THOR/cus_ops/cus_matmul_cube_dense_left.py

@@ -12,27 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-import numpy as np
-from mindspore.ops import prim_attr_register, PrimitiveWithInfer
-from mindspore import Tensor
 import mindspore as ms
+from mindspore.ops import prim_attr_register, PrimitiveWithInfer
 from mindspore.ops.composite import multitype_ops as C
+
+
 # y = x^2
 class CusMatMulCubeDenseLeft(PrimitiveWithInfer):
     """CusMatMulCube definition"""
+
     @prim_attr_register
     def __init__(self):
         """init CusMatMulCube"""
         self.init_prim_io_names(inputs=['x1', 'x2'], outputs=['y'])
-        from .matmul_cube_dense_left import CusMatMulCubeDenseLeft
+
- 
     def get_bprop(self):
         def bprop(x1, x2, out, dout):
-            return (C.zeros_like(x1),C.zeros_like(x2))
+            return (C.zeros_like(x1), C.zeros_like(x2))
+
         return bprop
- 
+
     def infer_shape(self, data1_shape, data2_shape):
         return data2_shape
- 
+
     def infer_dtype(self, data1_dtype, data2_dtype):
         return ms.common.dtype.tensor_type(getattr(ms, "float16"))

example/resnet101_imagenet2012_THOR/cus_ops/cus_matmul_cube_fracz_right_mul.py

@@ -12,27 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-import numpy as np
-from mindspore.ops import prim_attr_register, PrimitiveWithInfer
-from mindspore import Tensor
 import mindspore as ms
+from mindspore.ops import prim_attr_register, PrimitiveWithInfer
 from mindspore.ops.composite import multitype_ops as C
-# y = x^2
+
+
 class CusMatMulCubeFraczRightMul(PrimitiveWithInfer):
     """CusMatMulCubeFraczRightMul definition"""
+
     @prim_attr_register
     def __init__(self):
         """init CusMatMulCubeFraczRightMul"""
         self.init_prim_io_names(inputs=['x1', 'x2', 'x3'], outputs=['y'])
-        from .matmul_cube_fracz_right_mul_impl import CusMatMulCubeFraczRightMul
 
     def get_bprop(self):
         def bprop(x1, x2, x3, out, dout):
-            return (C.zeros_like(x1),C.zeros_like(x2),C.zeros_like(x3))
+            return (C.zeros_like(x1), C.zeros_like(x2), C.zeros_like(x3))
+
         return bprop
- 
+
     def infer_shape(self, data1_shape, data2_shape, data3_shape):
         return data1_shape
- 
+
     def infer_dtype(self, data1_dtype, data2_dtype, data3_dtype):
         return ms.common.dtype.tensor_type(getattr(ms, "float32"))

example/resnet101_imagenet2012_THOR/cus_ops/cus_matrix_combine.py

@@ -12,29 +12,29 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-import numpy as np
 from mindspore.ops import prim_attr_register, PrimitiveWithInfer
-from mindspore import Tensor
-import mindspore as ms
 from mindspore.ops.composite import multitype_ops as C
-# y = x^2
+
+
 class CusMatrixCombine(PrimitiveWithInfer):
     """CusMatMulCube definition"""
+
     @prim_attr_register
     def __init__(self):
         """init CusMatMulCube"""
         self.init_prim_io_names(inputs=['x'], outputs=['y'])
-        from .matrix_combine_impl import CusMatrixCombine
+
     def get_bprop(self):
         def bprop(x, out, dout):
             return (C.zeros_like(x),)
+
         return bprop
- 
+
     def infer_shape(self, data_shape):
         a, b, c = data_shape
-        shape = [a*b, a*c]
+        shape = [a * b, a * c]
- 
+
         return shape
- 
+
     def infer_dtype(self, data_dtype):
         return data_dtype

example/resnet101_imagenet2012_THOR/cus_ops/cus_transpose02314.py

@@ -12,35 +12,33 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
- 
+
- 
+
-import numpy as np
 from mindspore.ops import prim_attr_register, PrimitiveWithInfer
-from mindspore import Tensor
 from mindspore.ops.composite import multitype_ops as C
- 
+
+
 class CusTranspose02314(PrimitiveWithInfer):
     """CusTranspose02314 definition"""
+
     @prim_attr_register
     def __init__(self):
         """init CusTranspose02314"""
         self.init_prim_io_names(inputs=['x1'], outputs=['y'])
-        from .transpose02314_impl import CusTranspose02314
+
- 
     def get_bprop(self):
         def bprop(x, out, dout):
             return (C.zeros_like(x),)
+
         return bprop
- 
+
     def infer_shape(self, data1_shape):
         assert len(data1_shape) == 4
         n, c, h, w = data1_shape
         c0 = 16
         c1 = c // 16
         shape = (n * h * w, c1 * c0)
-        # axis_0, axis_1, axis_2, axis_3, axis_4 = data1_shape
-        # shape = (axis_0, axis_2, axis_3, axis_1, axis_4)
         return shape
- 
+
     def infer_dtype(self, data1_dtype):
         return data1_dtype

example/resnet101_imagenet2012_THOR/cus_ops/fused_abs_max1.py

@@ -13,9 +13,9 @@
 # limitations under the License.
 # ============================================================================
 
-from te import tik
-from topi.cce import util
 from mindspore.ops.op_info_register import op_info_register
+
+
 @op_info_register("""{
     "op_name": "CusFusedAbsMax1",
     "imply_type": "TBE",
@@ -64,5 +64,5 @@ from mindspore.ops.op_info_register import op_info_register
         }
     ]
 }""")
-def CusFusedAbsMax1(input_x, output, origin_shape = None, kernel_name="fused_abs_max1"):
+def CusFusedAbsMax1(input_x, output, origin_shape=None, kernel_name="fused_abs_max1"):
     return

example/resnet101_imagenet2012_THOR/cus_ops/img2col_impl.py

@@ -13,9 +13,9 @@
 # limitations under the License.
 # ============================================================================
 
-from te import tik
-from topi.cce import util
 from mindspore.ops.op_info_register import op_info_register
+
+
 @op_info_register("""{
     "op_name": "CusImg2ColNC1HWC0",
     "imply_type": "TBE",
@@ -82,6 +82,5 @@ from mindspore.ops.op_info_register import op_info_register
         }
     ]
 }""")
- 
 def CusImg2ColNC1HWC0(input_x, output, ksizes, strides, dilates, padding, kernel_name="img2col"):
     return

example/resnet101_imagenet2012_THOR/cus_ops/matmul_cube_dense_left.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 """
-copyright 2019 Huawei Technologies Co., Ltd
+copyright 2020 Huawei Technologies Co., Ltd
  
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -18,22 +18,15 @@ limitations under the License.
 matmul
 """
 from __future__ import absolute_import
- 
+
-import te.lang.cce
-import te.platform.cce_params as cce
-from te.platform.fusion_manager import fusion_manager
-from te import tvm
-from topi import generic
-from topi.cce import util
- 
-from impl.matmul_vector import matmul_vector_cce
- 
-from te import tik
 from mindspore.ops.op_info_register import op_info_register
+from topi.cce import util
+
 # General limitation of the size for input shape: 2**31
 SHAPE_SIZE_LIMIT = 2147483648
 NoneType = type(None)
- 
+
+
 @op_info_register("""{
     "op_name": "CusMatMulCubeDenseLeft",
     "imply_type": "TBE",
@@ -102,8 +95,7 @@ NoneType = type(None)
         }
     ]
 }""")
- 
 @util.check_input_type(dict, dict, (dict, NoneType), dict, bool, bool, str)
-def CusMatMulCubeDenseLeft(input_x1, input_x2, bias=None, output_y={}, trans_a=False, trans_b=False, kernel_name="matmulcube"):
+def CusMatMulCubeDenseLeft(input_x1, input_x2, bias=None, output_y={}, trans_a=False, trans_b=False,
+                           kernel_name="matmulcube"):
     return
-

example/resnet101_imagenet2012_THOR/cus_ops/matmul_cube_fracz_left_cast_impl.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 """
-copyright 2019 Huawei Technologies Co., Ltd
+copyright 2020 Huawei Technologies Co., Ltd
  
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -18,19 +18,15 @@ limitations under the License.
 matmul
 """
 from __future__ import absolute_import
- 
+
-import te.platform.cce_params as cce
-from te import tvm
-from topi.cce import util
- 
-from te import tik
 from mindspore.ops.op_info_register import op_info_register
- 
+from topi.cce import util
+
 # General limitation of the size for input shape: 2**31
 SHAPE_SIZE_LIMIT = 2147483648
 NoneType = type(None)
- 
+
- 
+
 @op_info_register("""{
     "op_name": "CusMatMulCubeFraczLeftCast",
     "imply_type": "TBE",
@@ -99,7 +95,6 @@ NoneType = type(None)
         }
     ]
 }""")
- 
 # pylint: disable=locally-disabled,too-many-arguments, too-many-locals, too-many-statements
 @util.check_input_type(dict, dict, (dict, NoneType), dict, bool, bool, str)
 def CusMatMulCubeFraczLeftCast(input_x1, input_x2, bias=None, output_y={}, trans_a=False, trans_b=False,

example/resnet101_imagenet2012_THOR/cus_ops/matmul_cube_fracz_right_mul_impl.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 """
-copyright 2019 Huawei Technologies Co., Ltd
+copyright 2020 Huawei Technologies Co., Ltd
  
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -18,21 +18,14 @@ limitations under the License.
 matmul
 """
 from __future__ import absolute_import
- 
+
-import te.lang.cce
-import te.platform.cce_params as cce
-from te.platform.fusion_manager import fusion_manager
-from te import tvm
-from topi import generic
-from topi.cce import util
-from te import tik
-from impl.matmul_vector import matmul_vector_cce
 from mindspore.ops.op_info_register import op_info_register
+
 # General limitation of the size for input shape: 2**31
 SHAPE_SIZE_LIMIT = 2147483648
 NoneType = type(None)
- 
+
- 
+
 @op_info_register("""{
     "op_name": "CusMatMulCubeFraczRightMul",
     "imply_type": "TBE",
@@ -114,8 +107,6 @@ NoneType = type(None)
         }
     ]
 }""")
- 
+def CusMatMulCubeFraczRightMul(input_x1, input_x2, input_x3, bias=None, output_y={}, trans_a=False, trans_b=False,
-def CusMatMulCubeFraczRightMul(input_x1, input_x2, input_x3, bias=None, output_y={}, trans_a=False, trans_b=False, kernel_name="matmulcube"):
+                               kernel_name="matmulcube"):
     return
-
-

example/resnet101_imagenet2012_THOR/cus_ops/matmul_cube_impl.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 """
-copyright 2019 Huawei Technologies Co., Ltd
+copyright 2020 Huawei Technologies Co., Ltd
  
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -18,20 +18,15 @@ limitations under the License.
 matmul
 """
 from __future__ import absolute_import
- 
+
-import te.lang.cce
-import te.platform.cce_params as cce
-from te import tvm
-from topi import generic
-from topi.cce import util
- 
-from impl.matmul_vector import matmul_vector_cce
 from mindspore.ops.op_info_register import op_info_register
- 
+from topi.cce import util
+
 # General limitation of the size for input shape: 2**31
 SHAPE_SIZE_LIMIT = 2147483648
 NoneType = type(None)
- 
+
+
 @op_info_register("""{
     "op_name": "CusMatMulCube",
     "imply_type": "TBE",
@@ -112,8 +107,7 @@ NoneType = type(None)
         }
     ]
 }""")
- 
 # pylint: disable=locally-disabled,too-many-arguments, too-many-locals, too-many-statements
 @util.check_input_type(dict, dict, (dict, NoneType), dict, bool, bool, str)
 def CusMatMulCube(input_x1, input_x2, bias=None, output_y={}, trans_a=False, trans_b=False, kernel_name="matmulcube"):
-   return
+    return

example/resnet101_imagenet2012_THOR/cus_ops/matrix_combine_impl.py

@@ -13,9 +13,9 @@
 # limitations under the License.
 # ============================================================================
 
-from te import tik
-from topi.cce import util
 from mindspore.ops.op_info_register import op_info_register
+
+
 @op_info_register("""{
     "op_name": "CusMatrixCombine",
     "imply_type": "TBE",
@@ -58,7 +58,5 @@ from mindspore.ops.op_info_register import op_info_register
         }
     ]
 }""")
- 
+def CusMatrixCombine(input_x, output, kernel_name="matrix_combine"):
- 
-def CusMatrixCombine(input_x, output,kernel_name="matrix_combine"):
     return

example/resnet101_imagenet2012_THOR/cus_ops/transpose02314_impl.py

@@ -13,9 +13,9 @@
 # limitations under the License.
 # ============================================================================
 
-from te import tik
-from topi.cce import util
 from mindspore.ops.op_info_register import op_info_register
+
+
 @op_info_register("""{
     "op_name": "CusTranspose02314",
     "imply_type": "TBE",
@@ -58,6 +58,5 @@ from mindspore.ops.op_info_register import op_info_register
         }
     ]
 }""")
- 
 def CusTranspose02314(input_x, output, kernel_name="transpose021354"):
     return

example/resnet101_imagenet2012_THOR/dataset_imagenet.py

@@ -16,11 +16,12 @@
 create train or eval dataset.
 """
 import os
+
 import mindspore.common.dtype as mstype
 import mindspore.dataset.engine as de
-import mindspore.dataset.transforms.vision.c_transforms as V_C
 import mindspore.dataset.transforms.c_transforms as C2
-from config_imagenet import config
+import mindspore.dataset.transforms.vision.c_transforms as V_C
+
 
 def create_dataset(dataset_path, do_train, repeat_num=1, batch_size=32):
     """
@@ -41,7 +42,7 @@ def create_dataset(dataset_path, do_train, repeat_num=1, batch_size=32):
         ds = de.ImageFolderDatasetV2(dataset_path, num_parallel_workers=8, shuffle=False)
     else:
         ds = de.ImageFolderDatasetV2(dataset_path, num_parallel_workers=8, shuffle=True,
-                                      num_shards=device_num, shard_id=rank_id)
+                                     num_shards=device_num, shard_id=rank_id)
 
     image_size = 224
     mean = [0.485 * 255, 0.456 * 255, 0.406 * 255]
@@ -61,9 +62,9 @@ def create_dataset(dataset_path, do_train, repeat_num=1, batch_size=32):
             V_C.Normalize(mean=mean, std=std),
             V_C.HWC2CHW()
         ]
-    #type_cast_op = C2.TypeCast(mstype.float16)
+    # type_cast_op = C2.TypeCast(mstype.float16)
     type_cast_op = C2.TypeCast(mstype.int32)
- 
+
     ds = ds.map(input_columns="image", operations=transform_img, num_parallel_workers=8)
     ds = ds.map(input_columns="label", operations=type_cast_op, num_parallel_workers=8)
 

example/resnet101_imagenet2012_THOR/lr_generator.py

@@ -13,14 +13,17 @@
 # limitations under the License.
 # ============================================================================
 """learning rate generator"""
-import numpy as np
 import math
 
+import numpy as np
+
+
 def linear_warmup_lr(current_step, warmup_steps, base_lr, init_lr):
     lr_inc = (float(base_lr) - float(init_lr)) / float(warmup_steps)
     lr = float(init_lr) + lr_inc * current_step
     return lr
 
+
 def cosine_annealing_lr(lr, steps_per_epoch, warmup_epochs, max_epoch, T_max, eta_min=0, num_periods=0.5):
     base_lr = lr
     warmup_init_lr = 0
@@ -39,6 +42,7 @@ def cosine_annealing_lr(lr, steps_per_epoch, warmup_epochs, max_epoch, T_max, et
         lr_each_step.append(lr)
     return np.array(lr_each_step).astype(np.float32)
 
+
 def warmup_cosine_annealing_lr(lr, steps_per_epoch, warmup_epochs, max_epoch, T_max, eta_min=0, num_periods=0.5):
     base_lr = lr
     warmup_init_lr = 0
@@ -57,6 +61,7 @@ def warmup_cosine_annealing_lr(lr, steps_per_epoch, warmup_epochs, max_epoch, T_
         lr_each_step.append(lr)
     return np.array(lr_each_step).astype(np.float32)
 
+
 def get_lr(global_step, lr_init, lr_end, lr_max, warmup_epochs, total_epochs, steps_per_epoch, lr_decay_mode):
     """
     generate learning rate array

example/resnet101_imagenet2012_THOR/model/dataset_helper.py

@@ -13,15 +13,15 @@
 # limitations under the License.
 # ============================================================================
 """Dataset help for minddata dataset"""
-from mindspore._checkparam import check_bool
 from mindspore import context
-from mindspore.train.parallel_utils import ParallelMode
+from mindspore._checkparam import check_bool
-from mindspore.train._utils import _exec_datagraph, _get_types_and_shapes, _to_tensor, \
-    _construct_tensor_list, _to_full_shapes, _to_full_tensor
 from mindspore.nn.wrap import GetNextSingleOp
 from mindspore.parallel._utils import _get_device_num, _get_global_rank, _get_parallel_mode
- 
+from mindspore.train._utils import _exec_datagraph, _get_types_and_shapes, _to_tensor, \
- 
+    _construct_tensor_list, _to_full_shapes, _to_full_tensor
+from mindspore.train.parallel_utils import ParallelMode
+
+
 class DatasetHelper:
     """
     Help function to use the Minddata dataset.
@@ -41,9 +41,10 @@ class DatasetHelper:
         >>> for inputs in dataset_helper:
         >>>     outputs = network(*inputs)
     """
+
     def __init__(self, dataset, first_order_iter=0, dataset_sink_mode=True):
         check_bool(dataset_sink_mode)
- 
+
         iterclass = _DatasetIterGE
         if not dataset_sink_mode:
             iterclass = _DatasetIterFeed
@@ -52,24 +53,25 @@ class DatasetHelper:
                 iterclass = _DatasetIterMSLoopSink
             else:
                 iterclass = _DatasetIterMS
- 
+
         self.iter = iterclass(dataset, first_order_iter)
- 
+
     def __iter__(self):
         return self.iter.__iter__()
- 
+
     # A temp solution for loop sink. Delete later
     def types_shapes(self):
         """Get the types and shapes from dataset on current config."""
         return self.iter.types_shapes()
- 
+
     def loop_size(self):
         """Get loop_size for every iteration."""
         return self.iter.loop_size
- 
+
- 
+
 class _DatasetIter:
     """Base iter for dataset help"""
+
     def __init__(self, dataset):
         self.loop_size = 1
         if not hasattr(dataset, '__ME_INITED__'):
@@ -78,7 +80,7 @@ class _DatasetIter:
             else:
                 self.loop_size = dataset.__loop_size__
             dataset.__ME_INITED__ = _exec_datagraph(dataset, self.loop_size).queue_name
- 
+
         self.ind = 0
         self.dataset = dataset
         dataset_types, dataset_shapes = _get_types_and_shapes(dataset)
@@ -89,53 +91,57 @@ class _DatasetIter:
         if _get_parallel_mode() in (ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL):
             device_num = _get_device_num()
             self.dataset_shapes = _to_full_shapes(dataset_shapes, device_num)
- 
+
     def __iter__(self):
         self.ind = 0
         return self
- 
+
     def __next__(self):
         if self.ind >= self.loop_count:
             raise StopIteration()
         self.ind += 1
         return self.op()
- 
+
     def types_shapes(self):
         return self.dataset_types, self.dataset_shapes
- 
+
     def get_loop_count(self, dataset):
         loop_count = 1
         if hasattr(dataset, '__loop_size__'):
             loop_size = dataset.__loop_size__
-            loop_count = int(dataset.get_dataset_size()/loop_size)
+            loop_count = int(dataset.get_dataset_size() / loop_size)
         return loop_count
- 
+
- 
+
 class _DatasetIterMSLoopSink(_DatasetIter):
     """Iter for context (enable_loop_sink=True)"""
+
     def __init__(self, dataset, first_order_iter):
         super(_DatasetIterMSLoopSink, self).__init__(dataset)
         # self.loop_count = self.get_loop_count(dataset)
         loop_size = dataset.__loop_size__ + first_order_iter
-        self.loop_count = int(dataset.get_dataset_size()/loop_size) * 2
+        self.loop_count = int(dataset.get_dataset_size() / loop_size) * 2
- 
+
         def op():
             return tuple()
+
         self.op = op
- 
+
- 
+
 class _DatasetIterMS(_DatasetIter):
     """Iter for context (enable_loop_sink=False)"""
+
     def __init__(self, dataset, first_order_order):
         super(_DatasetIterMS, self).__init__(dataset)
         self.loop_count = dataset.get_dataset_size()
         self.loop_size = 1
         queue_name = dataset.__ME_INITED__
         self.op = GetNextSingleOp(self.dataset_types, self.dataset_shapes, queue_name)
- 
+
 
 class _DatasetIterGE(_DatasetIter):
     """Iter for ge"""
+
     def __init__(self, dataset):
         super(_DatasetIterGE, self).__init__(dataset)
         self.loop_count = self.get_loop_count(dataset)
@@ -145,14 +151,16 @@ class _DatasetIterGE(_DatasetIter):
         if self.need_to_full:
             batch_expand_num = _get_device_num()
         tensor_list_run = _construct_tensor_list(self.dataset_types, self.dataset_shapes, batch_expand_num)
- 
+
         def op():
             return tensor_list_run
+
         self.op = op
- 
+
- 
+
 class _DatasetIterFeed:
     """Iter for feed data"""
+
     def __init__(self, dataset, first_order_order):
         self.dataset = dataset
         self.device_num = _get_device_num()
@@ -161,18 +169,18 @@ class _DatasetIterFeed:
         self.repeat_ind = 0
         self.loop_count = dataset.get_dataset_size()
         self.ind = 0
- 
+
         parallel_mode = context.get_auto_parallel_context("parallel_mode")
         self.need_to_full = parallel_mode in (ParallelMode.SEMI_AUTO_PARALLEL, ParallelMode.AUTO_PARALLEL)
- 
+
     def __iter__(self):
         if self.repeat_ind % self.repeat_count == 0:
             self.iter = self.dataset.__iter__()
- 
+
         self.repeat_ind += 1
         self.ind = 0
         return self
- 
+
     def __next__(self):
         if self.ind >= self.loop_count:
             raise StopIteration()

example/resnet101_imagenet2012_THOR/model/grad_reducer_thor.py

@@ -12,28 +12,30 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-from mindspore.nn.cell import Cell
+import mindspore.common.dtype as mstype
 from mindspore.communication.management import GlobalComm, get_group_size
+from mindspore.nn.cell import Cell
 from mindspore.ops import functional as F, composite as C, operations as P
 from mindspore.ops.operations.comm_ops import AllReduce, ReduceOp
-import mindspore.common.dtype as mstype
-from mindspore.communication import create_group
 
 reduce_opt = C.MultitypeFuncGraph("reduce_opt")
 
 _all_reduce_A = AllReduce()
 
+
 def _init_optimizer_allreduce(group):
     global _all_reduce_A
     _all_reduce_A = AllReduce(ReduceOp.SUM, GlobalComm.WORLD_COMM_GROUP)
     _all_reduce_A.add_prim_attr('fusion', group)
 
+
 @reduce_opt.register("Function", "Number", "Tensor")
 def _tensors_allreduce_mean(mul, degree, grad):
     degree = F.scalar_cast(degree, F.dtype(grad))
     grad = _all_reduce_A(grad)
     cast_op = P.Cast()
-    return mul(grad, cast_op(F.scalar_to_array(1.0/degree), F.dtype(grad)))
+    return mul(grad, cast_op(F.scalar_to_array(1.0 / degree), F.dtype(grad)))
+
 
 @reduce_opt.register("Bool", "Tensor")
 def _tensors_allreduce(allreduce_filter, grad):
@@ -41,8 +43,10 @@ def _tensors_allreduce(allreduce_filter, grad):
         return _all_reduce_A(grad)
     return grad
 
+
 _get_datatype = C.MultitypeFuncGraph("_get_datatype")
 
+
 @_get_datatype.register("Tensor")
 def _tensors_get_datatype(grad):
     """