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

mindspore/ops/_grad_experimental/grad_image_ops.py

@@ -23,12 +23,14 @@ from mindspore.ops import functional as F
 from mindspore.ops.operations import _grad_ops as G
 from mindspore.ops.operations.image_ops import ResizeBicubic
 from mindspore.ops.operations._grad_ops import ResizeBicubicGrad
+from mindspore.ops.operations.image_ops import ResizeV2
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops.operations.image_ops import CropAndResize
 from mindspore.ops.operations.image_ops import CropAndResizeGradImage
 from mindspore.ops.operations.image_ops import CropAndResizeGradBoxes
 from mindspore.ops.operations.image_ops import RGBToHSV
 from mindspore.ops.operations.image_ops import ScaleAndTranslate
+from mindspore import context
 
 
 @bprop_getters.register(ResizeBicubic)
@@ -38,33 +40,49 @@ def get_bprop_resize_bicubic(self):
                                             half_pixel_centers=self.half_pixel_centers)
 
     def bprop(images, size, out, dout):
-        images_type = F.dtype(images)
-        type_list = [mstype.int8, mstype.uint8, mstype.int16, mstype.uint16, mstype.int32,
-                     mstype.int64, mstype.float16]
-        if images_type in type_list:
-            images = F.cast(images, mstype.float64)
         dx = resize_bicubic_grad(dout, images)
         return (dx, P.ZerosLike()(size))
     return bprop
 
 
+@bprop_getters.register(ResizeV2)
+def get_bprop_resize_v2(self):
+    """Grad definition for `ResizeV2` operation."""
+    resize_v2_grad = G.ResizeV2Grad(coordinate_transformation_mode=self.coordinate_transformation_mode,
+                                    mode=self.mode)
+
+    def bprop(x, roi, scales, sizes, out, dout):
+        input_size = P.Shape()(x)
+        dx = resize_v2_grad(dout, roi, scales, Tensor(input_size))
+        return (dx, zeros_like(roi), zeros_like(scales), zeros_like(sizes))
+    return bprop
+
+
 @bprop_getters.register(CropAndResize)
 def get_bprop_crop_and_resize(self):
     """Grad definition for `CropAndResize` operation."""
     allowed_types = [mstype.float16, mstype.float32, mstype.float64]
     gradboxes = CropAndResizeGradBoxes(method="bilinear")
     method_ = self.method
+    dyn_shape = P.TensorShape()
+
+    is_ascend_cpu = context.get_context('device_target') in ("Ascend", "CPU")
 
     def bprop(x, boxes, box_index, crop_size, out, dout):
         if method_ != "bilinear":
-            return (zeros_like(x), zeros_like(boxes), zeros_like(box_index), zeros_like(crop_size))
+            if not is_ascend_cpu:
+                return (zeros_like(x), zeros_like(boxes), zeros_like(box_index), zeros_like(crop_size))
         image_type = x.dtype
         if image_type not in allowed_types:
             x = F.cast(x, mstype.float32)
         dimage_type = image_type
         gradimage = CropAndResizeGradImage(dimage_type, method=method_)
         image_shape = x.shape
-        image_size = Tensor(image_shape, dtype=mstype.int32)
+        if F.is_sequence_value_unknown(image_shape):
+            image_size = dyn_shape(x)
+            image_size = F.cast(image_size, mstype.int32)
+        else:
+            image_size = Tensor(image_shape, dtype=mstype.int32)
         dimage = gradimage(dout, boxes, box_index, image_size)
         dbox = gradboxes(dout, x, boxes, box_index)
         return (dimage, dbox, zeros_like(box_index), zeros_like(crop_size))

mindspore/ops/_grad_experimental/grad_inner_ops.py

@@ -14,7 +14,8 @@
 # ============================================================================
 
 """inner_ops"""
-from mindspore import context
+from __future__ import absolute_import
+
 from mindspore.ops.operations.comm_ops import _VirtualPipelineEnd
 from mindspore.ops._grad.grad_base import bprop_getters
 from mindspore.ops.operations import _inner_ops as inner
@@ -22,7 +23,6 @@ from mindspore.ops.operations import _grad_ops as G
 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.common import dtype as mstype
 
 
 @bprop_getters.register(inner.TensorCopySlices)
@@ -38,27 +38,6 @@ def get_bprop_tensor_copy_slices(self):
     return bprop
 
 
-@bprop_getters.register(inner.Roll)
-def get_bprop_roll(self):
-    """Generate bprop for Roll"""
-    if context.get_context("device_target") == "GPU":
-        shift = []
-        axis = self.axis
-        for tmp in enumerate(self.shift):
-            shift.append(-tmp[1])
-        roll_grad = inner.Roll(shift, axis)
-    else:
-        shift = self.shift
-        axis = self.axis
-        roll_grad = inner.Roll(-shift, axis)
-
-    def bprop(x_input, out, dout):
-        dx = roll_grad(dout)
-        return (dx,)
-
-    return bprop
-
-
 @bprop_getters.register(_VirtualPipelineEnd)
 def get_bprop_virtual_pipeline_end(self):
     """Backpropagator for _VirtualPipelineEnd."""
