From 8ac955e8bf2be8192a1fa6c2eaaa8c5f23034951 Mon Sep 17 00:00:00 2001 From: yanglf1121 Date: Mon, 17 May 2021 16:40:05 +0800 Subject: [PATCH] fix static check errors --- mindspore/numpy/array_creations.py | 59 ++++++++------- mindspore/numpy/math_ops.py | 118 ++++++++++++++++------------- mindspore/numpy/utils_const.py | 11 ++- 3 files changed, 107 insertions(+), 81 deletions(-) diff --git a/mindspore/numpy/array_creations.py b/mindspore/numpy/array_creations.py index 7c8e2ca7bf3..8a644bbb0c6 100644 --- a/mindspore/numpy/array_creations.py +++ b/mindspore/numpy/array_creations.py @@ -219,8 +219,7 @@ def asfarray(a, dtype=mstype.float32): return asarray(a) dtype = _check_dtype(dtype) - # pylint: disable=consider-using-in - if dtype != mstype.float16 and dtype != mstype.float32 and dtype != mstype.float64: + if dtype not in (mstype.float16, mstype.float32, mstype.float64): dtype = mstype.float32 if isinstance(a, Tensor): @@ -436,7 +435,7 @@ def arange(start, stop=None, step=None, dtype=None): return out.astype(dtype) -def _type_checking_for_xspace(start, stop, num, endpoint, dtype, axis): +def _type_checking_for_xspace(start, stop, num, endpoint, dtype): """utility parameter checking function for linspace, logspace, geomspace.""" if not isinstance(start, ARRAY_TYPES): _raise_type_error("start should be int, float, bool, list, tuple, Tensor, but got", start) @@ -455,8 +454,18 @@ def _type_checking_for_xspace(start, stop, num, endpoint, dtype, axis): else: dtype = mstype.float32 start, stop = broadcast_arrays(start, stop) - axis = _canonicalize_axis(axis, start.ndim+1) - return start, stop, num, endpoint, dtype, axis + return start, stop, num, endpoint, dtype + + +def _compute_shapes(start, axis, num, endpoint): + """Computes shapes for local variables for np.linspace""" + bounds_shape = start.shape + bounds_shape = _tuple_slice(bounds_shape, None, axis) + (1,) + _tuple_slice(bounds_shape, axis, None) + iota_shape = _list_comprehensions(start.ndim+1, 1, True) + iota_shape = _tuple_slice(iota_shape, None, axis) + (num,) + _tuple_slice(iota_shape, axis+1, None) + num_tensor = _type_convert(Tensor, num).astype(mstype.float32) + div = (num_tensor - 1) if endpoint else num_tensor + return bounds_shape, iota_shape, div def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0): @@ -500,15 +509,11 @@ def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis [0. 1. 2. 3. 4. 5.] """ # This implementation was inspired by jax.numpy.linspace and numpy.linspace - start, stop, num, endpoint, dtype, axis = _type_checking_for_xspace(start, stop, num, endpoint, dtype, axis) + start, stop, num, endpoint, dtype = _type_checking_for_xspace(start, stop, num, endpoint, dtype) + axis = _canonicalize_axis(axis, start.ndim+1) if not isinstance(retstep, bool): _raise_type_error("retstep should be an boolean, but got ", retstep) - bounds_shape = start.shape - bounds_shape = _tuple_slice(bounds_shape, None, axis) + (1,) + _tuple_slice(bounds_shape, axis, None) - iota_shape = _list_comprehensions(start.ndim+1, 1, True) - iota_shape = _tuple_slice(iota_shape, None, axis) + (num,) + _tuple_slice(iota_shape, axis+1, None) - num_tensor = _type_convert(Tensor, num).astype(mstype.float32) - div = (num_tensor - 1) if endpoint else num_tensor + bounds_shape, iota_shape, div = _compute_shapes(start, axis, num, endpoint) out = None delta = None if num > 1: @@ -572,7 +577,8 @@ def logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0): [ 1. 2. 4. 8. 16. 32.] """ # This implementation was inspired by jax.numpy.linspace and numpy.linspace - start, stop, num, endpoint, dtype, axis = _type_checking_for_xspace(start, stop, num, endpoint, dtype, axis) + start, stop, num, endpoint, dtype = _type_checking_for_xspace(start, stop, num, endpoint, dtype) + axis = _canonicalize_axis(axis, start.ndim+1) if not isinstance(base, (int, float, bool)): _raise_type_error("base should be a number, but got ", base) linspace_res = linspace(start, stop, num, endpoint=endpoint, retstep=False, dtype=None, axis=axis) @@ -620,7 +626,8 @@ def geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0): >>> print(output) [ 1. 2. 4. 8. 16. 32. 64. 128.] """ - start, stop, num, endpoint, dtype, axis = _type_checking_for_xspace(start, stop, num, endpoint, dtype, axis) + start, stop, num, endpoint, dtype = _type_checking_for_xspace(start, stop, num, endpoint, dtype) + axis = _canonicalize_axis(axis, start.ndim+1) root = num if endpoint: root -= 1 @@ -728,6 +735,7 @@ def identity(n, dtype=mstype.float32): @constexpr def empty_compile(dtype, shape): + """Returns an empty Tensor.""" return Tensor_(dtype, shape) @@ -1183,9 +1191,9 @@ def trace(a, offset=0, axis1=0, axis2=1, dtype=None): return a.trace(offset=offset, axis1=axis1, axis2=axis2, dtype=dtype) -def _index(i, size, Cartesian=True): - """If Cartesian=True, index 0 is swapped with index 1.""" - if Cartesian: +def _index(i, size, cartesian=True): + """If cartesian=True, index 0 is swapped with index 1.""" + if cartesian: if i == 1: return 0 if i == 0 and size >= 2: @@ -1272,12 +1280,12 @@ def meshgrid(*xi, sparse=False, indexing='xy'): Cartesian = indexing == 'xy' shape_out = () for i in range(len(grids)): - grid_index = _index(i, ndim, Cartesian=Cartesian) + grid_index = _index(i, ndim, cartesian=Cartesian) shape_out += (F.shape(grids[grid_index])[0],) res = [] for i, x in enumerate(grids): - grid_index = _index(i, ndim, Cartesian=Cartesian) + grid_index = _index(i, ndim, cartesian=Cartesian) shape_expanded = _expanded_shape(ndim, shape_out[grid_index], grid_index) x = x.reshape(shape_expanded) if not sparse: @@ -1341,7 +1349,7 @@ class nd_grid: return res -class mGridClass(nd_grid): +class MGridClass(nd_grid): """ mgrid is an :class:`nd_grid` instance with ``sparse=False``. @@ -1386,10 +1394,10 @@ class mGridClass(nd_grid): [-1. -0.5 0. 0.5 1. ] """ def __init__(self): - super(mGridClass, self).__init__(sparse=False) + super(MGridClass, self).__init__(sparse=False) -class oGridClass(nd_grid): +class OGridClass(nd_grid): """ ogrid is an :class:`nd_grid` instance with ``sparse=True``. @@ -1428,13 +1436,13 @@ class oGridClass(nd_grid): [-1. -0.5 0. 0.5 1. ] """ def __init__(self): - super(oGridClass, self).__init__(sparse=True) + super(OGridClass, self).__init__(sparse=True) -mgrid = mGridClass() +mgrid = MGridClass() -ogrid = oGridClass() +ogrid = OGridClass() def diag(v, k=0): @@ -1635,7 +1643,6 @@ def ix_(*args): [1]]), Tensor(shape=[1, 2], dtype=Int32, value= [[2, 4]])) """ - # TODO boolean mask _check_input_tensor(*args) ndim = len(args) res = () diff --git a/mindspore/numpy/math_ops.py b/mindspore/numpy/math_ops.py index 6d8ca82254b..98ab4d693e9 100644 --- a/mindspore/numpy/math_ops.py +++ b/mindspore/numpy/math_ops.py @@ -50,7 +50,7 @@ ZERO_TENSOR = asarray_const(0) _mean_keepdims = P.ReduceMean(True) _matmul = P.MatMul(False, False) -_matmul_T = P.MatMul(False, True) +_matmul_t = P.MatMul(False, True) _reduce_sum_default = P.ReduceSum() _reduce_sum_keepdims = P.ReduceSum(True) _reduce_min_default = P.ReduceMin() @@ -63,6 +63,7 @@ _cumprod_default = P.CumProd() _round = P.Round() + def absolute(x, dtype=None): """ Calculates the absolute value element-wise. @@ -669,7 +670,7 @@ def inner(a, b): a_aligned = F.reshape(a, aligned_shape_a) b_aligned = F.reshape(b, aligned_shape_b) - res = _matmul_T(a_aligned, b_aligned) + res = _matmul_t(a_aligned, b_aligned) res = F.reshape(res, F.shape(a)[:-1] + F.shape(b)[:-1]) return res @@ -733,7 +734,7 @@ def dot(a, b): a_aligned = F.reshape(a, (-1, F.shape(a)[-1])) b_aligned = F.reshape(b, (-1, F.shape(b)[-1])) - res = _matmul_T(a_aligned, b_aligned) + res = _matmul_t(a_aligned, b_aligned) res = F.reshape(res, F.shape(a)[:-1] + F.shape(b)[:-1]) return res @@ -1008,21 +1009,10 @@ def average(x, axis=None, weights=None, returned=False): x_avg = full((), nan, F.dtype(x)) sum_of_weights = None + if weights is None: x_avg = mean(x, axis) - if axis is None: - sum_of_weights = full((), x.size, F.dtype(x)) - else: - fill_value = 1 - if isinstance(axis, int) or (isinstance(axis, tuple) and F.tuple_len(axis) == 1): - fill_value = x.shape[axis] if isinstance(axis, int) else x.shape[axis[0]] - elif axis is None: - for sh in x.shape: - fill_value *= sh - else: - for ax in axis: - fill_value *= x.shape[ax] - sum_of_weights = full_like(x_avg, fill_value, F.dtype(x)) + sum_of_weights = compute_weights_for_mean(x, x_avg, axis) else: _check_input_tensor(weights) if x.shape == weights.shape: @@ -1043,6 +1033,24 @@ def average(x, axis=None, weights=None, returned=False): return x_avg +def compute_weights_for_mean(x, x_avg, axis): + """Computes weights for np.average.""" + if axis is None: + sum_of_weights = full((), x.size, F.dtype(x)) + else: + fill_value = 1 + if isinstance(axis, int) or (isinstance(axis, tuple) and F.tuple_len(axis) == 1): + fill_value = x.shape[axis] if isinstance(axis, int) else x.shape[axis[0]] + elif axis is None: + for sh in x.shape: + fill_value *= sh + else: + for ax in axis: + fill_value *= x.shape[ax] + sum_of_weights = full_like(x_avg, fill_value, F.dtype(x)) + return sum_of_weights + + def comput_avg(x, axis, weights): """Computes average value of input x with given parameters.""" axis = () if axis is None else axis @@ -1578,7 +1586,7 @@ def floor_divide(x1, x2, dtype=None): return _apply_tensor_op(F.tensor_floordiv, x1, x2, dtype=dtype) -def _remainder(x1, x2, C_style=False): +def _remainder(x1, x2, c_style=False): """Computes remainder without applying keyword arguments.""" dtype = _promote(F.dtype(x1), F.dtype(x2)) if not _check_is_float(dtype): @@ -1586,7 +1594,7 @@ def _remainder(x1, x2, C_style=False): x2 = F.cast(x2, mstype.float32) quotient = F.tensor_div(x1, x2) - if C_style: + if c_style: quotient = fix(quotient) else: quotient = F.floor(quotient) @@ -1671,7 +1679,7 @@ def fix(x): if not _check_is_float(F.dtype(x)): x = F.cast(x, mstype.float32) floored = F.floor(x) - # TODO change to F.ceil once supported on CPU. + # change to F.ceil once supported on CPU. ceiled = F.neg_tensor(F.floor(F.neg_tensor(x))) is_neg = F.tensor_lt(x, zeros(F.shape(x), F.dtype(x))) return F.select(is_neg, ceiled, floored) @@ -1708,7 +1716,7 @@ def fmod(x1, x2, dtype=None): >>> print(output) [-1 0 -1 1 0 1] """ - return _apply_tensor_op(lambda x1, x2: _remainder(x1, x2, C_style=True), x1, x2, dtype=dtype) + return _apply_tensor_op(lambda x1, x2: _remainder(x1, x2, c_style=True), x1, x2, dtype=dtype) def trunc(x, dtype=None): @@ -1845,6 +1853,19 @@ def divmod_(x1, x2, dtype=None): return (q, r) +def _handle_prepend_append(combined, tensor, additional_tensor, axis): + """Concatenates prepend or append to tensor.""" + if isinstance(additional_tensor, (int, float, bool)): + additional_tensor = asarray_const(additional_tensor) + elif not isinstance(additional_tensor, Tensor): + _raise_type_error("prepend must be scalar or Tensor, but got ", additional_tensor) + additional_shape = tensor.shape + additional_shape = _tuple_setitem(additional_shape, axis, 1) + additional_tensor = _broadcast_to_shape(additional_tensor, additional_shape) + combined += (additional_tensor,) + return combined + + def diff(a, n=1, axis=-1, prepend=None, append=None): """ Calculates the n-th discrete difference along the given axis. @@ -1899,26 +1920,12 @@ def diff(a, n=1, axis=-1, prepend=None, append=None): combined = () if prepend is not None: - if isinstance(prepend, (int, float, bool)): - prepend = asarray_const(prepend) - elif not isinstance(prepend, Tensor): - _raise_type_error("prepend must be scalar or Tensor, but got ", prepend) - prepend_shape = a.shape - prepend_shape = _tuple_setitem(prepend_shape, axis, 1) - prepend = _broadcast_to_shape(prepend, prepend_shape) - combined += (prepend,) + combined = _handle_prepend_append(combined, a, prepend, axis) combined += (a,) if append is not None: - if isinstance(append, (int, float, bool)): - append = asarray_const(append) - elif not isinstance(append, Tensor): - _raise_type_error("append must be scalar or Tensor, but got ", append) - append_shape = a.shape - append_shape = _tuple_setitem(append_shape, axis, 1) - append = _broadcast_to_shape(append, append_shape) - combined += (append,) + combined = _handle_prepend_append(combined, a, append, axis) if combined: a = concatenate(combined, axis) @@ -2240,6 +2247,22 @@ def _handle_inputs(cov_input, rowvar): return cov_input +def _handle_facts(w, m, ddof, aweights): + """Computes facts for np.cov""" + fact = None + if w is None: + fact = m.shape[1] - ddof + else: + w_sum = _reduce_sum_default(w, -1) + if ddof == 0: + fact = w_sum + elif aweights is None: + fact = w_sum - ddof + else: + fact = w_sum - ddof * F.reduce_sum(w * aweights) / w_sum + return fact + + def cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None, dtype=None): """ Estimates a covariance matrix, given data and weights. @@ -2329,23 +2352,14 @@ def cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=N avg = average(m, axis=1, weights=w) # Determine the Normalization - if w is None: - fact = m.shape[1] - ddof - else: - w_sum = _reduce_sum_default(w, -1) - if ddof == 0: - fact = w_sum - elif aweights is None: - fact = w_sum - ddof - else: - fact = w_sum - ddof * F.reduce_sum(w * aweights) / w_sum + fact = _handle_facts(w, m, ddof, aweights) m = m - F.expand_dims(avg, -1) if w is None: - m_T = m.T + m_t = m.T else: - m_T = (m * w).T - res = true_divide(dot(m, m_T), fact).squeeze() + m_t = (m * w).T + res = true_divide(dot(m, m_t), fact).squeeze() if dtype is not None: return res.astype(dtype) return res @@ -2418,7 +2432,7 @@ def _reduce(a, reduce_fn, cmp_fn=None, axis=None, keepdims=False, initial=None, if cmp_fn is None: initial = nan else: - return _raise_value_error('initial value must be provided for zero-size arrays') + _raise_value_error('initial value must be provided for zero-size arrays') return full(shape_out, initial, dtype) if initial is not None: @@ -2427,7 +2441,7 @@ def _reduce(a, reduce_fn, cmp_fn=None, axis=None, keepdims=False, initial=None, if isinstance(where, Tensor): if initial is None: - return _raise_value_error('initial value must be provided for where masks') + _raise_value_error('initial value must be provided for where masks') ndim_orig = F.rank(a) a = where_(where, a, initial) axes = _real_axes(ndim_orig, F.rank(a), axes) @@ -3278,8 +3292,10 @@ def log2(x, dtype=None): [1. 2. 3.] """ tensor_2 = _make_tensor(2, x.dtype) + def _log2(x): return F.log(x) / F.log(tensor_2) + return _apply_tensor_op(_log2, x, dtype=dtype) diff --git a/mindspore/numpy/utils_const.py b/mindspore/numpy/utils_const.py index 394eb22440b..b29644cc930 100644 --- a/mindspore/numpy/utils_const.py +++ b/mindspore/numpy/utils_const.py @@ -311,9 +311,12 @@ def _check_axis_type(axis, type_int=True, type_tuple=True, type_list=True): return True type_str = "" - if type_int: type_str += "int, " - if type_tuple: type_str += "tuple, " - if type_list: type_str += "list, " + if type_int: + type_str += "int, " + if type_tuple: + type_str += "tuple, " + if type_list: + type_str += "list, " raise TypeError(f"Axis should be {type_str}but got {type(axis)}.") @@ -451,7 +454,7 @@ def _tuple_setitem(tup, idx, value): @constexpr def _iota(dtype, num, increasing=True): """Creates a 1-D tensor with value: [0,1,...num-1] and dtype.""" - # TODO: Change to P.Linspace when the kernel is implemented on CPU. + # Change to P.Linspace when the kernel is implemented on CPU. if num <= 0: raise ValueError("zero shape Tensor is not currently supported.") if increasing: