mindspore 2.1.0__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/ops/_grad_experimental/grad_linalg_ops.py

@@ -1,181 +0,0 @@
-# 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 linalg related operations."""
-from __future__ import absolute_import
-
-import mindspore
-
-from mindspore.ops import Tensor
-from mindspore.ops import functional as F
-from mindspore.ops import operations as P
-from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
-from mindspore.ops.operations import math_ops as math
-from mindspore.ops.operations import linalg_ops as linalg
-from mindspore.ops.operations import array_ops as arrays
-from mindspore.ops.primitive import constexpr, _primexpr
-from mindspore.ops._grad_experimental.grad_base import bprop_getters
-
-_shape = arrays.Shape()
-
-_dtype = arrays.DType()
-_cast = arrays.Cast()
-_transpose = arrays.Transpose()
-
-_conj = math.Conj()
-_reciprocal = math.Reciprocal()
-
-_k_0 = Tensor(0, mindspore.int32)
-
-
-@_primexpr
-def _check_dim(dim):
-    if dim < 2:
-        raise ValueError(f"The dim can not be less than 2, which is {dim}.")
-
-
-@_primexpr
-def generate_perm_for_matrix_transpose(input_dim):
-    perm = tuple(range(input_dim - 2))
-    perm = perm + (input_dim - 1, input_dim - 2)
-    return perm
-
-
-def _matrix_transpose(a):
-    """Transpose last two axes"""
-    a_shape = _shape(a)
-    if F.is_sequence_value_unknown(a_shape):
-        dim = P.Rank()(a)
-        perm = P.Range()(P.Cast()(0, mindspore.int64), P.Cast()(dim, mindspore.int64), P.Cast()(1, mindspore.int64))
-        perm = P.Concat(axis=-1)((perm[:-2], perm[-1:], perm[-2:-1]))
-    else:
-        dim = P.Rank()(a)
-        _check_dim(dim)
-        perm = generate_perm_for_matrix_transpose(dim)
-    return _transpose(a, perm)
-
-
-def _adjoint(a):
-    return _matrix_transpose(_conj(a))
-
-
-def _safe_reciprocal(x, epsilon=1e-20):
-    return x * _reciprocal(x * x + epsilon)
-
-
-@constexpr
-def _make_tensor(value, dtype):
-    return Tensor(value, dtype)
-
-
-def _matrix_diag(diagonal):
-    """Do matrix diagnoal"""
-    diagonal_shape = _shape(diagonal)
-    if F.is_sequence_value_unknown(diagonal_shape):
-        row = P.Cast()(diagonal_shape[-1], mindspore.int32)
-        return arrays.MatrixDiagV3()(diagonal, _k_0, row, row, P.Cast()(0, _dtype(diagonal)))
-
-    row = _make_tensor(diagonal_shape[-1], mindspore.int32)
-    return arrays.MatrixDiagV3()(diagonal, _k_0, row, row, _make_tensor(0, _dtype(diagonal)))
-
-
-def _mat_mul(x, y):
-    """Do matmul"""
-    tensor_rank = P.Rank()(x)
-    if tensor_rank > 2:
-        return math.BatchMatMul()(x, y)
-    return math.MatMul()(x, y)
-
-
-@bprop_getters.register(linalg.Svd)
-def get_bprop_svd(self):
-    """Generate bprop for Svd"""
-    full_matrices = self.full_matrices
-    compute_uv = self.compute_uv
-
-    svd = linalg.Svd(compute_uv=True)
-    square = math.Square()
-    matrix_set_diag = arrays.MatrixSetDiagV3()
-    expand_dims = arrays.ExpandDims()
-
-    def bprop(a, out, dout):
-        if not compute_uv:
-            s, u, v = svd(a)
-            da = _mat_mul(u, _mat_mul(_matrix_diag(dout[0]), _adjoint(v)))
-            return (da,)
-
-        a_shape = _shape(a)
-        tensor_rank = P.Rank()(a)
-        _check_dim(tensor_rank)
-        m = a_shape[-2]
-        n = a_shape[-1]
-        s, u, v = out
-        ds, du, dv = dout
-        use_adjoint = False
-        if m > n:
-            use_adjoint = True
-            m, n = n, m
-            u, v = v, u
-            du, dv = dv, du
-
-        if full_matrices and abs(m - n) > 1:
-            raise ValueError("For 'Svd' gradient, not support for abs(m - n) > 1 with full_matrices is True.")
-
-        s_mat = _matrix_diag(s)
-        s2 = square(s)
-
-        f = matrix_set_diag(_safe_reciprocal(expand_dims(s2, -2) - expand_dims(s2, -1)), zeros_like(s), _k_0)
-        s_inv_mat = _matrix_diag(_safe_reciprocal(s))
-
-        v1 = v[..., :, :m]
-        dv1 = dv[..., :, :m]
-
-        u_gu = _mat_mul(_adjoint(u), du)
-        v_gv = _mat_mul(_adjoint(v1), dv1)
-
-        f_u = f * u_gu
-        f_v = f * v_gv
-        ds_mat = _matrix_diag(_cast(ds, _dtype(a)))
-        term1_nouv = (ds_mat + _mat_mul(f_u + _adjoint(f_u), s_mat) + _mat_mul(s_mat, f_v + _adjoint(f_v)))
-
-        term1 = _mat_mul(u, _mat_mul(term1_nouv, _adjoint(v1)))
-
-        if m == n:
-            da_before_transpose = term1
-        else:
-            gv1t = _matrix_transpose(dv1)
-            gv1t_v1 = _mat_mul(gv1t, v1)
-            term2_nous = gv1t - _mat_mul(gv1t_v1, _adjoint(v1))
-
-            if full_matrices:
-                v2 = v[..., :, m:n]
-                d_v2 = dv[..., :, m:n]
-
-                v1t_gv2 = _mat_mul(_adjoint(v1), d_v2)
-                term2_nous -= _mat_mul(v1t_gv2, _adjoint(v2))
-
-            u_s_inv = _mat_mul(u, s_inv_mat)
-            term2 = _mat_mul(u_s_inv, term2_nous)
-
-            da_before_transpose = term1 + term2
-
-        if use_adjoint:
-            da = _matrix_transpose(da_before_transpose)
-        else:
-            da = da_before_transpose
-
-        return (da,)
-
-    return bprop

