mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/ops/function/clip_func.py

@@ -22,9 +22,10 @@ from mindspore.ops import functional as F
 from mindspore.nn.cell import Cell
 from mindspore.common.tensor import Tensor
 from mindspore.common import dtype as mstype
-from mindspore.common.api import jit
 from mindspore.ops.primitive import _primexpr
+from mindspore.ops._primitive_cache import _get_cache_prim
 from mindspore import _checkparam as Validator
+from mindspore.ops.auto_generate import clamp_tensor, clamp_scalar
 
 __all__ = [
     'clip_by_value',
@@ -34,15 +35,16 @@ __all__ = [
     'clip_by_global_norm',
 ]
 
+apply_global_norm = C.MultitypeFuncGraph("apply_global_norm")
+cast_op = P.Cast()
+expand_dims = P.ExpandDims().add_prim_attr("grad_scale", True)
+get_square_sum = C.MultitypeFuncGraph("get_square_sum")
+greater_equal_ = P.GreaterEqual()
 hyper_map = C.HyperMap()
 max_op = P.Maximum()
 min_op = P.Minimum()
-cast_op = P.Cast()
-scalar2tensor_op = P.ScalarToTensor()
 partial_op = P.Partial()
-expand_dims = P.ExpandDims().add_prim_attr("grad_scale", True)
-get_square_sum = C.MultitypeFuncGraph("get_square_sum")
-apply_global_norm = C.MultitypeFuncGraph("apply_global_norm")
+scalar2tensor_op = P.ScalarToTensor()
 
 
 def _old_norm(norm_type, x):
@@ -51,7 +53,6 @@ def _old_norm(norm_type, x):
     return out
 
 
-@jit
 def _cal_total_norm(x, norm_type):
     if norm_type == float('inf'):
         func = lambda data: data.abs().max()
@@ -229,9 +230,9 @@ def clamp(input, min=None, max=None):
 
         out_i= \left\{
         \begin{array}{align}
-            max & \text{ if } x_i\ge max \\
-            x_i & \text{ if } min \lt x_i \lt max \\
-            min & \text{ if } x_i \le min \\
+            max & \text{ if } input_i\ge max \\
+            input_i & \text{ if } min \lt input_i \lt max \\
+            min & \text{ if } input_i \le min \\
         \end{array}\right.
 
     Note:
@@ -242,18 +243,17 @@ def clamp(input, min=None, max=None):
         - The data type of `input`, `min` and `max` should support implicit type conversion and cannot be bool type.
 
     Args:
-          input (Union(Tensor, list[Tensor], tuple[Tensor])): Input data, which type is Tensor or a list or tuple of
-            Tensor. Tensors of arbitrary dimensions are supported.
+          input (Tensor): Input data, which type is Tensor. Tensors of arbitrary dimensions are supported.
           min (Union(Tensor, float, int), optional): The minimum value. Default: ``None`` .
           max (Union(Tensor, float, int), optional): The maximum value. Default: ``None`` .
 
     Returns:
-          Union(Tensor, tuple[Tensor], list[Tensor]), a clipped Tensor or a tuple or a list of clipped Tensor.
+          Tensor, a clipped Tensor.
           The data type and shape are the same as input.
 
     Raises:
           ValueError: If both `min` and `max` are None.
-          TypeError: If the type of `input` is not in Tensor or list[Tensor] or tuple[Tensor].
+          TypeError: If the type of `input` is not in Tensor.
           TypeError: If the type of `min` is not in None, Tensor, float or int.
           TypeError: If the type of `max` is not in None, Tensor, float or int.
 
@@ -272,21 +272,10 @@ def clamp(input, min=None, max=None):
         >>> print(output)
         [[ 5. 20.  5.  7.]
          [ 5. 11.  6. 20.]]
-        >>> # case 2: the data type of input is list[Tensor]
-        >>> min_value = 5
-        >>> max_value = 20
-        >>> input_x = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> input_y = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
-        >>> output = ops.clamp([input_x,input_y], min_value, max_value)
-        >>> for out in output:
-        ...     print(out)
-        [[ 5. 20.  5.  7.]
-         [ 5. 11.  6. 20.]]
-        [[ 5. 20.  5.  7.]
-         [ 5. 11.  6. 20.]]
     """
-    return clip_by_value(input, min, max)
-
+    if isinstance(min, Tensor) or isinstance(max, Tensor):
+        return clamp_tensor(input, min, max)
+    return clamp_scalar(input, min, max)
 
 def clip(input, min=None, max=None):
     r"""
@@ -300,7 +289,7 @@ def clip(input, min=None, max=None):
 
 @get_square_sum.register("Tensor")
 def _get_square_sum(x):
-    norm = P.ReduceSum(False)(F.square(x), ())
+    norm = _get_cache_prim(P.ReduceSum)(False)(F.square(x), ())
     norm = expand_dims(F.cast(norm, mstype.float32), 0)
     return norm
 
@@ -338,12 +327,11 @@ class _ClipByGlobalNorm(Cell):
         Validator.check_number("clip_norm", clip_norm, 0.0, Validator.GT, self.cls_name)
         self.clip_norm = Tensor([clip_norm], mstype.float32)
         self.hyper_map = C.HyperMap()
-        self.greater_equal = P.GreaterEqual()
 
     def construct(self, x):
         square_sum = self.hyper_map(get_square_sum, x)
         global_norm = F.sqrt(F.addn(square_sum))
-        cond = self.greater_equal(global_norm, self.clip_norm)
+        cond = greater_equal_(global_norm, self.clip_norm)
         global_norm = F.select(cond, global_norm, self.clip_norm)
         clip_x = self.hyper_map(F.partial(apply_global_norm, self.clip_norm, global_norm), x)
         return clip_x

mindspore/ops/function/debug_func.py

@@ -16,6 +16,8 @@
 """Operators for debug function."""
 
 from mindspore.ops.operations.debug_ops import Print
+from mindspore.common.tensor import Tensor
+from mindspore.ops import operations as P
 from .._primitive_cache import _get_cache_prim
 
 
@@ -26,15 +28,14 @@ def print_(*input_x):
     Once set, the output will be saved in the file specified by print_file_path.
     :func:`mindspore.parse_print` can be employed to reload the data.
     For more information, please refer to :func:`mindspore.set_context` and :func:`mindspore.parse_print`.
+    In Ascend platform with graph mode, can set environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
+    to solve operator execution failure when outputting big tensor or outputting tensor intensively.
 
     Note:
         In pynative mode, please use python print function.
         In Ascend platform with graph mode, the bool, int and float would be converted into Tensor to print, and
         str remains unchanged.
-        This function is used for debugging. When too much data is printed at the same time,
-        in order not to affect the main process, the framework may discard some data. If you need to record the
-        data completely, you are recommended to use the `Summary` function, and can check
-        `Summary <https://www.mindspore.cn/mindinsight/docs/en/r2.2/summary_record.html>`_.
+        This function is used for debugging.
 
     Args:
         input_x (Union[Tensor, bool, int, float, str, tuple, list]): The inputs of print_.
@@ -67,6 +68,114 @@ def print_(*input_x):
     return print_op(*input_x)
 
 
-__all__ = ['print_']
+
+def tensordump(file_name, tensor, mode='out'):
+    """
+    Save Tensor in numpy's npy format.
+
+    In Parallel situation, tensordump will dump slice of data at each rank.
+
+    In Ascend platform with graph mode,
+    Your code OpA --> OpB may compiled as OpA --> RedistributionOps --> OpB.
+
+    Note: The redistribution operator is introduced,
+    Due to inter-device communication and shard strategies in the static graph parallel scenario.
+
+    In case of OpA --> OpB, the dump data of OpA's output is equal to OpB's input.
+
+    But in case of OpA --> RedistributionOps --> OpB,
+    The dump data of OpA's output is not equal to OpB's input (Due to the redistribution operators).
+    So the parameter mode is to handle this situation.
+
+    Assuming OpA's output is used as both tensordump's input parameter and OpB's input parameter.
+    Different requirements of saving dump data can be achieved by configuring parameter mode:
+
+    - If the mode is 'out', the dump data contains only OpA's output slice.
+    - If the mode is 'all', the dump data contains both OpA's output slice and OpB's input slice.
+    - If the mode is 'in', the dump data contains only OpB's input slice.
+
+    For mode 'all' or 'in', the input slice npy file format is: id_fileName_cNodeID_dumpMode_rankID.npy.
+
+    For mode 'out' or 'all' the output slice npy file format is: id_filename.npy.
+
+    - id: An auto increment ID.
+    - fileName: Value of the parameter file_name
+      (if parameter file_name is a user-specified path, the value of fileName is the last level of the path).
+    - cNodeID: The cnode ID in ir graph of step_parallel_end.ir.
+    - dumpMode: Value of the parameter mode.
+    - rankID: Logical device id.
+
+    Note:
+        - The operator of tensordump doesn't support in control flow.
+        - If current parallel mode is STAND_ALONE, mode should only be 'out'.
+        - Parameter mode will be set to 'out' if user doesn't configure it.
+        - This function is used for debugging.
+
+    Args:
+        file_name (str): The path of the npy file saves.
+        tensor (Tensor): The tensor that user want to dump.
+        mode (str, optional): Used to control tensordump behavior, available value is one of ['in', 'out', 'all'].
+            Default value is ``out``.
+
+    Raises:
+        TypeError: If `file_name` is not str.
+        TypeError: If `tensor` is not Tensor.
+        TypeError: If `mode` is not str.
+        ValueError: If `mode` is not in one of ['in', 'out', 'all'].
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        .. note::
+            Using msrun command to run below example: msrun --worker_num=2 --local_worker_num=2 --master_port=11450
+            --log_dir=msrun_log --join=True --cluster_time_out=300 tensordump_example.py
+
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> from mindspore import nn, Tensor, ops, context
+        >>> from mindspore.ops import operations as P
+        >>> from mindspore.communication import init, get_rank
+        >>> init()
+        >>> rank_id = get_rank()
+        >>> dump_path = f'dumps/rank_{rank_id}/mul1_mul2.npy'
+        >>> class Net(nn.Cell):
+        ...     def __init__(self, strategy1, strategy2):
+        ...         super(Net, self).__init__()
+        ...         self.matmul1 = P.MatMul().shard(strategy1)
+        ...         self.matmul2 = P.MatMul().shard(strategy2)
+        ...
+        ...     def construct(self, x, y, b):
+        ...         out1 = self.matmul1(x, y)
+        ...         ops.tensordump(dump_path, out1, 'all')
+        ...         out2 = self.matmul2(out1, b)
+        ...         return out2
+        ...
+        >>> ms.set_context(mode=ms.GRAPH_MODE, save_graphs=2)
+        >>> context.set_auto_parallel_context(parallel_mode='semi_auto_parallel', full_batch=True)
+        >>> strategy1 = ((1, 2), (2, 1))
+        >>> strategy2 = ((1, 2), (2, 1))
+        >>> net = Net(strategy1, strategy2)
+        >>> x = Tensor(0.1 * np.random.randn(64, 64).astype(np.float32))
+        >>> y = Tensor(0.1 * np.random.randn(64, 64).astype(np.float32))
+        >>> b = Tensor(0.1 * np.random.randn(64, 64).astype(np.float32))
+        >>> out = net(x, y, b)
+        >>> print(f"out shape is: {out.shape}")
+        >>> matmul1_output_slice = np.load('0_mul1_mul2.npy')                       # load matmul1's output slice
+        >>> matmul2_input_slice = np.load('1_mul1_mul2_CNode_64_all_rank_0.npy')    # load matmul2's input slice
+    """
+    if not isinstance(file_name, str):
+        raise TypeError(f"Parameter file_name should only be build_in str type but got: {type(file_name)}")
+    if not isinstance(tensor, Tensor):
+        raise TypeError(f"Parameter tensor should only be Tensor type, but got: {type(tensor)}")
+    if not isinstance(mode, str):
+        raise TypeError(f"Parameter mode should only be build_in str type, but got: {type(mode)}")
+    mode_list = ['out', 'in', 'all']
+    if mode not in mode_list:
+        raise ValueError(f"Parameter mode should in {mode_list}, but got {mode}")
+    _tensordump = _get_cache_prim(P.TensorDump)(input_output=mode)
+    return _tensordump(file_name, tensor)
+
+__all__ = ['print_', 'tensordump']
 
 __all__.sort()

mindspore/ops/function/fft_func.py

@@ -0,0 +1,44 @@
+# 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.
+# ============================================================================
+"""Defines Fast Fourier Transform operators with functional form."""
+from mindspore.ops.auto_generate import fft, fft2, fftn, ifft, ifft2, ifftn, fftshift, ifftshift, \
+    rfft, irfft, rfft2, irfft2, rfftn, irfftn, hfft, ihfft, hfft2, ihfft2, hfftn, ihfftn, fftfreq, rfftfreq
+
+__all__ = [
+    'fftshift',
+    'ifftshift',
+    'fft',
+    'fft2',
+    'fftn',
+    'ifft',
+    'ifft2',
+    'ifftn',
+    'rfft',
+    'irfft',
+    'rfft2',
+    'irfft2',
+    'rfftn',
+    'irfftn',
+    'hfft',
+    'ihfft',
+    'hfft2',
+    'ihfft2',
+    'hfftn',
+    'ihfftn',
+    'fftfreq',
+    'rfftfreq'
+]
+
+__all__.sort()

mindspore/ops/function/grad/grad_func.py

@@ -22,6 +22,7 @@ from mindspore.common import Tensor
 from mindspore.common import dtype as mstype
 from mindspore.nn.cell import Cell
 from mindspore.nn.grad.cell_grad import _LinearizeInner
+from mindspore.ops.operations.other_ops import stop_gradient_
 from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.ops.function.array_func import ones, expand_dims, size, reshape, broadcast_to, transpose, zeros
 from mindspore.ops.composite import _Vmap, _Grad, _TaylorOperation, GradOperation
@@ -123,8 +124,8 @@ def grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=False):
         Function, the gradient function to calculate gradient for the input function or cell.
         For example, as for `out1, out2 = fn(*args)`, when `has_aux` is set ``True`` , gradient function will return
         outputs like `(gradient, out2)` and `out2` does not contribute to the differentiation, otherwise `gradient`.
-        When return_ids is set to ``True`` , The format of the output will be the same with the output of grad when
-        return_ids is set to false, but every gradient in the output will be replaced by a tuple of position id or
+        When return_ids is set to ``True`` , the format of the output will be the same with the output of grad when
+        return_ids is set to ``False``, but every gradient in the output will be replaced by a tuple of position id or
         parameter name and its gradient.
 
     Raises:
@@ -230,7 +231,7 @@ def grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=False):
     return _get_grad_op(True, True, has_aux, False, return_ids)(fn, weights, grad_position)
 
 
