revert apache#15309 apache#15256 apache#15219 apache#15161

Author: haojin2

python/mxnet/_numpy_op_doc.py

@@ -114,54 +114,6 @@ def _np_repeat(a, repeats, axis=None):
     pass
 
 
-def _np_cumsum(a, axis=None, dtype=None, out=None):
-    """cumsum(a, axis=None, dtype=None, out=None)
-
-    Return the cumulative sum of the elements along a given axis.
-
-    Parameters
-    ----------
-    a : ndarray
-        Input array.
-    axis : int, optional
-        Axis along which the cumulative sum is computed. The default
-        (None) is to compute the cumsum over the flattened array.
-    dtype : dtype, optional
-        Type of the returned array and of the accumulator in which the
-        elements are summed.  If `dtype` is not specified, it defaults
-        to the dtype of `a`.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must
-        have the same shape, type and buffer length as the expected output.
-
-    Returns
-    -------
-    cumsum_along_axis : ndarray.
-        A new array holding the result is returned unless `out` is
-        specified, in which case a reference to `out` is returned. The
-        result has the same size as `a`, and the same shape as `a` if
-        `axis` is not None or `a` is a 1-d array.
-
-    Examples
-    --------
-    >>> a = np.array([[1,2,3], [4,5,6]])
-    >>> a
-    array([[1., 2., 3.],
-           [4., 5., 6.]])
-    >>> np.cumsum(a)
-    array([ 1.,  3.,  6., 10., 15., 21.])
-    >>> np.cumsum(a, dtype=float)     
-    array([ 1.,  3.,  6., 10., 15., 21.], dtype=float64)
-    >>> np.cumsum(a,axis=0)      
-    array([[1., 2., 3.],
-           [5., 7., 9.]])
-    >>> np.cumsum(a,axis=1)      
-    array([[ 1.,  3.,  6.],
-           [ 4.,  9., 15.]])
-    """
-    pass
-
-
 def _np_dot(a, b, out=None):
     """dot(a, b, out=None)
 

python/mxnet/ndarray/numpy/_op.py

@@ -28,7 +28,7 @@
 
 __all__ = ['zeros', 'ones', 'maximum', 'minimum', 'stack', 'arange', 'argmax',
            'add', 'subtract', 'multiply', 'divide', 'mod', 'power', 'concatenate',
-           'clip', 'split', 'swapaxes', 'expand_dims', 'tile', 'linspace',
+           'clip', 'split', 'swapaxes', 'expand_dims', 'tile',
            'sin', 'cos', 'sinh', 'cosh', 'log10', 'sqrt', 'abs', 'exp', 'arctan']
 
 
@@ -649,67 +649,6 @@ def tile(A, reps):
     return _npi.tile(A, reps)
 
 
-@set_module('mxnet.ndarray.numpy')
-def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0, **kwargs):  # pylint: disable=too-many-arguments
-    """Return evenly spaced numbers over a specified interval.
-
-    Returns num evenly spaced samples, calculated over the interval [start, stop].
-    The endpoint of the interval can optionally be excluded.
-
-    Parameters
-    ----------
-    start : array_like
-        The starting value of the sequence.
-    stop : array_like
-        The end value of the sequence, unless endpoint is set to False. In
-        that case, the sequence consists of all but the last of num + 1
-        evenly spaced samples, so that stop is excluded. Note that the step
-        size changes when endpoint is False.
-    num : int, optional
-        Number of samples to generate. Default is 50. Must be non-negative.
-    endpoint : bool, optional
-        If True, stop is the last sample. Otherwise, it is not included.
-        Default is True.
-    retstep : bool, optional
-        If True, return (samples, step), where step is the spacing between samples.
-    dtype : dtype, optional
-        The type of the output array. If dtype is not given, infer the data
-        type from the other input arguments.
-    axis : int, optional
-        The axis in the result to store the samples. Relevant only if start or
-        stop are array-like. By default (0), the samples will be along a new
-        axis inserted at the beginning. Use -1 to get an axis at the end.
-
-    Returns
-    -------
-    samples : ndarray
-        There are num equally spaced samples in the closed interval
-        `[start, stop]` or the half-open interval `[start, stop)`
-        (depending on whether endpoint is True or False).
-    step : float, optional
-        Only returned if retstep is True
-        Size of spacing between samples.
-
-    Notes
-    -----
-    This function currently does not support ``start`` and ``stop`` as ndarrays and
-    axis could only be 0 now.
-    """
-    if isinstance(start, (list, _np.ndarray, NDArray)) or \
-       isinstance(stop, (list, _np.ndarray, NDArray)):
-        raise NotImplementedError('start and stop only support int')
-    if axis != 0:
-        raise NotImplementedError("the function only support axis 0")
-    ctx = kwargs.pop('ctx', current_context())
-    if ctx is None:
-        ctx = current_context()
-    if retstep:
-        step = (stop - start) / (num - 1)
-        return _npi.linspace(start=start, stop=stop, num=num, endpoint=endpoint, ctx=ctx, dtype=dtype), step
-    else:
-        return _npi.linspace(start=start, stop=stop, num=num, endpoint=endpoint, ctx=ctx, dtype=dtype)
-
-
 def _unary_func_helper(x, fn_array, fn_scalar, out=None, **kwargs):
     """Helper function for unary operators.
 

