mindspore 2.0.0a0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/ops/_grad_experimental/grad_nn_ops.py

@@ -18,6 +18,7 @@
 from __future__ import absolute_import
 
 from mindspore import Tensor
+import mindspore.numpy as mnp
 from mindspore.ops import matmul
 from mindspore.ops.operations.nn_ops import GridSampler2D
 from mindspore.ops.operations.nn_ops import GridSampler3D
@@ -52,8 +53,6 @@ from mindspore.ops.operations.nn_ops import PadV3
 from mindspore.ops.operations._grad_ops import PadV3Grad
 from mindspore.ops.operations.nn_ops import AvgPoolV1
 from mindspore.ops.operations._grad_ops import AvgPoolGradV1
-from mindspore.ops.operations.nn_ops import AdaptiveAvgPool2DV1
-from mindspore.ops.operations._grad_ops import AdaptiveAvgPool2DGradV1
 from mindspore.ops.operations.nn_ops import UpsampleNearest3D
 from mindspore.ops.operations._grad_ops import UpsampleNearest3DGrad
 from mindspore.ops.operations.nn_ops import MaxPoolV1
@@ -62,6 +61,7 @@ from mindspore.ops.operations.nn_ops import ReLUV3
 from mindspore.ops.operations._grad_ops import ReluGrad
 from mindspore.ops.operations.image_ops import ResizeLinear1D
 from mindspore.ops.operations.nn_ops import MaxPool3DWithArgmax
+from mindspore.ops.operations.nn_ops import MaxPoolWithArgmaxV2
 from mindspore.ops.operations.nn_ops import FractionalMaxPoolWithFixedKsize
 from mindspore.ops.operations._grad_ops import FractionalMaxPoolGradWithFixedKsize
 from mindspore.ops.operations.nn_ops import AdaptiveAvgPool3D
@@ -193,12 +193,10 @@ def get_bprop_celu(self):
     """Grad definition for `CeLU` operation."""
     alpha = self.alpha
     greater_equal = P.GreaterEqual()
-    less = P.Less()
 
     def bprop(x, out, dout):
-        greater = greater_equal(x, 0.0)
-        lesser = less(x, 0.0)
-        dx = dout * (greater * 1.0 + lesser * (out / alpha + 1.0))
+        condition = greater_equal(x, 0.0)
+        dx = dout * mnp.where(condition, 1.0, out / alpha + 1.0)
         return (dx,)
 
     return bprop
@@ -328,10 +326,10 @@ def get_bprop_nth_element(self):
     divide = P.Div()
 
     def bprop(input_x, n, out, dout):
-        indicators = cast(equal(expand_dims(out, -1), input_x), input_x.dtype)
+        indicators = cast(equal(expand_dims(out, -1), input_x), mstype.float32)
         dout = expand_dims(dout, -1)
         num_select = expand_dims(reduce_sum(indicators, -1), -1)
-        return divide(indicators, num_select) * dout, None
+        return cast(divide(indicators, num_select) * dout, input_x.dtype), None
 
     return bprop
 
@@ -350,19 +348,6 @@ def get_bprop_adaptiveavgpool3d(self):
     return bprop
 
 
-@bprop_getters.register(AdaptiveAvgPool2DV1)
-def get_bprop_adaptive_avg_pool_2d_v1(self):
-    """Grad definition for `AdaptiveAvgPool2DV1` operation."""
-
-    shape = P.Shape()
-    def bprop(x, out, dout):
-        adaptive_avgpool_grad = AdaptiveAvgPool2DGradV1(orig_input_shape=shape(x))
-        dx = adaptive_avgpool_grad(dout)
-        return (dx,)
-
-    return bprop
-
-
 @bprop_getters.register(FractionalMaxPool)
 def get_bprop_fractional_max_pool(self):
     """Grad definition for `FractionalMaxPool` operation."""
@@ -396,9 +381,10 @@ def _create_tensor(x_shape):
 def get_bprop_fractional_avg_pool(self):
     """Grad definition for `FractionalAvgPool` operation."""
     fractional_avg_pool_grad = FractionalAvgPoolGrad(overlapping=self.overlapping)
