mindspore 2.1.0__cp39-cp39-win_amd64.whl → 2.2.10__cp39-cp39-win_amd64.whl

mindspore/ops/_grad_experimental/grad_math_ops.py

@@ -34,14 +34,12 @@ from mindspore.ops.operations.math_ops import MatrixTriangularSolve
 from mindspore.ops.operations.math_ops import NanToNum
 from mindspore.ops.operations.math_ops import FFTWithSize
 from mindspore.ops.operations.math_ops import Cholesky
-from mindspore.ops.operations.math_ops import Fmin
 from mindspore.ops.operations.math_ops import CholeskySolve
 from mindspore.ops.operations.math_ops import InplaceIndexAdd
 from mindspore.ops.operations.math_ops import TridiagonalSolve
 from mindspore.ops.operations.math_ops import Diagonal
 from mindspore.ops.operations.math_ops import EuclideanNorm
 from mindspore.ops.operations.array_ops import Transpose, MatrixSetDiagV3
-from mindspore.ops.operations.math_ops import Fmax
 from mindspore.ops.operations._inner_ops import DynamicBroadcastGradientArgs
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops.primitive import _primexpr
@@ -137,7 +135,7 @@ def get_bprop_matrix_triangular_solve(self):
 
     def bprop(matrix, rhs, out, dout):
         grad_rhs = matrix_triangular_solve_op(matrix, dout)
-        if matrix.dtype == mstype.complex64 or matrix.dtype == mstype.complex128:
+        if matrix.dtype in (mstype.complex64, mstype.complex128):
             grad_rhs_temp = _adjoint(grad_rhs)
             out_temp = _adjoint(out)
         else:
@@ -158,14 +156,14 @@ def get_bprop_matrix_triangular_solve(self):
                 grad_matrix = mat_mul_op(grad_rhs, out_temp)
                 grad_matrix = neg_op(grad_matrix)
         if lower_a:
-            if grad_matrix.dtype == mstype.complex64 or grad_matrix.dtype == mstype.complex128:
+            if grad_matrix.dtype in (mstype.complex64, mstype.complex128):
                 grad_matrix_real = matrix_band_part_op(real_op(grad_matrix), -1, 0)
                 grad_matrix_imag = matrix_band_part_op(imag_op(grad_matrix), -1, 0)
                 grad_matrix = complex_op(grad_matrix_real, grad_matrix_imag)
             else:
                 grad_matrix = matrix_band_part_op(grad_matrix, -1, 0)
         else:
-            if grad_matrix.dtype == mstype.complex64 or grad_matrix.dtype == mstype.complex128:
+            if grad_matrix.dtype in (mstype.complex64, mstype.complex128):
                 grad_matrix_real = matrix_band_part_op(real_op(grad_matrix), 0, -1)
                 grad_matrix_imag = matrix_band_part_op(imag_op(grad_matrix), 0, -1)
                 grad_matrix = complex_op(grad_matrix_real, grad_matrix_imag)
@@ -221,7 +219,7 @@ def get_bprop_matrix_solve(self):
 @_primexpr
 def _generate_perm_matrix_solve_ls(x_dim):
     perm = tuple(range(x_dim - 2))
-    perm = perm + (x_dim-1, x_dim-2)
+    perm = perm + (x_dim - 1, x_dim - 2)
     return perm
 
 
@@ -424,115 +422,6 @@ def get_bprop_polar(self):
     return bprop
 
 