python/mxnet/ndarray/numpy/random.py

@@ -23,7 +23,7 @@
 from ..ndarray import NDArray
 from . import _internal as _npi
 
-__all__ = ['uniform', 'normal', 'multinomial']
+__all__ = ['uniform', 'normal']
 
 
 def _random_helper(random, sampler, params, shape, dtype, ctx, out, kwargs):
@@ -137,55 +137,3 @@ def normal(loc=0.0, scale=1.0, size=None, **kwargs):
     out = kwargs.pop('out', None)
     return _random_helper(_npi.random_normal, None,
                           [loc, scale], size, dtype, ctx, out, kwargs)
-
-
-def multinomial(n, pvals, size=None):
-    """multinomial(n, pvals, size=None)
-
-    Draw samples from a multinomial distribution.
-
-    The multinomial distribution is a multivariate generalisation of the binomial distribution.
-    Take an experiment with one of ``p`` possible outcomes. An example of such an experiment is throwing a dice,
-    where the outcome can be 1 through 6. Each sample drawn from the distribution represents n such experiments.
-    Its values, ``X_i = [X_0, X_1, ..., X_p]``, represent the number of times the outcome was ``i``.
-
-    Parameters
-    ----------
-    n : int
-        Number of experiments.
-    pvals : sequence of floats, length p
-        Probabilities of each of the p different outcomes. These should sum to 1.
-    size : int or tuple of ints, optional
-        Output shape. If the given shape is, e.g., ``(m, n, k)``, then ``m * n * k`` samples
-        are drawn. Default is None, in which case a single value is returned.
-
-    Returns
-    -------
-    out : ndarray
-        The drawn samples, of shape size, if that was provided. If not, the shape is ``(N,)``.
-        In other words, each entry ``out[i,j,...,:]`` is an N-dimensional value drawn from the distribution.
-
-    Examples
-    --------
-    Throw a dice 1000 times, and 1000 times again:
-
-    >>> np.random.multinomial(1000, [1/6.]*6, size=2)
-    array([[164, 161, 179, 158, 150, 188],
-           [178, 162, 177, 143, 163, 177]])
-
-    A loaded die is more likely to land on number 6:
-
-    >>> np.random.multinomial(100, [1/7.]*5 + [2/7.])
-    array([19, 14, 12, 11, 21, 23])
-
-    >>> np.random.multinomial(100, [1.0 / 3, 2.0 / 3])
-    array([32, 68])
-    """
-    if isinstance(pvals, NDArray):
-        return _npi.multinomial(pvals, pvals=None, n=n, size=size)
-    else:
-        if isinstance(pvals, np.ndarray):
-            pvals = pvals.tolist()
-        if any(isinstance(i, list) for i in pvals):
-            raise ValueError('object too deep for desired array')
-        return _npi.multinomial(n=n, pvals=pvals, size=size)

python/mxnet/numpy/multiarray.py

@@ -45,7 +45,7 @@
 
 __all__ = ['ndarray', 'empty', 'array', 'zeros', 'ones', 'maximum', 'minimum', 'stack', 'arange',
            'argmax', 'add', 'subtract', 'multiply', 'divide', 'mod', 'power', 'concatenate',
-           'clip', 'split', 'swapaxes', 'expand_dims', 'tile', 'linspace', 'sin', 'cos',
+           'clip', 'split', 'swapaxes', 'expand_dims', 'tile', 'sin', 'cos',
            'sinh', 'cosh', 'log10', 'sqrt', 'abs', 'exp', 'arctan']
 
 