+    shape_op = P.Shape()
 
     def bprop(x, out, dout):
-        dx = fractional_avg_pool_grad(_create_tensor(x.shape), dout[0], out[1], out[2])
+        dx = fractional_avg_pool_grad(_create_tensor(shape_op(x)), dout[0], out[1], out[2])
         return (dx,)
 
     return bprop
@@ -541,6 +527,24 @@ def get_bprop_maxpool3dwithargmax(self):
     return bprop
 
 
+@bprop_getters.register(MaxPoolWithArgmaxV2)
+def get_bprop_maxpoolwithargmaxv2(self):
+    """Grad definition for `MaxPoolWithArgmaxV2` operation."""
+    maxpoolwithargmaxv2_grad = G.MaxPoolGradWithArgmaxV2(
+        kernel_size=self.kernel_size,
+        strides=self.strides,
+        pads=self.pads,
+        dilation=self.dilation,
+        ceil_mode=self.ceil_mode,
+        argmax_type=self.argmax_type)
+
+    def bprop(x, out, dout):
+        dx = maxpoolwithargmaxv2_grad(x, dout[0], out[1])
+        return (dx,)
+
+    return bprop
+
+
 @bprop_getters.register(FractionalMaxPoolWithFixedKsize)
 def get_bprop_fractional_max_pool_with_fixed_ksize(self):
     """Grad definition for 'FractionalMaxPoolWithFixedKsize' operation."""

mindspore/ops/_grad_experimental/grad_scalar_ops.py

@@ -0,0 +1,112 @@
+# 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/_grad_experimental/grad_sparse_ops.py

@@ -14,6 +14,7 @@
 # ============================================================================
 
 """bprop primitives"""
+from mindspore.ops.operations.sparse_ops import RaggedTensorToSparse
 from mindspore.ops.operations.sparse_ops import CSRSparseMatrixToSparseTensor
 from mindspore.ops.operations.sparse_ops import SparseReorder
 from mindspore.ops.operations.sparse_ops import SparseTensorToCSRSparseMatrix
@@ -30,6 +31,9 @@ from mindspore.ops.operations.sparse_ops import SparseSlice
 from mindspore.ops.operations.sparse_ops import SparseDenseCwiseMul
 from mindspore.ops.operations.sparse_ops import SparseDenseCwiseDiv
 from mindspore.ops.operations.sparse_ops import SparseTensorDenseAdd
+from mindspore.ops.operations.sparse_ops import Sspaddmm
+from mindspore.ops.operations._inner_ops import IsSubClass
+import mindspore as ms
 from mindspore.ops.operations import _map_tensor_ops
 from mindspore.common import dtype as mstype
 from mindspore import Tensor
@@ -39,11 +43,11 @@ from mindspore.ops import operations as P
 from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
 from mindspore.ops.operations import _grad_ops as G
 from mindspore.ops._grad.grad_base import bprop_getters
-from mindspore.ops._utils.utils import is_shape_unknown
 from mindspore import context
 
 # Unused parameters are placeholders.
 dyn_shape_op = P.TensorShape()
+is_sub_class = IsSubClass()
 
 
 @bprop_getters.register(SparseDenseCwiseMul)
@@ -129,7 +133,7 @@ def get_bprop_sparse_softmax(self):
         default_values = _create_tensor(0, values.dtype)
         out_dout = mul(out, dout)
         sp_product = sparse_to_dense(indices, shape, out_dout, default_values)
-        sum_reduced = -reduce_sum(sp_product, -1)
+        sum_reduced = -1 * reduce_sum(sp_product, -1)
         sp_sum = sparse_dense_cwise_add(indices, dout, shape, sum_reduced)
         grad_x = mul(sp_sum, out)
         return zeros_like(indices), grad_x, zeros_like(shape)
@@ -184,7 +188,7 @@ def get_bprop_sparse_segment_sqrt_n(self):
 
     def bprop(x, indices, segment_ids, out, dout):
         shape_x = shape(x)
-        if is_shape_unknown(shape_x):
+        if F.is_sequence_value_unknown(shape_x):
             shape_x = dyn_shape_op(x)
         output_dim0 = P.Cast()(shape_x[0], mstype.int32)
         indices = F.cast(indices, mstype.int32)
@@ -204,7 +208,7 @@ def get_bprop_sparse_segment_sqrt_n_with_num_segments(self):
 
     def bprop(x, indices, segment_ids, num_segments, out, dout):
         shape_x = shape(x)
-        if is_shape_unknown(shape_x):
+        if F.is_sequence_value_unknown(shape_x):
             shape_x = dyn_shape_op(x)
         output_dim0 = P.Cast()(shape_x[0], mstype.int32)
         indices = F.cast(indices, mstype.int32)
@@ -226,7 +230,7 @@ def get_bprop_sparse_segment_sum(self):
     def bprop_gpu(x, indices, segment_ids, out, dout):
         input_grad = G.SparseSegmentSumGrad()
         shape_x = shape(x)
-        if is_shape_unknown(shape_x):
+        if F.is_sequence_value_unknown(shape_x):
             shape_x = dyn_shape_op(x)
         output_dim0 = P.Cast()(shape_x[0], mstype.int32)
         indices = F.cast(indices, mstype.int32)
@@ -274,7 +278,7 @@ def get_bprop_sparse_segment_sum_with_num_segments(self):
     def bprop_gpu(x, indices, segment_ids, num_segments, out, dout):
         input_grad = G.SparseSegmentSumGrad()
         shape_x = shape(x)
-        if is_shape_unknown(shape_x):
+        if F.is_sequence_value_unknown(shape_x):
             shape_x = dyn_shape_op(x)
         output_dim0 = P.Cast()(shape_x[0], mstype.int32)
         indices = F.cast(indices, mstype.int32)
@@ -309,7 +313,7 @@ def get_bprop_sparse_segment_mean_with_num_segments(self):
 
     def bprop(x, indices, segment_ids, num_segments, out, dout):
         x_shp = shape(x)
-        if is_shape_unknown(x_shp):
+        if F.is_sequence_value_unknown(x_shp):
             x_shp = dyn_shape_op(x)
             output_dim0 = F.cast(x_shp[0], mstype.int32)
         else:
@@ -336,6 +340,43 @@ def get_bprop_sparse_slice(self):
     return bprop
 
 
+@bprop_getters.register(Sspaddmm)
+def get_bprop_sspaddmm(self):
+    """Grad definition for `Sspaddmm` operation."""
+    def bprop(x1_indices, x1_values, x1_shape, x2_indices, x2_values, x2_shape, x3_dense, alpha, beta, out, dout):
+        dx_all = (zeros_like(x1_indices), zeros_like(x1_values), zeros_like(x1_shape),
+                  zeros_like(x2_indices), zeros_like(x2_values), zeros_like(x2_shape),
+                  zeros_like(x3_dense), zeros_like(alpha), zeros_like(beta))
+        return dx_all
+
+    return bprop
+
+
+@bprop_getters.register(RaggedTensorToSparse)
+def get_bprop_ragged_tensor_to_sparse(self):
+    """Grad definition for `RaggedTensorToSparse` operation."""
+    shape = P.Shape()
+    reshape = P.Reshape()
+
+    def bprop(rt_nested_splits, rt_dense_values, out, dout):
+        ragged_values_shape = shape(rt_dense_values)
+        ragged_values_grad = reshape(dout[1], ragged_values_shape)
+
+        if is_sub_class(F.typeof(rt_nested_splits), ms.list_):
+            split = []
+            for i in enumerate(rt_nested_splits):
+                split.append(zeros_like(i))
+            all_d = (split, ragged_values_grad)
+            return all_d
+        split = ()
+        for i in enumerate(rt_nested_splits):
+            split = split + (zeros_like(i),)
+        all_d = (split, ragged_values_grad)
+        return all_d
+
+    return bprop
+
+
 @bprop_getters.register(SparseReorder)
 def get_bprop_sparse_reorder(self):
     """Grad definition for `SparseReorder` operation."""
