diff --git a/python/mxnet/ndarray/numpy/_op.py b/python/mxnet/ndarray/numpy/_op.py index 02e42145fb18..728813243e99 100644 --- a/python/mxnet/ndarray/numpy/_op.py +++ b/python/mxnet/ndarray/numpy/_op.py @@ -28,7 +28,7 @@ from . import _internal as _npi from ..ndarray import NDArray -__all__ = ['shape', 'zeros', 'zeros_like', 'ones', 'ones_like', 'full', 'full_like', 'invert', +__all__ = ['shape', 'zeros', 'zeros_like', 'ones', 'ones_like', 'full', 'full_like', 'empty_like', 'invert', 'add', 'subtract', 'multiply', 'divide', 'mod', 'remainder', 'power', 'bitwise_not', 'arctan2', 'sin', 'cos', 'tan', 'sinh', 'cosh', 'tanh', 'log10', 'sqrt', 'cbrt', 'abs', 'absolute', 'exp', 'expm1', 'arcsin', 'arccos', 'arctan', 'sign', 'log', 'degrees', 'log2', @@ -372,6 +372,75 @@ def full_like(a, fill_value, dtype=None, order='C', ctx=None, out=None): # pylin return _npi.full_like(a, fill_value=fill_value, dtype=dtype, ctx=ctx, out=out) +@set_module('mxnet.ndarray.numpy') +def empty_like(prototype, dtype=None, order='K', subok=True, shape=None): # pylint: disable=W0621 + """ + Return a new array with the same shape and type as a given array. + + Parameters + ---------- + prototype : ndarray + The shape and data-type of `prototype` define these same attributes + of the returned array. + dtype : data-type, optional + Overrides the data type of the result. + + order : {'C', 'F', 'A', or 'K'}, optional + Overrides the memory layout of the result. 'C' means C-order, + 'F' means F-order, 'A' means 'F' if ``prototype`` is Fortran + contiguous, 'C' otherwise. 'K' means match the layout of ``prototype`` + as closely as possible. + + subok : bool, optional. + If True, then the newly created array will use the sub-class + type of 'a', otherwise it will be a base-class array. Defaults + to True. + shape : int or sequence of ints, optional. + Overrides the shape of the result. If order='K' and the number of + dimensions is unchanged, will try to keep order, otherwise, + order='C' is implied. + (Not supported at this moment) + + Returns + ------- + out : ndarray + Array of uninitialized (arbitrary) data with the same + shape and type as `prototype`. + + See Also + -------- + ones_like : Return an array of ones with shape and type of input. + zeros_like : Return an array of zeros with shape and type of input. + full_like : Return a new array with shape of input filled with value. + empty : Return a new uninitialized array. + + Notes + ----- + This function does *not* initialize the returned array; to do that use + `zeros_like` or `ones_like` instead. It may be marginally faster than + the functions that do set the array values. + + Examples + -------- + >>> a = np.array([[1,2,3], [4,5,6]]) + >>> np.empty_like(a) + array([[-5764607523034234880, -2305834244544065442, 4563075075], # uninitialized + [ 4567052944, -5764607523034234880, 844424930131968]]) + >>> a = np.array([[1., 2., 3.],[4.,5.,6.]]) + >>> np.empty_like(a) + array([[4.9e-324, 9.9e-324, 1.5e-323], # uninitialized + [2.0e-323, 2.5e-323, 3.0e-323]]) + """ + dtype_list = {None:'None', _np.int8:'int8', _np.uint8:'uint8', _np.int32:'int32', + _np.int64:'int64', _np.float16:'float16', _np.float32:'float32', + _np.float64:'float64', _np.bool_:'bool'} + try: + dtype = dtype if isinstance(dtype, str) else dtype_list[dtype] + except: + raise NotImplementedError("Do not support this dtype at this moment") + return _npi.empty_like_fallback(prototype, dtype=dtype, order=order, subok=subok, shape=shape) + + @set_module('mxnet.ndarray.numpy') def arange(start, stop=None, step=1, dtype=None, ctx=None): """Return evenly spaced values within a given interval. diff --git a/python/mxnet/numpy/multiarray.py b/python/mxnet/numpy/multiarray.py index 4910b4d6b925..13ea45a29ac2 100644 --- a/python/mxnet/numpy/multiarray.py +++ b/python/mxnet/numpy/multiarray.py @@ -46,7 +46,8 @@ from ..ndarray.numpy import _internal as _npi from ..ndarray.ndarray import _storage_type -__all__ = ['ndarray', 'empty', 'array', 'shape', 'zeros', 'zeros_like', 'ones', 'ones_like', 'full', 'full_like', +__all__ = ['ndarray', 'empty', 'empty_like', 'array', 'shape', + 'zeros', 'zeros_like', 'ones', 'ones_like', 'full', 'full_like', 'add', 'subtract', 'multiply', 'divide', 'mod', 'remainder', 'power', 'bitwise_not', 'arctan2', 'sin', 'cos', 'tan', 'sinh', 'cosh', 'tanh', 'log10', 'invert', 'sqrt', 'cbrt', 'abs', 'absolute', 'exp', 'expm1', 'arcsin', 'arccos', 'arctan', 'sign', 'log', @@ -2202,6 +2203,68 @@ def full(shape, fill_value, dtype=None, order='C', ctx=None, out=None): # pylint: enable=too-many-arguments, redefined-outer-name +@set_module('mxnet.numpy') +def empty_like(prototype, dtype=None, order='K', subok=True, shape=None): # pylint: disable=W0621 + """ + Return a new array with the same shape and type as a given array. + + Parameters + ---------- + prototype : ndarray + The shape and data-type of `prototype` define these same attributes + of the returned array. + dtype : data-type, optional + Overrides the data type of the result. + + order : {'C', 'F', 'A', or 'K'}, optional + Overrides the memory layout of the result. 'C' means C-order, + 'F' means F-order, 'A' means 'F' if ``prototype`` is Fortran + contiguous, 'C' otherwise. 'K' means match the layout of ``prototype`` + as closely as possible. + + subok : bool, optional. + If True, then the newly created array will use the sub-class + type of 'a', otherwise it will be a base-class array. Defaults + to True. + shape : int or sequence of ints, optional. + Overrides the shape of the result. If order='K' and the number of + dimensions is unchanged, will try to keep order, otherwise, + order='C' is implied. + (Not supported at this moment) + + Returns + ------- + out : ndarray + Array of uninitialized (arbitrary) data with the same + shape and type as `prototype`. + + See Also + -------- + ones_like : Return an array of ones with shape and type of input. + zeros_like : Return an array of zeros with shape and type of input. + full_like : Return a new array with shape of input filled with value. + empty : Return a new uninitialized array. + + Notes + ----- + This function does *not* initialize the returned array; to do that use + `zeros_like` or `ones_like` instead. It may be marginally faster than + the functions that do set the array values. + + Examples + -------- + >>> a = np.array([[1,2,3], [4,5,6]]) + >>> np.empty_like(a) + array([[-5764607523034234880, -2305834244544065442, 4563075075], # uninitialized + [ 4567052944, -5764607523034234880, 844424930131968]]) + >>> a = np.array([[1., 2., 3.],[4.,5.,6.]]) + >>> np.empty_like(a) + array([[4.9e-324, 9.9e-324, 1.5e-323], # uninitialized + [2.0e-323, 2.5e-323, 3.0e-323]]) + """ + return _mx_nd_np.empty_like(prototype, dtype=dtype, order=order, subok=subok, shape=shape) + + @set_module('mxnet.numpy') def identity(n, dtype=None, ctx=None): """ diff --git a/python/mxnet/numpy_dispatch_protocol.py b/python/mxnet/numpy_dispatch_protocol.py index c7e9dd1398eb..3758c9326c8c 100644 --- a/python/mxnet/numpy_dispatch_protocol.py +++ b/python/mxnet/numpy_dispatch_protocol.py @@ -147,7 +147,9 @@ def _run_with_array_ufunc_proto(*args, **kwargs): 'resize', 'where', 'full_like', - 'bincount' + 'bincount', + 'empty_like', + 'nan_to_num', ] diff --git a/python/mxnet/numpy_op_fallback.py b/python/mxnet/numpy_op_fallback.py index f3fd2bf6ae6c..301f510b7db3 100644 --- a/python/mxnet/numpy_op_fallback.py +++ b/python/mxnet/numpy_op_fallback.py @@ -18,6 +18,7 @@ """Fallback-to-NumPy operator implementation.""" from __future__ import absolute_import +from distutils.version import StrictVersion import functools import ast import numpy as np @@ -49,6 +50,49 @@ def _register_helper(prop_cls): return _register_helper +@use_np # enforce np shape and array semantics for all the methods in this class +class EmptyLike(operator.CustomOp): + """Fallback to NumPy empty_like operator.""" + def __init__(self, dtype, order, subok, shape): + super(EmptyLike, self).__init__() + self._dtype = dtype + self._order = order + self._subok = subok + self._shape = shape + + def forward(self, is_train, req, in_data, out_data, aux): + np_version = np.version.version + if StrictVersion(np_version) >= StrictVersion('1.6.0'): + out = np.empty_like(in_data[0].asnumpy(), dtype=self._dtype, order=self._order, + subok=self._subok) + else: + out = np.empty_like(in_data[0].asnumpy()) + self.assign(out_data[0], req[0], _mx_np.array(out, dtype=out.dtype, ctx=out_data[0].ctx)) + + def backward(self, req, out_grad, in_data, out_data, in_grad, aux): + raise NotImplementedError('Operator empty_like does not support gradient computation') + + +@register('empty_like_fallback') +class EmptyLikeProp(operator.CustomOpProp): + """Fallback empty_like operator properties.""" + def __init__(self, dtype, order, subok, shape): + super(EmptyLikeProp, self).__init__(need_top_grad=True) + self._dtype = None if dtype == 'None' else dtype + self._order = order + self._subok = ast.literal_eval(subok) + self._shape = ast.literal_eval(shape) + + def list_arguments(self): + return ['prototype'] + + def infer_shape(self, in_shape): + return (in_shape[0],), (in_shape[0],), () + + def create_operator(self, ctx, in_shapes, in_dtypes): + return EmptyLike(self._dtype, self._order, self._subok, self._shape) + + @use_np # enforce np shape and array semantics for all the methods in this class class Resize(operator.CustomOp): """Fallback to NumPy resize operator.""" diff --git a/python/mxnet/symbol/numpy/_symbol.py b/python/mxnet/symbol/numpy/_symbol.py index 6efc333cc16c..f59e4bdb158d 100644 --- a/python/mxnet/symbol/numpy/_symbol.py +++ b/python/mxnet/symbol/numpy/_symbol.py @@ -36,7 +36,7 @@ except ImportError: from builtins import slice as py_slice -__all__ = ['zeros', 'zeros_like', 'ones', 'ones_like', 'full_like', 'bitwise_not', 'invert', +__all__ = ['zeros', 'zeros_like', 'ones', 'ones_like', 'full_like', 'empty_like', 'bitwise_not', 'invert', 'add', 'subtract', 'multiply', 'divide', 'mod', 'remainder', 'power', 'arctan2', 'sin', 'cos', 'tan', 'sinh', 'cosh', 'tanh', 'log10', 'sqrt', 'cbrt', 'abs', 'absolute', 'exp', 'expm1', 'arcsin', 'arccos', 'arctan', 'sign', 'log', 'degrees', 'log2', 'log1p', @@ -1719,6 +1719,64 @@ def eye(N, M=None, k=0, dtype=_np.float32, **kwargs): return _npi.eye(N, M, k, ctx, dtype) +@set_module('mxnet.symbol.numpy') +def empty_like(prototype, dtype=None, order='K', subok=True, shape=None): # pylint: disable=W0621 + """ + Return a new array with the same shape and type as a given array. + + Parameters + ---------- + prototype : _Symbol + The shape and data-type of `prototype` define these same attributes + of the returned array. + dtype : data-type, optional + Overrides the data type of the result. + + order : {'C', 'F', 'A', or 'K'}, optional + Overrides the memory layout of the result. 'C' means C-order, + 'F' means F-order, 'A' means 'F' if ``prototype`` is Fortran + contiguous, 'C' otherwise. 'K' means match the layout of ``prototype`` + as closely as possible. + + subok : bool, optional. + If True, then the newly created array will use the sub-class + type of 'a', otherwise it will be a base-class array. Defaults + to True. + shape : int or sequence of ints, optional. + Overrides the shape of the result. If order='K' and the number of + dimensions is unchanged, will try to keep order, otherwise, + order='C' is implied. + (Not supported at this moment) + + Returns + ------- + out : _Symbol + Array of uninitialized (arbitrary) data with the same + shape and type as `prototype`. + + See Also + -------- + ones_like : Return an array of ones with shape and type of input. + zeros_like : Return an array of zeros with shape and type of input. + full_like : Return a new array with shape of input filled with value. + empty : Return a new uninitialized array. + + Notes + ----- + This function does *not* initialize the returned array; to do that use + `zeros_like` or `ones_like` instead. It may be marginally faster than + the functions that do set the array values. + """ + dtype_list = {None:'None', _np.int8:'int8', _np.uint8:'uint8', _np.int32:'int32', + _np.int64:'int64', _np.float16:'float16', _np.float32:'float32', + _np.float64:'float64', _np.bool_:'bool'} + try: + dtype = dtype if isinstance(dtype, str) else dtype_list[dtype] + except: + raise NotImplementedError("Do not support this dtype at this moment") + return _npi.empty_like_fallback(prototype, dtype=dtype, order=order, subok=subok, shape=shape) + + @set_module('mxnet.symbol.numpy') def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0, ctx=None): # pylint: disable=too-many-arguments r""" diff --git a/tests/python/unittest/test_numpy_interoperability.py b/tests/python/unittest/test_numpy_interoperability.py index fcdf547bfbec..b77531d53b81 100644 --- a/tests/python/unittest/test_numpy_interoperability.py +++ b/tests/python/unittest/test_numpy_interoperability.py @@ -1430,6 +1430,24 @@ def _add_workload_resize(): OpArgMngr.add_workload('resize', np.zeros((10, 0)), (0, 10)) OpArgMngr.add_workload('resize', np.zeros((10, 0)), (0, 100)) +def _add_workload_empty_like(): + OpArgMngr.add_workload('empty_like', np.random.uniform(low=0, high=100, size=(1,3,4), dtype='float64')) + OpArgMngr.add_workload('empty_like', np.random.uniform(low=0, high=100, size=(9,3,1)), np.int32) + OpArgMngr.add_workload('empty_like', np.random.uniform(low=0, high=100, size=(9,3)), 'float32') + OpArgMngr.add_workload('empty_like', np.random.uniform(low=0, high=100, size=(9,3,1)), np.bool_, 'K', True) + OpArgMngr.add_workload('empty_like', np.random.uniform(low=0, high=100, size=(0,3)), np.float32) + + +def _add_workload_nan_to_num(): + array1 = np.array([[-433, 0, 456, _np.inf], [-1, -_np.inf, 0, 1]]) + array2 = np.array([_np.nan, _np.inf, -_np.inf, -574, 0, 23425, 24234,-5]) + array3 = np.array(-_np.inf) + OpArgMngr.add_workload('nan_to_num', array1, True, 0, 100, -100) + OpArgMngr.add_workload('nan_to_num', array1, True, 0.00) + OpArgMngr.add_workload('nan_to_num', array2, True) + OpArgMngr.add_workload('nan_to_num', array2, True, -2000, 10000, -10000) + OpArgMngr.add_workload('nan_to_num', array3, True) + @use_np def _prepare_workloads(): @@ -1560,6 +1578,8 @@ def _prepare_workloads(): _add_workload_diff() _add_workload_resize() _add_workload_full_like(array_pool) + _add_workload_empty_like() + _add_workload_nan_to_num() _prepare_workloads() @@ -1604,7 +1624,7 @@ def check_interoperability(op_list): for name in op_list: if name in _TVM_OPS and not is_op_runnable(): continue - if name in ['shares_memory', 'may_share_memory']: # skip list + if name in ['shares_memory', 'may_share_memory', 'empty_like']: # skip list continue if name in ['full_like', 'zeros_like', 'ones_like'] and \ StrictVersion(platform.python_version()) < StrictVersion('3.0.0'): diff --git a/tests/python/unittest/test_numpy_op.py b/tests/python/unittest/test_numpy_op.py index af9228d45991..f5698fa1b2c5 100644 --- a/tests/python/unittest/test_numpy_op.py +++ b/tests/python/unittest/test_numpy_op.py @@ -5775,7 +5775,66 @@ def hybrid_forward(self, F, a, weights): np_out = _np.bincount(data.asnumpy(), weights_np, minlength) assert_almost_equal(mx_out.asnumpy(), np_out, rtol=rtol, atol=atol) - + +@with_seed() +@use_np +def test_np_empty_like(): + class TestEmptyLike(HybridBlock): + def __init__(self, dtype, order, subok, shape): + super(TestEmptyLike, self).__init__() + self._dtype = dtype + self._order = order + self._subok = subok + self._shape = shape + + def hybrid_forward(self, F, x, *args, **kwargs): + return F.np.empty_like(x, self._dtype, self._order, self._subok, self._shape) + + if StrictVersion(platform.python_version()) < StrictVersion('3.0.0'): + return + + dtypes = [None, 'float16', 'float32', np.int8, np.uint8, np.int32, np.int64, + np.float16, np.float32, np.float64, np.bool_] + shapes = [ + (), + (1,), + (5,), + (4, 3), + (3, 5), + (4, 4), + (4, 5), + (5, 5), + (5, 6), + (6, 6), + (0, 1), + (6, 5, 6), + (2, 3, 3, 4), + (4, 2, 1, 2), + (0, 5, 3, 3), + (5, 0, 3, 3), + (3, 3, 0, 0), + ] + orders = ["C", "F", "A", "K"] + subok_list = [True, False] + flags = [True, False] + _np_version = _np.version.version + for dtype, shape, hybridize, order, subok in itertools.product(dtypes, shapes, flags, orders, subok_list): + prototype = np.random.uniform(low=0, high=100, size=shape, dtype='float64').astype(dtype) + test = TestEmptyLike(dtype, order, subok, shape) + if StrictVersion(_np_version) >= StrictVersion('1.6.0'): + expected_ret = _np.empty_like(prototype, dtype=dtype, order=order, subok=subok) + else: + expected_ret = _np.empty_like(prototype) + if hybridize: + test.hybridize() + ret = test(prototype) + assert ret.asnumpy().shape == expected_ret.shape + + # check imperative again + ret = np.empty_like(prototype, dtype, order, subok, shape) + assert ret.asnumpy().shape == expected_ret.shape + + if __name__ == '__main__': import nose nose.runmodule()