-def value_and_grad(fn, grad_position=0, weights=None, has_aux=False):
+def value_and_grad(fn, grad_position=0, weights=None, has_aux=False, return_ids=False):
     """
     A wrapper function to generate the function to calculate forward output and gradient for the input function.
 
@@ -253,11 +254,16 @@ def value_and_grad(fn, grad_position=0, weights=None, has_aux=False):
         has_aux (bool): If ``True`` , only the first output of `fn` contributes the gradient of `fn`, while the other
             outputs will be returned straightly. It means the `fn` must return more than one outputs in this case.
             Default: ``False`` .
+        return_ids(bool): Whether return the tuple made by gradients and the index to specify which inputs
+            to be differentiated or the name of parameters of the training network that need to calculate the gradient.
+            If ``True`` , the output gradients will be replaced by the tuples made by gradients and the index to specify
+            which inputs to be differentiated or the name of parameters of the training network.
+            Default: ``False`` .
 
     Returns:
         Function, returns the gradient function to calculate forward output and gradient for the input function or cell.
         For example, as for `out1, out2 = fn(*args)` , gradient function will return outputs like
-        `((out1, out2), gradient)` . When `has_aux` is set True, only `out1` contributes to the differentiation.
+        `((out1, out2), gradient)` . When `has_aux` is set to ``True``, only `out1` contributes to the differentiation.
 
     Raises:
         ValueError: If both `grad_position` and `weights` are None.
@@ -346,18 +352,19 @@ def value_and_grad(fn, grad_position=0, weights=None, has_aux=False):
         raise ValueError("`grad_position` and `weight` can not be None at the same time.")
 
     if grad_position is None:
-        return _get_grad_op(True, False, has_aux, True)(fn, weights)
+        return _get_grad_op(True, False, has_aux, True, return_ids)(fn, weights)
 
     grad_position = _convert_grad_position_type(grad_position)
     if weights is None:
-        return _get_grad_op(False, True, has_aux, True)(fn, None, grad_position)
-    return _get_grad_op(True, True, has_aux, True)(fn, weights, grad_position)
+        return _get_grad_op(False, True, has_aux, True, return_ids)(fn, None, grad_position)
+    return _get_grad_op(True, True, has_aux, True, return_ids)(fn, weights, grad_position)
 
 
 def get_grad(gradients, identifier):
     """
-    When `return_ids` of :func:`mindspore.grad` is set to True, use its return value as gradients. Then find
-    the specific gradient from `gradients` according to `identifier` .
+    When `return_ids` of :func:`mindspore.grad` or :func:`mindspore.grad` is set to ``True`` ,
+    use return value of `mindspore.grad`, or the second return value of `mindspore.grad` as gradients.
+    Then find the specific gradient from `gradients` according to `identifier` .
 
     As for gradient, two typical cases are included:
 
@@ -477,7 +484,7 @@ def jet(fn, primals, series):
         >>> import numpy as np
         >>> import mindspore.nn as nn
         >>> import mindspore as ms
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import Tensor
         >>> ms.set_context(mode=ms.GRAPH_MODE)
         >>> class Net(nn.Cell):
@@ -587,7 +594,7 @@ def derivative(fn, primals, order):
         >>> import numpy as np
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import Tensor
         >>> ms.set_context(mode=ms.GRAPH_MODE)
         >>> class Net(nn.Cell):
@@ -652,9 +659,9 @@ def _check_jvp_input_v_len(inputs_len, v_len):
 
 def jvp(fn, inputs, v, has_aux=False):
     """
-    Compute the jacobian-vector-product of the given network. `jvp` matches
+    Compute the jacobian-vector-product of the given network. The calculation procedure of JVP can be found in
     `forward-mode differentiation
-    <https://www.mindspore.cn/docs/en/r2.2/design/programming_paradigm.html#forward-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#forward-mode-ad>`_.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -869,7 +876,7 @@ def vjp(fn, *inputs, weights=None, has_aux=False):
     """
     Compute the vector-jacobian-product of the given network. `vjp` matches
     `reverse-mode differentiation
-    <https://www.mindspore.cn/docs/en/r2.2/design/programming_paradigm.html#reverse-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#reverse-mode-ad>`_.
 
     Args:
         fn (Union[Function, Cell]): The function or net that takes Tensor inputs and returns single Tensor or tuple of