mindspore/ops/_grad_experimental/grad_other_ops.py

@@ -1,72 +0,0 @@
-# Copyright 2020-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.
-# ============================================================================
-
-"""Generate bprop for other ops"""
-
-from mindspore.ops import operations as P
-from mindspore.ops.operations import _grad_ops as G
-from mindspore.ops.operations import _inner_ops as inner
-from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
-from mindspore.ops._grad_experimental.grad_base import bprop_getters
-
-# Unused parameters are placeholders.
-
-
-@bprop_getters.register(P.InvertPermutation)
-def get_bprop_invert_permutation(self):
-    """Generate bprop for InvertPermutation"""
-
-    def bprop(x, out, dout):
-        return (zeros_like(x),)
-    return bprop
-
-
-@bprop_getters.register(inner.SyncBatchNorm)
-def get_bprop_sync_batch_norm(self):
-    """Grad definition for `SyncBatchNorm` operation."""
-    input_grad = G.SyncBatchNormGrad(self.epsilon, self.group, self.device_num)
-
-    def bprop(x, scale, b, mean, variance, out, dout):
-        saved_mean = out[3]
-        saved_variance = out[4]
-        out = input_grad(dout[0], x, scale, saved_mean, saved_variance)
-        dx = out[0]
-        dscale = out[1]
-        dbias = out[2]
-        res = (dx, dscale, dbias, zeros_like(mean), zeros_like(variance))
-        return res
-    return bprop
-
-
-@bprop_getters.register(inner.GpuConvertToDynamicShape)
-def get_bprop_gpu_convert_to_dynamic_shape(self):
-    """Get backprop for GpuConvertToDynamicShape."""
-
-    def bprop(x, out, dout):
-        return (dout,)
-    return bprop
-
-
-@bprop_getters.register(P._DynamicLossScale) # pylint: disable=W0212
-def get_bprop_dynamic_loss_scale(self):
-    """Get backprop for dynamic_loss_scale."""
-    mul = P.Mul()
-    mul.add_prim_attr('split_overflow', True)
-    mul.add_prim_attr('layer_overflow', self.layer)
-
-    def bprop(x, loss_scale, out, dout):
-        res = mul(dout, loss_scale)
-        return res, zeros_like(loss_scale)
-    return bprop

mindspore/ops/_grad_experimental/grad_scalar_ops.py