@@ -346,7 +387,7 @@ def get_bprop_sparse_reorder(self):
     def bprop(indices, values, shape, out, dout):
         num_entries = F.shape(indices)[0]
         start = Tensor(0, dtype=mstype.int32)
-        limit = Tensor(num_entries, dtype=mstype.int32)
+        limit = P.Cast()(num_entries, mstype.int32)
         delta = Tensor(1, dtype=mstype.int32)
         entry_indices = range_op(start, limit, delta)
         output = sparse_reorder_op(indices, entry_indices, shape)

mindspore/ops/_op_impl/_custom_op/batch_matmul_impl.py

@@ -16,7 +16,7 @@
 from __future__ import absolute_import
 
 from te import tik
-from topi.cce import util
+from tbe.tvm.topi.cce import util
 
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 

mindspore/ops/_op_impl/_custom_op/batchnorm_fold.py

@@ -18,8 +18,8 @@ from __future__ import absolute_import
 
 import te
 from te import tvm
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 batch_norm_op_info = TBERegOp("BatchNormFoldD") \

mindspore/ops/_op_impl/_custom_op/batchnorm_fold2.py

@@ -17,8 +17,8 @@
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 SHAPE_SIZE_LIMIT = 2147483648

mindspore/ops/_op_impl/_custom_op/batchnorm_fold2_grad.py

@@ -17,8 +17,8 @@
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 SHAPE_SIZE_LIMIT = 2147483648

mindspore/ops/_op_impl/_custom_op/batchnorm_fold2_grad_reduce.py