@@ -885,10 +892,11 @@ def vjp(fn, *inputs, weights=None, has_aux=False):
     Returns:
         Forward outputs and function to calculate vjp.
 
-        - **net_output** (Union[Tensor, tuple[Tensor]]) - The output of `fn(inputs)`. Specially, when `has_aux` is set
-          True, `netout` is the first output of `fn(inputs)`.
+        - **net_output** (Union[Tensor, tuple[Tensor]]) - The output of `fn(inputs)`.
+          Specially, when `has_aux` is set to
+          ``True``, `net_output` is the first output of `fn(inputs)`.
         - **vjp_fn** (Function) - To calculate vector-jacobian-product. Its inputs are the vectors whose shape and
-          type should be the same as `netout` .
+          type should be the same as `net_output` .
         - **aux_value** (Union[Tensor, tuple[Tensor]], optional) - When `has_aux` is True, `aux_value` will be returned.
           It means the second to last outputs of `fn(inputs)`. Specially, `aux_value` does not contribute to gradient.
 
@@ -1067,7 +1075,7 @@ def jacfwd(fn, grad_position=0, has_aux=False):
     """
     Compute Jacobian via forward mode, corresponding to
     `forward-mode differentiation
-    <https://www.mindspore.cn/docs/en/r2.2/design/programming_paradigm.html#forward-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#forward-mode-ad>`_.
     When number of outputs is much greater than that of inputs, it's better to calculate Jacobian via forward mode than
     reverse mode to get better performance.
 
@@ -1238,7 +1246,7 @@ def jacrev(fn, grad_position=0, has_aux=False):
     """
     Compute Jacobian via reverse mode, corresponding to
     `reverse-mode differentiation
-    <https://www.mindspore.cn/docs/en/r2.2/design/programming_paradigm.html#reverse-mode-ad>`_.
+    <https://www.mindspore.cn/docs/en/master/design/programming_paradigm.html#reverse-mode-ad>`_.
     When number of inputs is much greater than that of outputs, it's better to calculate Jacobian via reverse mode than
     forward mode to get better performance.
 