@@ -1,112 +0,0 @@
-# Copyright 2023 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.
-# ============================================================================
-
-"""Generate bprop for quantization aware ops"""
-
-from mindspore.ops.operations import _scalar_ops
-from mindspore.ops._grad_experimental.grad_base import bprop_getters
-from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
-
-
-@bprop_getters.register(_scalar_ops.ScalarAdd)
-def get_bprop_scalar_add(self):
-    """Grad definition for `ScalarAdd` operation."""
-
-    def bprop(x, y, out, dout):
-        return dout, dout
-
-    return bprop
-
-
-@bprop_getters.register(_scalar_ops.ScalarSub)
-def get_bprop_scalar_sub(self):
-    """Grad definition for `ScalarSub` operation."""
-
-    def bprop(x, y, out, dout):
-        return dout, 0 - dout
-
-    return bprop
-
-
-@bprop_getters.register(_scalar_ops.ScalarMul)
-def get_bprop_scalar_mul(self):
-    """Grad definition for `ScalarMul` operation."""
-
-    def bprop(x, y, out, dout):
-        bc_dx = y * dout
-        bc_dy = x * dout
-        return bc_dx, bc_dy
-
-    return bprop
-
-
-@bprop_getters.register(_scalar_ops.ScalarDiv)
-def get_bprop_scalar_div(self):
-    """Grad definition for `ScalarDiv` operation."""
-
-    def bprop(x, y, out, dout):
-        bc_dx = dout / y
-        bc_dy = 0 - bc_dx * out
-        return bc_dx, bc_dy
-
-    return bprop
-
-
-@bprop_getters.register(_scalar_ops.ScalarFloordiv)
-def get_bprop_scalar_floordiv(self):
-    """Grad definition for `ScalarFloorDiv` operation."""
-
-    def bprop(x, y, out, dout):
-        return zeros_like(x), zeros_like(y)
-
-    return bprop
-
-
-@bprop_getters.register(_scalar_ops.ScalarMod)
-def get_bprop_scalar_mod(self):
-    """Grad definition for `ScalarMod` operation."""
-
-    def bprop(x, y, out, dout):
-        bc_dx = dout
-        bc_dy = -dout * (x // y)
-        return bc_dx, bc_dy
-
-    return bprop
-
-
-@bprop_getters.register(_scalar_ops.scalar_eq)
-@bprop_getters.register(_scalar_ops.scalar_le)
-@bprop_getters.register(_scalar_ops.scalar_lt)
-@bprop_getters.register(_scalar_ops.scalar_ge)
-@bprop_getters.register(_scalar_ops.scalar_gt)
-@bprop_getters.register(_scalar_ops.bit_and)
-@bprop_getters.register(_scalar_ops.bit_or)
-def get_bprop_scalar_logic(self):
-    """Grad definition for `ScalarLogicOps` operation."""
-
-    def bprop(x, y, out, dout):
-        return zeros_like(x), zeros_like(y)
-
-    return bprop
-
-
-@bprop_getters.register(_scalar_ops.ScalarBool)
-def get_bprop_scalar_bool(self):
-    """Grad definition for `ScalarBool` operation."""
-
-    def bprop(x, out, dout):
-        return zeros_like(x)
-
-    return bprop

mindspore/ops/_grad_experimental/grad_sequence_ops.py

@@ -1,351 +0,0 @@
-# Copyright 2023 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.
-# ============================================================================
-
-"""grad_sequence_ops"""
-
-from mindspore.ops.operations import _sequence_ops as seq
-from mindspore.ops import operations as P
-from mindspore.ops import functional as F
-from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
-from mindspore.ops._grad_experimental.grad_base import bprop_getters
-from mindspore.ops.primitive import Primitive
-
-
-tuple_setitem = Primitive("tuple_setitem")
-list_setitem = Primitive("list_setitem")
-
-
-@bprop_getters.register(seq.SequenceCount)
-def get_bprop_count(self):
-    """Generate bprop for SequenceCount"""
-
-    def bprop(x, y, out, dout):
-        return (zeros_like(x), zeros_like(y))
-
-    return bprop
-
-
-@bprop_getters.register(seq.sequence_len)
-def get_bprop_sequence_len(self):
-    """Generate bprop for sequence_len"""
-    def bprop(x, out, dout):
-        return (zeros_like(x),)
-
-    return bprop
-
-
-@bprop_getters.register(seq.SequenceAdd)
-def get_bprop_sequence_add(self):
-    """Generate bprop for SequenceAdd"""
-    def bprop(x, y, out, dout):
-        out_offset = seq.SequenceAddOffset()(x, y)
-        dx = seq.SequenceSlice()(dout, out_offset[0], len(x), 1)
-        dy = seq.SequenceSlice()(dout, out_offset[1], len(x) + len(y), 1)
-
-        return (dx, dy)
-
-    return bprop
-
-
-@bprop_getters.register(seq.SequenceUnstack)
-def get_bprop_sequence_unstack(self):
-    """Generate bprop for SequenceUnstack"""
-    axis = self.axis
-
-    def bprop(x, out, dout):
-        seq_unstack_grad = seq.SequenceStack(axis)
-        out = seq_unstack_grad(dout)
-        return (out,)
-
-    return bprop
-
-
-@bprop_getters.register(seq.SequenceSlice)
-def get_bprop_slice(self):
-    """Generate bprop for SequenceSlice"""
-
-    def bprop(x, start, stop, step, out, dout):
-        dx = seq.SequenceSliceGrad()(dout, x, start, stop, step)
-        res = (dx, zeros_like(start), zeros_like(stop), zeros_like(step))
-        return res
-
-    return bprop
-
-
-@bprop_getters.register(seq.SequenceIndex)
-def get_bprop_index(self):
-    """Generate bprop for SequenceIndex"""
-
-    def bprop(x, y, start, end, out, dout):
-        res = (zeros_like(x), zeros_like(y), zeros_like(start), zeros_like(end))
-        return res
-
-    return bprop
-
-
-@bprop_getters.register(seq.InSequence)
-def get_bprop_insequence(self):
-    """Generate bprop for InSequence"""
-
-    def bprop(x, y, out, dout):
-        return (zeros_like(x), seq.SequenceZerosLike()(y))
-
-    return bprop
-
-
-@bprop_getters.register("tuple_equal")
-@bprop_getters.register("list_equal")
-def get_bprop_seq_equal(self):
-    """Generate bprop for tuple_equal and list_equal"""
-
-    def bprop(x, y, out, dout):
-        return (zeros_like(x), zeros_like(y))
-
-    return bprop
-
-
-@bprop_getters.register("shape_mul")
-def get_bprop_shape_mul(self):
-    """Generate bprop for tuple_equal and list_equal"""
-
-    def bprop(x, out, dout):
-        dx = seq.ShapeMulGrad()(x, dout)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register("tuple_setitem")
-def get_bprop_tuple_setitem(self):
-    """Generate bprop for TupleSetItem and ListSetItem"""
-
-    def bprop(x, idx, value, out, dout):
-        d_x = tuple_setitem(dout, idx, zeros_like(value))
-        d_value = dout[idx]
-        d_idx = 0
-        return (d_x, zeros_like(d_idx), d_value)
-
-    return bprop
-
-
-@bprop_getters.register("list_setitem")
-def get_bprop_list_setitem(self):
-    """Generate bprop for TupleSetItem and ListSetItem"""
-
-    def bprop(x, idx, value, out, dout):
-        d_x = list_setitem(dout, idx, zeros_like(value))
-        d_value = dout[idx]
-        d_idx = 0
-        return (d_x, zeros_like(d_idx), d_value)
-
-    return bprop
-
-
-@bprop_getters.register("ListInplaceReverse")
-def get_bprop_list_inplace_reverse(self):
-    """Generate bprop for list inplace reverse"""
-
-    def bprop(x, out, dout):
-        return (zeros_like(x),)
-
-    return bprop
-
-
-@bprop_getters.register("ListInplaceExtend")
-def get_bprop_list_inplace_extend(self):
-    """Generate bprop for list inplace extend"""
-
-    def bprop(x, y, out, dout):
-        return (zeros_like(x), zeros_like(y))
-
-    return bprop
-
-
-@bprop_getters.register("ListInplaceInsert")
-def get_bprop_list_inplace_insert(self):
-    """Generate bprop for list inplace insert"""
-
-    def bprop(x, index, target, out, dout):
-        return (zeros_like(x), zeros_like(index), zeros_like(target))
-
-    return bprop
-
-
-@bprop_getters.register("ListInplacePop")
-def get_bprop_list_inplace_pop(self):
-    """Generate bprop for list inplace pop"""
-
-    def bprop(x, index, out, dout):
-        return (zeros_like(x), zeros_like(index))
-
-    return bprop
-
-
-@bprop_getters.register(seq.ListAppend)
-def get_bprop_list_append(self):
-    """Generate bprop for ListAppend"""
-
-    def bprop(x, value, out, dout):
-        d_x = seq.ListAppendAndInsertGrad()(dout, -1)
-        return (d_x, zeros_like(value))
-
-    return bprop
-
-
-@bprop_getters.register(seq.ListInsert)
-def get_bprop_list_insert(self):
-    """Generate bprop for ListInsert"""
-
-    def bprop(x, idx, value, out, dout):
-        d_x = seq.ListAppendAndInsertGrad()(dout, idx)
-        return (d_x, zeros_like(idx), zeros_like(value))
-
-    return bprop
-
-
-@bprop_getters.register(seq.TupleToTensor)
-def get_bprop_tuple_to_tensor(self):
-    """Generate bprop for TupleToTensor"""
-
-    def bprop(x, dtype, out, dout):
-        tuple_type = F.typeof(x)
-        dout = P.Cast()(dout, tuple_type)
-        d_x = seq.TensorToTuple()(dout)
-        return (d_x, zeros_like(dtype))
-
-    return bprop
-
-
-@bprop_getters.register(seq.ListToTensor)
-def get_bprop_list_to_tensor(self):
-    """Generate bprop for ListToTensor"""
-
-    def bprop(x, dtype, out, dout):
-        tuple_type = F.typeof(x)
-        dout = P.Cast()(dout, tuple_type)
-        d_x = seq.TensorToList()(dout)
-        return (d_x, zeros_like(dtype))
-
-    return bprop
-
-
-@bprop_getters.register(P.ScalarToTensor)
-def get_bprop_scalar_to_tensor(self):
-    """Generate bprop for ScalarToTensor"""
-
-    def bprop(x, dtype, out, dout):
-        scalar_type = F.typeof(x)
-        dout = P.Cast()(dout, scalar_type)
-        d_x = seq.TensorToScalar()(dout)
-        return (d_x, zeros_like(dtype))
-
-    return bprop
-
-
-@bprop_getters.register(seq.TensorToTuple)
-def get_bprop_tensor_to_tuple(self):
-    """Generate bprop for TensorToTuple"""
-
-    def bprop(x, out, dout):
-        dtype = F.typeof(x)
-        d_x = seq.TupleToTensor()(dout, dtype)
-        return (d_x,)
-
-    return bprop
-
-
-@bprop_getters.register(seq.TensorToList)
-def get_bprop_tensor_to_list(self):
-    """Generate bprop for TensorToList"""
-
-    def bprop(x, out, dout):
-        dtype = F.typeof(x)
-        d_x = seq.ListToTensor()(dout, dtype)
-        return (d_x,)
-
-    return bprop
-
-
-@bprop_getters.register(seq.TensorToScalar)
-def get_bprop_tensor_to_scalar(self):
-    """Generate bprop for TensorToScalar"""
-
-    def bprop(x, out, dout):
-        dtype = F.typeof(x)
-        d_x = P.ScalarToTensor()(dout, dtype)
-        return (d_x,)
-
-    return bprop
-
-
-@bprop_getters.register("tuple_le")
-@bprop_getters.register("tuple_lt")
-@bprop_getters.register("list_le")
-@bprop_getters.register("list_lt")
-def get_bprop_less(self):
-    """Generate bprop for SequenceLessThan and SequenceLessEqual"""
-
-    def bprop(x, y, out, dout):
-        return (zeros_like(x), zeros_like(y))
-
-    return bprop
-
-
-@bprop_getters.register(seq.SequenceMul)
-def get_bprop_mul(self):
-    """Generate bprop for SequenceMul"""
-
-    def bprop(x, y, out, dout):
-        dx = x
-        if isinstance(x, tuple):
-            for i in range(len(x)):
-                dx = tuple_setitem(dx, i, dout[i])
-        else:
-            for i in range(len(x)):
-                dx = list_setitem(dx, i, dout[i])
-        return (dx, zeros_like(y))
-
-    return bprop
-
-
-@bprop_getters.register(seq.SequenceMin)
-@bprop_getters.register(seq.SequenceMax)
-def get_bprop_max_min(self):
-    """Generate bprop for SequenceMax and SequenceMax"""
-
-    def bprop(x, out, dout):
-        index = x.index(out)
-        if isinstance(x, tuple):
-            dx = tuple_setitem(zeros_like(x), index, dout)
-        else:
-            dx = list_setitem(zeros_like(x), index, dout)
-        return (dx,)
-
-    return bprop
-
-
-@bprop_getters.register("tuple_greater_than")
-@bprop_getters.register("list_greater_than")
-@bprop_getters.register("tuple_greater_equal")
-@bprop_getters.register("list_greater_equal")
-def get_bprop_greater(self):
-    """Generate bprop for tuple_greater_than, list_greater_than,
-    tuple_greater_equal, list_greater_equal.
-    """
-
-    def bprop(x, y, out, dout):
-        return (zeros_like(x), zeros_like(y))
-
-    return bprop