mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/ops/_grad/grad_sequence_ops.py

@@ -0,0 +1,296 @@
+# 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.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.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)
+        return (dx, zeros_like(start), zeros_like(stop), zeros_like(step))
+
+    return bprop
+
+
+@bprop_getters.register(seq.SequenceIndex)
+def get_bprop_index(self):
+    """Generate bprop for SequenceIndex"""
+
+    def bprop(x, y, start, end, out, dout):
+        return (zeros_like(x), zeros_like(y), zeros_like(start), zeros_like(end))
+
+    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_lsit_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(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

mindspore/ops/_grad/grad_sparse.py

@@ -14,7 +14,6 @@
 # ============================================================================
 
 """bprop primitives"""
-from mindspore.ops._utils.utils import is_shape_unknown
 from mindspore.ops._grad.grad_base import bprops, bprop_getters
 from mindspore.ops.composite.multitype_ops._constexpr_utils import infer_out_shape
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
@@ -85,6 +84,8 @@ def get_bprop_sparse_tensor_dense_matmul(self):
     adj_s = self.adjoint_st
     adj_d = self.adjoint_dt
     sparse_tensor_dense_mat_mul = P.SparseTensorDenseMatmul(not adj_s)
+    split = P.Split(-1, 2)
+    reduce_sum = P.ReduceSum()
 
     def bprop(indices, values, dense_shape, dense, out, dout):
         dense_grad = sparse_tensor_dense_mat_mul(indices, values, dense_shape, dout)
@@ -96,11 +97,12 @@ def get_bprop_sparse_tensor_dense_matmul(self):
             dense = P.Cast()(dense, mstype.float32)
             dout = P.Cast()(dout, mstype.float32)
             is_half = True
-        rows = indices[:, 0]
-        cols = indices[:, 1]
+        split_indices = split(indices)
+        rows = reduce_sum(split_indices[0], -1)
+        cols = reduce_sum(split_indices[1], -1)
         parts_a = F.gather(dout, cols if adj_s else rows, 0)
         parts_b = F.gather(F.transpose(dense, perm) if adj_d else dense, rows if adj_s else cols, 0)
-        values_grad = F.reduce_sum(parts_a * parts_b, 1)
+        values_grad = F.reduce_sum(parts_a * parts_b, -1)
         if is_half:
             values_grad = P.Cast()(values_grad, mstype.float16)
         return zeros_like(indices), values_grad, zeros_like(dense_shape), dense_grad
@@ -119,7 +121,7 @@ def get_bprop_sparse_add(self):
         dx1, dx2 = sparse_add_grad(dout[1], x1_indices, x2_indices, out[0])
         ret0 = zeros_like(x1_indices)
         shp = shape_op(x1_values)
-        if is_shape_unknown(shp):
+        if F.is_sequence_value_unknown(shp):
             shp = dyn_shape_op(x1_values)
         dx1_shape = shp
         ret1 = reshape(dx1, dx1_shape)
@@ -127,7 +129,7 @@ def get_bprop_sparse_add(self):
 
         ret3 = zeros_like(x2_indices)
         shp = shape_op(x2_values)
-        if is_shape_unknown(shp):
+        if F.is_sequence_value_unknown(shp):
             shp = dyn_shape_op(x2_values)
         dx2_shape = shp
         ret4 = reshape(dx2, dx2_shape)
@@ -220,7 +222,7 @@ def get_bprop_csr_mul(self):
     to index the dense input.
     """
     def bprop(indptr, indices, values, shape, dense, out, dout):
-        csr_tensor_grad_value = F.csr_mul(F.make_csr_tensor(indptr, indices, dout, shape), dense)
+        csr_tensor_grad_value = F.csr_mul(F.make_csr_tensor(indptr, indices, dout, shape), dense).values
         dense_grad_value = F.mul(dout, values)
         dense_grad = F.make_csr_tensor(indptr, indices, dense_grad_value, shape)
         if len(dense.shape) == 1 or dense.shape[0] == 1:
@@ -258,9 +260,11 @@ def get_bprop_csr_div(self):
         shape_y = feature_dim + shape[batch_dim_dense_start:]
         reduce_x, reduce_y = F.broadcast_gradient_args(shape_x, shape_y)
 
-        csr_tensor_grad_value = F.csr_div(F.make_csr_tensor(indptr, indices, dout, shape), dense)
+        csr_tensor_grad = F.csr_div(F.make_csr_tensor(indptr, indices, dout, shape), dense)
         if reduce_x:
-            csr_tensor_grad_value = P.ReduceSum(True)(csr_tensor_grad_value, reduce_x)
+            csr_tensor_grad_value = P.ReduceSum(True)(csr_tensor_grad.values, reduce_x)
+        else:
+            csr_tensor_grad_value = csr_tensor_grad.values
         dense_grad_value = F.neg_tensor(F.mul(out, csr_tensor_grad_value))
         dense_grad = F.make_csr_tensor(indptr, indices, dense_grad_value, shape)
         if len(dense.shape) == 1 or dense.shape[0] == 1:
@@ -281,6 +285,7 @@ def get_bprop_csr_div(self):
 
 @bprop_getters.register(_csr_ops.CSR2COO)
 def get_bprop_csr2coo(self):
+    "Back-propagation for CSR2COO."
     def bprop(indptr, nnz, out, dout):
         return zeros_like(indptr), zeros_like(nnz)
     return bprop
@@ -288,6 +293,7 @@ def get_bprop_csr2coo(self):
 
 @bprop_getters.register(_csr_ops.COO2CSR)
 def get_bprop_coo2csr(self):
+    "Back-propagation for COO2CSR."
     def bprop(row_indices, height, out, dout):
         return zeros_like(row_indices), zeros_like(height)
     return bprop

mindspore/ops/_grad_experimental/__init__.py

@@ -24,5 +24,6 @@ from mindspore.ops._grad_experimental import grad_math_ops
 from mindspore.ops._grad_experimental import grad_linalg_ops
 from mindspore.ops._grad_experimental import grad_sparse
 from mindspore.ops._grad_experimental import grad_sparse_ops
+from mindspore.ops._grad_experimental import grad_scalar_ops
 
 __all__ = ['get_bprop_fn']