@@ -1369,7 +1377,7 @@ def stop_gradient(value):
     StopGradient is used for eliminating the effect of a value on the gradient, such as truncating
     the gradient propagation from an output of a function.
     For more details, please refer to `Stop Gradient
-    <https://www.mindspore.cn/tutorials/en/r2.2/beginner/autograd.html#stop-gradient>`_.
+    <https://www.mindspore.cn/tutorials/en/master/beginner/autograd.html#stop-gradient>`_.
 
     Args:
         value (Any): The value whose effect on the gradient to be eliminated.
@@ -1381,7 +1389,7 @@ def stop_gradient(value):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> from mindspore import Tensor
         >>> from mindspore import dtype as mstype
         >>> def net(x, y):
@@ -1398,7 +1406,7 @@ def stop_gradient(value):
         [[1.4100001 1.6       6.5999994]
          [1.4100001 1.6       6.5999994]]
     """
-    return P.StopGradient()(value)
+    return stop_gradient_(value)
 
 
 __all__ = [

mindspore/ops/function/image_func.py

@@ -22,6 +22,9 @@ from mindspore.common.tensor import Tensor
 from mindspore._c_expression import Tensor as Tensor_
 from .._primitive_cache import _get_cache_prim
 
+check_valid_ = P.CheckValid()
+dtype_ = P.DType()
+
 
 def bounding_box_decode(anchor_box, deltas, max_shape, means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0),
                         wh_ratio_clip=0.016):
@@ -156,8 +159,25 @@ def check_valid(bboxes, img_metas):
         >>> print(output)
         [ True False False]
     """
