mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/ops/_grad_experimental/grad_image_ops.py

@@ -1,249 +0,0 @@
-# Copyright 2021-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.
-# ============================================================================
-
-"""image_ops"""
-
-from mindspore import Tensor
-from mindspore.common import dtype as mstype
-from mindspore.ops._grad.grad_base import bprop_getters
-from mindspore.ops import operations as P
-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)
-def get_bprop_resize_bicubic(self):
-    """Grad definition for `ResizeBicubic` operation."""
-    resize_bicubic_grad = ResizeBicubicGrad(align_corners=self.align_corners,
-                                            half_pixel_centers=self.half_pixel_centers)
-
-    def bprop(images, size, out, dout):
-        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":
-            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
-        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))
-    return bprop
-
-
-def crcp(x):
-    """Grad definition for `RGBToHSV` operations."""
-    return P.DivNoNan()(1, x)
-
-
-def function1_rgbtohsv(images, out, dout):
-    """Grad definition for `RGBToHSV` operations."""
-    dout = P.Cast()(dout, mstype.float32)
-    images = P.Cast()(images, mstype.float32)
-    out = P.Cast()(out, mstype.float32)
-    return images, out, dout
-
-
-def function2_rgbtohsv(images):
-    """Grad definition for `RGBToHSV` operations."""
-    # Input Channels
-    reds = images[..., 0]
-    greens = images[..., 1]
-    blues = images[..., 2]
-    return reds, greens, blues
-
-
-def function3_rgbtohsv(out, reds):
-    """Grad definition for `RGBToHSV` operations."""
-    # Output Channels
-    saturation = out[..., 1]
-    value = out[..., 2]
-    dsr1 = P.Cast()(reds > 0, mstype.float32)
-    return dsr1, saturation, value
-
-
-def function4_rgbtohsv(reds, greens, blues):
-    """Grad definition for `RGBToHSV` operations."""
-    r_b = P.LogicalAnd()((reds >= blues), (reds >= greens))
-    red_biggest = P.Cast()(r_b, mstype.float32)
-    g_b = P.LogicalAnd()((greens > reds), (greens >= blues))
-    green_biggest = P.Cast()(g_b, mstype.float32)
-    b_b = P.LogicalAnd()((blues > reds), (blues > greens))
-    blue_biggest = P.Cast()(b_b, mstype.float32)
-    return red_biggest, green_biggest, blue_biggest
-
-
-def function5_rgbtohsv(reds, greens, blues):
-    """Grad definition for `RGBToHSV` operations."""
-    r_s = P.LogicalAnd()((reds < blues), (reds < greens))
-    red_smallest = P.Cast()(r_s, mstype.float32)
-    g_s = P.LogicalAnd()((greens <= reds), (greens < blues))
-    green_smallest = P.Cast()(g_s, mstype.float32)
-    b_s = P.LogicalAnd()((blues <= reds), (blues <= greens))
-    blue_smallest = P.Cast()(b_s, mstype.float32)
-    return red_smallest, green_smallest, blue_smallest
-
-
-def function6_rgbtohsv(red_biggest, green_biggest, blue_biggest):
-    """Grad definition for `RGBToHSV` operations."""
-    dv_dr = red_biggest
-    dv_dg = green_biggest
-    dv_db = blue_biggest
-    return dv_dr, dv_dg, dv_db
-
-
-def function7_rgbtohsv(greens, green_biggest, dhb5, dh_db_1, dh_db_2, dh_db_3, dh_db_4,\
-              dout, dv_dr, dv_dg, dv_db, ds_dr, ds_dg, ds_db, dh_dr, dh_dg):
-    """Grad definition for `RGBToHSV` operations."""
-    dh_db_5 = 60 * (P.Cast()((greens > 0), mstype.float32) * green_biggest * dhb5)
-
-    dh_db = dh_db_1 + dh_db_2 + dh_db_3 + dh_db_4 + dh_db_5
-
-    dh_db = dh_db / 360
-
-    dv_drgb = P.Stack(-1)(
-        [dout[..., 2] * dv_dr, dout[..., 2] * dv_dg, dout[..., 2] * dv_db])
-    ds_drgb = P.Stack(-1)(
-        [dout[..., 1] * ds_dr, dout[..., 1] * ds_dg, dout[..., 1] * ds_db])
-    dh_drgb = P.Stack(-1)(
-        [dout[..., 0] * dh_dr, dout[..., 0] * dh_dg, dout[..., 0] * dh_db])
-    dvds_drgb = P.Add()(dv_drgb, ds_drgb)
-    doutient_input = P.Add()(dvds_drgb, dh_drgb)
-    return (doutient_input,)
-
-
-@bprop_getters.register(RGBToHSV)
-def get_bprop_rgb_to_hsv(self):
-    """dout definition for 'RGBToHSV' operation"""
-
-    def bprop(images, out, dout):
-        images, out, dout = function1_rgbtohsv(images, out, dout)
-        reds, greens, blues = function2_rgbtohsv(images)
-        dsr1, saturation, value = function3_rgbtohsv(out, reds)
-        red_biggest, green_biggest, blue_biggest = function4_rgbtohsv(reds, greens, blues)
-        red_smallest, green_smallest, blue_smallest = function5_rgbtohsv(reds, greens, blues)
-        dv_dr, dv_dg, dv_db = function6_rgbtohsv(red_biggest, green_biggest, blue_biggest)
-        dsr2 = red_biggest * P.Add()(green_smallest * greens, blue_smallest * blues) * crcp(P.Square()(reds))
-        dsr3 = red_smallest * -1 * crcp((green_biggest * greens) + (blue_biggest * blues))
-        ds_dr = dsr1 * P.Add()(dsr2, dsr3)
-        dsg1 = P.Cast()((greens > 0), mstype.float32)
-        dsg2 = green_biggest * P.Add()(red_smallest * reds, blue_smallest * blues) * crcp(P.Square()(greens))
-        dsg3 = green_smallest * -1 * crcp((red_biggest * reds) + (blue_biggest * blues))
-        ds_dg = dsg1 * P.Add()(dsg2, dsg3)
-
-        dsb1 = P.Cast()((blues > 0), mstype.float32)
-        dsb2 = blue_biggest * P.Add()(green_smallest * greens, red_smallest * reds) * crcp(P.Square()(blues))
-        dsb3 = blue_smallest * -1 * crcp((green_biggest * greens) + (red_biggest * reds))
-        ds_db = dsb1 * P.Add()(dsb2, dsb3)
-
-        dhr1 = (greens - blues) * crcp(P.Square()(saturation)) * crcp(P.Square()(value))
-        dh_dr_1 = 60 * (P.Cast()((reds > 0), mstype.float32) * red_biggest * -1 * dhr1)
-        dhr2 = red_smallest * (blues - greens) * crcp(P.Square()(reds - greens))
-        dh_dr_2 = 60 * (P.Cast()((greens > 0), mstype.float32) * green_biggest * dhr2)
-        dhr3 = blue_smallest * -1 * crcp(greens - blues)
-        dh_dr_3 = 60 * (P.Cast()((greens > 0), mstype.float32) * green_biggest * dhr3)
-        dhr4 = red_smallest * (blues - greens) * crcp(P.Square()(blues - reds))
-        dh_dr_4 = 60 * (P.Cast()((blues > 0), mstype.float32) * blue_biggest * dhr4)
-        dhr5 = green_smallest * crcp(blues - greens)
-        dh_dr_5 = 60 * (P.Cast()((blues > 0), mstype.float32) * blue_biggest * dhr5)
-
-        dh_dr = (dh_dr_1 + dh_dr_2 + dh_dr_3 + dh_dr_4 + dh_dr_5) / 360
-
-        dhg1 = (blues - reds) * crcp(P.Square()(saturation)) * crcp(P.Square()(value))
-        dh_dg_1 = 60 * (P.Cast()((greens > 0), mstype.float32) * green_biggest * -1 * dhg1)
-        dhg2 = green_smallest * (reds - blues) * crcp(P.Square()(reds - greens))
-        dh_dg_2 = 60 * (P.Cast()((reds > 0), mstype.float32) * red_biggest * dhg2)
-        dhg3 = blue_smallest * crcp(reds - blues)
-        dh_dg_3 = 60 * (P.Cast()((reds > 0), mstype.float32) * red_biggest * dhg3)
-        dhg4 = green_smallest * (reds - blues) * crcp(P.Square()(blues - greens))
-        dh_dg_4 = 60 * (P.Cast()((blues > 0), mstype.float32) * blue_biggest * dhg4)
-        dhg5 = red_smallest * -1 * crcp(blues - reds)
-        dh_dg_5 = 60 * (P.Cast()((blues > 0), mstype.float32) * blue_biggest * dhg5)
-
-        dh_dg = (dh_dg_1 + dh_dg_2 + dh_dg_3 + dh_dg_4 + dh_dg_5) / 360
-
-        dhb1 = (reds - greens) * crcp(P.Square()(saturation)) * crcp(P.Square()(value))
-        dh_db_1 = 60 * (P.Cast()((blues > 0), mstype.float32) * blue_biggest * -1 * dhb1)
-        dhb2 = blue_smallest * (greens - reds) * crcp(P.Square()(reds - blues))
-        dh_db_2 = 60 * (P.Cast()((reds > 0), mstype.float32) * red_biggest * dhb2)
-        dhb3 = green_smallest * -1 * crcp(reds - greens)
-        dh_db_3 = 60 * (P.Cast()((reds > 0), mstype.float32) * red_biggest * dhb3)
-        dhb4 = blue_smallest * (greens - reds) * crcp(P.Square()(greens - blues))
-        dh_db_4 = 60 * (P.Cast()((greens > 0), mstype.float32) * green_biggest * dhb4)
-        dhb5 = red_smallest * crcp(greens - reds)
-        return function7_rgbtohsv(greens, green_biggest, dhb5, dh_db_1, dh_db_2, dh_db_3,\
-                         dh_db_4, dout, dv_dr, dv_dg, dv_db, ds_dr, ds_dg, ds_db, dh_dr, dh_dg)
-    return bprop
-
-
-@bprop_getters.register(ScaleAndTranslate)
-def get_bprop_scale_and_translate(self):
-    """Grad definition for `ScaleAndTranslate` operation"""
-    scale_and_translate_grad = G.ScaleAndTranslateGrad(self.kernel_type, self.antialias)
-
-    def bprop(images, size, scale, translation, out, dout):
-        images_fp32 = F.cast(images, mstype.float32)
-        grad0_fp32 = scale_and_translate_grad(dout, images_fp32, scale, translation)
-        grad0 = F.cast(grad0_fp32, F.dtype(images))
-        result = (grad0, F.zeros_like(size), F.zeros_like(scale), F.zeros_like(translation))
-        return result
-
-    return bprop

