You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mxnet.apache.org by re...@apache.org on 2019/10/20 04:52:52 UTC
[incubator-mxnet] branch numpy_1_6_prs updated (be041d2 -> 79c08d3)
This is an automated email from the ASF dual-hosted git repository.
reminisce pushed a change to branch numpy_1_6_prs
in repository https://gitbox.apache.org/repos/asf/incubator-mxnet.git.
discard be041d2 numpy op doc: max, min, prod (#16506)
add 9fecfbb Add test pipeline for USE_TVM_OP=OFF on Unix (#16450)
add b583059 Numpy dispatch test of ...... (#16422)
add 149e034 typo fix in r doc lstm tutorial (#16546)
add fc81c64 Correct Google Analytics Tracker (#16490)
add ffec31f Aggregated adamw update (#16398)
add 5b67a69 try to fix block (#16465)
add c1d02ce setup and concatenate, copy, expand_dims, expm1 (#16493)
add cdfaf39 add sum for boolean type in mainline (#16436)
new 79c08d3 numpy op doc: max, min, prod (#16506)
This update added new revisions after undoing existing revisions.
That is to say, some revisions that were in the old version of the
branch are not in the new version. This situation occurs
when a user --force pushes a change and generates a repository
containing something like this:
* -- * -- B -- O -- O -- O (be041d2)
\
N -- N -- N refs/heads/numpy_1_6_prs (79c08d3)
You should already have received notification emails for all of the O
revisions, and so the following emails describe only the N revisions
from the common base, B.
Any revisions marked "omit" are not gone; other references still
refer to them. Any revisions marked "discard" are gone forever.
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
3rdparty/mshadow/mshadow/base.h | 10 +
ci/docker/runtime_functions.sh | 71 ++
ci/jenkins/Jenkins_steps.groovy | 75 ++
ci/jenkins/Jenkinsfile_unix_cpu | 4 +-
ci/jenkins/Jenkinsfile_unix_gpu | 9 +-
docs/python_docs/_static/google_analytics.js | 2 +-
.../pages/api/r/docs/tutorials/multi_dim_lstm.md | 2 +-
python/mxnet/gluon/block.py | 110 ++-
python/mxnet/ndarray/contrib.py | 56 +-
python/mxnet/ndarray/numpy/_op.py | 44 +-
python/mxnet/numpy/multiarray.py | 31 +-
python/mxnet/numpy/utils.py | 4 +-
python/mxnet/numpy_dispatch_protocol.py | 18 +-
python/mxnet/symbol/numpy/_symbol.py | 14 +-
src/operator/contrib/adamw-inl.h | 368 ++++++++--
src/operator/contrib/adamw.cc | 166 ++++-
src/operator/contrib/adamw.cu | 34 +-
src/operator/mxnet_op.h | 22 +-
src/operator/numpy/np_broadcast_reduce_op.h | 4 +-
src/operator/tensor/broadcast_reduce_op.h | 2 +-
tests/python/gpu/test_gluon_gpu.py | 15 +
tests/python/gpu/test_operator_gpu.py | 1 +
tests/python/unittest/test_contrib_optimizer.py | 236 ++++---
tests/python/unittest/test_gluon.py | 44 ++
.../python/unittest/test_numpy_interoperability.py | 767 +++++++++++++++++++--
tests/python/unittest/test_numpy_op.py | 13 +-
26 files changed, 1803 insertions(+), 319 deletions(-)
[incubator-mxnet] 01/01: numpy op doc: max, min, prod (#16506)
Posted by re...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
reminisce pushed a commit to branch numpy_1_6_prs
in repository https://gitbox.apache.org/repos/asf/incubator-mxnet.git
commit 79c08d3c463910ff98118caf6801211ea7d6d74d
Author: alicia <32...@users.noreply.github.com>
AuthorDate: Sat Oct 19 13:16:12 2019 +0800
numpy op doc: max, min, prod (#16506)
---
python/mxnet/_numpy_op_doc.py | 213 +++++++++++++++++++++++++++++++++++++++++-
1 file changed, 211 insertions(+), 2 deletions(-)
diff --git a/python/mxnet/_numpy_op_doc.py b/python/mxnet/_numpy_op_doc.py
index f08d19a..ce8be59 100644
--- a/python/mxnet/_numpy_op_doc.py
+++ b/python/mxnet/_numpy_op_doc.py
@@ -130,8 +130,8 @@ def _npx_nonzero(a):
Notes
-----
- This function differs from the original numpy.prod in the following aspects:
- - Do not support python numeric.
+ This function differs from the original numpy.nonzero in the following aspects:
+ - Does not support python numeric.
- The return value is same as numpy.transpose(numpy.nonzero(a)).
Examples
@@ -706,6 +706,214 @@ def _np_squeeze(a, axis=None, out=None):
pass
+def _np_max(a, axis=None, out=None, keepdims=False):
+ """
+ Return the maximum of an array or maximum along an axis.
+
+ Parameters
+ ----------
+ a : ndarray
+ Input data.
+ axis : int, optional
+ Axis along which to operate. By default, flattened input is used.
+ out : ndarray, optional
+ Alternative output array in which to place the result. Must
+ be of the same shape and buffer length as the expected output.
+ See `doc.ufuncs` (Section "Output arguments") for more details.
+ keepdims : bool, optional
+ If this is set to True, the axes which are reduced are left
+ in the result as dimensions with size one. With this option,
+ the result will broadcast correctly against the original `arr`.
+
+ Returns
+ -------
+ max : ndarray
+ Maximum of `a`. If `axis` is None, the result is an array of dimension 1.
+ If `axis` is given, the result is an array of dimension
+ ``a.ndim - 1``.
+
+ See Also
+ --------
+ min :
+ The minimum value of an array along a given axis, ignoring any nan.
+ maximum :
+ Element-wise maximum of two arrays, ignoring any nan.
+ argmax :
+ Return the indices of the maximum values.
+
+ Notes
+ -----
+ NaN in the orginal `numpy` is denoted as nan and will be ignored.
+
+ Don't use `max` for element-wise comparison of 2 arrays; when
+ ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than
+ ``max(a, axis=0)``.
+
+ Examples
+ --------
+ >>> a = np.arange(4).reshape((2,2))
+ >>> a
+ array([[0., 1.],
+ [2., 3.]])
+ >>> np.max(a) # Maximum of the flattened array
+ array(3.)
+ >>> np.max(a, axis=0) # Maxima along the first axis
+ array([2., 3.])
+ >>> np.max(a, axis=1) # Maxima along the second axis
+ array([1., 3.])
+
+ >>> b = np.arange(5, dtype=np.float32)
+ >>> b[2] = np.nan
+ >>> np.max(b)
+ array(4.)
+ """
+ pass
+
+
+def _np_min(a, axis=None, out=None, keepdims=False):
+ """
+ Return the minimum of an array or minimum along an axis.
+
+ Parameters
+ ----------
+ a : ndarray
+ Input data.
+ axis : int, optional
+ Axis along which to operate. By default, flattened input is used.
+ out : ndarray, optional
+ Alternative output array in which to place the result. Must
+ be of the same shape and buffer length as the expected output.
+ See `doc.ufuncs` (Section "Output arguments") for more details.
+ keepdims : bool, optional
+ If this is set to True, the axes which are reduced are left
+ in the result as dimensions with size one. With this option,
+ the result will broadcast correctly against the original `arr`.
+
+ Returns
+ -------
+ min : ndarray
+ Minimum of `a`. If `axis` is None, the result is an array of dimension 1.
+ If `axis` is given, the result is an array of dimension
+ ``a.ndim - 1``.
+
+ See Also
+ --------
+ max :
+ The maximum value of an array along a given axis, ignoring any nan.
+ minimum :
+ Element-wise minimum of two arrays, ignoring any nan.
+
+ Notes
+ -----
+ NaN in the orginal `numpy` is denoted as nan and will be ignored.
+
+ Don't use `min` for element-wise comparison of 2 arrays; when
+ ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than
+ ``min(a, axis=0)``.
+
+ Examples
+ --------
+ >>> a = np.arange(4).reshape((2,2))
+ >>> a
+ array([[0., 1.],
+ [2., 3.]])
+ >>> np.min(a) # Minimum of the flattened array
+ array(0.)
+ >>> np.min(a, axis=0) # Minima along the first axis
+ array([0., 1.])
+ >>> np.min(a, axis=1) # Minima along the second axis
+ array([0., 2.])
+ >>> b = np.arange(5, dtype=np.float32)
+ >>> b[2] = np.nan
+ >>> np.min(b)
+ array(0.) # nan will be ignored
+ """
+ pass
+
+
+def _np_prod(a, axis=None, dtype=None, out=None, keepdims=False):
+ """
+ Return the product of array elements over a given axis.
+
+ Parameters
+ ----------
+ a : ndarray
+ Input data.
+ axis : None or int or tuple of ints, optional
+ Axis or axes along which a product is performed.
+ The default (`axis` = `None`) is perform a product over all
+ the dimensions of the input array. `axis` may be negative, in
+ which case it counts from the last to the first axis.
+ If this is a tuple of ints, a product is performed on multiple
+ axes, instead of a single axis or all the axes as before.
+ dtype : data-type, optional
+ The data-type of the returned array, as well as of the accumulator
+ in which the elements are multiplied. By default, if `a` is of
+ integer type, `dtype` is the default platform integer. (Note: if
+ the type of `a` is unsigned, then so is `dtype`.) Otherwise,
+ the dtype is the same as that of `a`.
+ out : ndarray, optional
+ Alternative output array in which to place the result. It must have
+ the same shape as the expected output, but the type of the
+ output values will be cast if necessary.
+ keepdims : bool, optional
+ If this is set to True, the axes which are reduced are left
+ in the result as dimensions with size one. With this option,
+ the result will broadcast correctly against the original `arr`.
+
+ Returns
+ -------
+ product_along_axis : ndarray, see `dtype` parameter above.
+ An array shaped as `a` but with the specified axis removed.
+ Returns a reference to `out` if specified.
+
+ See Also
+ --------
+ ndarray.prod : equivalent method
+
+ Notes
+ -----
+ Arithmetic is modular when using integer types, and no error is
+ raised on overflow. That means that, on a 32-bit platform:
+
+ >>> x = np.array([536870910, 536870910, 536870910, 536870910])
+ >>> np.prod(x) #random
+ array(8.307675e+34)
+
+ Examples
+ --------
+ By default, calculate the product of all elements:
+
+ >>> np.prod(np.array([1.,2.]))
+ array(2.)
+
+ Even when the input array is two-dimensional:
+
+ >>> np.prod(np.array([1.,2.,3.,4.]).reshape((2,2)))
+ array(24.)
+
+ But we can also specify the axis over which to multiply:
+
+ >>> np.prod(np.array([1.,2.,3.,4.]).reshape((2,2)), axis=1)
+ array([ 2., 12.])
+
+ If the type of `x` is unsigned, then the output type is
+ the unsigned platform integer:
+
+ >>> x = np.array([1, 2, 3], dtype=np.uint8)
+ >>> np.prod(x).dtype == np.uint8
+ True
+
+ If `x` is of a signed integer type, then the output type
+ is the default platform integer:
+
+ >>> x = np.array([1, 2, 3], dtype=np.int8)
+ >>> np.prod(x).dtype == np.int8
+ True
+ """
+ pass
+
+
def _np_moveaxis(a, source, destination):
"""Move axes of an array to new positions.
Other axes remain in their original order.
@@ -784,6 +992,7 @@ def _np__random_shuffle(x):
"""
pass
+
def _np_broadcast_to(array, shape, out=None):
"""
Broadcast an array to a new shape.