-    check_valid_op = _get_cache_prim(P.CheckValid)()
-    return check_valid_op(bboxes, img_metas)
+    return check_valid_(bboxes, img_metas)
+
+
+def _crop_and_resize_check(image, boxes, box_indices, crop_size):
+    """Check crop and resize input"""
+    if not isinstance(image, (Tensor, Tensor_)):
+        raise TypeError("For crop_and_resize, the input image must be a tensor")
+    if not isinstance(boxes, (Tensor, Tensor_)):
+        raise TypeError("For crop_and_resize, the input boxes must be a tensor")
+    if not isinstance(box_indices, (Tensor, Tensor_)):
+        raise TypeError("For crop_and_resize, the input box_indices must be a tensor")
+    if not isinstance(crop_size, tuple):
+        raise TypeError("For crop_and_resize, the input crop_size must be a tuple, but got {}".format(type(crop_size)))
+    if len(crop_size) != 2:
+        raise ValueError("For crop_and_resize, the crop_size's length must be 2, bot got {}".format(len(crop_size)))
+    if not isinstance(crop_size[0], int) or not isinstance(crop_size[1], int):
+        raise TypeError("For crop_and_resize, the crop_size's value must be int.")
+    if crop_size[0] <= 0 or crop_size[1] <= 0:
+        raise ValueError("For crop_and_resize, the crop_size's value must be positive.")
 
 
 def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", extrapolation_value=0.0):
