ndarray.sparse¶

Sparse NDArray API of MXNet.

Functions

Classes

mxnet.ndarray.sparse.csr_matrix(arg1, shape=None, ctx=None, dtype=None)[source]¶

Creates a CSRNDArray, an 2D array with compressed sparse row (CSR) format.

The CSRNDArray can be instantiated in several ways:

• csr_matrix(D):

  to construct a CSRNDArray with a dense 2D array D

  • D (array_like) - An object exposing the array interface, an object whose __array__ method returns an array, or any (nested) sequence.

  • ctx (Context, optional) - Device context (default is the current default context).

  • dtype (str or numpy.dtype, optional) - The data type of the output array. The default dtype is D.dtype if D is an NDArray or numpy.ndarray, float32 otherwise.

• csr_matrix(S)

  to construct a CSRNDArray with a sparse 2D array S

  • S (CSRNDArray or scipy.sparse.csr.csr_matrix) - A sparse matrix.

  • ctx (Context, optional) - Device context (default is the current default context).

  • dtype (str or numpy.dtype, optional) - The data type of the output array. The default dtype is S.dtype.

• csr_matrix((M, N))

  to construct an empty CSRNDArray with shape (M, N)

  • M (int) - Number of rows in the matrix

  • N (int) - Number of columns in the matrix

  • ctx (Context, optional) - Device context (default is the current default context).

  • dtype (str or numpy.dtype, optional) - The data type of the output array. The default dtype is float32.

• csr_matrix((data, indices, indptr))

  to construct a CSRNDArray based on the definition of compressed sparse row format using three separate arrays, where the column indices for row i are stored in indices[indptr[i]:indptr[i+1]] and their corresponding values are stored in data[indptr[i]:indptr[i+1]]. The column indices for a given row are expected to be sorted in ascending order. Duplicate column entries for the same row are not allowed.

  • data (array_like) - An object exposing the array interface, which holds all the non-zero entries of the matrix in row-major order.

  • indices (array_like) - An object exposing the array interface, which stores the column index for each non-zero element in data.

  • indptr (array_like) - An object exposing the array interface, which stores the offset into data of the first non-zero element number of each row of the matrix.

  • shape (tuple of int, optional) - The shape of the array. The default shape is inferred from the indices and indptr arrays.

  • ctx (Context, optional) - Device context (default is the current default context).

  • dtype (str or numpy.dtype, optional) - The data type of the output array. The default dtype is data.dtype if data is an NDArray or numpy.ndarray, float32 otherwise.

• csr_matrix((data, (row, col)))

  to construct a CSRNDArray based on the COOrdinate format using three seperate arrays, where row[i] is the row index of the element, col[i] is the column index of the element and data[i] is the data corresponding to the element. All the missing elements in the input are taken to be zeroes.

  • data (array_like) - An object exposing the array interface, which holds all the non-zero entries of the matrix in COO format.

  • row (array_like) - An object exposing the array interface, which stores the row index for each non zero element in data.

  • col (array_like) - An object exposing the array interface, which stores the col index for each non zero element in data.

  • shape (tuple of int, optional) - The shape of the array. The default shape is inferred from the row and col arrays.

  • ctx (Context, optional) - Device context (default is the current default context).

  • dtype (str or numpy.dtype, optional) - The data type of the output array. The default dtype is float32.

Parameters

• arg1 (tuple of int, tuple of array_like, array_like, CSRNDArray, scipy.sparse.csr_matrix, scipy.sparse.coo_matrix, tuple of int or tuple of array_like) – The argument to help instantiate the csr matrix. See above for further details.

• shape (tuple of int, optional) – The shape of the csr matrix.

• ctx (Context, optional) – Device context (default is the current default context).

• dtype (str or numpy.dtype, optional) – The data type of the output array.

Returns

A CSRNDArray with the csr storage representation.

Return type

CSRNDArray

Example