-@bprop_getters.register(Fmin)
-def get_bprop_fmin(self):
-    """Grad definition for 'Fmin' operation"""
-    shape_ = P.Shape()
-    masked_fill_op = P.MaskedFill()
-    logical_or_op = P.LogicalOr()
-    logical_not_op = P.LogicalNot()
-    logical_and_op = P.LogicalAnd()
-    mul_op = P.Mul()
-    is_nan_op = P.IsNan()
-    reshape_ = P.Reshape()
-
-    def bprop(x1, x2, out, dout):
-        x1_dtype = F.dtype(x1)
-        x2_dtype = F.dtype(x2)
-        x1 = F.cast(x1, mstype.float32)
-        x2 = F.cast(x2, mstype.float32)
-        dout = F.cast(dout, mstype.float32)
-        b1 = logical_or_op((x1 <= x2), is_nan_op(x2))
-        b2 = logical_or_op((x2 < x1), logical_and_op(is_nan_op(x1), logical_not_op(is_nan_op(x2))))
-        rx1 = masked_fill_op(x1, b1, 1.)
-        rx1 = masked_fill_op(rx1, logical_not_op(b1), 0.)
-        rx2 = masked_fill_op(x2, b2, 1.)
-        rx2 = masked_fill_op(rx2, logical_not_op(b2), 0.)
-        rrx1 = mul_op(rx1, dout)
-        rrx2 = mul_op(rx2, dout)
-        shape_of_x1 = shape_(x1)
-        shape_of_x2 = shape_(x2)
-        x1_dim = len(shape_of_x1)
-        x2_dim = len(shape_of_x2)
-        if x1_dim == 0 and x2_dim != 0:
-            sum_r1 = rrx1.sum()
-            sum_r2 = rrx2
-        elif x1_dim == 0 and x2_dim == 0:
-            sum_r1 = rrx1.sum()
-            sum_r2 = rrx2.sum()
-        elif x1_dim != 0 and x2_dim == 0:
-            sum_r2 = rrx2.sum()
-            sum_r1 = rrx1
-        else:
-            rx, ry = DynamicBroadcastGradientArgs()(shape_of_x1, shape_of_x2)
-            sum_r1 = sum_grad_reduce_axis(rrx1, rx)
-            sum_r2 = sum_grad_reduce_axis(rrx2, ry)
-        brrx1 = reshape_(sum_r1, shape_of_x1)
-        brrx2 = reshape_(sum_r2, shape_of_x2)
-        brrx1 = F.cast(brrx1, x1_dtype)
-        brrx2 = F.cast(brrx2, x2_dtype)
-        return brrx1, brrx2
-
-    return bprop
-
-
-@bprop_getters.register(Fmax)
-def get_bprop_fmax(self):
-    """Grad definition for 'Fmax' operation"""
-    shape_ = P.Shape()
-    masked_fill_op = P.MaskedFill()
-    logical_or_op = P.LogicalOr()
-    logical_not_op = P.LogicalNot()
-    logical_and_op = P.LogicalAnd()
-    mul_op = P.Mul()
-    is_nan_op = P.IsNan()
-    reshape_ = P.Reshape()
-
-    def bprop(x1, x2, out, dout):
-        x1_dtype = F.dtype(x1)
-        x2_dtype = F.dtype(x2)
-        if x1_dtype != mstype.float32:
-            x1 = F.cast(x1, mstype.float32)
-            dout = F.cast(dout, mstype.float32)
-        if x2_dtype != mstype.float32:
-            x2 = F.cast(x2, mstype.float32)
-            dout = F.cast(dout, mstype.float32)
-        b1 = logical_or_op(logical_and_op((x1 >= x2), logical_not_op(is_nan_op(x1))), is_nan_op(x2))
-        b2 = logical_or_op(logical_and_op(x2 > x1, logical_not_op(is_nan_op(x2))),
-                           logical_and_op(is_nan_op(x1), logical_not_op(is_nan_op(x2))))
-        rx1 = masked_fill_op(x1, b1, 1.)
-        rx1 = masked_fill_op(rx1, logical_not_op(b1), 0.)
-        rx2 = masked_fill_op(x2, b2, 1.)
-        rx2 = masked_fill_op(rx2, logical_not_op(b2), 0.)
-        rrx1 = mul_op(rx1, dout)
-        rrx2 = mul_op(rx2, dout)
-        shape_of_x1 = shape_(x1)
-        shape_of_x2 = shape_(x2)
-        x1_dim = len(shape_of_x1)
-        x2_dim = len(shape_of_x2)
-        if x1_dim == 0 and x2_dim != 0:
-            sum_r1 = rrx1.sum()
-            sum_r2 = rrx2
-        elif x1_dim == 0 and x2_dim == 0:
-            sum_r1 = rrx1.sum()
-            sum_r2 = rrx2.sum()
-        elif x1_dim != 0 and x2_dim == 0:
-            sum_r2 = rrx2.sum()
-            sum_r1 = rrx1
-        else:
-            rx, ry = DynamicBroadcastGradientArgs()(shape_of_x1, shape_of_x2)
-            sum_r1 = sum_grad_reduce_axis(rrx1, rx)
-            sum_r2 = sum_grad_reduce_axis(rrx2, ry)
-        brrx1 = reshape_(sum_r1, shape_of_x1)
-        brrx2 = reshape_(sum_r2, shape_of_x2)
-        brrx1 = F.cast(brrx1, x1_dtype)
-        brrx2 = F.cast(brrx2, x2_dtype)
-        return brrx1, brrx2
-
-
-    return bprop
-
-
 @bprop_getters.register(TridiagonalSolve)
 def get_bprop_tridiagonalsolve(self):
     """Grad definition for 'TridiagonalSolve' operation"""
@@ -758,20 +647,21 @@ def _fft_rank_offset(norm_shape, rank):
 @_primexpr
 def _fft_with_size_back_norm(norm_shape, norm, inverse, rank):
     """generate reverse term for fft_with_size"""
+    norm_ = None
     if inverse is False:
         if norm == "forward":
-            norm_ = 1 / _fft_rank_offset(norm_shape, rank)
-        if norm == "backward":
-            norm_ = 1 * _fft_rank_offset(norm_shape, rank)
-        if norm == "ortho":
-            norm_ = 1
-    if inverse is True:
+            norm_ = 1.0 / _fft_rank_offset(norm_shape, rank)
+        elif norm == "backward":
+            norm_ = 1.0 * _fft_rank_offset(norm_shape, rank)
+        elif norm == "ortho":
+            norm_ = 1.0
+    else:
         if norm == "forward":