@@ -166,7 +186,7 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
 
     Note:
         In case that the output shape depends on crop_size, the crop_size must be constant.
-        For now, the backward of the operator only support bilinear method, for other methods, will return 0.
+        For now, the backward of the operator only supports bilinear method, for other methods, will return 0.
 
     Args:
         image (Tensor): A 4-D Tensor representing a batch of images. It has shape
@@ -203,7 +223,7 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
     Raises:
         TypeError: If `image` or `boxes` or `box_indices` is not a Tensor.
         TypeError: If `crop_size` is not a Tuple with two int32 elements.
-        TypeError: If dtype of `boxes` is not float or that of `box_indices` is not int.
+        TypeError: If dtype of `boxes` is not float or that of `box_indices` is not int32.
         TypeError: If `method` is not a str.
         TypeError: If `extrapolation_value` is not a float.
         ValueError: If the shape rank of `image` is not 4.
@@ -234,26 +254,12 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
         >>> print(output.shape)
          (5, 24, 24, 3)
     """
-    if not isinstance(image, (Tensor, Tensor_)):
-        raise TypeError("For crop_and_resize, the input image must be a tensor")
-    if not isinstance(boxes, (Tensor, Tensor_)):
-        raise TypeError("For crop_and_resize, the input boxes must be a tensor")
-    if not isinstance(box_indices, (Tensor, Tensor_)):
-        raise TypeError("For crop_and_resize, the input box_indices must be a tensor")
-    if not isinstance(crop_size, tuple):
-        raise TypeError("For crop_and_resize, the input crop_size must be a tuple, but got {}".format(type(crop_size)))
-    if len(crop_size) != 2:
-        raise ValueError("For crop_and_resize, the crop_size's length must be 2, bot got {}".format(len(crop_size)))
-    if not isinstance(crop_size[0], int) or not isinstance(crop_size[1], int):
-        raise TypeError("For crop_and_resize, the crop_size's value must be int.")
-    if crop_size[0] <= 0 or crop_size[1] <= 0:
-        raise ValueError("For crop_and_resize, the crop_size's value must be positive.")
-
+    _crop_and_resize_check(image, boxes, box_indices, crop_size)
     image_shape = image.shape
     if len(image_shape) != 4:
         raise ValueError(
             "For crop_and_resize, the input image must be 4D Tensor, but got is {}D".format(len(image_shape)))
-    boxes_dtype = _get_cache_prim(P.DType)()(boxes)
+    boxes_dtype = dtype_(boxes)
     if boxes_dtype not in [mstype.float32]:
         raise TypeError(
             "For crop_and_resize, the input boxes must be {}, but got {}".format(mstype.float32, boxes_dtype))
@@ -261,7 +267,7 @@ def crop_and_resize(image, boxes, box_indices, crop_size, method="bilinear", ext
     if len(boxes_shape) != 2 or boxes_shape[-1] != 4:
         raise ValueError("For crop_and_resize, the input boxes must be 2D and the second-dim must be 4, "
                          "but got {}".format(boxes_shape))
-    box_indices_dtype = _get_cache_prim(P.DType)()(box_indices)
+    box_indices_dtype = dtype_(box_indices)
     if box_indices_dtype not in [mstype.int32]:
         raise TypeError(
             "For crop_and_resize, the input box_indices must be {}, but got {}".format(mstype.int32, box_indices_dtype))