You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mxnet.apache.org by jx...@apache.org on 2017/11/13 19:30:42 UTC
[incubator-mxnet] branch master updated: Continued Work on Advanced
Indexing (#8246)
This is an automated email from the ASF dual-hosted git repository.
jxie pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-mxnet.git
The following commit(s) were added to refs/heads/master by this push:
new d8d2c39 Continued Work on Advanced Indexing (#8246)
d8d2c39 is described below
commit d8d2c3924f453aab0c7c90d20312faee1f87d85a
Author: reminisce <wu...@gmail.com>
AuthorDate: Mon Nov 13 11:30:35 2017 -0800
Continued Work on Advanced Indexing (#8246)
* Add step to ndarrays slice
* Support broadcasting indices
* Enhance advanced indexing
* Fix
* Support mix of basic and advanced indices
* Add unit test
* Change name
* Add comment
* Fix pylint
* Add one more test case
* Address comments
* Add __setitem__ support
* Fix bug and add unit test for __setitem__
* Add docstring
* Fix bug
* Fix bug
* Fix gpu compile
* Add value assignment type support for array-like objects
* Fix test cases
* Rewrite _slice_assign and _slice_assign_scalar using kernel launch and support step
* Replace _gather_nd for basic indexing with _slice_assign and _slice_assign_scalar
* Clean up and bug fix
* Fix lint and bug fix
* Add autograd unit test for getitem and fix a bug
* Fix indent and docstring
---
python/mxnet/ndarray/ndarray.py | 678 +++++++++++++++++++++++++---------
src/operator/tensor/indexing_op.cc | 29 ++
src/operator/tensor/indexing_op.cu | 3 +
src/operator/tensor/indexing_op.h | 25 +-
src/operator/tensor/matrix_op-inl.h | 382 ++++++++-----------
src/operator/tensor/matrix_op.cc | 17 +-
src/operator/tensor/matrix_op.cu | 4 +-
tests/python/unittest/test_ndarray.py | 138 ++++++-
8 files changed, 851 insertions(+), 425 deletions(-)
diff --git a/python/mxnet/ndarray/ndarray.py b/python/mxnet/ndarray/ndarray.py
index ad1acaf..6cbf328 100644
--- a/python/mxnet/ndarray/ndarray.py
+++ b/python/mxnet/ndarray/ndarray.py
@@ -96,6 +96,11 @@ _GRAD_REQ_MAP = {
}
# pylint: enable= no-member
+# Return code for dispatching indexing function call
+_NDARRAY_UNSUPPORTED_INDEXING = -1
+_NDARRAY_BASIC_INDEXING = 0
+_NDARRAY_ADVANCED_INDEXING = 1
+
def _new_empty_handle():
"""Returns a new empty handle.
@@ -389,100 +394,36 @@ fixed-size items.
>>> x.asnumpy()
array([[ 1., 2., 1.],
[ 0., 0., 4.]], dtype=float32)
- """
- # pylint: disable=too-many-branches
- if not self.writable:
- raise ValueError('Cannot assign to readonly NDArray')
- if isinstance(key, integer_types):
- sliced_arr = self._at(key)
- sliced_arr[:] = value
- return
- elif isinstance(key, py_slice):
- if key.step is not None:
- raise ValueError('NDArray only supports slicing with step size 1')
- if key.start is not None or key.stop is not None:
- sliced_arr = self._slice(key.start, key.stop)
- sliced_arr[:] = value
- return
- if isinstance(value, NDArray):
- if value.handle is not self.handle:
- value.copyto(self)
- elif isinstance(value, numeric_types):
- _internal._set_value(float(value), out=self)
- elif isinstance(value, (np.ndarray, np.generic)):
- self._sync_copyfrom(value)
- else:
- raise TypeError(
- 'NDArray does not support assignment with %s of type %s'%(
- str(value), str(type(value))))
- elif isinstance(key, tuple):
- # multi-dimension indexing
- my_shape = self.shape
- assert len(key) <= len(my_shape), \
- "Indexing dimensions exceed array dimensions, %d vs %d"%(
- len(key), len(my_shape))
- begin = [0 for _ in my_shape]
- end = [x for x in my_shape]
- expand = []
- for i, slice_i in enumerate(key):
- if isinstance(slice_i, integer_types):
- assert slice_i < my_shape[i]
- begin[i] = slice_i
- end[i] = slice_i + 1
- expand.append(i)
- elif isinstance(slice_i, py_slice):
- # only support continuous slicing
- assert slice_i.step is None, \
- "NDArray only supports slicing with step size 1."
- begin[i] = slice_i.start or 0
- end[i] = slice_i.stop or my_shape[i]
- assert begin[i] < end[i]
- assert end[i] <= my_shape[i]
- else:
- raise ValueError(
- "NDArray does not support slicing with key %s of type %s."%(
- str(slice_i), str(type(slice_i))))
-
- if isinstance(value, NDArray):
- value = value.as_in_context(self.context)
- self._slice_assign(value, begin, end, expand)
- elif isinstance(value, numeric_types):
- _internal._crop_assign_scalar(self, out=self,
- begin=begin, end=end,
- scalar=value)
- elif isinstance(value, (np.ndarray, np.generic)):
- value = array(value, ctx=self.context, dtype=self.dtype)
- self._slice_assign(value, begin, end, expand)
- else:
- raise TypeError(
- 'NDArray does not support assignment with %s of type %s'%(
- str(value), str(type(value))))
+ >>> x[[0], [1, 2]] = 5
+ >>> x.asnumpy()
+ array([[ 1., 5., 5.],
+ [ 0., 0., 4.]], dtype=float32)
+ >>> x[::-1, 0:2:2] = [6]
+ >>> x.asnumpy()
+ array([[ 6., 5., 5.],
+ [ 6., 0., 4.]], dtype=float32)
+ """
+ indexing_dispatch_code = _get_indexing_dispatch_code(key)
+ if indexing_dispatch_code == _NDARRAY_BASIC_INDEXING:
+ self._set_nd_basic_indexing(key, value)
+ elif indexing_dispatch_code == _NDARRAY_ADVANCED_INDEXING:
+ self._set_nd_advanced_indexing(key, value)
else:
- raise ValueError(
- "NDArray does not support slicing with key %s of type %s."%(
- str(key), str(type(key))))
- # pylint: enable=too-many-branches
-
- def _slice_assign(self, value, begin, end, expand):
- vshape = list(value.shape)
- if expand and len(vshape) != len(begin):
- if len(expand) + len(vshape) != len(begin):
- sshape = [e - b for e, b in zip(end, begin)]
- for i in reversed(expand):
- sshape.pop(i)
- raise ValueError(
- "Cannot assign NDArray with shape %s to NDArray slice with " \
- "shape %s"%(str(vshape), str(sshape)))
- for i in expand:
- vshape.insert(i, 1)
- value = value.reshape(vshape)
- _internal._crop_assign(self, value, out=self,
- begin=begin, end=end)
+ raise ValueError('Indexing NDArray with index=%s and type=%s is not supported'
+ % (str(key), str(type(key))))
def __getitem__(self, key):
"""x.__getitem__(i) <=> x[i]
-
- Returns a sliced view of this array.
+ Returns a sliced view of this array if the elements fetched are contiguous in memory;
+ otherwise, returns a newly created NDArray.
+ This functions supports advanced indexing defined in the following reference with
+ some limitations.
+ https://docs.scipy.org/doc/numpy-1.13.0/reference/arrays.indexing.html#combining-advanced-and-basic-indexing # pylint: disable=line-too-long
+ The following features/functionality are not supported for now:
+ 1. If key is a list type, only a list of integers is supported,
+ i.e. key=[1, 2] is okay, while not for key=[[1]].
+ 2. Ellipsis (...) and np.newaxis are not supported.
+ 3. Boolean array indexing.
Parameters
----------
@@ -502,80 +443,353 @@ fixed-size items.
>>> x.asnumpy()
array([[ 2., 2., 2.],
[ 3., 4., 5.]], dtype=float32)
- """
- # multi-dimensional slicing is not supported yet
+ >>> x = mx.nd.arange(0, 8, dtype='int32').reshape((2, 2, 2))
+ >>> x[[0, 1]]
+ [[[0 1]
+ [2 3]]
+ [[4 5]
+ [6 7]]]
+ >>> x[1:, [0, 1]]
+ [[[4 5]
+ [6 7]]]
+ >>> y = np.array([0, 1], dtype='int32')
+ >>> x[1:, y]
+ [[[4 5]
+ [6 7]]]
+ >>> y = mx.nd.array([0, 1], dtype='int32')
+ >>> x[1:, y]
+ [[[4 5]
+ [6 7]]]
+ """
+ indexing_dispatch_code = _get_indexing_dispatch_code(key)
+ if indexing_dispatch_code == _NDARRAY_BASIC_INDEXING:
+ return self._get_nd_basic_indexing(key)
+ elif indexing_dispatch_code == _NDARRAY_ADVANCED_INDEXING:
+ return self._get_nd_advanced_indexing(key)
+ else:
+ raise ValueError('Indexing NDArray with index=%s and type=%s is not supported'
+ % (str(key), str(type(key))))
+
+ def _get_index_nd(self, key):
+ """Returns an index array for use in scatter_nd and gather_nd."""
+ def _is_advanced_index(index):
+ """The definition of advanced index here includes integers as well, while
+ integers are considered as basic index type when the key contains only
+ slices and integers."""
+ return not isinstance(index, py_slice)
+
+ if isinstance(key, (NDArray, np.ndarray, list, integer_types, py_slice)):
+ key = (key,)
+
+ assert isinstance(key, tuple),\
+ 'index=%s must be a NDArray, or np.ndarray, or list, or tuple ' \
+ ' type to use advanced indexing, received type=%s' % (str(key), str(type(key)))
+
+ assert len(key) > 0, "Cannot slice with empty indices"
+ shape = self.shape
+ assert len(shape) >= len(key),\
+ "Slicing dimensions exceeds array dimensions, %d vs %d" % (len(key), len(shape))
+ indices = []
+ dtype = 'int32' # index data type passed to gather_nd op
+ need_broadcast = (len(key) != 1)
+ advanced_indices = [] # include list, NDArray, np.ndarray, integer
+ basic_indices = [] # include only slices
+ advanced_index_bshape = None # final advanced index shape
+ for i, idx_i in enumerate(key):
+ is_advanced_index = True
+ if isinstance(idx_i, (np.ndarray, list, tuple)):
+ idx_i = array(idx_i, ctx=self.context, dtype=dtype)
+ advanced_indices.append(i)
+ elif isinstance(idx_i, py_slice):
+ start, stop, step = _get_index_range(idx_i.start, idx_i.stop, shape[i], idx_i.step)
+ idx_i = arange(start, stop, step, ctx=self.context, dtype=dtype)
+ basic_indices.append(i)
+ is_advanced_index = False
+ elif isinstance(idx_i, integer_types):
+ start, stop, step = _get_index_range(idx_i, idx_i+1, shape[i], 1)
+ idx_i = arange(start, stop, step, ctx=self.context, dtype=dtype)
+ advanced_indices.append(i)
+ elif isinstance(idx_i, NDArray):
+ if dtype != idx_i.dtype:
+ idx_i = idx_i.astype(dtype)
+ advanced_indices.append(i)
+ else:
+ raise IndexError('Indexing NDArray with index=%s of type=%s is not supported'
+ % (str(key), str(type(key))))
+ if is_advanced_index:
+ if advanced_index_bshape is None:
+ advanced_index_bshape = idx_i.shape
+ elif advanced_index_bshape != idx_i.shape:
+ need_broadcast = True
+ advanced_index_bshape = _get_broadcast_shape(advanced_index_bshape, idx_i.shape)
+ indices.append(idx_i)
+
+ # Get final index shape for gather_nd. See the following reference
+ # for determining the output array shape.
+ # https://docs.scipy.org/doc/numpy-1.13.0/reference/arrays.indexing.html#combining-advanced-and-basic-indexing # pylint: disable=line-too-long
+ if len(advanced_indices) == 0:
+ raise ValueError('Advanced index tuple must contain at least one of the following types:'
+ ' list, tuple, NDArray, np.ndarray, integer, received index=%s' % key)
+ # determine the output array's shape by checking whether advanced_indices are all adjacent
+ # or separated by slices
+ advanced_indices_adjacent = True
+ for i in range(0, len(advanced_indices)-1):
+ if advanced_indices[i] + 1 != advanced_indices[i+1]:
+ advanced_indices_adjacent = False
+ break
+
+ index_bshape_list = [] # index broadcasted shape
+ if advanced_indices_adjacent:
+ for i in range(0, advanced_indices[0]):
+ index_bshape_list.extend(indices[i].shape)
+ if not need_broadcast and indices[i].shape != advanced_index_bshape:
+ need_broadcast = True
+ index_bshape_list.extend(advanced_index_bshape)
+ for i in range(advanced_indices[-1]+1, len(indices)):
+ if not need_broadcast and indices[i].shape != advanced_index_bshape:
+ need_broadcast = True
+ index_bshape_list.extend(indices[i].shape)
+ else:
+ index_bshape_list.extend(advanced_index_bshape)
+ for i in basic_indices:
+ index_bshape_list.extend(indices[i].shape)
+ if not need_broadcast and indices[i].shape != advanced_index_bshape:
+ need_broadcast = True
+ index_bshape = tuple(index_bshape_list)
+
+ # Need to broadcast all ndarrays in indices to the final shape.
+ # For example, suppose an array has shape=(5, 6, 7, 8) and
+ # key=(slice(1, 5), [[1, 2]], slice(2, 5), [1]).
+ # Since key[1] and key[3] are two advanced indices here and they are
+ # separated by basic indices key[0] and key[2], the output shape
+ # is (1, 2, 4, 3), where the first two elements come from the shape
+ # that key[1] and key[3] should broadcast to, which is (1, 2), and
+ # the last two elements come from the shape of two basic indices.
+ # In order to broadcast all basic and advanced indices to the output shape,
+ # we need to reshape them based on their axis. For example, to broadcast key[0],
+ # with shape=(4,), we first need to reshape it into (1, 1, 4, 1), and then
+ # broadcast the reshaped array to (1, 2, 4, 3); to broadcast key[1], we first
+ # reshape it into (1, 2, 1, 1), then broadcast the reshaped array to (1, 2, 4, 3).
+ if need_broadcast:
+ broadcasted_indices = []
+ idx_rshape = [1] * len(index_bshape)
+ if advanced_indices_adjacent:
+ advanced_index_bshape_start = advanced_indices[0] # start index of advanced_index_bshape in index_shape
+ advanced_index_bshape_stop = advanced_index_bshape_start + len(advanced_index_bshape)
+ for i, idx in enumerate(key):
+ if _is_advanced_index(idx):
+ k = advanced_index_bshape_stop
+ # find the reshaped shape for indices[i]
+ for dim_size in indices[i].shape[::-1]:
+ k -= 1
+ idx_rshape[k] = dim_size
+ else:
+ if i < advanced_indices[0]: # slice is on the left side of advanced indices
+ idx_rshape[i] = indices[i].shape[0]
+ elif i > advanced_indices[-1]: # slice is on the right side of advanced indices
+ idx_rshape[i-len(key)] = indices[i].shape[0]
+ else:
+ raise ValueError('basic index i=%d cannot be between advanced index i=%d and i=%d'
+ % (i, advanced_indices[0], advanced_indices[-1]))
+ # broadcast current index to the final shape
+ broadcasted_indices.append(indices[i].reshape(tuple(idx_rshape)).broadcast_to(index_bshape))
+ # reset idx_rshape to ones
+ for j, _ in enumerate(idx_rshape):
+ idx_rshape[j] = 1
+ else:
+ basic_index_offset = len(advanced_index_bshape)
+ for i, idx in enumerate(key):
+ if _is_advanced_index(idx):
+ k = len(advanced_index_bshape)
+ for dim_size in indices[i].shape[::-1]:
+ k -= 1
+ idx_rshape[k] = dim_size
+ else:
+ idx_rshape[basic_index_offset] = indices[i].shape[0]
+ basic_index_offset += 1
+ # broadcast current index to the final shape
+ broadcasted_indices.append(indices[i].reshape(tuple(idx_rshape)).broadcast_to(index_bshape))
+ # reset idx_rshape to ones
+ for j, _ in enumerate(idx_rshape):
+ idx_rshape[j] = 1
+
+ indices = broadcasted_indices
+ return op.stack(*indices)
+
+ def _prepare_value_nd(self, value, vshape):
+ """Given value and vshape, create an `NDArray` from value with the same
+ context and dtype as the current one and broadcast it to vshape."""
+ if isinstance(value, numeric_types):
+ value_nd = full(shape=vshape, val=value, ctx=self.context, dtype=self.dtype)
+ elif isinstance(value, NDArray):
+ value_nd = value.as_in_context(self.context)
+ if value_nd.dtype != self.dtype:
+ value_nd = value_nd.astype(self.dtype)
+ else:
+ try:
+ value_nd = array(value, ctx=self.context, dtype=self.dtype)
+ except:
+ raise TypeError('NDArray does not support assignment with non-array-like'
+ ' object %s of type %s' % (str(value), str(type(value))))
+ if value_nd.shape != vshape:
+ value_nd = value_nd.broadcast_to(vshape)
+ return value_nd
+
+ def _set_nd_basic_indexing(self, key, value):
+ """This function is called by __setitem__ when key is a basic index, i.e.
+ an integer, or a slice, or a tuple of integers and slices. No restrictions
+ on the values of slices' steps."""
+ shape = self.shape
+ if isinstance(key, integer_types):
+ sliced_arr = self._at(key)
+ sliced_arr[:] = value
+ return
+ elif isinstance(key, py_slice):
+ if key.step is None or key.step == 1: # trivial step
+ if key.start is not None or key.stop is not None:
+ sliced_arr = self._slice(key.start, key.stop)
+ sliced_arr[:] = value
+ return
+ # assign value to the whole NDArray
+ # may need to broadcast first
+ if isinstance(value, NDArray):
+ if value.handle is not self.handle:
+ value.copyto(self)
+ elif isinstance(value, numeric_types):
+ _internal._full(shape=shape, ctx=self.context,
+ dtype=self.dtype, value=value, out=self)
+ elif isinstance(value, (np.ndarray, np.generic)):
+ if isinstance(value, np.generic) or value.shape != shape:
+ value = np.broadcast_to(value, shape)
+ self._sync_copyfrom(value)
+ else: # value might be a list or a tuple
+ value_nd = self._prepare_value_nd(value, shape)
+ value_nd.copyto(self)
+ return
+ else: # non-trivial step, use _slice_assign or _slice_assign_scalar
+ key = (key,)
+
+ assert isinstance(key, tuple), "key=%s must be a tuple of slices and integers" % str(key)
+
+ assert len(key) <= len(shape), "Indexing dimensions exceed array dimensions, %d vs %d"\
+ % (len(key), len(shape))
+ begin = []
+ end = []
+ steps = []
+ oshape = [] # output shape of slice using key
+ vshape = [] # value shape of data[key]
+ for i, slice_i in enumerate(key):
+ dim_size = 1
+ if isinstance(slice_i, py_slice):
+ begin.append(slice_i.start)
+ end.append(slice_i.stop)
+ steps.append(slice_i.step)
+ start, stop, step = _get_index_range(slice_i.start, slice_i.stop,
+ shape[i], slice_i.step)
+ dim_size = _get_dim_size(start, stop, step)
+ vshape.append(dim_size)
+ elif isinstance(slice_i, integer_types):
+ begin.append(slice_i)
+ end.append(slice_i+1)
+ steps.append(1)
+ else:
+ raise ValueError("basic indexing does not support index=%s of type=%s"
+ % (str(slice_i), str(type(slice_i))))
+ oshape.append(dim_size)
+
+ oshape.extend(shape[len(key):])
+ vshape.extend(shape[len(key):])
+ # if key contains all integers, vshape should be (1,)
+ if len(vshape) == 0:
+ vshape.append(1)
+ oshape = tuple(oshape)
+ vshape = tuple(vshape)
+
+ if isinstance(value, numeric_types):
+ _internal._slice_assign_scalar(self, out=self, begin=begin, end=end,
+ step=steps, scalar=float(value))
+ else:
+ value_nd = self._prepare_value_nd(value, vshape)
+ if vshape != oshape:
+ value_nd = value_nd.reshape(oshape)
+ _internal._slice_assign(self, value_nd, begin, end, steps, out=self)
+
+ def _set_nd_advanced_indexing(self, key, value):
+ """This function is called by __setitem__ when key is an advanced index."""
+ indices = self._get_index_nd(key)
+ vshape = _get_oshape_of_gather_nd_op(self.shape, indices.shape)
+ value_nd = self._prepare_value_nd(value, vshape)
+ _internal._scatter_set_nd(data=value_nd, indices=indices, shape=self.shape, out=self)
+
+ def _get_nd_basic_indexing(self, key):
+ """This function is called when key is a slice, or an integer,
+ or a tuple of slices or integers"""
+ shape = self.shape
if isinstance(key, integer_types):
- if key > self.shape[0] - 1:
+ if key > shape[0] - 1:
raise IndexError(
'index {} is out of bounds for axis 0 with size {}'.format(
- key, self.shape[0]))
+ key, shape[0]))
return self._at(key)
elif isinstance(key, py_slice):
- if key.step is not None:
- raise ValueError("NDArray only supports slicing with step size 1.")
- if key.start is not None or key.stop is not None:
+ if key.step is not None and key.step != 1:
+ if key.step == 0:
+ raise ValueError("slice step cannot be zero")
+ return op.slice(self, begin=(key.start,), end=(key.stop,), step=(key.step,))
+ elif key.start is not None or key.stop is not None:
return self._slice(key.start, key.stop)
- return self
- elif isinstance(key, tuple):
- shape = self.shape
- assert len(key) > 0, "Cannot slice with empty indices"
- assert len(shape) >= len(key), \
- "Slicing dimensions exceeds array dimensions, %d vs %d"%(
- len(key), len(shape))
- if isinstance(key[0], (NDArray, np.ndarray, list, tuple)):
- indices = []
- dtype = 'int32'
- shape = None
- for idx_i in key:
- if not isinstance(idx_i, NDArray):
- assert isinstance(idx_i, (NDArray, np.ndarray, list, tuple)), \
- "Combining basic and advanced indexing is not supported " \
- "yet. Indices must be all NDArray or all slice, not a " \
- "mix of both."
- idx_i = array(idx_i, ctx=self.context, dtype=dtype)
- else:
- dtype = idx_i.dtype
- if shape is None:
- shape = idx_i.shape
- else:
- assert shape == idx_i.shape, \
- "All index arrays must have the same shape: %s vs %s. " \
- "Broadcasting is not supported yet."%(shape, idx_i.shape)
- indices.append(idx_i)
- indices = op.stack(*indices)
- return op.gather_nd(self, indices)
else:
- oshape = []
- begin = []
- end = []
- i = -1
- for i, slice_i in enumerate(key):
- if isinstance(slice_i, integer_types):
- begin.append(slice_i)
- end.append(slice_i+1)
- elif isinstance(slice_i, py_slice):
- if slice_i.step is not None:
- raise ValueError("NDArray only supports slicing with step size 1.")
- begin.append(0 if slice_i.start is None else slice_i.start)
- end.append(shape[i] if slice_i.stop is None else slice_i.stop)
- oshape.append(end[i] - begin[i])
- elif isinstance(slice_i, (NDArray, np.ndarray, list, tuple)):
- raise ValueError(
- "Combining basic and advanced indexing is not supported " \
- "yet. Indices must be all NDArray or all slice, not a " \
- "mix of both.")
- else:
- raise ValueError(
- "NDArray does not support slicing with key %s of type %s."%(
- str(slice_i), str(type(slice_i))))
- oshape.extend(shape[i+1:])
- if len(oshape) == 0:
- oshape.append(1)
- return op.slice(self, begin, end).reshape(oshape)
- else:
- raise ValueError(
- "NDArray does not support slicing with key %s of type %s."%(
- str(key), str(type(key))))
+ return self
+
+ if not isinstance(key, tuple):
+ raise ValueError('index=%s must be a slice, or an ineger, or a tuple'
+ ' of slices and integers to use basic indexing, received type=%s'
+ % (str(key), str(type(key))))
+ assert len(key) != 0, 'basic index cannot be an empty tuple'
+ begin = []
+ end = []
+ step = []
+ kept_axes = [] # axes where slice_i is a slice
+ i = -1
+ for i, slice_i in enumerate(key):
+ if isinstance(slice_i, integer_types):
+ begin.append(slice_i)
+ end.append(slice_i+1)
+ step.append(1)
+ elif isinstance(slice_i, py_slice):
+ if slice_i.step == 0:
+ raise ValueError('basic index=%s cannot have slice=%s with step = 0'
+ % (str(key), str(slice_i)))
+ begin.append(slice_i.start)
+ end.append(slice_i.stop)
+ step.append(slice_i.step)
+ kept_axes.append(i)
+ else:
+ raise ValueError('basic_indexing does not support slicing with '
+ 'index=%s of type=%s.' % (str(slice_i), str(type(slice_i))))
+ kept_axes.extend(range(i+1, len(shape)))
+ sliced_nd = op.slice(self, begin, end, step)
+ if len(kept_axes) == len(shape):
+ return sliced_nd
+ # squeeze sliced_shape to remove the axes indexed by integers
+ oshape = []
+ sliced_shape = sliced_nd.shape
+ for axis in kept_axes:
+ oshape.append(sliced_shape[axis])
+ # if key is a tuple of integers, still need to keep 1 dim
+ # while in Numpy, the output will become an value instead of an ndarray
+ if len(oshape) == 0:
+ oshape.append(1)
+ oshape = tuple(oshape)
+ assert np.prod(oshape) == np.prod(sliced_shape), 'oshape=%s has different size'\
+ ' than sliced_shape=%s'\
+ % (oshape, sliced_shape)
+ return sliced_nd.reshape(oshape)
+
+ def _get_nd_advanced_indexing(self, key):
+ """Get item when key is a tuple of any objects of the following types:
+ NDArray, np.ndarray, list, tuple, slice, and integer."""
+ return op.gather_nd(self, self._get_index_nd(key))
def _sync_copyfrom(self, source_array):
"""Performs a synchronized copy from the `source_array` to the current array.
@@ -638,26 +852,10 @@ fixed-size items.
array([], shape=(0, 2), dtype=float32)
"""
handle = NDArrayHandle()
- if start is None:
- start = mx_uint(0)
- elif start < 0:
- length = self.shape[0]
- start += length
- assert start >= 0, "Slicing start %d exceeds limit of %d"%(start-length, length)
- start = mx_uint(start)
- else:
- start = mx_uint(start)
- if stop is None:
- stop = mx_uint(self.shape[0])
- elif stop < 0:
- length = self.shape[0]
- stop += length
- assert stop >= 0, "Slicing end %d exceeds limit of %d"%(stop-length, length)
- stop = mx_uint(stop)
- else:
- stop = mx_uint(stop)
+ start, stop, _ = _get_index_range(start, stop, self.shape[0])
+
check_call(_LIB.MXNDArraySlice(
- self.handle, start, stop, ctypes.byref(handle)))
+ self.handle, mx_uint(start), mx_uint(stop), ctypes.byref(handle)))
return NDArray(handle=handle, writable=self.writable)
def _at(self, idx):
@@ -684,9 +882,14 @@ fixed-size items.
array([ 1.], dtype=float32)
"""
handle = NDArrayHandle()
- idx = mx_uint(idx)
+ if idx < 0:
+ length = self.shape[0]
+ idx += length
+ if idx < 0:
+ raise IndexError('index %d is out of bounds for axis 0 with size %d'
+ % (idx-length, length))
check_call(_LIB.MXNDArrayAt(
- self.handle, idx, ctypes.byref(handle)))
+ self.handle, mx_uint(idx), ctypes.byref(handle)))
return NDArray(handle=handle, writable=self.writable)
def reshape(self, shape):
@@ -1779,6 +1982,119 @@ fixed-size items.
return op.cast_storage(self, stype=stype)
+def _get_indexing_dispatch_code(key):
+ """Returns a dispatch code for calling basic or advanced indexing functions."""
+ if isinstance(key, (NDArray, np.ndarray)):
+ return _NDARRAY_ADVANCED_INDEXING
+ elif isinstance(key, list):
+ # TODO(junwu): Add support for nested lists besides integer list
+ for i in key:
+ if not isinstance(i, integer_types):
+ raise TypeError('Indexing NDArray only supports a list of integers as index'
+ ' when key is of list type, received element=%s of type=%s'
+ % (str(i), str(type(i))))
+ return _NDARRAY_ADVANCED_INDEXING
+ elif isinstance(key, (integer_types, py_slice)):
+ return _NDARRAY_BASIC_INDEXING
+ elif isinstance(key, tuple):
+ for idx in key:
+ if isinstance(idx, (NDArray, np.ndarray, list, tuple)):
+ return _NDARRAY_ADVANCED_INDEXING
+ elif not isinstance(idx, (py_slice, integer_types)):
+ raise ValueError("NDArray does not support slicing with key %s of type %s."
+ % (str(idx), str(type(idx))))
+ return _NDARRAY_BASIC_INDEXING
+ else:
+ return _NDARRAY_UNSUPPORTED_INDEXING
+
+
+def _get_index_range(start, stop, length, step=1):
+ """Given start, stop, step and array length, return
+ absolute values of start, stop, and step for generating index range.
+ The returned values have been compensated by adding length if they
+ are less than zero for all the cases but slice(None, None, -1).
+ Note that the returned value of stop is not necessarily >= 0, since
+ absolute stop is -1 in the case of slice(None, None, -1)."""
+ if step == 0:
+ raise ValueError('step size cannot be zero')
+ if length < 0:
+ raise ValueError('array length cannot be less than zero')
+ if step is None:
+ step = 1
+ if start is None:
+ if step > 0:
+ start = 0
+ else:
+ start = length - 1
+ elif start < 0:
+ start += length
+ if start < 0:
+ raise IndexError('Slicing start %d exceeds limit of %d' % (start-length, length))
+ elif start >= length:
+ raise IndexError('Slicing start %d exceeds limit of %d' % (start, length))
+
+ if stop is None:
+ if step > 0:
+ stop = length
+ else:
+ # this supports case such as ::-1
+ # stop = -1 here refers to the element before index 0,
+ # instead of the last element in the array
+ stop = -1
+ elif stop < 0:
+ stop += length
+ if stop < 0:
+ raise IndexError('Slicing stop %d exceeds limit of %d' % (stop-length, length))
+ elif stop > length:
+ raise IndexError('Slicing stop %d exceeds limit of %d' % (stop, length))
+
+ return start, stop, step
+
+
+def _get_oshape_of_gather_nd_op(dshape, ishape):
+ """Given data and index shapes, get the output `NDArray` shape.
+ This basically implements the infer shape logic of op gather_nd."""
+ assert len(dshape) > 0 and len(ishape) > 0
+ oshape = list(ishape[1:])
+ if ishape[0] < len(dshape):
+ oshape.extend(dshape[ishape[0]:])
+ return tuple(oshape)
+
+
+def _get_dim_size(start, stop, step):
+ """Given start, stop, and stop, calculate the number of elements
+ of this slice."""
+ assert step != 0
+ if step > 0:
+ assert start < stop
+ dim_size = (stop - start - 1) // step + 1
+ else:
+ assert stop < start
+ dim_size = (start - stop - 1) // (-step) + 1
+ return dim_size
+
+
+def _get_broadcast_shape(shape1, shape2):
+ """Given two shapes that are not identical, find the shape
+ that both input shapes can broadcast to."""
+ if shape1 == shape2:
+ return shape1
+
+ length1 = len(shape1)
+ length2 = len(shape2)
+ if length1 > length2:
+ shape = list(shape1)
+ else:
+ shape = list(shape2)
+ i = max(length1, length2) - 1
+ for a, b in zip(shape1[::-1], shape2[::-1]):
+ if a != 1 and b != 1 and a != b:
+ raise ValueError('shape1=%s is not broadcastable to shape2=%s' % (shape1, shape2))
+ shape[i] = max(a, b)
+ i -= 1
+ return tuple(shape)
+
+
def onehot_encode(indices, out):
"""One-hot encoding indices into matrix out.
@@ -1858,10 +2174,8 @@ def full(shape, val, ctx=None, dtype=mx_real_t, out=None):
>>> mx.nd.full((1, 2), 2.0, dtype='float16').asnumpy()
array([[ 2., 2.]], dtype=float16)
"""
- if ctx is None:
- ctx = Context.default_ctx
- dtype = mx_real_t if dtype is None else dtype
- out = _internal._full(shape=shape, ctx=ctx, dtype=dtype, value=val, out=out)
+ out = empty(shape, ctx, dtype) if out is None else out
+ out[:] = val
return out
diff --git a/src/operator/tensor/indexing_op.cc b/src/operator/tensor/indexing_op.cc
index 7c8e53e..273ebec 100644
--- a/src/operator/tensor/indexing_op.cc
+++ b/src/operator/tensor/indexing_op.cc
@@ -438,6 +438,35 @@ Examples::
.add_argument("indices", "NDArray-or-Symbol", "indices")
.add_arguments(ScatterNDParam::__FIELDS__());
+NNVM_REGISTER_OP(_scatter_set_nd)
+.describe(R"code(This operator has the same functionality as scatter_nd
+except that it does not reset the elements not indexed by the input
+index `NDArray` in the input data `NDArray`.
+
+.. note:: This operator is for internal use only.
+
+Examples::
+
+ data = [2, 3, 0]
+ indices = [[1, 1, 0], [0, 1, 0]]
+ out = [[1, 1], [1, 1]]
+ scatter_nd(data=data, indices=indices, out=out)
+ out = [[0, 1], [2, 3]]
+
+)code")
+.set_num_outputs(1)
+.set_num_inputs(2)
+.set_attr_parser(ParamParser<ScatterNDParam>)
+.set_attr<nnvm::FListInputNames>("FListInputNames",
+ [](const NodeAttrs& attrs) {
+ return std::vector<std::string>{"data", "indices"};
+ })
+.set_attr<nnvm::FInferShape>("FInferShape", ScatterNDShape)
+.set_attr<nnvm::FInferType>("FInferType", ScatterNDType)
+.set_attr<FCompute>("FCompute<cpu>", ScatterSetNDForward<cpu>)
+.add_argument("data", "NDArray-or-Symbol", "data")
+.add_argument("indices", "NDArray-or-Symbol", "indices")
+.add_arguments(ScatterNDParam::__FIELDS__());
} // namespace op
} // namespace mxnet
diff --git a/src/operator/tensor/indexing_op.cu b/src/operator/tensor/indexing_op.cu
index e2822e8..2cddd00 100644
--- a/src/operator/tensor/indexing_op.cu
+++ b/src/operator/tensor/indexing_op.cu
@@ -49,5 +49,8 @@ NNVM_REGISTER_OP(gather_nd)
NNVM_REGISTER_OP(scatter_nd)
.set_attr<FCompute>("FCompute<gpu>", ScatterNDForward<gpu>);
+
+NNVM_REGISTER_OP(_scatter_set_nd)
+.set_attr<FCompute>("FCompute<gpu>", ScatterSetNDForward<gpu>);
} // namespace op
} // namespace mxnet
diff --git a/src/operator/tensor/indexing_op.h b/src/operator/tensor/indexing_op.h
index 7624f2d..684794b 100644
--- a/src/operator/tensor/indexing_op.h
+++ b/src/operator/tensor/indexing_op.h
@@ -1208,10 +1208,10 @@ struct scatter_nd {
template<typename xpu>
void ScatterNDForward(const nnvm::NodeAttrs& attrs,
- const OpContext& ctx,
- const std::vector<TBlob>& inputs,
- const std::vector<OpReqType>& req,
- const std::vector<TBlob>& outputs) {
+ const OpContext& ctx,
+ const std::vector<TBlob>& inputs,
+ const std::vector<OpReqType>& req,
+ const std::vector<TBlob>& outputs) {
using namespace mshadow;
CHECK_EQ(inputs.size(), 2U);
CHECK_EQ(outputs.size(), 1U);
@@ -1225,7 +1225,9 @@ void ScatterNDForward(const nnvm::NodeAttrs& attrs,
mshadow::Shape<10> strides;
for (int i = M-1, stride = K; i >= 0; stride *= oshape[i], --i) strides[i] = stride;
MSHADOW_TYPE_SWITCH(inputs[0].type_flag_, DType, { // output data type switch
- Fill<true>(s, outputs[0], req[0], 0);
+ if (kWriteTo == req[0]) {
+ Fill<true>(s, outputs[0], req[0], 0);
+ }
MSHADOW_TYPE_SWITCH(inputs[1].type_flag_, IType, { // indices data type switch
mxnet_op::Kernel<scatter_nd, xpu>::Launch(
s, N, req[0], N, M, K, strides, outputs[0].dptr<DType>(),
@@ -1234,6 +1236,19 @@ void ScatterNDForward(const nnvm::NodeAttrs& attrs,
});
}
+/*!
+ * This is for internal use only.
+ * DO NOT call this function unless you have to.
+ */
+template<typename xpu>
+void ScatterSetNDForward(const nnvm::NodeAttrs& attrs,
+ const OpContext& ctx,
+ const std::vector<TBlob>& inputs,
+ const std::vector<OpReqType>& req,
+ const std::vector<TBlob>& outputs) {
+ ScatterNDForward<xpu>(attrs, ctx, inputs, {kWriteInplace}, outputs);
+}
+
} // namespace op
} // namespace mxnet
#ifdef __CUDACC__
diff --git a/src/operator/tensor/matrix_op-inl.h b/src/operator/tensor/matrix_op-inl.h
index 6940cfa..1f25b94 100644
--- a/src/operator/tensor/matrix_op-inl.h
+++ b/src/operator/tensor/matrix_op-inl.h
@@ -385,41 +385,6 @@ struct SliceParam : public dmlc::Parameter<SliceParam> {
}
};
-inline TShape GetSliceShape(const SliceParam& param, const TShape& dshape) {
- CHECK_LE(param.begin.ndim(), dshape.ndim())
- << "Slicing axis exceeds data dimensions";
- CHECK_LE(param.end.ndim(), dshape.ndim())
- << "Slicing axis exceeds data dimensions";
- CHECK_EQ(param.begin.ndim(), param.end.ndim())
- << "begin and end must have the same length";
-
- TShape oshape = dshape;
- for (index_t i = 0; i < param.begin.ndim(); ++i) {
- int s = 0, e = dshape[i];
- if (e != 0) {
- if (param.begin[i]) {
- CHECK_LE(*param.begin[i], e)
- << "Slicing begin exceeds data dimensions "
- << param.begin << " vs " << dshape;
- s = *param.begin[i];
- if (s < 0) s += dshape[i];
- }
- if (param.end[i]) {
- CHECK_LE(*param.end[i], e)
- << "Slicing end exceeds data dimensions "
- << param.end << " vs " << dshape;
- e = *param.end[i];
- if (e < 0) e += dshape[i];
- }
- CHECK(s >= 0 && s < e && e <= static_cast<int>(dshape[i]))
- << "Invalid slicing begin " << param.begin << " and end "
- << param.end << " for data of shape " << dshape;
- }
- oshape[i] = e - s;
- }
- return oshape;
-}
-
inline bool SliceForwardInferStorageType(const nnvm::NodeAttrs& attrs,
const int dev_mask,
DispatchMode* dispatch_mode,
@@ -683,41 +648,43 @@ void SliceEx(const nnvm::NodeAttrs& attrs,
}
template<int ndim>
-inline void GetIndexRange(const SliceParam& param,
- const TShape& dshape,
+inline void GetIndexRange(const TShape& dshape,
+ const nnvm::Tuple<dmlc::optional<int>>& param_begin,
+ const nnvm::Tuple<dmlc::optional<int>>& param_end,
+ const nnvm::Tuple<dmlc::optional<int>>& param_step,
common::StaticArray<int, ndim>* begin,
common::StaticArray<int, ndim>* end,
common::StaticArray<int, ndim>* step) {
CHECK_NE(dshape.ndim(), 0U);
CHECK_NE(dshape.Size(), 0U);
- CHECK_LE(param.begin.ndim(), dshape.ndim())
+ CHECK_LE(param_begin.ndim(), dshape.ndim())
<< "Slicing axis exceeds data dimensions";
- CHECK_LE(param.end.ndim(), dshape.ndim())
+ CHECK_LE(param_end.ndim(), dshape.ndim())
<< "Slicing axis exceeds data dimensions";
- CHECK_EQ(param.begin.ndim(), param.end.ndim())
+ CHECK_EQ(param_begin.ndim(), param_end.ndim())
<< "begin and end must have the same length";
CHECK_EQ(ndim, dshape.ndim())
<< "Static array size=" << ndim
<< " is not equal to data shape ndim=" << dshape.ndim();
- if (param.step.ndim() != 0U) {
- CHECK_EQ(param.step.ndim(), param.begin.ndim())
+ if (param_step.ndim() != 0U) {
+ CHECK_EQ(param_step.ndim(), param_begin.ndim())
<< "step and begin must have the same length";
}
- for (index_t i = 0; i < param.begin.ndim(); ++i) {
+ for (index_t i = 0; i < param_begin.ndim(); ++i) {
int b = 0, e = dshape[i], s = 1;
const int len = dshape[i];
- if (param.step.ndim() != 0U) {
- const auto& opt_step_val = param.step[i];
+ if (param_step.ndim() != 0U) {
+ const auto& opt_step_val = param_step[i];
if (opt_step_val.has_value()) {
s = opt_step_val.value();
CHECK_NE(s, 0) << "slice op step[" << i << "] cannot be 0";
}
}
- if (param.begin[i].has_value()) {
- b = param.begin[i].value();
+ if (param_begin[i].has_value()) {
+ b = param_begin[i].value();
if (b < 0) {
b += len;
CHECK_GE(b, 0) << "slicing with begin[" << i << "]="
@@ -729,8 +696,8 @@ inline void GetIndexRange(const SliceParam& param,
CHECK_LT(b, len) << "slicing with begin[" << i << "]="
<< b << " exceends limit of " << len;
- if (param.end[i].has_value()) {
- e = param.end[i].value();
+ if (param_end[i].has_value()) {
+ e = param_end[i].value();
if (e < 0) {
e += len;
CHECK_GE(e, 0) << "slicing with end[" << i << "]="
@@ -746,13 +713,27 @@ inline void GetIndexRange(const SliceParam& param,
(*end)[i] = e;
(*step)[i] = s;
}
- for (index_t i = param.begin.ndim(); i < dshape.ndim(); ++i) {
+ for (index_t i = param_begin.ndim(); i < dshape.ndim(); ++i) {
(*begin)[i] = 0;
(*end)[i] = dshape[i];
(*step)[i] = 1;
}
}
+inline void SetSliceOpOutputDimSize(const index_t i, const int b,
+ const int e, const int s,
+ TShape* oshape) {
+ if (s > 0) {
+ CHECK_LT(b, e) << "slicing with begin=[" << i << "]=" << b << ", end[" << i << "]="
+ << e << ", and step[" << i << "]=" << s << " is invalid";
+ (*oshape)[i] = (e - b - 1) / s + 1;
+ } else {
+ CHECK_LT(e, b) << "slicing with begin=[" << i << "]=" << b << ", end[" << i << "]="
+ << e << ", and step[" << i << "]=" << s << " is invalid";
+ (*oshape)[i] = (b - e - 1) / (-s) + 1;
+ }
+}
+
inline bool SliceOpShape(const nnvm::NodeAttrs& attrs,
std::vector<TShape>* in_attrs,
std::vector<TShape>* out_attrs) {
@@ -764,19 +745,10 @@ inline bool SliceOpShape(const nnvm::NodeAttrs& attrs,
TShape oshape = dshape;
MXNET_NDIM_SWITCH(dshape.ndim(), ndim, {
common::StaticArray<int, ndim> begin, end, step;
- GetIndexRange(param, dshape, &begin, &end, &step);
-
+ GetIndexRange(dshape, param.begin, param.end, param.step, &begin, &end, &step);
for (index_t i = 0; i < param.begin.ndim(); ++i) {
const int b = begin[i], e = end[i], s = step[i];
- if (s > 0) {
- CHECK_LT(b, e) << "slicing with begin=[" << i << "]=" << b << ", end[" << i << "]="
- << e << ", and step[" << i << "]=" << s << " is invalid";
- oshape[i] = (e - b - 1) / s + 1;
- } else {
- CHECK_LT(e, b) << "slicing with begin=[" << i << "]=" << b << ", end[" << i << "]="
- << e << ", and step[" << i << "]=" << s << " is invalid";
- oshape[i] = (b - e - 1) / (-s) + 1;
- }
+ SetSliceOpOutputDimSize(i, b, e, s, &oshape);
}
});
@@ -832,7 +804,7 @@ void SliceOpForward(const nnvm::NodeAttrs& attrs,
const SliceParam& param = nnvm::get<SliceParam>(attrs.parsed);
MXNET_NDIM_SWITCH(data.ndim(), ndim, {
common::StaticArray<int, ndim> begin, end, step;
- GetIndexRange(param, data.shape_, &begin, &end, &step);
+ GetIndexRange(data.shape_, param.begin, param.end, param.step, &begin, &end, &step);
MSHADOW_TYPE_SWITCH(out.type_flag_, DType, {
mxnet_op::Kernel<slice_forward<ndim>, xpu>::Launch(s, out.shape_.FlatTo2D()[0],
out.dptr<DType>(), data.dptr<DType>(), req[0],
@@ -842,32 +814,32 @@ void SliceOpForward(const nnvm::NodeAttrs& attrs,
}
template<int ndim>
-struct slice_backward {
+struct slice_assign {
// i is the i-th row after flattening out into 2D tensor
template<typename DType>
- MSHADOW_XINLINE static void Map(int i, DType* igrad, const DType* ograd,
+ MSHADOW_XINLINE static void Map(int i, DType* out, const DType* val,
const OpReqType req,
- const mshadow::Shape<ndim> dshape,
const mshadow::Shape<ndim> oshape,
+ const mshadow::Shape<ndim> vshape,
const common::StaticArray<int, ndim> begin,
const common::StaticArray<int, ndim> step) {
- const int data_last_dim_size = dshape[ndim-1];
- const int out_last_dim_size = oshape[ndim-1];
+ const int data_last_dim_size = oshape[ndim-1];
+ const int out_last_dim_size = vshape[ndim-1];
const int step_last_dim = step[ndim-1];
const int begin_last_dim = begin[ndim-1];
- int ograd_offset = i * out_last_dim_size;
+ int offset = i * out_last_dim_size;
for (int j = 0; j < out_last_dim_size; ++j) {
- int irow = 0; // row id of flattend 2D igrad
+ int irow = 0; // row id of flattend 2D out
int stride = 1;
int idx = i;
#pragma unroll
for (int k = ndim - 2; k >= 0; --k) {
- irow += stride * ((idx % oshape[k]) * step[k] + begin[k]);
- idx /= oshape[k];
- stride *= dshape[k];
+ irow += stride * ((idx % vshape[k]) * step[k] + begin[k]);
+ idx /= vshape[k];
+ stride *= oshape[k];
}
- KERNEL_ASSIGN(igrad[irow * data_last_dim_size + j * step_last_dim + begin_last_dim],
- req, ograd[ograd_offset++]);
+ KERNEL_ASSIGN(out[irow * data_last_dim_size + j * step_last_dim + begin_last_dim],
+ req, val[offset++]);
}
}
};
@@ -894,136 +866,145 @@ void SliceOpBackward(const nnvm::NodeAttrs& attrs,
}
MXNET_NDIM_SWITCH(ograd.ndim(), ndim, {
common::StaticArray<int, ndim> begin, end, step;
- GetIndexRange(param, igrad.shape_, &begin, &end, &step);
+ GetIndexRange(igrad.shape_, param.begin, param.end, param.step, &begin, &end, &step);
MSHADOW_TYPE_SWITCH(ograd.type_flag_, DType, {
- mxnet_op::Kernel<slice_backward<ndim>, xpu>::Launch(s, ograd.shape_.FlatTo2D()[0],
+ mxnet_op::Kernel<slice_assign<ndim>, xpu>::Launch(s, ograd.shape_.FlatTo2D()[0],
igrad.dptr<DType>(), ograd.dptr<DType>(), req[0],
igrad.shape_.get<ndim>(), ograd.shape_.get<ndim>(), begin, step);
})
})
}
-inline bool SliceAssignShape(const nnvm::NodeAttrs& attrs,
- std::vector<TShape> *in_attrs,
- std::vector<TShape> *out_attrs) {
- const TShape& lshape = (*in_attrs)[0];
- if (lshape.ndim() == 0) return false;
+inline bool SliceAssignOpShape(const nnvm::NodeAttrs& attrs,
+ std::vector<TShape> *in_attrs,
+ std::vector<TShape> *out_attrs) {
+ CHECK_EQ(in_attrs->size(), 2U);
+ CHECK_EQ(out_attrs->size(), 1U);
+ const TShape& dshape = (*in_attrs)[0];
+ if (dshape.ndim() == 0U || dshape.Size() == 0U) return false;
+ TShape vshape = dshape; // vshape is the value shape on the right hand side
const SliceParam& param = nnvm::get<SliceParam>(attrs.parsed);
- SHAPE_ASSIGN_CHECK(*in_attrs, 1, GetSliceShape(param, lshape));
- SHAPE_ASSIGN_CHECK(*out_attrs, 0, lshape);
- return true;
-}
-
-template<typename xpu>
-void SliceAssignImpl(mshadow::Stream<xpu> *s, const SliceParam& param,
- const TBlob& dst, const TBlob& src) {
- using namespace mshadow;
- using namespace mshadow::expr;
- index_t N = dst.ndim();
- TShape begin(N), end(N);
- for (index_t i = 0; i < N; ++i) {
- int s = 0;
- if (param.begin[i]) {
- s = *param.begin[i];
- if (s < 0) s += dst.size(i);
- }
- begin[i] = s;
- end[i] = s + src.size(i);
- }
-
- MSHADOW_TYPE_SWITCH(dst.type_flag_, DType, {
- switch (dst.ndim()) {
- case 0:
- break;
- case 1: {
- Tensor<xpu, 1, DType> out = dst.get<xpu, 1, DType>(s);
- Tensor<xpu, 1, DType> in = src.get<xpu, 1, DType>(s);
- slice(out, begin.get<1>(), end.get<1>()) = in;
- break;
- }
- case 2: {
- Tensor<xpu, 2, DType> out = dst.get<xpu, 2, DType>(s);
- Tensor<xpu, 2, DType> in = src.get<xpu, 2, DType>(s);
- slice(out, begin.get<2>(), end.get<2>()) = in;
- break;
- }
- case 3: {
- Tensor<xpu, 3, DType> out = dst.get<xpu, 3, DType>(s);
- Tensor<xpu, 3, DType> in = src.get<xpu, 3, DType>(s);
- slice(out, begin.get<3>(), end.get<3>()) = in;
- break;
- }
- case 4: {
- Tensor<xpu, 4, DType> out = dst.get<xpu, 4, DType>(s);
- Tensor<xpu, 4, DType> in = src.get<xpu, 4, DType>(s);
- slice(out, begin.get<4>(), end.get<4>()) = in;
- break;
- }
- case 5: {
- Tensor<xpu, 5, DType> out = dst.get<xpu, 5, DType>(s);
- Tensor<xpu, 5, DType> in = src.get<xpu, 5, DType>(s);
- slice(out, begin.get<5>(), end.get<5>()) = in;
- break;
- }
- default:
- LOG(FATAL) << "CropAssign supports at most 5 dimensions";
- break;
+ MXNET_NDIM_SWITCH(dshape.ndim(), ndim, {
+ common::StaticArray<int, ndim> begin, end, step;
+ GetIndexRange(dshape, param.begin, param.end, param.step, &begin, &end, &step);
+ for (index_t i = 0; i < param.begin.ndim(); ++i) {
+ const int b = begin[i], e = end[i], s = step[i];
+ SetSliceOpOutputDimSize(i, b, e, s, &vshape);
}
});
+ SHAPE_ASSIGN_CHECK(*in_attrs, 1, vshape);
+ SHAPE_ASSIGN_CHECK(*out_attrs, 0, dshape);
+ return true;
}
template<typename xpu>
-void SliceAssign(const nnvm::NodeAttrs& attrs,
- const OpContext& ctx,
- const std::vector<TBlob>& inputs,
- const std::vector<OpReqType>& req,
- const std::vector<TBlob>& outputs) {
+void SliceAssignOpForward(const nnvm::NodeAttrs& attrs,
+ const OpContext& ctx,
+ const std::vector<TBlob>& inputs,
+ const std::vector<OpReqType>& req,
+ const std::vector<TBlob>& outputs) {
using namespace mshadow;
- using namespace mshadow::expr;
-
- const SliceParam& param = nnvm::get<SliceParam>(attrs.parsed);
+ CHECK_EQ(inputs.size(), 2U); // data[index] = val, data and val are two inputs
+ CHECK_EQ(outputs.size(), 1U);
+ if (req[0] == kNullOp) return;
Stream<xpu> *s = ctx.get_stream<xpu>();
-
- if (req[0] == kNullOp) {
- return;
- } else if (req[0] == kWriteTo) {
+ const TBlob& data = inputs[0];
+ const TBlob& val = inputs[1];
+ const TBlob& out = outputs[0];
+ if (req[0] == kWriteTo) {
MSHADOW_TYPE_SWITCH(outputs[0].type_flag_, DType, {
Tensor<xpu, 1, DType> in = inputs[0].FlatTo1D<xpu, DType>(s);
Tensor<xpu, 1, DType> out = outputs[0].FlatTo1D<xpu, DType>(s);
Copy(out, in, s);
});
} else if (req[0] != kWriteInplace) {
- LOG(FATAL) << "CropAssign only supports kWriteTo and kWriteInplace";
+ LOG(FATAL) << "_slice_assign only supports kWriteTo and kWriteInplace";
}
- SliceAssignImpl<xpu>(s, param, outputs[0], inputs[1]);
+ const SliceParam& param = nnvm::get<SliceParam>(attrs.parsed);
+ MXNET_NDIM_SWITCH(data.ndim(), ndim, {
+ common::StaticArray<int, ndim> begin, end, step;
+ GetIndexRange(data.shape_, param.begin, param.end, param.step, &begin, &end, &step);
+ MSHADOW_TYPE_SWITCH(out.type_flag_, DType, {
+ mxnet_op::Kernel<slice_assign<ndim>, xpu>::Launch(s, val.shape_.FlatTo2D()[0],
+ out.dptr<DType>(), val.dptr<DType>(), req[0],
+ out.shape_.get<ndim>(), val.shape_.get<ndim>(), begin, step);
+ })
+ })
}
-struct SimpleCropAssignScalarParam : public dmlc::Parameter<SimpleCropAssignScalarParam> {
+struct SliceAssignScalarParam : public dmlc::Parameter<SliceAssignScalarParam> {
real_t scalar;
- TShape begin, end;
- DMLC_DECLARE_PARAMETER(SimpleCropAssignScalarParam) {
+ nnvm::Tuple<dmlc::optional<int>> begin, end;
+ nnvm::Tuple<dmlc::optional<int>> step;
+ DMLC_DECLARE_PARAMETER(SliceAssignScalarParam) {
DMLC_DECLARE_FIELD(scalar)
.set_default(0)
.describe("The scalar value for assignment.");
DMLC_DECLARE_FIELD(begin)
- .describe("starting coordinates");
+ .describe("starting indices for the slice operation, supports negative indices.");
DMLC_DECLARE_FIELD(end)
- .describe("ending coordinates");
+ .describe("ending indices for the slice operation, supports negative indices.");
+ DMLC_DECLARE_FIELD(step)
+ .set_default(nnvm::Tuple<dmlc::optional<int>>())
+ .describe("step for the slice operation, supports negative values.");
+ }
+};
+
+inline bool SliceAssignScalarOpShape(const nnvm::NodeAttrs& attrs,
+ std::vector<TShape> *in_attrs,
+ std::vector<TShape> *out_attrs) {
+ CHECK_EQ(in_attrs->size(), 1U);
+ CHECK_EQ(out_attrs->size(), 1U);
+ const TShape& dshape = (*in_attrs)[0];
+ if (dshape.ndim() == 0U || dshape.Size() == 0U) return false;
+ SHAPE_ASSIGN_CHECK(*out_attrs, 0, dshape);
+ return true;
+}
+
+template<int ndim>
+struct slice_assign_scalar {
+ // i is the i-th row after flattening out into 2D tensor
+ template<typename DType>
+ MSHADOW_XINLINE static void Map(int i, DType* out, const DType val,
+ const OpReqType req,
+ const mshadow::Shape<ndim> oshape,
+ const mshadow::Shape<ndim> vshape,
+ const common::StaticArray<int, ndim> begin,
+ const common::StaticArray<int, ndim> step) {
+ const int data_last_dim_size = oshape[ndim-1];
+ const int out_last_dim_size = vshape[ndim-1];
+ const int step_last_dim = step[ndim-1];
+ const int begin_last_dim = begin[ndim-1];
+ for (int j = 0; j < out_last_dim_size; ++j) {
+ int irow = 0; // row id of flattend 2D out
+ int stride = 1;
+ int idx = i;
+ #pragma unroll
+ for (int k = ndim - 2; k >= 0; --k) {
+ irow += stride * ((idx % vshape[k]) * step[k] + begin[k]);
+ idx /= vshape[k];
+ stride *= oshape[k];
+ }
+ KERNEL_ASSIGN(out[irow * data_last_dim_size + j * step_last_dim + begin_last_dim], req, val);
+ }
}
};
template<typename xpu>
-void CropAssignScalar(const nnvm::NodeAttrs& attrs,
- const OpContext& ctx,
- const std::vector<TBlob>& inputs,
- const std::vector<OpReqType>& req,
- const std::vector<TBlob>& outputs) {
+void SliceAssignScalarOpForward(const nnvm::NodeAttrs& attrs,
+ const OpContext& ctx,
+ const std::vector<TBlob>& inputs,
+ const std::vector<OpReqType>& req,
+ const std::vector<TBlob>& outputs) {
+ CHECK_EQ(inputs.size(), 1U);
+ CHECK_EQ(outputs.size(), 1U);
+ CHECK_EQ(req.size(), 1U);
using namespace mshadow;
- using namespace mshadow::expr;
- const SimpleCropAssignScalarParam& param = nnvm::get<SimpleCropAssignScalarParam>(attrs.parsed);
Stream<xpu> *s = ctx.get_stream<xpu>();
+ const TBlob& data = inputs[0];
+ const TBlob& out = outputs[0];
if (req[0] == kWriteTo) {
MSHADOW_TYPE_SWITCH(outputs[0].type_flag_, DType, {
Tensor<xpu, 1, DType> in = inputs[0].FlatTo1D<xpu, DType>(s);
@@ -1031,63 +1012,24 @@ void CropAssignScalar(const nnvm::NodeAttrs& attrs,
Copy(out, in, s);
});
} else if (req[0] != kWriteInplace) {
- LOG(FATAL) << "CropAssignScalar only supports kWriteTo and kWriteInplace";
+ LOG(FATAL) << "_crop_assign_scalar only supports kWriteTo and kWriteInplace";
}
- MSHADOW_TYPE_SWITCH(outputs[0].type_flag_, DType, {
- switch (outputs[0].shape_.ndim()) {
- case 0:
- break;
- case 1: {
- Tensor<xpu, 1, DType> out = outputs[0].get<xpu, 1, DType>(s);
- slice(out, param.begin.get<1>(), param.end.get<1>()) = \
- static_cast<DType>(param.scalar);
- break;
- }
- case 2: {
- Tensor<xpu, 2, DType> out = outputs[0].get<xpu, 2, DType>(s);
- slice(out, param.begin.get<2>(), param.end.get<2>()) = \
- static_cast<DType>(param.scalar);
- break;
- }
- case 3: {
- Tensor<xpu, 3, DType> out = outputs[0].get<xpu, 3, DType>(s);
- slice(out, param.begin.get<3>(), param.end.get<3>()) = \
- static_cast<DType>(param.scalar);
- break;
- }
- case 4: {
- Tensor<xpu, 4, DType> out = outputs[0].get<xpu, 4, DType>(s);
- slice(out, param.begin.get<4>(), param.end.get<4>()) = \
- static_cast<DType>(param.scalar);
- break;
- }
- case 5: {
- Tensor<xpu, 5, DType> out = outputs[0].get<xpu, 5, DType>(s);
- slice(out, param.begin.get<5>(), param.end.get<5>()) = \
- static_cast<DType>(param.scalar);
- break;
- }
- default:
- LOG(FATAL) << "CropAssign supports at most 5 dimensions";
- break;
+ TShape vshape = data.shape_;
+ const SliceAssignScalarParam& param = nnvm::get<SliceAssignScalarParam>(attrs.parsed);
+ MXNET_NDIM_SWITCH(data.ndim(), ndim, {
+ common::StaticArray<int, ndim> begin, end, step;
+ GetIndexRange(data.shape_, param.begin, param.end, param.step, &begin, &end, &step);
+ for (index_t i = 0; i < param.begin.ndim(); ++i) {
+ const int b = begin[i], e = end[i], s = step[i];
+ SetSliceOpOutputDimSize(i, b, e, s, &vshape);
}
- });
-}
-
-inline bool CropAssignScalarShape(const nnvm::NodeAttrs& attrs,
- std::vector<TShape> *in_attrs,
- std::vector<TShape> *out_attrs) {
- const SimpleCropAssignScalarParam& param = nnvm::get<SimpleCropAssignScalarParam>(attrs.parsed);
- TShape& lshape = (*in_attrs)[0];
- CHECK_EQ(lshape.ndim(), param.begin.ndim());
- CHECK_EQ(lshape.ndim(), param.end.ndim());
- for (index_t i = 0; i < lshape.ndim(); ++i) {
- CHECK_LT(param.begin[i], param.end[i]);
- CHECK_LE(param.end[i], lshape[i]);
- }
- SHAPE_ASSIGN_CHECK(*out_attrs, 0, lshape);
- return true;
+ MSHADOW_TYPE_SWITCH(out.type_flag_, DType, {
+ mxnet_op::Kernel<slice_assign_scalar<ndim>, xpu>::Launch(s, vshape.FlatTo2D()[0],
+ out.dptr<DType>(), static_cast<DType>(param.scalar), req[0],
+ out.shape_.get<ndim>(), vshape.get<ndim>(), begin, step);
+ })
+ })
}
struct SliceAxisParam : public dmlc::Parameter<SliceAxisParam> {
diff --git a/src/operator/tensor/matrix_op.cc b/src/operator/tensor/matrix_op.cc
index 7f109b6..cba9efd 100644
--- a/src/operator/tensor/matrix_op.cc
+++ b/src/operator/tensor/matrix_op.cc
@@ -31,7 +31,7 @@ DMLC_REGISTER_PARAMETER(ReshapeParam);
DMLC_REGISTER_PARAMETER(TransposeParam);
DMLC_REGISTER_PARAMETER(ExpandDimParam);
DMLC_REGISTER_PARAMETER(ClipParam);
-DMLC_REGISTER_PARAMETER(SimpleCropAssignScalarParam);
+DMLC_REGISTER_PARAMETER(SliceAssignScalarParam);
DMLC_REGISTER_PARAMETER(SliceParam);
DMLC_REGISTER_PARAMETER(SliceAxisParam);
DMLC_REGISTER_PARAMETER(RepeatParam);
@@ -323,18 +323,19 @@ NNVM_REGISTER_OP(_slice_assign)
return std::vector<std::string>{"lhs", "rhs"};
})
.set_attr_parser(ParamParser<SliceParam>)
-.set_attr<nnvm::FInferShape>("FInferShape", SliceAssignShape)
+.set_attr<nnvm::FInferShape>("FInferShape", SliceAssignOpShape)
.set_attr<nnvm::FInferType>("FInferType", ElemwiseType<2, 1>)
.set_attr<nnvm::FInplaceOption>("FInplaceOption",
[](const NodeAttrs& attrs){
return std::vector<std::pair<int, int> >{{0, 0}};
})
-.set_attr<FCompute>("FCompute<cpu>", SliceAssign<cpu>)
+.set_attr<FCompute>("FCompute<cpu>", SliceAssignOpForward<cpu>)
.add_argument("lhs", "NDArray-or-Symbol", "Source input")
.add_argument("rhs", "NDArray-or-Symbol", "value to assign")
.add_arguments(SliceParam::__FIELDS__());
-NNVM_REGISTER_OP(_crop_assign_scalar)
+NNVM_REGISTER_OP(_slice_assign_scalar)
+.add_alias("_crop_assign_scalar")
.MXNET_DESCRIBE("(Assign the scalar to a cropped subset of the input.\n\n"
"Requirements\n"
"------------\n"
@@ -342,16 +343,16 @@ NNVM_REGISTER_OP(_crop_assign_scalar)
")")
.set_num_inputs(1)
.set_num_outputs(1)
-.set_attr_parser(ParamParser<SimpleCropAssignScalarParam>)
-.set_attr<nnvm::FInferShape>("FInferShape", CropAssignScalarShape)
+.set_attr_parser(ParamParser<SliceAssignScalarParam>)
+.set_attr<nnvm::FInferShape>("FInferShape", SliceAssignScalarOpShape)
.set_attr<nnvm::FInferType>("FInferType", ElemwiseType<1, 1>)
.set_attr<nnvm::FInplaceOption>("FInplaceOption",
[](const NodeAttrs& attrs){
return std::vector<std::pair<int, int> >{{0, 0}};
})
-.set_attr<FCompute>("FCompute<cpu>", CropAssignScalar<cpu>)
+.set_attr<FCompute>("FCompute<cpu>", SliceAssignScalarOpForward<cpu>)
.add_argument("data", "NDArray-or-Symbol", "Source input")
-.add_arguments(SimpleCropAssignScalarParam::__FIELDS__());
+.add_arguments(SliceAssignScalarParam::__FIELDS__());
NNVM_REGISTER_OP(slice_axis)
.describe(R"code(Slices along a given axis.
diff --git a/src/operator/tensor/matrix_op.cu b/src/operator/tensor/matrix_op.cu
index 3866fc4..237b872 100644
--- a/src/operator/tensor/matrix_op.cu
+++ b/src/operator/tensor/matrix_op.cu
@@ -45,10 +45,10 @@ NNVM_REGISTER_OP(_backward_slice)
.set_attr<FCompute>("FCompute<gpu>", SliceOpBackward<gpu>);
NNVM_REGISTER_OP(_slice_assign)
-.set_attr<FCompute>("FCompute<gpu>", SliceAssign<gpu>);
+.set_attr<FCompute>("FCompute<gpu>", SliceAssignOpForward<gpu>);
NNVM_REGISTER_OP(_crop_assign_scalar)
-.set_attr<FCompute>("FCompute<gpu>", CropAssignScalar<gpu>);
+.set_attr<FCompute>("FCompute<gpu>", SliceAssignScalarOpForward<gpu>);
NNVM_REGISTER_OP(slice_axis)
.set_attr<FCompute>("FCompute<gpu>", SliceAxis<gpu>);
diff --git a/tests/python/unittest/test_ndarray.py b/tests/python/unittest/test_ndarray.py
index 28aab7a..5bdadc4 100644
--- a/tests/python/unittest/test_ndarray.py
+++ b/tests/python/unittest/test_ndarray.py
@@ -24,6 +24,7 @@ from nose.tools import raises
from mxnet.test_utils import *
from numpy.testing import assert_allclose
import unittest
+import mxnet.autograd
def check_with_uniform(uf, arg_shapes, dim=None, npuf=None, rmin=-10, type_list=[np.float32]):
"""check function consistency with uniform random numbers"""
@@ -88,14 +89,6 @@ def test_ndarray_setitem():
x_np[1] = 1
assert same(x.asnumpy(), x_np)
- # all-dim indexing
- x = mx.nd.zeros(shape)
- val = mx.nd.ones((3, 2, 1))
- x[:, 1:3, 1] = val
- x_np = np.zeros(shape, dtype=x.dtype)
- x_np[:, 1:3, 1:2] = val.asnumpy()
- assert same(x.asnumpy(), x_np)
-
# short all-dim indexing
x = mx.nd.zeros(shape)
val = mx.nd.ones((3, 2))
@@ -804,6 +797,135 @@ def test_bool():
assert not bool(mx.nd.zeros((1,)))
assert bool(mx.nd.ones((1,)))
+
+def test_ndarray_indexing():
+ def test_getitem(np_array, index, is_scalar=False):
+ """`is_scalar` indicates whether we should expect a scalar for the result.
+ If so, the indexed array of NDArray should call asscalar to compare
+ with numpy's indexed array."""
+ np_index = index
+ if isinstance(index, mx.nd.NDArray):
+ np_index = index.asnumpy()
+ if isinstance(index, tuple):
+ np_index = []
+ for idx in index:
+ if isinstance(idx, mx.nd.NDArray):
+ np_index.append(idx.asnumpy())
+ else:
+ np_index.append(idx)
+ np_index = tuple(np_index)
+
+ np_indexed_array = np_array[np_index]
+ mx_array = mx.nd.array(np_array, dtype=np_array.dtype)
+ mx_indexed_array = mx_array[index]
+ if is_scalar:
+ mx_indexed_array = mx_indexed_array.asscalar()
+ else:
+ mx_indexed_array = mx_indexed_array.asnumpy()
+ assert same(np_indexed_array, mx_indexed_array), 'Failed with index=%s' % str(index)
+
+ def test_setitem(np_array, index, is_scalar):
+ def assert_same(np_array, np_index, mx_array, mx_index, mx_value, np_value=None):
+ if np_value is not None:
+ np_array[np_index] = np_value
+ else:
+ np_array[np_index] = mx_value
+ mx_array[mx_index] = mx_value
+ assert same(np_array, mx_array.asnumpy())
+
+ np_index = index
+ if isinstance(index, mx.nd.NDArray):
+ np_index = index.asnumpy()
+ if isinstance(index, tuple):
+ np_index = []
+ for idx in index:
+ if isinstance(idx, mx.nd.NDArray):
+ np_index.append(idx.asnumpy())
+ else:
+ np_index.append(idx)
+ np_index = tuple(np_index)
+
+ mx_array = mx.nd.array(np_array, dtype=np_array.dtype)
+ np_array = mx_array.asnumpy()
+ if is_scalar:
+ # test value is a numeric type
+ assert_same(np_array, np_index, mx_array, index, np.random.randint(low=-10000, high=0))
+ value_nd = [np.random.randint(low=-10000, high=0)]
+ assert_same(np_array, np_index, mx_array, index, value_nd, value_nd[0])
+ else:
+ indexed_array_shape = np_array[np_index].shape
+ np_indexed_array = np.random.randint(low=-10000, high=0, size=indexed_array_shape)
+ # test value is a numpy array without broadcast
+ assert_same(np_array, np_index, mx_array, index, np_indexed_array)
+ # test value is an numeric_type
+ assert_same(np_array, np_index, mx_array, index, np.random.randint(low=-10000, high=0))
+ if len(indexed_array_shape) > 1:
+ # test numpy array with broadcast
+ assert_same(np_array, np_index, mx_array, index,
+ np.random.randint(low=-10000, high=0, size=(indexed_array_shape[-1],)))
+ # test list with broadcast
+ assert_same(np_array, np_index, mx_array, index,
+ [np.random.randint(low=-10000, high=0)] * indexed_array_shape[-1])
+
+ def test_getitem_autograd(np_array, index):
+ x = mx.nd.array(np_array, dtype=np_array.dtype)
+ x.attach_grad()
+ with mx.autograd.record():
+ y = x[index]
+ y.backward()
+ value = mx.nd.ones_like(y)
+ x_grad = mx.nd.zeros_like(x)
+ x_grad[index] = value
+ assert same(x_grad.asnumpy(), x.grad.asnumpy())
+
+ shape = (8, 16, 9, 9)
+ np_array = np.arange(np.prod(shape), dtype='int32').reshape(shape)
+ # index_list is a list of tuples. The tuple's first element is the index, the second one is a boolean value
+ # indicating whether we should expect the result as a scalar compared to numpy.
+ index_list = [(0, False), (5, False), (-1, False),
+ (slice(5), False), (slice(1, 5), False), (slice(1, 5, 2), False),
+ (slice(7, 0, -1), False), (slice(None, 6), False), (slice(None, 6, 3), False),
+ (slice(1, None), False), (slice(1, None, 3), False), (slice(None, None, 2), False),
+ (slice(None, None, -1), False), (slice(None, None, -2), False),
+ ((slice(None), slice(None), 1, 8), False),
+ ((slice(None), 2, slice(1, 5), 1), False),
+ ((1, 2, 3), False), ((1, 2, 3, 4), True),
+ ((slice(None, None, -1), 2, slice(1, 5), 1), False),
+ ((slice(None, None, -1), 2, slice(1, 7, 2), 1), False),
+ ((slice(1, 8, 2), slice(14, 2, -2), slice(3, 8), slice(0, 7, 3)), False),
+ ((slice(1, 8, 2), 1, slice(3, 8), 2), False),
+ ([1], False), ([1, 2], False), ([2, 1, 3], False), ([7, 5, 0, 3, 6, 2, 1], False),
+ (np.array([6, 3], dtype=np.int32), False),
+ (np.array([[3, 4], [0, 6]], dtype=np.int32), False),
+ (np.array([[7, 3], [2, 6], [0, 5], [4, 1]], dtype=np.int32), False),
+ (np.array([[2], [0], [1]], dtype=np.int32), False),
+ (mx.nd.array([4, 7], dtype=np.int32), False),
+ (mx.nd.array([[3, 6], [2, 1]], dtype=np.int32), False),
+ (mx.nd.array([[7, 3], [2, 6], [0, 5], [4, 1]], dtype=np.int32), False),
+ ((1, [2, 3]), False), ((1, [2, 3], np.array([[3], [0]], dtype=np.int32)), False),
+ ((1, [2], np.array([[5], [3]], dtype=np.int32), slice(None)), False),
+ ((1, [2, 3], np.array([[6], [0]], dtype=np.int32), slice(2, 5)), False),
+ ((1, [2, 3], np.array([[4], [7]], dtype=np.int32), slice(2, 5, 2)), False),
+ ((1, [2], np.array([[3]], dtype=np.int32), slice(None, None, -1)), False),
+ ((1, [2], np.array([[3]], dtype=np.int32), np.array([[5, 7], [2, 4]], dtype=np.int64)), False),
+ ((1, [2], mx.nd.array([[4]], dtype=np.int32), mx.nd.array([[1, 3], [5, 7]], dtype='int64')),
+ False),
+ ([0], False), ([0, 1], False), ([1, 2, 3], False), ([2, 0, 5, 6], False),
+ (([1, 1], [2, 3]), False), (([1], [4], [5]), False), (([1], [4], [5], [6]), False),
+ (([[1]], [[2]]), False), (([[1]], [[2]], [[3]], [[4]]), False),
+ ((slice(0, 2), [[1], [6]], slice(0, 2), slice(0, 5, 2)), False),
+ (([[[[1]]]], [[1]], slice(0, 3), [1, 5]), False),
+ (([[[[1]]]], 3, slice(0, 3), [1, 3]), False),
+ (([[[[1]]]], 3, slice(0, 3), 0), False),
+ (([[[[1]]]], [[2], [12]], slice(0, 3), slice(None)), False),
+ (([1, 2], slice(3, 5), [2, 3], [3, 4]), False),
+ (([1, 2], slice(3, 5), (2, 3), [3, 4]), False)]
+ for index in index_list:
+ test_getitem(np_array, index[0], index[1])
+ test_setitem(np_array, index[0], index[1])
+ test_getitem_autograd(np_array, index[0])
+
+
if __name__ == '__main__':
import nose
nose.runmodule()
--
To stop receiving notification emails like this one, please contact
['"commits@mxnet.apache.org" <co...@mxnet.apache.org>'].