@@ -936,7 +936,7 @@ def std(self, axis=None, dtype=None, out=None, ddof=0, keepdims=False):  # pylin
 
     def cumsum(self, axis=None, dtype=None, out=None):
         """Return the cumulative sum of the elements along the given axis."""
-        return _mx_np_op.cumsum(self, axis=axis, dtype=dtype, out=out)
+        raise NotImplementedError
 
     def tolist(self):
         return self.asnumpy().tolist()
@@ -1871,49 +1871,6 @@ def tile(A, reps):
     return _npi.tile(A, reps)
 
 
-@set_module('mxnet.numpy')
-def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0, **kwargs):
-    """Return evenly spaced numbers over a specified interval.
-
-    Returns num evenly spaced samples, calculated over the interval [start, stop].
-    The endpoint of the interval can optionally be excluded.
-
-    Parameters
-    ----------
-    start : array_like
-        The starting value of the sequence.
-    stop : array_like
-        The end value of the sequence, unless endpoint is set to False. In
-        that case, the sequence consists of all but the last of num + 1
-        evenly spaced samples, so that stop is excluded. Note that the step
-        size changes when endpoint is False.
-    num : int, optional
-        Number of samples to generate. Default is 50. Must be non-negative.
-    endpoint : bool, optional
-        If True, stop is the last sample. Otherwise, it is not included.
-        Default is True.
-    retstep: bool, optional
-        If True, return (samples, step), where step is the spacing between samples.
-    dtype: dtype, optional
-        The type of the output array. If dtype is not given, infer the data
-        type from the other input arguments.
-    axis : int, optional
-        The axis in the result to store the samples. Relevant only if start or
-        stop are array-like. By default (0), the samples will be along a new
-        axis inserted at the beginning. Use -1 to get an axis at the end.
-    Returns
-    -------
-    samples : ndarray
-        There are num equally spaced samples in the closed interval
-        `[start, stop]` or the half-open interval `[start, stop)`
-        (depending on whether endpoint is True or False).
-    step : float, optional
-        Only returned if retstep is True
-        Size of spacing between samples.
-    """
-    return _mx_nd_np.linspace(start, stop, num, endpoint, retstep, dtype, axis, **kwargs)
-
-
 @set_module('mxnet.numpy')
 def sin(x, out=None, **kwargs):
     r"""Trigonometric sine, element-wise.

python/mxnet/numpy/random.py

@@ -98,48 +98,3 @@ def normal(loc=0.0, scale=1.0, size=None, **kwargs):
     This function currently does not support ``loc`` and ``scale`` as ndarrays.
     """
     return _mx_nd_np.random.normal(loc, scale, size, **kwargs)
-
-
-def multinomial(n, pvals, size=None, **kwargs):
-    """multinomial(n, pvals, size=None)
-
-    Draw samples from a multinomial distribution.
-
-    The multinomial distribution is a multivariate generalisation of the binomial distribution.
-    Take an experiment with one of ``p`` possible outcomes. An example of such an experiment is throwing a dice,
-    where the outcome can be 1 through 6. Each sample drawn from the distribution represents n such experiments.
-    Its values, ``X_i = [X_0, X_1, ..., X_p]``, represent the number of times the outcome was ``i``.
-
-    Parameters
-    ----------
-    n : int
-        Number of experiments.
-    pvals : sequence of floats, length p
-        Probabilities of each of the p different outcomes. These should sum to 1.
-    size : int or tuple of ints, optional
-        Output shape. If the given shape is, e.g., ``(m, n, k)``, then ``m * n * k`` samples
-        are drawn. Default is None, in which case a single value is returned.
-
-    Returns
-    -------
-    out : ndarray
-        The drawn samples, of shape size, if that was provided. If not, the shape is ``(N,)``.
-        In other words, each entry ``out[i,j,...,:]`` is an N-dimensional value drawn from the distribution.
-
-    Examples
-    --------
-    Throw a dice 1000 times, and 1000 times again:
-
-    >>> np.random.multinomial(1000, [1/6.]*6, size=2)
-    array([[164, 161, 179, 158, 150, 188],
-           [178, 162, 177, 143, 163, 177]])
-
-    A loaded die is more likely to land on number 6:
-
-    >>> np.random.multinomial(100, [1/7.]*5 + [2/7.])
-    array([19, 14, 12, 11, 21, 23])
-
-    >>> np.random.multinomial(100, [1.0 / 3, 2.0 / 3])
-    array([32, 68])
-    """
-    return _mx_nd_np.random.multinomial(n, pvals, size, **kwargs)