@@ -78,7 +57,7 @@ def get_bprop_dynamic_resize_nearest_neighbor(self):
     shape_op = P.Shape()
 
     def bprop(inputs, size, out, dout):
-        if -1 in shape_op(inputs):
+        if F.is_sequence_value_unknown(shape_op(inputs)):
             shp = tensor_shape(inputs)
         else:
             shp = shape_op(inputs)
@@ -102,26 +81,6 @@ def get_bprop_parallel_resize_bilinear(self):
     return bprop
 
 
-@bprop_getters.register(inner.FillV2)
-def get_bprop_fill_v2(self):
-    """Generate bprop for FillV2"""
-    sum_op = P.ReduceSum()
-    cast_op = P.Cast()
-
-    def bprop(shape, value, out, dout):
-        dout_type = F.dtype(dout)
-        type_list = [mstype.int8, mstype.int16, mstype.int32, mstype.int64,
-                     mstype.uint8, mstype.uint16, mstype.uint32, mstype.uint64, mstype.float16]
-        if dout_type in type_list:
-            dout = cast_op(dout, mstype.float32)
-        if dout_type == mstype.float64:
-            dout = cast_op(dout, mstype.float32)
-        dvalue = sum_op(dout)
-        return zeros_like(shape), cast_op(dvalue, dout_type)
-
-    return bprop
-
-
 @bprop_getters.register(inner.ConvertToDynamic)
 def get_bprop_gpu_convert_to_dynamic_rank(self):
     """Get backprop for ConvertToDynamic."""

mindspore/ops/_grad_experimental/grad_linalg_ops.py

@@ -14,20 +14,20 @@
 # ============================================================================
 
 """Define the grad rules of linalg related operations."""
-import numpy as np
+from __future__ import absolute_import
+
 import mindspore
 
-from .. import Tensor
-from .. import functional as F
-from .. import operations as P
-from ..composite.multitype_ops.zeros_like_impl import zeros_like
-from ..operations import math_ops as math
-from ..operations import linalg_ops as linalg
-from ..operations import array_ops as arrays
-from ..primitive import constexpr
-from .._grad.grad_base import bprop_getters
-from .._grad.grad_base import dyn_rank
-from .._utils.utils import is_shape_unknown
+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
+from mindspore.ops._grad.grad_base import bprop_getters
+from mindspore.ops._grad.grad_base import dyn_rank
 
 _shape = arrays.Shape()
 _dyn_shape = arrays.TensorShape()
@@ -53,7 +53,7 @@ def _raise_value_error(*info):
 
 def _matrix_transpose(a):
     """Transpose last two axes"""
-    if is_shape_unknown(_shape(a)):
+    if F.is_sequence_value_unknown(_shape(a)):
         dims = dyn_rank(a)
         axes = P.Range()(P.Cast()(0, mindspore.int64), dims, P.Cast()(1, mindspore.int64))
         axes = P.Concat(axis=-1)((axes[:-2], axes[-1:], axes[-2:-1]))
@@ -82,15 +82,10 @@ def _make_tensor(value, dtype):
     return Tensor(value, dtype)
 
 
-@constexpr
-def _make_zero_matrix(shape, dtype):
-    return Tensor(np.zeros(shape), dtype)
-
-
 def _matrix_diag(diagonal):
     """Do matrix diagnoal"""
     diagonal_shape = _shape(diagonal)
-    if is_shape_unknown(diagonal_shape):
+    if F.is_sequence_value_unknown(diagonal_shape):
         diagonal_shape = _dyn_shape(diagonal)
         row = P.Cast()(diagonal_shape[-1], mindspore.int32)
         return arrays.MatrixDiagV3()(diagonal, _k_0, row, row, P.Cast()(0, _dtype(diagonal)))
@@ -102,7 +97,7 @@ def _matrix_diag(diagonal):
 def _mat_mul(x, y):
     """Do matmul"""
     shape = _shape(x)
-    if is_shape_unknown(shape):
+    if F.is_sequence_value_unknown(shape):
         shape = _dyn_shape(x)
         tensor_rank = dyn_rank(x)
     else:
@@ -130,7 +125,7 @@ def get_bprop_svd(self):
             return (da,)
 
         a_shape = _shape(a)
-        if is_shape_unknown(a_shape):
+        if F.is_sequence_value_unknown(a_shape):
             a_shape = _dyn_shape(a)
             tensor_rank = dyn_rank(a)
         else: