mindspore 2.0.0a0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/scipy/sparse/linalg.py

@@ -16,342 +16,11 @@
 from ... import nn
 from ... import numpy as mnp
 from ...ops import functional as F
-from ...ops import operations as P
-from ...common import Tensor, CSRTensor, COOTensor, dtype as mstype
+from ...common import Tensor, CSRTensor
 from ...ops.composite.multitype_ops.zeros_like_impl import zeros_like
-from ..linalg import solve_triangular
-from ..linalg import cho_factor, cho_solve
-from ..utils import _to_tensor, _safe_normalize, _eps, _norm, _type_check, _value_check, \
+from ..utils import _to_tensor, _norm, _type_check, _value_check, \
     _sparse_check, _matvec
-from ..utils_const import _raise_value_error, _raise_type_error, is_within_graph
-
-
-def gram_schmidt(Q, q):
-    """Do Gram–Schmidt process to normalize vector v"""
-    h = mnp.dot(Q.T, q)
-    Qh = mnp.dot(Q, h)
-    q = q - Qh
-    return q, h
-
-
-def arnoldi_iteration(k, A, M, V, H):
-    """Performs a single (the k'th) step of the Arnoldi process."""
-    v_ = V[..., k]
-    v = _matvec(M, _matvec(A, v_))
-    v, h = gram_schmidt(V, v)
-    _, v_norm_0 = _safe_normalize(v)
-    tol = _eps(v) * v_norm_0
-    unit_v, v_norm_1 = _safe_normalize(v, tol)
-    V[..., k + 1] = unit_v
-    h[k + 1] = v_norm_1
-    H[k, :] = h
-    breakdown = v_norm_1 == 0
-    return V, H, breakdown
-
-
-def rotate_vectors(H, i, cs, sn):
-    """Rotate vectors."""
-    x1 = H[i]
-    y1 = H[i + 1]
-    x2 = cs * x1 - sn * y1
-    y2 = sn * x1 + cs * y1
-    H[i] = x2
-    H[i + 1] = y2
-    return H
-
-
-def _high_precision_cho_solve(a, b, data_type=mstype.float64):
-    """As a core computing module of gmres, cholesky solver must explicitly cast to double precision."""
-    a = a.astype(mstype.float64)
-    b = b.astype(mstype.float64)
-    a_a = mnp.dot(a, a.T)
-    a_b = mnp.dot(a, b)
-    c, lower = cho_factor(a_a, lower=False)
-    factor = (c, lower)
-    y = cho_solve(factor, a_b)
-    return y.astype(data_type)
-
-
-def _batch_gmres(A, b, x0, tol, restart, maxiter, M, atol):
-    """
-    batched gmres: solve the least squares problem from scratch at the end of each GMRES iteration.
-    It does not allow for early termination, but has much less overhead on GPUs.
-    """
-    # Constant tensor which avoids loop unrolling
-    const_int_zero = _to_tensor(0)
-    dtype = b.dtype
-    _, b_norm = _safe_normalize(b)
-    atol = mnp.maximum(tol * b_norm, _to_tensor(atol), dtype=dtype)
-    residual = _matvec(M, b - _matvec(A, x0))
-    unit_residual, residual_norm = _safe_normalize(residual)
-    k = const_int_zero
-    x = x0
-    while k < maxiter and residual_norm > atol:
-        pad_width = ((0, 0),) * unit_residual.ndim + ((0, restart),)
-        V = mnp.pad(unit_residual[..., None], pad_width=pad_width)
-        H = mnp.eye(restart, restart + 1, dtype=dtype)
-        k_iter = const_int_zero
-        breakdown = _to_tensor(False)
-        while k_iter < restart and mnp.logical_not(breakdown):
-            V, H, breakdown = arnoldi_iteration(k_iter, A, M, V, H)
-            k_iter += 1
-        beta_vec = mnp.zeros((restart + 1,), dtype=dtype)
-        beta_vec[0] = residual_norm
-        y = _high_precision_cho_solve(H, beta_vec, data_type=dtype)
-        dx = mnp.dot(V[..., :-1], y)
-        x = x + dx
-        residual = _matvec(M, b - _matvec(A, x))
-        unit_residual, residual_norm = _safe_normalize(residual)
-        k += 1
-    return x, F.select(residual_norm > atol, k, const_int_zero)
-
-
-def _incremental_gmres(A, b, x0, tol, restart, maxiter, M, atol):
-    """
-    incremental gmres: builds a QR decomposition for the Krylov subspace incrementally during
-    the GMRES process using Givens rotations. This improves numerical stability and gives a free estimate of
-    the residual norm that allows for early termination within a single "restart".
-    """
-    const_int_zero = _to_tensor(0)
-    _, b_norm = _safe_normalize(b)
-    atol = mnp.maximum(tol * b_norm, atol)
-
-    Mb = _matvec(M, b)
-    _, Mb_norm = _safe_normalize(Mb)
-    ptol = Mb_norm * mnp.minimum(1.0, atol / b_norm)
-
-    r = _matvec(M, b - _matvec(A, x0))
-    r, r_norm = _safe_normalize(r)
-
-    iters = const_int_zero
-    while iters < maxiter and r_norm > atol:
-        V = mnp.pad(r[..., None], ((0, 0),) * r.ndim + ((0, restart),))
-        dtype = mnp.result_type(b)
-        # Use eye() to avoid constructing a singular matrix in case of early
-        # Termination
-        R = mnp.eye(restart, restart + 1, dtype=dtype)
-        givens = mnp.zeros((restart, 2), dtype=dtype)
-        beta_vec = mnp.zeros((restart + 1), dtype=dtype)
-        beta_vec[0] = r_norm
-
-        k = const_int_zero
-        err = r_norm
-        while mnp.logical_and(mnp.less(k, restart), mnp.less(ptol, err)):
-            V, R, _ = arnoldi_iteration(k, A, M, V, R)
-            # Givens rotation
-            row_k = R[k, :]
-            i = const_int_zero
-            while i < k:
-                row_k = rotate_vectors(row_k, i, givens[i, 0], givens[i, 1])
-                i += 1
-
-            if row_k[k + 1] == 0:
-                givens[k, 0] = 1
-                givens[k, 1] = 0
-            else:
-                increase = mnp.absolute(row_k[k]) < mnp.absolute(row_k[k + 1])
-                t = mnp.where(increase, -row_k[k] / row_k[k + 1], -row_k[k + 1] / row_k[k])
-                r = 1 / F.sqrt(1 + mnp.absolute(t) ** 2)
-                givens[k, 0] = mnp.where(increase, r * t, r)
-                givens[k, 1] = mnp.where(increase, r, r * t)
-
-            R[k, :] = rotate_vectors(row_k, k, givens[k, 0], givens[k, 1])
-            beta_vec = rotate_vectors(beta_vec, k, givens[k, 0], givens[k, 1])
-            err = mnp.absolute(beta_vec[k + 1])
-            k += 1
-
-        y = solve_triangular(R[:, :-1], beta_vec[:-1], trans='T', lower=True)
-        dx = mnp.dot(V[:, :-1], y)
-
-        x = x0 + dx
-        r = _matvec(M, b - _matvec(A, x))
-        r, r_norm = _safe_normalize(r)
-        x0 = x
-        iters += 1
-    return x0, F.select(r_norm > atol, iters, const_int_zero)
-
-
-class GMRES(nn.Cell):
-    """
-    Given given A and b, GMRES solves the linear system:
-
-    .. math::
-        A x = b
-    """
-
-    def __init__(self, A, M, solve_method):
-        super(GMRES, self).__init__()
-        self.A = A
-        self.M = M
-        self.solve_method = solve_method
-
-    def construct(self, b, x0, tol, restart, maxiter, atol):
-        # Constant tensor which avoids loop unrolling
-        x = x0
-        info = _to_tensor(0)
-        if self.solve_method == 'batched':
-            x, info = _batch_gmres(self.A, b, x0, tol, restart, maxiter, self.M, atol)
-        elif self.solve_method == "incremental":
-            x, info = _incremental_gmres(self.A, b, x0, tol, restart, maxiter, self.M, atol)
-        else:
-            _raise_value_error("solve_method should be in ('incremental' or 'batched'), but got ", self.solve_method,
-                               ".")
-        return x, info
-
-
-class GMRESV2(nn.Cell):
-    """
-    This is a new version of GMRES, which contains all parameters in a graph.
-    """
-
-    def __init__(self, solve_method):
-        super(GMRESV2, self).__init__()
-        self.solve_method = solve_method
-
-    def transpose(self, a):
-        if isinstance(a, CSRTensor):
-            a_coo = a.to_coo()
-            row_indices = a_coo.indices[:, 0]
-            col_indices = a_coo.indices[:, 1]
-            coo_indices = P.Stack(1)([col_indices, row_indices])
-            a_t_coo = COOTensor(coo_indices, a_coo.values, a_coo.shape)
-            a_t_csr = a_t_coo.to_csr()
-            return a_t_csr
-        return a.T
-
-    def construct(self, A, b, x0, tol, restart, maxiter, M, atol):
-        x = x0
-        info = _to_tensor(0)
-        if self.solve_method == 'batched':
-            x, info = _batch_gmres(A, b, x0, tol, restart, maxiter, M, atol)
-        elif self.solve_method == "incremental":
-            x, info = _incremental_gmres(A, b, x0, tol, restart, maxiter, M, atol)
-        else:
-            _raise_value_error("solve_method should be in ('incremental' or 'batched'), but got ", self.solve_method,
-                               ".")
-        return x, info
-
-    def bprop(self, A, b, x0, tol, restart, maxiter, M, atol, out, dout):
-        """
-        Derivatives of `gmres` are implemented via implicit differentiation with
-        another `gmres` solve, rather than by differentiating *through* the solver.
-        They will be accurate only if both solves converge.
-        """
-        n = b.shape[0]
-        if not isinstance(M, (Tensor, CSRTensor)):
-            M = F.eye(n, n, b.dtype)
-        A_T = self.transpose(A)
-        grad_b, _ = self.construct(A_T, dout[0], x0, tol, restart, maxiter, M, atol)
-        if isinstance(A, CSRTensor):
-            grad_a_dense = -1 * F.reshape(grad_b, (n, 1)) * F.reshape(out[0], (1, n))
-            values = F.csr_gather(A.indptr, A.indices, grad_a_dense, A.shape)
-            grad_a = CSRTensor(A.indptr, A.indices, values, A.shape)
-        else:
-            grad_a = -1 * F.reshape(grad_b, (n, 1)) * F.reshape(out[0], (1, n))
-        return grad_a, grad_b, zeros_like(x0), zeros_like(tol), zeros_like(atol), zeros_like(maxiter), zeros_like(M)
-
-
-def gmres(A, b, x0=None, *, tol=1e-5, restart=20, maxiter=None,
-          M=None, callback=None, restrt=None, atol=0.0, callback_type=None, solve_method='batched'):
-    """
-    Given given A and b, GMRES solves the linear system:
-
-    .. math::
-        A x = b
-
-    A is specified as a function performing A(vi) -> vf = A @ vi, and in principle
-    need not have any particular special properties, such as symmetry. However,
-    convergence is often slow for nearly symmetric operators.
-
-    Note:
-        - `gmres` is not supported on Windows platform yet.
-
-    Args:
-        A (Union[Tensor, function]): 2D Tensor or function that calculates the linear
-            map (matrix-vector product) :math:`Ax` when called like :math:`A(x)`.
-            As function, `A` must return Tensor with the same structure and shape as its input matrix.
-        b (Tensor): Right hand side of the linear system representing a single vector.
-            Can be stored as a Tensor.
-        x0 (Tensor, optional): Starting guess for the solution. Must have the same structure
-            as `b`. If this is unspecified, zeroes are used. Default: None.
-        tol (float, optional): Tolerances for convergence,
-            :math:`norm(residual) <= max(tol*norm(b), atol)`. We do not implement SciPy's
-            "legacy" behavior, so MindSpore's tolerance will differ from SciPy unless you
-            explicitly pass `atol` to SciPy's `gmres`. Default: 1e-5.
-        restart (integer, optional): Size of the Krylov subspace ("number of iterations")
-            built between restarts. GMRES works by approximating the true solution x as its
-            projection into a Krylov space of this dimension - this parameter
-            therefore bounds the maximum accuracy achievable from any guess
-            solution. Larger values increase both number of iterations and iteration
-            cost, but may be necessary for convergence. The algorithm terminates
-            early if convergence is achieved before the full subspace is built. Default: 20.
-        maxiter (int): Maximum number of times to rebuild the size-`restart`
-            Krylov space starting from the solution found at the last iteration. If GMRES
-            halts or is very slow, decreasing this parameter may help. Default: None.
-        M (Union[Tensor, function]): Preconditioner for A.  The preconditioner should approximate the
-            inverse of A.  Effective preconditioning dramatically improves the
-            rate of convergence, which implies that fewer iterations are needed
-            to reach a given error tolerance. Default: None.
-        callback (function): User-supplied function to call after each iteration. It is called as callback(args),
-            where args are selected by callback_type. Default: None.
-        restrt (int, optional): Deprecated, use restart instead. Default: None.
-        atol (float, optional): The same as `tol`. Default: 0.0.
-        callback_type (str, optional): Callback function argument requested:
-            Default: None.
-
-            - x: current iterate (ndarray), called on every restart
-            - pr_norm: relative (preconditioned) residual norm (float), called on every inner iteration
-            - legacy (default): same as pr_norm, but also changes the meaning of ‘maxiter’ to count inner
-              iterations instead of restart cycles.
-
-        solve_method (str): There are two kinds of solve methods,'incremental' or 'batched'. Default: "batched".
-
-            - incremental: builds a QR decomposition for the Krylov subspace incrementally during
-              the GMRES process using Givens rotations. This improves numerical stability and gives
-              a free estimate of the residual norm that allows for early termination within a single "restart".
-            - batched: solve the least squares problem from scratch at the end of each GMRES
-              iteration. It does not allow for early termination, but has much less overhead on GPUs.
-
-    Returns:
-        - Tensor, the converged solution. Has the same structure as `b`.
-        - Tensor, placeholder for convergence information: 0 : successful exit.
-          >0 : convergence to tolerance not achieved, number of iterations. <0 : illegal input or breakdown.
-
-    Supported Platforms:
-        ``CPU`` ``GPU``
-
-    Examples:
-        >>> import numpy as onp
-        >>> import mindspore.numpy as mnp
-        >>> from mindspore.common import Tensor
-        >>> from mindspore.scipy.sparse.linalg import gmres
-        >>> A = Tensor(mnp.array([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=mnp.float32))
-        >>> b = Tensor(mnp.array([2, 4, -1], dtype=mnp.float32))
-        >>> x, exitCode = gmres(A, b)
-        >>> print(exitCode)            # 0 indicates successful convergence
-        0
-        >>> print(onp.allclose(mnp.dot(A,x).asnumpy(), b.asnumpy()))
-        True
-    """
-    func_name = "gmres"
-    A, M, b, x0 = _sparse_check(func_name, A, M, b, x0)
-    size = b.size
-    if maxiter is None:
-        maxiter = 10 * size  # copied from scipy
-    _type_check(func_name, tol, float, 'tol')
-    _type_check(func_name, restart, int, 'restart')
-    _type_check(func_name, maxiter, int, 'maxiter')
-    _type_check(func_name, solve_method, str, 'solve_method')
-    _value_check(func_name, callback, None, 'callback', op='is', fmt='todo')
-    _value_check(func_name, restrt, None, 'restrt', op='is', fmt='todo')
-    _value_check(func_name, callback_type, None, 'callback_type', op='is', fmt='todo')
-    if restart > size:
-        restart = size
-    if not is_within_graph(b):
-        x, info = GMRES(A, M, solve_method)(b, x0, tol, restart, maxiter, atol)
-    else:
-        x, info = GMRESV2(solve_method)(A, b, x0, tol, restart, maxiter, M, atol)
-    return x, info
+from ..utils_const import is_within_graph
 
 
 def _cg(A, b, x0, tol, atol, maxiter, M):
@@ -493,7 +162,7 @@ def cg(A, b, x0=None, *, tol=1e-5, atol=0.0, maxiter=None, M=None, callback=None
         TypeError: If `A` and `b` don't have the same data types.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as onp
@@ -521,132 +190,3 @@ def cg(A, b, x0=None, *, tol=1e-5, atol=0.0, maxiter=None, M=None, callback=None
     else:
         x, info = CGv2()(A, b, x0, tol, atol, maxiter, M)
     return x, info
-
-
-class BiCGStab(nn.Cell):
-    """Figure 2.10 from Barrett R, et al. 'Templates for the sulution of linear systems:
-    building blocks for iterative methods', 1994, pg. 24-25
-    """
-
-    def __init__(self, A, M):
-        super(BiCGStab, self).__init__()
-        self.A = A
-        self.M = M
-
-    def construct(self, b, x0, tol, atol, maxiter):
-        # Constant tensors which avoid loop unrolling
-        const_int_zero = _to_tensor(0)
-        const_int_neg_one = _to_tensor(-1)
-
-        const_float_one = _to_tensor(1., dtype=b.dtype)
-        atol_ = mnp.maximum(atol, tol * _norm(b))
-
-        r = r_tilde = v = p = b - _matvec(self.A, x0)
-        rho = alpha = omega = const_float_one
-        k = const_int_zero
-        x = x0
-        while k < maxiter:
-            rho_ = mnp.dot(r_tilde, r)
-            if rho_ == 0. or omega == 0.:
-                k = const_int_neg_one
-                break
-
-            beta = rho_ / rho * (alpha / omega)
-            p = r + beta * (p - omega * v)
-            p_hat = _matvec(self.M, p)
-            v = _matvec(self.A, p_hat)
-            alpha = rho_ / mnp.dot(r_tilde, v)
-            s = r - alpha * v
-            x = x + alpha * p_hat
-            if _norm(s) <= atol_:
-                break
-
-            s_hat = _matvec(self.M, s)
-            t = _matvec(self.A, s_hat)
-            omega = mnp.dot(t, s) / mnp.dot(t, t)
-            x = x + omega * s_hat
-            r = s - omega * t
-            if _norm(r) <= atol_:
-                break
-
-            rho = rho_
-            k += 1
-
-        return x, F.select(k == const_int_neg_one or k >= maxiter, k, const_int_zero)
-
-
-def bicgstab(A, b, x0=None, *, tol=1e-5, atol=0.0, maxiter=None, M=None):
-    """Use Bi-Conjugate Gradient Stable iteration to solve :math:`Ax = b`.
-
-    The numerics of MindSpore's `bicgstab` should exact match SciPy's
-    `bicgstab` (up to numerical precision).
-
-    As with `cg`, derivatives of `bicgstab` are implemented via implicit
-    differentiation with another `bicgstab` solve, rather than by
-    differentiating *through* the solver. They will be accurate only if
-    both solves converge.
-
-    Note:
-        - `bicgstab` is not supported on Windows platform yet.
-
-    Args:
-        A (Union[Tensor, function]): 2D Tensor or function that calculates the linear
-            map (matrix-vector product) :math:`Ax` when called like :math:`A(x)`.
-            As function, `A` must return Tensor with the same structure and shape as its input matrix.
-        b (Tensor): Right hand side of the linear system representing a single vector. Can be
-            stored as a Tensor.
-        x0 (Tensor): Starting guess for the solution. Must have the same structure as `b`. Default: None.
-        tol (float, optional): Tolerances for convergence, :math:`norm(residual) <= max(tol*norm(b), atol)`.
-            We do not implement SciPy's "legacy" behavior, so MindSpore's tolerance will
-            differ from SciPy unless you explicitly pass `atol` to SciPy's `bicgstab`. Default: 1e-5.
-        atol (float, optional): The same as `tol`. Default: 0.0.
-        maxiter (int): Maximum number of iterations.  Iteration will stop after maxiter
-            steps even if the specified tolerance has not been achieved. Default: None.
-        M (Union[Tensor, function]): Preconditioner for A.  The preconditioner should approximate the
-            inverse of A. Effective preconditioning dramatically improves the
-            rate of convergence, which implies that fewer iterations are needed
-            to reach a given error tolerance. Default: None.
-
-    Returns:
-        - Tensor, the converged solution. Has the same structure as `b`.
-        - Tensor, placeholder for convergence information: 0 : successful exit.
-          >0 : convergence to tolerance not achieved, number of iterations. <0 : illegal input or breakdown.
-
-    Raises:
-        ValueError: If `x0` and `b` don't have the same structure.
-        TypeError: If `A`, `x0` and `b` don't have the same float types(`mstype.float32` or `mstype.float64`).
-
-    Supported Platforms:
-        ``CPU`` ``GPU``
-
-    Examples:
-        >>> import numpy as onp
-        >>> from mindspore.common import Tensor
-        >>> from mindspore.scipy.sparse.linalg import bicgstab
-        >>> A = Tensor(onp.array([[1, 2], [2, 1]], dtype='float32'))
-        >>> b = Tensor(onp.array([1, -1], dtype='float32'))
-        >>> result, info = bicgstab(A, b)
-        >>> print(result)
-        [-1.  1.]
-        >>> print(info)
-        0
-    """
-    if x0 is None:
-        x0 = mnp.zeros_like(b)
-
-    if maxiter is None:
-        maxiter = 10 * b.shape[0]
-
-    if M is None:
-        M = lambda x: x
-
-    if x0.shape != b.shape:
-        _raise_value_error(
-            'Input x0 and b must have matching shapes: ', x0.shape, ' vs ', b.shape)
-
-    if (F.dtype(b) not in (mstype.float32, mstype.float64)) or (F.dtype(b) != F.dtype(x0)) or (
-            F.dtype(b) != F.dtype(A)):
-        _raise_type_error('Input A, x0 and b must have same float types')
-
-    x, info = BiCGStab(A, M)(b, x0, tol, atol, maxiter)
-    return x, info

mindspore/scipy/utils.py

@@ -157,7 +157,7 @@ def _solve_check(func_name, arg1, arg2, arg1_name='a', arg2_name='b', sparse=Fal
 
 
 def _sparse_check(func_name, a, m, b, x0):
-    """Used for cg, bicgstab and gmres method."""
+    """Used for cg method."""
 
     def _check_right(arg, arg_name):
         if arg is None:

mindspore/scipy/utils_const.py

@@ -16,6 +16,7 @@
 from __future__ import absolute_import
 from types import FunctionType
 from collections.abc import Iterable
+from mindspore.ops import functional as F
 from .. import context
 from ..ops.primitive import constexpr
 from ..common import Tensor, CSRTensor
@@ -29,13 +30,18 @@ def _callable_const(x):
 
 
 @constexpr
+def is_pynative():
+    """Returns true if the current mode is PYNATIVE mode."""
+    return context.get_context("mode") == context.PYNATIVE_MODE
+
+
 def is_within_graph(x):
     """
     Returns true if x is None. It's aim to check whether the call is within MindSpore graph.
     Because in graph mode, x should be None in constexpr when x is a variable of MindSpore.
     Note that always return true if the call is in pynative mode.
     """
-    return context.get_context("mode") == context.PYNATIVE_MODE or x is None
+    return is_pynative() or not F.isconstant(x) or x is None
 
 
 @constexpr

mindspore/train/__init__.py

@@ -35,7 +35,7 @@ from mindspore.train.train_thor import ConvertNetUtils, ConvertModelUtils
 from mindspore.train.metrics import *
 from mindspore.train.data_sink import data_sink
 
-__all__ = ["Model", "DatasetHelper", "amp", "connect_network_with_dataset", "build_train_network", "LossScaleManager",
+__all__ = ["Model", "DatasetHelper", "connect_network_with_dataset", "build_train_network", "LossScaleManager",
            "FixedLossScaleManager", "DynamicLossScaleManager", "save_checkpoint", "load_checkpoint",
            "load_param_into_net", "export", "load", "parse_print", "build_searched_strategy", "merge_sliced_parameter",
            "load_distributed_checkpoint", "async_ckpt_thread_status", "restore_group_info_list", "convert_model",

mindspore/train/_utils.py

@@ -20,16 +20,18 @@ from collections.abc import Iterable
 import numpy as np
 
 from mindspore.common.tensor import Tensor
+from mindspore._c_expression import Tensor as Tensor_
 from mindspore.common.dtype import dtype_to_nptype, pytype_to_dtype
 from mindspore.common import dtype as mstype
 from mindspore import log as logger
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from mindspore.common.api import _cell_graph_executor
 from mindspore.train.mind_ir_pb2 import ModelProto as mindir_model
 from mindspore.train.checkpoint_pb2 import Checkpoint
 from mindspore.train.node_strategy_pb2 import ParallelStrategyMap as ckpt_strategy
 from mindspore.train.lineage_pb2 import DatasetGraph, TrainLineage, EvaluationLineage, UserDefinedInfo
 from mindspore.parallel._parallel_serialization import _make_dir
+from mindspore.ops.operations import debug_ops
 
 
 def _convert_type(types):
@@ -135,27 +137,48 @@ def _construct_input_tensors(dataset_types, dataset_shapes, device_number=1):
     return tensor_list_run, tensor_list_compile
 
 
-def _check_to_numpy(plugin, tensor):
+def _check_to_numpy(plugin, tensor, prim=None):
     """Check the tensor and return a numpy.ndarray."""
     np_value = tensor.asnumpy()
     np_value = np_value.copy()
+    summary_name = plugin.capitalize() + "Summary" if prim else "SummaryRecord"
     if plugin == 'scalar':
         if np_value.size == 1:
             return np_value
-        raise ValueError('The tensor holds more than one value, but the scalar plugin expects on value.')
+        raise ValueError(
+            f'For "{summary_name}", the v rank must be less than or equal to 1, but got {len(np_value)}.')
     if plugin == 'image':
         if np_value.ndim == 4:
             return np_value
-        raise ValueError('The tensor seems not to hold a valid image.')
+        raise ValueError(f'For "{summary_name}", The tensor seems not to hold a valid image.')
     if plugin in ('tensor', 'histogram'):
         if np_value.ndim > 0:
             return np_value
-        raise ValueError('The tensor should not be empty.')
+        raise ValueError(f'For "{summary_name}", The value should not be empty.')
     return np_value
 
 
+def check_summary_param(summary_name, tag, tensor):
+    """Checks the tag is valid for summary."""
+    plugin = summary_name.split('Summary')[0].lower()
+    try:
+        if not isinstance(tag, str) or not tag:
+            raise TypeError(f'For "{summary_name}", the name must be valid string, but got "{tag}".')
+        if not isinstance(tensor, (Tensor, Tensor_)):
+            raise TypeError(f'For "{summary_name}", the parameter "value" expect to be Tensor, '
+                            f'but got {type(tensor).__name__}')
+        _check_to_numpy(plugin, tensor, prim=True)
+    except TypeError as err:
+        raise TypeError(err)
+    except ValueError as err:
+        raise ValueError(err)
+    finally:
+        debug_ops.SUMMARY_TENSOR_CACHE = []
+
+
 def _check_lineage_value(plugin, value):
     """Check the lineage value."""
+
     def raises(plugin, prototype):
         raise TypeError(f'Plugin {repr(plugin)} expects a {prototype.__name__} value.')