>>> a = mx.nd.sparse.csr_matrix(([1, 2, 3], [1, 0, 2], [0, 1, 2, 2, 3]), shape=(4, 3))
>>> a.asnumpy()
array([[ 0.,  1.,  0.],
       [ 2.,  0.,  0.],
       [ 0.,  0.,  0.],
       [ 0.,  0.,  3.]], dtype=float32)

See also

CSRNDArray()

MXNet NDArray in compressed sparse row format.

mxnet.ndarray.sparse.row_sparse_array(arg1, shape=None, ctx=None, dtype=None)[source]¶

Creates a RowSparseNDArray, a multidimensional row sparse array with a set of tensor slices at given indices.

The RowSparseNDArray can be instantiated in several ways:

• row_sparse_array(D):

  to construct a RowSparseNDArray with a dense ndarray D - D (array_like) - An object exposing the array interface, an object whose __array__ method returns an array, or any (nested) sequence. - ctx (Context, optional) - Device context (default is the current default context). - dtype (str or numpy.dtype, optional) - The data type of the output array. The default dtype is D.dtype if D is an NDArray or numpy.ndarray, float32 otherwise.

• row_sparse_array(S)

  to construct a RowSparseNDArray with a sparse ndarray S - S (RowSparseNDArray) - A sparse ndarray. - ctx (Context, optional) - Device context (default is the current default context). - dtype (str or numpy.dtype, optional) - The data type of the output array. The default dtype is S.dtype.

• row_sparse_array((D0, D1 .. Dn))

  to construct an empty RowSparseNDArray with shape (D0, D1, ... Dn) - D0, D1 .. Dn (int) - The shape of the ndarray - ctx (Context, optional) - Device context (default is the current default context). - dtype (str or numpy.dtype, optional) - The data type of the output array. The default dtype is float32.

• row_sparse_array((data, indices))

  to construct a RowSparseNDArray based on the definition of row sparse format using two separate arrays, where the indices stores the indices of the row slices with non-zeros, while the values are stored in data. The corresponding NDArray dense represented by RowSparseNDArray rsp has dense[rsp.indices[i], :, :, :, ...] = rsp.data[i, :, :, :, ...] The row indices for are expected to be sorted in ascending order. - data (array_like) - An object exposing the array interface, which holds all the non-zero row slices of the array. - indices (array_like) - An object exposing the array interface, which stores the row index for each row slice with non-zero elements. - shape (tuple of int, optional) - The shape of the array. The default shape is inferred from the indices and indptr arrays. - ctx (Context, optional) - Device context (default is the current default context). - dtype (str or numpy.dtype, optional) - The data type of the output array. The default dtype is float32.

Parameters

• arg1 (NDArray, numpy.ndarray, RowSparseNDArray, tuple of int or tuple of array_like) – The argument to help instantiate the row sparse ndarray. See above for further details.

• shape (tuple of int, optional) – The shape of the row sparse ndarray. (Default value = None)

• ctx (Context, optional) – Device context (default is the current default context).

• dtype (str or numpy.dtype, optional) – The data type of the output array. (Default value = None)

Returns

An RowSparseNDArray with the row_sparse storage representation.

Return type

RowSparseNDArray

Examples

>>> a = mx.nd.sparse.row_sparse_array(([[1, 2], [3, 4]], [1, 4]), shape=(6, 2))
>>> a.asnumpy()
array([[ 0.,  0.],
       [ 1.,  2.],
       [ 0.,  0.],
       [ 0.,  0.],
       [ 3.,  4.],
       [ 0.,  0.]], dtype=float32)

See also

RowSparseNDArray()

MXNet NDArray in row sparse format.

class mxnet.ndarray.sparse.BaseSparseNDArray(handle, writable=True)[source]¶

Bases: mxnet.ndarray.ndarray.NDArray

The base class of an NDArray stored in a sparse storage format.

See CSRNDArray and RowSparseNDArray for more details.

Methods

asnumpy()	Return a dense numpy.ndarray object with value copied from this array
astype(dtype[, copy])	Return a copy of the array after casting to a specified type.
check_format([full_check])	Check whether the NDArray format is valid.
copyto(other)	Copies the value of this array to another array.
reshape(*shape, **kwargs)	Returns a view of this array with a new shape without altering any data.