-            norm_ = 1 * _fft_rank_offset(norm_shape, rank)
-        if norm == "backward":
-            norm_ = 1 / _fft_rank_offset(norm_shape, rank)
-        if norm == "ortho":
-            norm_ = 1
+            norm_ = 1.0 * _fft_rank_offset(norm_shape, rank)
+        elif norm == "backward":
+            norm_ = 1.0 / _fft_rank_offset(norm_shape, rank)
+        elif norm == "ortho":
+            norm_ = 1.0
     return norm_
 
 
@@ -781,9 +671,9 @@ def _rfft_norm(norm_shape, norm, rank):
     norm_ = 1.0
     if norm == "forward":
         norm_ = 1 / _fft_rank_offset(norm_shape, rank)
-    if norm == "backward":
-        norm_ = 1
-    if norm == "ortho":
+    elif norm == "backward":
+        norm_ = 1.0
+    elif norm == "ortho":
         norm_ = 1 / np.sqrt(_fft_rank_offset(norm_shape, rank))
     return norm_
 
@@ -1127,73 +1017,3 @@ def get_bprop_tensor_add(self):
         return binop_grad_common(x, y, dout, dout)
 
     return bprop
-
-
-@bprop_getters.register(P.BitwiseAnd)
-def get_bprop_bitwiseand(self):
-    """Grad definition for `BitwiseAnd` operation."""
-
-    def bprop(x, y, out, dout):
-        return zeros_like(x), zeros_like(y)
-
-    return bprop
-
-
-@bprop_getters.register(P.BitwiseOr)
-def get_bprop_bitwiseor(self):
-    """Grad definition for `BitwiseOr` operation."""
-
-    def bprop(x, y, out, dout):
-        return zeros_like(x), zeros_like(y)
-
-    return bprop
-
-
-@bprop_getters.register(P.BitwiseXor)
-def get_bprop_bitwisexor(self):
-    """Grad definition for `BitwiseXor` operation."""
-
-    def bprop(x, y, out, dout):
-        return zeros_like(x), zeros_like(y)
-
-    return bprop
-
-
-@bprop_getters.register(P.InplaceUpdate)
-def get_bprop_inplace_update(self):
-    """Grad definition for `InplaceUpdate` operation."""
-
-    def bprop(x, v, out, dout):
-        return zeros_like(x), zeros_like(v)
-
-    return bprop
-
-
-@bprop_getters.register(P.InplaceUpdateV2)
-def get_bprop_inplace_update_v2(self):
-    """Grad definition for `InplaceUpdateV2` operation."""
-
-    def bprop(x, indices, v, out, dout):
-        return zeros_like(x), zeros_like(indices), zeros_like(v)
-
-    return bprop
-
-
-@bprop_getters.register(P.InplaceSub)
-def get_bprop_inplace_sub(self):
-    """Grad definition for `InplaceSub` operation."""
-
-    def bprop(x, input_v, out, dout):
-        return zeros_like(x), zeros_like(input_v)
-
-    return bprop
-
-
-@bprop_getters.register(P.InplaceAdd)
-def get_bprop_inplace_add(self):
-    """Grad definition for `InplaceAdd` operation."""
-
-    def bprop(x, input_v, out, dout):
-        return zeros_like(x), zeros_like(input_v)
-
-    return bprop

mindspore/ops/_grad_experimental/grad_sparse.py

@@ -1,3 +1,18 @@
+# Copyright 2022 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+# ============================================================================
+
 """Define the grad rules of math related operations."""
 
 from mindspore.ops import functional as F

mindspore/ops/_grad_experimental/grad_sparse_ops.py

@@ -358,10 +358,10 @@ def get_bprop_ragged_tensor_to_sparse(self):
                 split.append(zeros_like(i))
             all_d = (split, ragged_values_grad)
             return all_d
-        split = ()
+        split_ = ()
         for i in enumerate(rt_nested_splits):
-            split = split + (zeros_like(i),)
-        all_d = (split, ragged_values_grad)
+            split_ = split_ + (zeros_like(i),)
+        all_d = (split_, ragged_values_grad)
         return all_d
 
     return bprop

mindspore/ops/_op_impl/_custom_op/dsd_back_impl.py

@@ -299,7 +299,7 @@ def dsdbpropimpl(w1_gm, w2_gm, v_gm, a_gm, d_a_gm, d_w1_gm={}, d_w2_gm={}, d_v_g
                                                            global_size // 16, 16, 16),
                                                name='v_global_l0b', scope=tik.scope_cb)
 
-                # d_w_global，小z大n
+                # d_w_global, 小z大n
                 d_w_global_l0c = tik_inst.Tensor('float32', (global_size // 16, head_size // (16 * ub_time), 16, 16),
                                                  name='d_w_global_l0c', scope=tik.scope_cc)
                 d_w_global_ub = tik_inst.Tensor('float16', (global_size // 16,