python/mxnet/symbol/numpy/_symbol.py

@@ -31,7 +31,7 @@
 
 __all__ = ['zeros', 'ones', 'maximum', 'minimum', 'stack', 'concatenate', 'arange', 'argmax',
            'clip', 'add', 'subtract', 'multiply', 'divide', 'mod', 'power', 'split', 'swapaxes',
-           'expand_dims', 'tile', 'linspace', 'sin', 'cos', 'sinh', 'cosh', 'log10', 'sqrt',
+           'expand_dims', 'tile', 'sin', 'cos', 'sinh', 'cosh', 'log10', 'sqrt',
            'abs', 'exp', 'arctan']
 
 
@@ -538,7 +538,7 @@ def mean(self, axis=None, dtype=None, out=None, keepdims=False):  # pylint: disa
 
     def cumsum(self, axis=None, dtype=None, out=None):
         """Return the cumulative sum of the elements along the given axis."""
-        return _mx_np_op.cumsum(self, axis=axis, dtype=dtype, out=out)
+        raise NotImplementedError
 
     def max(self, axis=None, out=None, keepdims=False):  # pylint: disable=arguments-differ
         """Return the maximum along a given axis."""
@@ -1327,66 +1327,6 @@ def tile(A, reps):
     return _npi.tile(A, reps)
 
 
-@set_module('mxnet.symbol.numpy')
-def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0, **kwargs): # pylint: disable=too-many-arguments
-    """Return evenly spaced numbers over a specified interval.
-
-    Returns num evenly spaced samples, calculated over the interval [start, stop].
-    The endpoint of the interval can optionally be excluded.
-
-    Parameters
-    ----------
-    start : array_like
-        The starting value of the sequence.
-    stop : array_like
-        The end value of the sequence, unless endpoint is set to False. In
-        that case, the sequence consists of all but the last of num + 1
-        evenly spaced samples, so that stop is excluded. Note that the step
-        size changes when endpoint is False.
-    num : int, optional
-        Number of samples to generate. Default is 50. Must be non-negative.
-    endpoint : bool, optional
-        If True, stop is the last sample. Otherwise, it is not included.
-        Default is True.
-    retstep: bool, optional
-        If True, return (samples, step), where step is the spacing between samples.
-    dtype: dtype, optional
-        The type of the output array. If dtype is not given, infer the data
-        type from the other input arguments.
-    axis : int, optional
-        The axis in the result to store the samples. Relevant only if start or
-        stop are array-like. By default (0), the samples will be along a new
-        axis inserted at the beginning. Use -1 to get an axis at the end.
-    Returns
-    -------
-    samples : ndarray
-        There are num equally spaced samples in the closed interval
-        `[start, stop]` or the half-open interval `[start, stop)`
-        (depending on whether endpoint is True or False).
-    step : float, optional
-        Only returned if retstep is True
-        Size of spacing between samples.
-
-    Notes
-    -----
-    This function currently does not support ``start`` and ``stop`` as ndarrays and
-    axis could only be 0 now.
-    """
-    if isinstance(start, (list, _np.ndarray)) or \
-        isinstance(stop, (list, _np.ndarray)):
-        raise NotImplementedError('start and stop only support int')
-    if axis != 0:
-        raise NotImplementedError("the function only support axis 0")
-    ctx = kwargs.pop('ctx', current_context())
-    if ctx is None:
-        ctx = current_context()
-    if retstep:
-        step = (stop - start) / (num - 1)
-        return (_npi.linspace(start=start, stop=stop, num=num, endpoint=endpoint, ctx=ctx, dtype=dtype), step)
-    else:
-        return _npi.linspace(start=start, stop=stop, num=num, endpoint=endpoint, ctx=ctx, dtype=dtype)
-
-
 def _unary_func_helper(x, fn_array, fn_scalar, out=None, **kwargs):
     """Helper function for unary operators.