Attributes

size	Number of elements in the array.

asnumpy()[source]¶

Return a dense numpy.ndarray object with value copied from this array

astype(dtype, copy=True)[source]¶

Return a copy of the array after casting to a specified type.

Parameters

• dtype (numpy.dtype or str) – The type of the returned array.

• copy (bool) – Default True. By default, astype always returns a newly allocated ndarray on the same context. If this is set to False, and the dtype requested is the same as the ndarray’s dtype, the ndarray is returned instead of a copy.

Examples

>>> x = mx.nd.sparse.zeros('row_sparse', (2,3), dtype='float32')
>>> y = x.astype('int32')
>>> y.dtype
<type 'numpy.int32'>

check_format(full_check=True)[source]¶

Check whether the NDArray format is valid.

Parameters

full_check (bool, optional) – If True, rigorous check, O(N) operations. Otherwise basic check, O(1) operations (default True).

copyto(other)[source]¶

Copies the value of this array to another array.

Parameters

other (NDArray or CSRNDArray or RowSparseNDArray or Context) – The destination array or context.

Returns

The copied array.

Return type

NDArray or CSRNDArray or RowSparseNDArray

reshape(*shape, **kwargs)[source]¶

Returns a view of this array with a new shape without altering any data.

Parameters

• shape (tuple of int, or n ints) –

  The new shape should not change the array size, namely np.prod(new_shape) should be equal to np.prod(self.shape). Some dimensions of the shape can take special values from the set {0, -1, -2, -3, -4}. The significance of each is explained below:

  • 0 copy this dimension from the input to the output shape.

    Example:

    - input shape = (2,3,4), shape = (4,0,2), output shape = (4,3,2)
    - input shape = (2,3,4), shape = (2,0,0), output shape = (2,3,4)
    

  • -1 infers the dimension of the output shape by using the remainder of the input dimensions keeping the size of the new array same as that of the input array. At most one dimension of shape can be -1.

    Example:

    - input shape = (2,3,4), shape = (6,1,-1), output shape = (6,1,4)
    - input shape = (2,3,4), shape = (3,-1,8), output shape = (3,1,8)
    - input shape = (2,3,4), shape=(-1,), output shape = (24,)
    

  • -2 copy all/remainder of the input dimensions to the output shape.

    Example:

    - input shape = (2,3,4), shape = (-2,), output shape = (2,3,4)
    - input shape = (2,3,4), shape = (2,-2), output shape = (2,3,4)
    - input shape = (2,3,4), shape = (-2,1,1), output shape = (2,3,4,1,1)
    

  • -3 use the product of two consecutive dimensions of the input shape as the output dimension.

    Example:

    - input shape = (2,3,4), shape = (-3,4), output shape = (6,4)
    - input shape = (2,3,4,5), shape = (-3,-3), output shape = (6,20)
    - input shape = (2,3,4), shape = (0,-3), output shape = (2,12)
    - input shape = (2,3,4), shape = (-3,-2), output shape = (6,4)
    

  • -4 split one dimension of the input into two dimensions passed subsequent to -4 in shape (can contain -1).

    Example:

    - input shape = (2,3,4), shape = (-4,1,2,-2), output shape =(1,2,3,4)
    - input shape = (2,3,4), shape = (2,-4,-1,3,-2), output shape = (2,1,3,4)
    

  • If the argument reverse is set to 1, then the special values are inferred from right to left.

    Example:

    - without reverse=1, for input shape = (10,5,4), shape = (-1,0), output shape would be                 (40,5).
    - with reverse=1, output shape will be (50,4).
    

• reverse (bool, default False) – If true then the special values are inferred from right to left. Only supported as keyword argument.

Returns

An array with desired shape that shares data with this array.

Return type

NDArray

Examples

>>> x = mx.nd.arange(0,6).reshape(2,3)
>>> x.asnumpy()
array([[ 0.,  1.,  2.],
       [ 3.,  4.,  5.]], dtype=float32)
>>> y = x.reshape(3,2)
>>> y.asnumpy()
array([[ 0.,  1.],
       [ 2.,  3.],
       [ 4.,  5.]], dtype=float32)
>>> y = x.reshape(3,-1)
>>> y.asnumpy()
array([[ 0.,  1.],
       [ 2.,  3.],
       [ 4.,  5.]], dtype=float32)
>>> y = x.reshape(3,2)
>>> y.asnumpy()
array([[ 0.,  1.],
       [ 2.,  3.],
       [ 4.,  5.]], dtype=float32)
>>> y = x.reshape(-3)
>>> y.asnumpy()
array([ 0.  1.  2.  3.  4.  5.], dtype=float32)
>>> y[:] = -1
>>> x.asnumpy()
array([[-1., -1., -1.],
       [-1., -1., -1.]], dtype=float32)

property size¶

Number of elements in the array.

Equivalent to the product of the array’s dimensions.

Examples

>>> import numpy as np
>>> x = mx.nd.zeros((3, 5, 2))
>>> x.size
30
>>> np.prod(x.shape)
30

class mxnet.ndarray.sparse.CSRNDArray(handle, writable=True)[source]¶

Bases: mxnet.ndarray.sparse.BaseSparseNDArray

A sparse representation of 2D NDArray in the Compressed Sparse Row format.

A CSRNDArray represents an NDArray as three separate arrays: data, indptr and indices. It uses the CSR representation where the column indices for row i are stored in indices[indptr[i]:indptr[i+1]] and their corresponding values are stored in data[indptr[i]:indptr[i+1]].

The column indices for a given row are expected to be sorted in ascending order. Duplicate column entries for the same row are not allowed.

Example

Methods

asscipy()	Returns a scipy.sparse.csr.csr_matrix object with value copied from this array
copyto(other)	Copies the value of this array to another array.
tostype(stype)	Return a copy of the array with chosen storage type.

Attributes

data	A deep copy NDArray of the data array of the CSRNDArray.
indices	A deep copy NDArray of the indices array of the CSRNDArray.
indptr	A deep copy NDArray of the indptr array of the CSRNDArray.

>>> a = mx.nd.array([[0, 1, 0], [2, 0, 0], [0, 0, 0], [0, 0, 3]])
>>> a = a.tostype('csr')
>>> a.data.asnumpy()
array([ 1.,  2.,  3.], dtype=float32)
>>> a.indices.asnumpy()
array([1, 0, 2])
>>> a.indptr.asnumpy()
array([0, 1, 2, 2, 3])

See also

csr_matrix

Several ways to construct a CSRNDArray

asscipy()[source]¶

Returns a scipy.sparse.csr.csr_matrix object with value copied from this array

Examples

>>> x = mx.nd.sparse.zeros('csr', (2,3))
>>> y = x.asscipy()
>>> type(y)
<type 'scipy.sparse.csr.csr_matrix'>
>>> y
<2x3 sparse matrix of type '<type 'numpy.float32'>'
with 0 stored elements in Compressed Sparse Row format>

copyto(other)[source]¶

Copies the value of this array to another array.

If other is a NDArray or CSRNDArray object, then other.shape and self.shape should be the same. This function copies the value from self to other.

If other is a context, a new CSRNDArray will be first created on the target context, and the value of self is copied.

Parameters

other (NDArray or CSRNDArray or Context) – The destination array or context.

Returns

The copied array. If other is an NDArray or CSRNDArray, then the return value and other will point to the same NDArray or CSRNDArray.

Return type

NDArray or CSRNDArray

property data¶

A deep copy NDArray of the data array of the CSRNDArray. This generates a deep copy of the data of the current csr matrix.

Returns

This CSRNDArray’s data array.

Return type

NDArray

property indices¶

A deep copy NDArray of the indices array of the CSRNDArray. This generates a deep copy of the column indices of the current csr matrix.

Returns

This CSRNDArray’s indices array.

Return type

NDArray

property indptr¶

A deep copy NDArray of the indptr array of the CSRNDArray. This generates a deep copy of the indptr of the current csr matrix.

Returns

This CSRNDArray’s indptr array.

Return type

NDArray

tostype(stype)[source]¶

Return a copy of the array with chosen storage type.

Returns

A copy of the array with the chosen storage stype

Return type

NDArray or CSRNDArray

class mxnet.ndarray.sparse.RowSparseNDArray(handle, writable=True)[source]¶

Bases: mxnet.ndarray.sparse.BaseSparseNDArray

A sparse representation of a set of NDArray row slices at given indices.

A RowSparseNDArray represents a multidimensional NDArray using two separate arrays: data and indices. The number of dimensions has to be at least 2.

• data: an NDArray of any dtype with shape [D0, D1, …, Dn].

• indices: a 1-D int64 NDArray with shape [D0] with values sorted in ascending order.

Methods

copyto(other)	Copies the value of this array to another array.
retain(*args, **kwargs)	Convenience fluent method for retain().
tostype(stype)	Return a copy of the array with chosen storage type.

Attributes

data	A deep copy NDArray of the data array of the RowSparseNDArray.
indices	A deep copy NDArray of the indices array of the RowSparseNDArray.

The indices stores the indices of the row slices with non-zeros, while the values are stored in data. The corresponding NDArray dense represented by RowSparseNDArray rsp has

dense[rsp.indices[i], :, :, :, ...] = rsp.data[i, :, :, :, ...]

>>> dense.asnumpy()
array([[ 1.,  2., 3.],
       [ 0.,  0., 0.],
       [ 4.,  0., 5.],
       [ 0.,  0., 0.],
       [ 0.,  0., 0.]], dtype=float32)
>>> rsp = dense.tostype('row_sparse')
>>> rsp.indices.asnumpy()
array([0, 2], dtype=int64)
>>> rsp.data.asnumpy()
array([[ 1.,  2., 3.],
       [ 4.,  0., 5.]], dtype=float32)

A RowSparseNDArray is typically used to represent non-zero row slices of a large NDArray of shape [LARGE0, D1, .. , Dn] where LARGE0 >> D0 and most row slices are zeros.

RowSparseNDArray is used principally in the definition of gradients for operations that have sparse gradients (e.g. sparse dot and sparse embedding).

See also

row_sparse_array

Several ways to construct a RowSparseNDArray

copyto(other)[source]¶

Copies the value of this array to another array.

If other is a NDArray or RowSparseNDArray object, then other.shape and self.shape should be the same. This function copies the value from self to other.

If other is a context, a new RowSparseNDArray will be first created on the target context, and the value of self is copied.

Parameters

other (NDArray or RowSparseNDArray or Context) – The destination array or context.

Returns

The copied array. If other is an NDArray or RowSparseNDArray, then the return value and other will point to the same NDArray or RowSparseNDArray.

Return type

NDArray or RowSparseNDArray

property data¶

A deep copy NDArray of the data array of the RowSparseNDArray. This generates a deep copy of the data of the current row_sparse matrix.

Returns

This RowSparseNDArray’s data array.

Return type

NDArray

property indices¶

A deep copy NDArray of the indices array of the RowSparseNDArray. This generates a deep copy of the row indices of the current row_sparse matrix.

Returns

This RowSparseNDArray’s indices array.

Return type

NDArray

retain(*args, **kwargs)[source]¶

Convenience fluent method for retain().

The arguments are the same as for retain(), with this array as data.

tostype(stype)[source]¶

Return a copy of the array with chosen storage type.

Returns

A copy of the array with the chosen storage stype

Return type

NDArray or RowSparseNDArray

mxnet.ndarray.sparse.add(lhs, rhs)[source]¶

Returns element-wise sum of the input arrays with broadcasting.

Equivalent to lhs + rhs, mx.nd.broadcast_add(lhs, rhs) and mx.nd.broadcast_plus(lhs, rhs) when shapes of lhs and rhs do not match. If lhs.shape == rhs.shape, this is equivalent to mx.nd.elemwise_add(lhs, rhs)

Note

If the corresponding dimensions of two arrays have the same size or one of them has size 1, then the arrays are broadcastable to a common shape.abs

Parameters

• lhs (scalar or mxnet.ndarray.sparse.array) – First array to be added.

• rhs (scalar or mxnet.ndarray.sparse.array) – Second array to be added. If lhs.shape != rhs.shape, they must be broadcastable to a common shape.

Returns

The element-wise sum of the input arrays.

Return type

NDArray

Examples

>>> a = mx.nd.ones((2,3)).tostype('csr')
>>> b = mx.nd.ones((2,3)).tostype('csr')
>>> a.asnumpy()
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float32)
>>> b.asnumpy()
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float32)
>>> (a+b).asnumpy()
array([[ 2.,  2.,  2.],
       [ 2.,  2.,  2.]], dtype=float32)
>>> c = mx.nd.ones((2,3)).tostype('row_sparse')
>>> d = mx.nd.ones((2,3)).tostype('row_sparse')
>>> c.asnumpy()
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float32)
>>> d.asnumpy()
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float32)
>>> (c+d).asnumpy()
array([[ 2.,  2.,  2.],
       [ 2.,  2.,  2.]], dtype=float32)

mxnet.ndarray.sparse.subtract(lhs, rhs)[source]¶

Returns element-wise difference of the input arrays with broadcasting.

Equivalent to lhs - rhs, mx.nd.broadcast_sub(lhs, rhs) and mx.nd.broadcast_minus(lhs, rhs) when shapes of lhs and rhs do not match. If lhs.shape == rhs.shape, this is equivalent to mx.nd.elemwise_sub(lhs, rhs)

Note

If the corresponding dimensions of two arrays have the same size or one of them has size 1, then the arrays are broadcastable to a common shape.

Parameters

• lhs (scalar or mxnet.ndarray.sparse.array) – First array to be subtracted.

• rhs (scalar or mxnet.ndarray.sparse.array) – Second array to be subtracted. If lhs.shape != rhs.shape, they must be broadcastable to a common shape.__spec__

Returns

The element-wise difference of the input arrays.

Return type

NDArray

Examples

>>> a = mx.nd.ones((2,3)).tostype('csr')
>>> b = mx.nd.ones((2,3)).tostype('csr')
>>> a.asnumpy()
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float32)
>>> b.asnumpy()
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float32)
>>> (a-b).asnumpy()
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]], dtype=float32)
>>> c = mx.nd.ones((2,3)).tostype('row_sparse')
>>> d = mx.nd.ones((2,3)).tostype('row_sparse')
>>> c.asnumpy()
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float32)
>>> d.asnumpy()
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float32)
>>> (c-d).asnumpy()
array([[ 0.,  0.,  0.],
       [ 0.,  0.,  0.]], dtype=float32)

mxnet.ndarray.sparse.multiply(lhs, rhs)[source]¶

Returns element-wise product of the input arrays with broadcasting.

Equivalent to lhs * rhs and mx.nd.broadcast_mul(lhs, rhs) when shapes of lhs and rhs do not match. If lhs.shape == rhs.shape, this is equivalent to mx.nd.elemwise_mul(lhs, rhs)

Note

If the corresponding dimensions of two arrays have the same size or one of them has size 1, then the arrays are broadcastable to a common shape.

Parameters

• lhs (scalar or mxnet.ndarray.sparse.array) – First array to be multiplied.

• rhs (scalar or mxnet.ndarray.sparse.array) – Second array to be multiplied. If lhs.shape != rhs.shape, they must be broadcastable to a common shape.

Returns

The element-wise multiplication of the input arrays.

Return type

NDArray

Examples

>>> x = mx.nd.ones((2,3)).tostype('csr')
>>> y = mx.nd.arange(2).reshape((2,1))
>>> z = mx.nd.arange(3)
>>> x.asnumpy()
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.]], dtype=float32)
>>> y.asnumpy()
array([[ 0.],
       [ 1.]], dtype=float32)
>>> z.asnumpy()
array([ 0.,  1.,  2.], dtype=float32)
>>> (x*2).asnumpy()
array([[ 2.,  2.,  2.],
       [ 2.,  2.,  2.]], dtype=float32)
>>> (x*y).asnumpy()
array([[ 0.,  0.,  0.],
       [ 1.,  1.,  1.]], dtype=float32)
>>> mx.nd.sparse.multiply(x, y).asnumpy()
array([[ 0.,  0.,  0.],
       [ 1.,  1.,  1.]], dtype=float32)
>>> (x*z).asnumpy()
array([[ 0.,  1.,  2.],
       [ 0.,  1.,  2.]], dtype=float32)
>>> mx.nd.sparse.multiply(x, z).asnumpy()
array([[ 0.,  1.,  2.],
       [ 0.,  1.,  2.]], dtype=float32)
>>> z = z.reshape((1, 3))
>>> z.asnumpy()
array([[ 0.,  1.,  2.]], dtype=float32)
>>> (x*z).asnumpy()
array([[ 0.,  1.,  2.],
       [ 0.,  1.,  2.]], dtype=float32)
>>> mx.nd.sparse.multiply(x, z).asnumpy()
array([[ 0.,  1.,  2.],
       [ 0.,  1.,  2.]], dtype=float32)

mxnet.ndarray.sparse.divide(lhs, rhs)[source]¶

Returns element-wise division of the input arrays with broadcasting.

Equivalent to lhs / rhs and mx.nd.broadcast_div(lhs, rhs) when shapes of lhs and rhs do not match. If lhs.shape == rhs.shape, this is equivalent to mx.nd.elemwise_div(lhs, rhs)

Note

If the corresponding dimensions of two arrays have the same size or one of them has size 1, then the arrays are broadcastable to a common shape.

Parameters

• lhs (scalar or mxnet.ndarray.sparse.array) – First array in division.

• rhs (scalar or mxnet.ndarray.sparse.array) – Second array in division. The arrays to be divided. If lhs.shape != rhs.shape, they must be broadcastable to a common shape.

Returns

The element-wise division of the input arrays.

Return type

NDArray

Examples

>>> x = (mx.nd.ones((2,3))*6).tostype('csr')
>>> y = mx.nd.arange(2).reshape((2,1)) + 1
>>> z = mx.nd.arange(3) + 1
>>> x.asnumpy()
array([[ 6.,  6.,  6.],
       [ 6.,  6.,  6.]], dtype=float32)
>>> y.asnumpy()
array([[ 1.],
       [ 2.]], dtype=float32)
>>> z.asnumpy()
array([ 1.,  2.,  3.], dtype=float32)
>>> x/2
<NDArray 2x3 @cpu(0)>
>>> (x/3).asnumpy()
array([[ 2.,  2.,  2.],
       [ 2.,  2.,  2.]], dtype=float32)
>>> (x/y).asnumpy()
array([[ 6.,  6.,  6.],
       [ 3.,  3.,  3.]], dtype=float32)
>>> mx.nd.sparse.divide(x,y).asnumpy()
array([[ 6.,  6.,  6.],
       [ 3.,  3.,  3.]], dtype=float32)
>>> (x/z).asnumpy()
array([[ 6.,  3.,  2.],
       [ 6.,  3.,  2.]], dtype=float32)
>>> mx.nd.sprase.divide(x,z).asnumpy()
array([[ 6.,  3.,  2.],
       [ 6.,  3.,  2.]], dtype=float32)
>>> z = z.reshape((1,3))
>>> z.asnumpy()
array([[ 1.,  2.,  3.]], dtype=float32)
>>> (x/z).asnumpy()
array([[ 6.,  3.,  2.],
       [ 6.,  3.,  2.]], dtype=float32)
>>> mx.nd.sparse.divide(x,z).asnumpy()
array([[ 6.,  3.,  2.],
       [ 6.,  3.,  2.]], dtype=float32)