mindspore/ops/_grad_experimental/grad_linalg_ops.py

@@ -1,195 +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
-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()
-
-_dtype = arrays.DType()
-_cast = arrays.Cast()
-_transpose = arrays.Transpose()
-
-_conj = math.Conj()
-_reciprocal = math.Reciprocal()
-
-_k_0 = Tensor(0, mindspore.int32)
-_padding_0 = Tensor(0, mindspore.int32)
-
-
-@constexpr
-def _raise_value_error(*info):
-    info_str = ""
-    for obj in info:
-        info_str = info_str + f"{obj}"
-    raise ValueError(info_str)
-
-
-def _matrix_transpose(a):
-    """Transpose last two axes"""
-    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]))
-    else:
-        dims = a.ndim
-        if dims < 2:
-            _raise_value_error(
-                "To do _matrix_transpose for input a's ndim is not greater or equal to 2, which is invalid: {}."
-                .format(dims))
-        axes = F.make_range(0, dims)
-        axes = axes[:-2] + (axes[-1],) + (axes[-2],)
-    return _transpose(a, axes)
-
-
-def _adjoint(a):
-    return _matrix_transpose(_conj(a))
-
-
-def _safe_reciprocal(x, epsilon=1e-20):
-    # Reciprocal do not support float64, force to float32
-    return x * _reciprocal(_cast(x * x + epsilon, mindspore.float32))
-
-
-@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):
-        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)))
-
-    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"""
-    shape = _shape(x)
-    if F.is_sequence_value_unknown(shape):
-        shape = _dyn_shape(x)
-        tensor_rank = dyn_rank(x)
-    else:
-        tensor_rank = len(shape)
-    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(_cast(dout[0], _dtype(a))), _adjoint(v)))
-            return (da,)
-
-        a_shape = _shape(a)
-        if F.is_sequence_value_unknown(a_shape):
-            a_shape = _dyn_shape(a)
-            tensor_rank = dyn_rank(a)
-        else:
-            tensor_rank = len(a_shape)
-        if tensor_rank < 2:
-            _raise_value_error(
-                "For input a's ndim is not greater or equal to 2, which is invalid.")
-        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_value_error("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_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.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/bprop_mindir/ApproximateEqual_bprop.mindir

@@ -1,19 +0,0 @@
-
-0.1.1	MindSpore*2.0.0:�
-�
.get_bprop_approximate_equal.1184:[CNode]1185:1.get_bprop_approximate_equal.1184:[CNode]1185:1"REF::bprop.1186:Default/bprop.1186-op927 get_bprop_approximate_equal.1184*'
-%get_bprop_approximate_equal.1184:self*$
-"get_bprop_approximate_equal.1184:x*$
-"get_bprop_approximate_equal.1184:y*&
-$get_bprop_approximate_equal.1184:out*'
-%get_bprop_approximate_equal.1184:dout20
-.get_bprop_approximate_equal.1184:[CNode]1185:1:@7fb54a66e55c2c40cd92783044880b792666a0d7fc794bb717bee3544337d6a0J/grad_math_ops.pyB�
-�

-"get_bprop_approximate_equal.1184:xbprop.1186:[CNode]1187:2bprop.1186:[CNode]1187:2".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:/Default/S-Prim-hyper_map[zeros_like_leaf]-op928
-�

-"get_bprop_approximate_equal.1184:ybprop.1186:[CNode]1188:3bprop.1186:[CNode]1188:3".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:/Default/S-Prim-hyper_map[zeros_like_leaf]-op929
-�

-bprop.1186:[CNode]1187:2
-bprop.1186:[CNode]1188:3bprop.1186:[CNode]1189:4bprop.1186:[CNode]1189:4"REF::S-Prim-MakeTuple:5:Default/S-Prim-MakeTuple-op930
-bprop.11862
-bprop.1186:[CNode]1189:4P
b&
-S-Prim-MakeTuple:5S-Prim-MakeTupleh

mindspore/ops/bprop_mindir/Argmax_bprop.mindir

@@ -1,15 +0,0 @@
-
-0.1.1	MindSpore*2.0.0:�
-u#get_bprop_argmax.1027:[CNode]1028:1#get_bprop_argmax.1027:[CNode]1028:1"REF::bprop.1029:Default/bprop.1029-op820get_bprop_argmax.1027*
-get_bprop_argmax.1027:self*
-get_bprop_argmax.1027:x*
-get_bprop_argmax.1027:out*
-get_bprop_argmax.1027:dout2%
-#get_bprop_argmax.1027:[CNode]1028:1:@c1bdaf52c4157e91a81b3f089baa28644b7ead8d17fa1975f3935bbc42cce80dJ/grad_array_ops.pyB�
-�

-get_bprop_argmax.1027:xbprop.1029:[CNode]1030:2bprop.1029:[CNode]1030:2".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:/Default/S-Prim-hyper_map[zeros_like_leaf]-op821
-�

-bprop.1029:[CNode]1030:2bprop.1029:[CNode]1031:3bprop.1029:[CNode]1031:3"REF::S-Prim-MakeTuple:4:Default/S-Prim-MakeTuple-op822
-bprop.10292
-bprop.1029:[CNode]1031:3P
b&
-S-Prim-MakeTuple:4S-Prim-MakeTupleh

mindspore/ops/bprop_mindir/Argmin_bprop.mindir

@@ -1,15 +0,0 @@
-
-0.1.1	MindSpore*2.0.0:�
-u#get_bprop_argmin.1032:[CNode]1033:1#get_bprop_argmin.1032:[CNode]1033:1"REF::bprop.1034:Default/bprop.1034-op823get_bprop_argmin.1032*
-get_bprop_argmin.1032:self*
-get_bprop_argmin.1032:x*
-get_bprop_argmin.1032:out*
-get_bprop_argmin.1032:dout2%
-#get_bprop_argmin.1032:[CNode]1033:1:@b37297e673329c499b5e17579a1d7071e4ddafbea9657a7714cda32d19c7e42dJ/grad_array_ops.pyB�
-�

-get_bprop_argmin.1032:xbprop.1034:[CNode]1035:2bprop.1034:[CNode]1035:2".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:/Default/S-Prim-hyper_map[zeros_like_leaf]-op824
-�

-bprop.1034:[CNode]1035:2bprop.1034:[CNode]1036:3bprop.1034:[CNode]1036:3"REF::S-Prim-MakeTuple:4:Default/S-Prim-MakeTuple-op825
-bprop.10342
-bprop.1034:[CNode]1036:3P
b&
-S-Prim-MakeTuple:4S-Prim-MakeTupleh

mindspore/ops/bprop_mindir/AssignSub_bprop.mindir

@@ -1,19 +0,0 @@
-
-0.1.1	MindSpore*2.0.0:�
-}'get_bprop_assign_sub.1237:[CNode]1238:1'get_bprop_assign_sub.1237:[CNode]1238:1"REF::bprop.1239:Default/bprop.1239-op962get_bprop_assign_sub.1237* 
-get_bprop_assign_sub.1237:self*
-get_bprop_assign_sub.1237:x*
-get_bprop_assign_sub.1237:y*
-get_bprop_assign_sub.1237:out* 
-get_bprop_assign_sub.1237:dout2)
-'get_bprop_assign_sub.1237:[CNode]1238:1:@c11c34e0f67efb3b34ee8b93b6fa6cd59afe26e67d7088ae1e06522bc79b9687J/grad_math_ops.pyB�
-�

-get_bprop_assign_sub.1237:xbprop.1239:[CNode]1240:2bprop.1239:[CNode]1240:2".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:/Default/S-Prim-hyper_map[zeros_like_leaf]-op963
-�

-get_bprop_assign_sub.1237:ybprop.1239:[CNode]1241:3bprop.1239:[CNode]1241:3".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:/Default/S-Prim-hyper_map[zeros_like_leaf]-op964
-�

-bprop.1239:[CNode]1240:2
-bprop.1239:[CNode]1241:3bprop.1239:[CNode]1242:4bprop.1239:[CNode]1242:4"REF::S-Prim-MakeTuple:5:Default/S-Prim-MakeTuple-op965
-bprop.12392
-bprop.1239:[CNode]1242:4P
b&
-S-Prim-MakeTuple:5S-Prim-MakeTupleh

mindspore/ops/bprop_mindir/Assign_bprop.mindir

@@ -1,17 +0,0 @@
-
-0.1.1	MindSpore*2.0.0:�
-v#get_bprop_assign.1297:[CNode]1298:1#get_bprop_assign.1297:[CNode]1298:1"REF::bprop.1299:Default/bprop.1299-op1008get_bprop_assign.1297*
-get_bprop_assign.1297:self*
-get_bprop_assign.1297:x*
-get_bprop_assign.1297:y*
-get_bprop_assign.1297:out*
-get_bprop_assign.1297:dout2%
-#get_bprop_assign.1297:[CNode]1298:1:@a71330e7616c3da1a8b708c7a0597e2e0b0da2efdbfef26d52786628c45139eeJ/grad_other_ops.pyB�
-�

-get_bprop_assign.1297:ybprop.1299:[CNode]1300:2bprop.1299:[CNode]1300:2".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:0Default/S-Prim-hyper_map[zeros_like_leaf]-op1009
-�

-get_bprop_assign.1297:dout
-bprop.1299:[CNode]1300:2bprop.1299:[CNode]1301:3bprop.1299:[CNode]1301:3"REF::S-Prim-MakeTuple:4:Default/S-Prim-MakeTuple-op1010
-bprop.12992
-bprop.1299:[CNode]1301:3P
b&
-S-Prim-MakeTuple:4S-Prim-MakeTupleh