@@ -17,9 +17,9 @@
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from te.platform.cce_build import build_config
-from topi import generic
-from topi.cce import util
+from tbe.common.buildcfg import build_config
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 SHAPE_SIZE_LIMIT = 2147483648
@@ -101,5 +101,5 @@ def batchnorm_fold2_grad_reduce(dout, x, dout_reduce, dout_x_reduce, kernel_name
         return
     from impl.bn_training_reduce import bn_training_reduce_schedule_nd
     sch, tensor_list = bn_training_reduce_schedule_nd(res_list)
-    with build_config:
+    with build_config():
         tvm.build(sch, tensor_list, "cce", name=kernel_name)

mindspore/ops/_op_impl/_custom_op/batchnorm_fold_grad.py

@@ -15,11 +15,11 @@
 
 """_BatchNormFoldGrad op"""
 
-from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 import te.lang.cce
 from te import tvm
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
+from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 batch_norm_op_info = TBERegOp("BatchNormFoldGradD") \
     .fusion_type("OPAQUE") \

mindspore/ops/_op_impl/_custom_op/cholesky_trsm_impl.py

@@ -17,7 +17,7 @@ from __future__ import absolute_import
 import logging
 
 from te import tik
-from topi.cce import util
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 logging.basicConfig(level=logging.DEBUG, format="%(asctime)s %(levelname)s %(message)s")

mindspore/ops/_op_impl/_custom_op/correction_mul.py

@@ -17,8 +17,8 @@
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 SHAPE_SIZE_LIMIT = 2147483648

mindspore/ops/_op_impl/_custom_op/correction_mul_grad.py

@@ -17,8 +17,8 @@
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 SHAPE_SIZE_LIMIT = 2147483648

mindspore/ops/_op_impl/_custom_op/dsd_back_impl.py

@@ -15,7 +15,7 @@
 """dsd back impl"""
 from __future__ import absolute_import
 from te import tik
-from topi.cce import util
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import DataType, TBERegOp, op_info_register
 
 dsd_grad_info = TBERegOp('DSDGrad') \
@@ -88,16 +88,12 @@ def dsdbpropimpl(w1_gm, w2_gm, v_gm, a_gm, d_a_gm, d_w1_gm={}, d_w2_gm={}, d_v_g
                             16, seq_len // 16, 16, 16),
                            name='a_gm',
                            scope=tik.scope_gm)
-    local_gm = a_gm
-    global_gm = a_gm
     # zN
     d_a_gm = tik_inst.Tensor('float16',
                              (batch_size, head, v_embedding //
                               16, seq_len // 16, 16, 16),
                              name='d_a_gm',
                              scope=tik.scope_gm)
-    d_local_gm = d_a_gm
-    d_global_gm = d_a_gm
 
     # output
     # w-zN

mindspore/ops/_op_impl/_custom_op/dsd_impl.py

@@ -15,7 +15,7 @@
 """ dense sparse to densne matmul"""
 from __future__ import absolute_import
 from te import tik
-from topi.cce import util
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import DataType, TBERegOp, op_info_register
 
 dsd_matmul_info = TBERegOp('DSDMatmul') \

mindspore/ops/_op_impl/_custom_op/fake_learned_scale_quant_perchannel.py

@@ -17,8 +17,8 @@
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 fake_learned_scale_quant_perchannel_op_info = TBERegOp("FakeLearnedScaleQuantPerChannel") \

mindspore/ops/_op_impl/_custom_op/fake_learned_scale_quant_perchannel_grad.py

@@ -17,8 +17,8 @@
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 NEG_SCALAR_MIN_FP16 = -(2 ** (-24))

mindspore/ops/_op_impl/_custom_op/fake_learned_scale_quant_perchannel_grad_reduce.py

@@ -17,8 +17,8 @@
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 

mindspore/ops/_op_impl/_custom_op/fake_learned_scale_quant_perlayer.py

@@ -18,8 +18,8 @@ from functools import reduce as functools_reduce
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 fake_learned_scale_quant_perlayer_op_info = TBERegOp("FakeLearnedScaleQuantPerLayer") \

mindspore/ops/_op_impl/_custom_op/fake_learned_scale_quant_perlayer_grad.py

@@ -19,8 +19,8 @@ from functools import reduce as functools_reduce
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 NEG_SCALAR_MIN_FP16 = -(2 ** (-24))

mindspore/ops/_op_impl/_custom_op/fake_learned_scale_quant_perlayer_grad_reduce.py

@@ -19,8 +19,8 @@ from functools import reduce as functools_reduce
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 

mindspore/ops/_op_impl/_custom_op/fake_quant_perchannel.py

@@ -19,8 +19,8 @@ from __future__ import absolute_import
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 fake_quant_perchannel_op_info = TBERegOp("FakeQuantPerChannel") \

mindspore/ops/_op_impl/_custom_op/fake_quant_perchannel_grad.py

@@ -19,8 +19,8 @@ from __future__ import absolute_import
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 SHAPE_SIZE_LIMIT = 2147483648

mindspore/ops/_op_impl/_custom_op/fake_quant_perlayer.py

@@ -20,8 +20,8 @@ from functools import reduce as functools_reduce
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 fake_quant_per_layer_op_info = TBERegOp("FakeQuantPerLayer") \

mindspore/ops/_op_impl/_custom_op/fake_quant_perlayer_grad.py

@@ -20,8 +20,8 @@ from functools import reduce as functools_reduce
 import te.lang.cce
 from te import tvm
 from te.platform.fusion_manager import fusion_manager
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 SHAPE_SIZE_LIMIT = 2147483648

mindspore/ops/_op_impl/_custom_op/fused_abs_max1_impl.py

@@ -16,7 +16,7 @@
 from __future__ import absolute_import
 
 from te import tik
-from topi.cce import util
+from tbe.tvm.topi.cce import util
 
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 

mindspore/ops/_op_impl/_custom_op/img2col_impl.py

@@ -16,7 +16,7 @@
 from __future__ import absolute_import
 
 from te import tik
-from topi.cce import util
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 
 cus_img2col_info = TBERegOp("CusImg2Col") \

mindspore/ops/_op_impl/_custom_op/matmul_cube_dense_left_impl.py

@@ -21,8 +21,8 @@ import te.lang.cce
 import te.platform.cce_params as cce
 from te import tik
 from te import tvm
-from topi import generic
-from topi.cce import util
+from tbe.tvm.topi import generic
+from tbe.tvm.topi.cce import util
 from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
 from mindspore.ops._op_impl._custom_op._basic import _shape_check, _get_bias, _get_input_shape