Sparse Symbol API¶

Overview¶

This document lists the routines of the sparse symbolic expression package:

mxnet.symbol.sparse Sparse Symbol API of MXNet.

The Sparse Symbol API, defined in the symbol.sparse package, provides sparse neural network graphs and auto-differentiation on CPU.

The storage type of a variable is speficied by the stype attribute of the variable. The storage type of a symbolic expression is inferred based on the storage types of the variables and the operators.

>>> a = mx.sym.Variable('a', stype='csr')
>>> b = mx.sym.Variable('b')
>>> c = mx.sym.dot(a, b, transpose_a=True)
>>> type(c)

>>> e = c.bind(mx.cpu(), {'a': mx.nd.array([[1,0,0]]).tostype('csr'), 'b':mx.nd.ones((1,2))})
>>> y = e.forward()
# the result storage type of dot(csr.T, dense) is inferred to be `row_sparse`
>>> y
[]
>>> y[0].asnumpy()
array([ 1.,  1.],
      [ 0.,  0.],
      [ 0.,  0.]], dtype=float32)

Note

most operators provided in mxnet.symbol.sparse are similar to those in mxnet.symbol although there are few differences:

Only a subset of operators in mxnet.symbol have specialized implementations in mxnet.symbol.sparse. Operators such as reduction and broadcasting do not have sparse implementations yet.
The storage types (stype) of sparse operators’ outputs depend on the storage types of inputs. By default the operators not available in mxnet.symbol.sparse infer “default” (dense) storage type for outputs. Please refer to the API reference section for further details on specific operators.
GPU support for mxnet.symbol.sparse is experimental.

In the rest of this document, we list sparse related routines provided by the symbol.sparse package.

Symbol creation routines¶

`zeros_like`	Return an array of zeros with the same shape and type as the input array.
`mxnet.symbol.var`	Creates a symbolic variable with specified name.

Symbol manipulation routines¶

Changing symbol storage type¶

cast_storage Casts tensor storage type to the new type.

Indexing routines¶

`slice`	Slices a contiguous region of the array.
`retain`	pick rows specified by user input index array from a row sparse matrix

Mathematical functions¶

Arithmetic operations¶

`elemwise_add`	Adds arguments element-wise.
`dot`	Dot product of two arrays.
`add_n`	Adds all input arguments element-wise.

API Reference¶

Sparse Symbol API of MXNet.

mxnet.symbol.sparse.ElementWiseSum(*args, **kwargs)¶

Adds all input arguments element-wise.

\[add\_n(a_1, a_2, ..., a_n) = a_1 + a_2 + ... + a_n\]

add_n is potentially more efficient than calling add by n times.

The storage type of add_n output depends on storage types of inputs

add_n(row_sparse, row_sparse, ..) = row_sparse
otherwise, add_n generates output with default storage

Defined in src/operator/tensor/elemwise_sum.cc:L122 This function support variable length of positional input.

Parameters:	args (Symbol[]) – Positional input arguments name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.abs(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise absolute value of the input.

Example:

abs([-2, 0, 3]) = [2, 0, 3]

The storage type of abs output depends upon the input storage type:

abs(default) = default

abs(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L334

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.add_n(*args, **kwargs)¶

Adds all input arguments element-wise.

\[add\_n(a_1, a_2, ..., a_n) = a_1 + a_2 + ... + a_n\]

add_n is potentially more efficient than calling add by n times.

The storage type of add_n output depends on storage types of inputs

add_n(row_sparse, row_sparse, ..) = row_sparse
otherwise, add_n generates output with default storage

Defined in src/operator/tensor/elemwise_sum.cc:L122 This function support variable length of positional input.

Parameters:	args (Symbol[]) – Positional input arguments name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.arccos(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise inverse cosine of the input array.

The input should be in range [-1, 1]. The output is in the closed interval \([0, \pi]\)

\[arccos([-1, -.707, 0, .707, 1]) = [\pi, 3\pi/4, \pi/2, \pi/4, 0]\]

The storage type of arccos output is always dense

Defined in src/operator/tensor/elemwise_unary_op.cc:L753

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.arccosh(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns the element-wise inverse hyperbolic cosine of the input array, computed element-wise.

The storage type of arccosh output is always dense

Defined in src/operator/tensor/elemwise_unary_op.cc:L894

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.arcsin(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise inverse sine of the input array.

The input should be in the range [-1, 1]. The output is in the closed interval of [\(-\pi/2\), \(\pi/2\)].

\[arcsin([-1, -.707, 0, .707, 1]) = [-\pi/2, -\pi/4, 0, \pi/4, \pi/2]\]

The storage type of arcsin output depends upon the input storage type:

arcsin(default) = default

arcsin(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L734

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.arcsinh(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns the element-wise inverse hyperbolic sine of the input array, computed element-wise.

The storage type of arcsinh output depends upon the input storage type:

arcsinh(default) = default

arcsinh(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L880

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.arctan(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise inverse tangent of the input array.

The output is in the closed interval \([-\pi/2, \pi/2]\)

\[arctan([-1, 0, 1]) = [-\pi/4, 0, \pi/4]\]

The storage type of arctan output depends upon the input storage type:

arctan(default) = default

arctan(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L774

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.arctanh(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns the element-wise inverse hyperbolic tangent of the input array, computed element-wise.

The storage type of arctanh output depends upon the input storage type:

arctanh(default) = default

arctanh(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L911

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.cast_storage(data=None, stype=_Null, name=None, attr=None, out=None, **kwargs)¶

Casts tensor storage type to the new type.

When an NDArray with default storage type is cast to csr or row_sparse storage, the result is compact, which means:

for csr, zero values will not be retained
for row_sparse, row slices of all zeros will not be retained

The storage type of cast_storage output depends on stype parameter:

cast_storage(csr, ‘default’) = default
cast_storage(row_sparse, ‘default’) = default
cast_storage(default, ‘csr’) = csr
cast_storage(default, ‘row_sparse’) = row_sparse

Example:

dense = [[ 0.,  1.,  0.],
         [ 2.,  0.,  3.],
         [ 0.,  0.,  0.],
         [ 0.,  0.,  0.]]

# cast to row_sparse storage type
rsp = cast_storage(default, 'row_sparse')
rsp.indices = [0, 1]
rsp.values = [[ 0.,  1.,  0.],
              [ 2.,  0.,  3.]]

# cast to csr storage type
csr = cast_storage(default, 'csr')
csr.indices = [1, 0, 2]
csr.values = [ 1.,  2.,  3.]
csr.indptr = [0, 1, 3, 3, 3]

Defined in src/operator/tensor/cast_storage.cc:L69

Parameters:	data (Symbol) – The input. stype ({'csr', 'default', 'row_sparse'}, required) – Output storage type. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.ceil(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise ceiling of the input.

The ceil of the scalar x is the smallest integer i, such that i >= x.

Example:

ceil([-2.1, -1.9, 1.5, 1.9, 2.1]) = [-2., -1.,  2.,  2.,  3.]

The storage type of ceil output depends upon the input storage type:

ceil(default) = default

ceil(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L411

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.cos(data=None, name=None, attr=None, out=None, **kwargs)¶

Computes the element-wise cosine of the input array.

The input should be in radians (\(2\pi\) rad equals 360 degrees).

\[cos([0, \pi/4, \pi/2]) = [1, 0.707, 0]\]

The storage type of cos output is always dense

Defined in src/operator/tensor/elemwise_unary_op.cc:L693

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.cosh(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns the hyperbolic cosine of the input array, computed element-wise.

\[cosh(x) = 0.5\times(exp(x) + exp(-x))\]

The storage type of cosh output is always dense

Defined in src/operator/tensor/elemwise_unary_op.cc:L846

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.degrees(data=None, name=None, attr=None, out=None, **kwargs)¶

Converts each element of the input array from radians to degrees.

\[degrees([0, \pi/2, \pi, 3\pi/2, 2\pi]) = [0, 90, 180, 270, 360]\]

The storage type of degrees output depends upon the input storage type:

degrees(default) = default

degrees(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L793

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.dot(lhs=None, rhs=None, transpose_a=_Null, transpose_b=_Null, name=None, attr=None, out=None, **kwargs)¶

Dot product of two arrays.

dot‘s behavior depends on the input array dimensions:

1-D arrays: inner product of vectors
2-D arrays: matrix multiplication
N-D arrays: a sum product over the last axis of the first input and the first axis of the second input

For example, given 3-D x with shape (n,m,k) and y with shape (k,r,s), the result array will have shape (n,m,r,s). It is computed by:
```
dot(x,y)[i,j,a,b] = sum(x[i,j,:]*y[:,a,b])
```
Example:
```
x = reshape([0,1,2,3,4,5,6,7], shape=(2,2,2))
y = reshape([7,6,5,4,3,2,1,0], shape=(2,2,2))
dot(x,y)[0,0,1,1] = 0
sum(x[0,0,:]*y[:,1,1]) = 0
```

The storage type of dot output depends on storage types of inputs and transpose options:

dot(csr, default) = default
dot(csr.T, default) = row_sparse
dot(csr, row_sparse) = default
otherwise, dot generates output with default storage

Defined in src/operator/tensor/dot.cc:L61

Parameters:	lhs (Symbol) – The first input rhs (Symbol) – The second input transpose_a (boolean, optional, default=False) – If true then transpose the first input before dot. transpose_b (boolean, optional, default=False) – If true then transpose the second input before dot. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.elemwise_add(lhs=None, rhs=None, name=None, attr=None, out=None, **kwargs)¶

Adds arguments element-wise.

The storage type of elemwise_add output depends on storage types of inputs

elemwise_add(row_sparse, row_sparse) = row_sparse

otherwise, elemwise_add generates output with default storage

Parameters:	lhs (Symbol) – first input rhs (Symbol) – second input name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.elemwise_div(lhs=None, rhs=None, name=None, attr=None, out=None, **kwargs)¶

Divides arguments element-wise.

The storage type of elemwise_dev output is always dense

Parameters:	lhs (Symbol) – first input rhs (Symbol) – second input name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.elemwise_mul(lhs=None, rhs=None, name=None, attr=None, out=None, **kwargs)¶

Multiplies arguments element-wise.

The storage type of elemwise_mul output depends on storage types of inputs

elemwise_mul(default, default) = default

elemwise_mul(row_sparse, row_sparse) = row_sparse

elemwise_mul(default, row_sparse) = row_sparse

elemwise_mul(row_sparse, default) = row_sparse

otherwise, elemwise_mul generates output with default storage

Parameters:	lhs (Symbol) – first input rhs (Symbol) – second input name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.elemwise_sub(lhs=None, rhs=None, name=None, attr=None, out=None, **kwargs)¶

Subtracts arguments element-wise.

The storage type of elemwise_sub output depends on storage types of inputs

elemwise_sub(row_sparse, row_sparse) = row_sparse

otherwise, elemwise_add generates output with default storage

Parameters:	lhs (Symbol) – first input rhs (Symbol) – second input name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.exp(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise exponential value of the input.

\[exp(x) = e^x \approx 2.718^x\]

Example:

exp([0, 1, 2]) = [1., 2.71828175, 7.38905621]

The storage type of exp output is always dense

Defined in src/operator/tensor/elemwise_unary_op.cc:L584

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.expm1(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns exp(x) - 1 computed element-wise on the input.

This function provides greater precision than exp(x) - 1 for small values of x.

The storage type of expm1 output depends upon the input storage type:

expm1(default) = default

expm1(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L676

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.fix(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise rounded value to the nearest integer towards zero of the input.

Example:

fix([-2.1, -1.9, 1.9, 2.1]) = [-2., -1.,  1., 2.]

The storage type of fix output depends upon the input storage type:

fix(default) = default

fix(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L465

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.floor(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise floor of the input.

The floor of the scalar x is the largest integer i, such that i <= x.

Example:

floor([-2.1, -1.9, 1.5, 1.9, 2.1]) = [-3., -2.,  1.,  1.,  2.]

The storage type of floor output depends upon the input storage type:

floor(default) = default

floor(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L429

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.gamma(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns the gamma function (extension of the factorial function to the reals), computed element-wise on the input array.

The storage type of gamma output is always dense

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.gammaln(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise log of the absolute value of the gamma function of the input.

The storage type of gammaln output is always dense

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.log(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise Natural logarithmic value of the input.

The natural logarithm is logarithm in base e, so that log(exp(x)) = x

The storage type of log output is always dense

Defined in src/operator/tensor/elemwise_unary_op.cc:L596

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.log10(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise Base-10 logarithmic value of the input.

10**log10(x) = x

The storage type of log10 output is always dense

Defined in src/operator/tensor/elemwise_unary_op.cc:L608

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.log1p(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise log(1 + x) value of the input.

This function is more accurate than log(1 + x) for small x so that \(1+x\approx 1\)

The storage type of log1p output depends upon the input storage type:

log1p(default) = default

log1p(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L658

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.log2(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise Base-2 logarithmic value of the input.

2**log2(x) = x

The storage type of log2 output is always dense

Defined in src/operator/tensor/elemwise_unary_op.cc:L620

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.make_loss(data=None, name=None, attr=None, out=None, **kwargs)¶

Stops gradient computation. .. note:: make_loss is deprecated, use MakeLoss.

The storage type of make_loss output depends upon the input storage type:

make_loss(default) = default

make_loss(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L148

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.negative(data=None, name=None, attr=None, out=None, **kwargs)¶

Numerical negative of the argument, element-wise.

The storage type of negative output depends upon the input storage type:

negative(default) = default

negative(row_sparse) = row_sparse

negative(csr) = csr

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.radians(data=None, name=None, attr=None, out=None, **kwargs)¶

Converts each element of the input array from degrees to radians.

\[radians([0, 90, 180, 270, 360]) = [0, \pi/2, \pi, 3\pi/2, 2\pi]\]

The storage type of radians output depends upon the input storage type:

radians(default) = default

radians(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L812

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.relu(data=None, name=None, attr=None, out=None, **kwargs)¶

Computes rectified linear.

\[max(features, 0)\]

The storage type of relu output depends upon the input storage type:

relu(default) = default

relu(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L44

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.retain(data=None, indices=None, name=None, attr=None, out=None, **kwargs)¶

pick rows specified by user input index array from a row sparse matrix and save them in the output sparse matrix.

Example:

data = [[1, 2], [3, 4], [5, 6]]
indices = [0, 1, 3]
shape = (4, 2)
rsp_in = row_sparse(data, indices)
to_retain = [0, 3]
rsp_out = retain(rsp_in, to_retain)
rsp_out.values = [[1, 2], [5, 6]]
rsp_out.indices = [0, 3]

The storage type of retain output depends on storage types of inputs

retain(row_sparse, default) = row_sparse
otherwise, retain is not supported

Defined in src/operator/tensor/sparse_retain.cc:L53

Parameters:	data (Symbol) – The input array for sparse_retain operator. indices (Symbol) – The index array of rows ids that will be retained. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.rint(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise rounded value to the nearest integer of the input.

Note

For input n.5 rint returns n while round returns n+1.
For input -n.5 both rint and round returns -n-1.

Example:

rint([-1.5, 1.5, -1.9, 1.9, 2.1]) = [-2.,  1., -2.,  2.,  2.]

The storage type of rint output depends upon the input storage type:

rint(default) = default

rint(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L393

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.round(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise rounded value to the nearest integer of the input.

Example:

round([-1.5, 1.5, -1.9, 1.9, 2.1]) = [-2.,  2., -2.,  2.,  2.]

The storage type of round output depends upon the input storage type:

round(default) = default

round(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L372

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.rsqrt(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise inverse square-root value of the input.

\[rsqrt(x) = 1/\sqrt{x}\]

Example:

rsqrt([4,9,16]) = [0.5, 0.33333334, 0.25]

The storage type of rsqrt output is always dense

Defined in src/operator/tensor/elemwise_unary_op.cc:L528

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.sigmoid(data=None, name=None, attr=None, out=None, **kwargs)¶

Computes sigmoid of x element-wise.

\[y = 1 / (1 + exp(-x))\]

The storage type of sigmoid output is always dense

Defined in src/operator/tensor/elemwise_unary_op.cc:L64

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.sign(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise sign of the input.

Example:

sign([-2, 0, 3]) = [-1, 0, 1]

The storage type of sign output depends upon the input storage type:

sign(default) = default

sign(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L353

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.sin(data=None, name=None, attr=None, out=None, **kwargs)¶

Computes the element-wise sine of the input array.

The input should be in radians (\(2\pi\) rad equals 360 degrees).

\[sin([0, \pi/4, \pi/2]) = [0, 0.707, 1]\]

The storage type of sin output depends upon the input storage type:

sin(default) = default

sin(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L640

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.sinh(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns the hyperbolic sine of the input array, computed element-wise.

\[sinh(x) = 0.5\times(exp(x) - exp(-x))\]

The storage type of sinh output depends upon the input storage type:

sinh(default) = default

sinh(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L831

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.slice(data=None, begin=_Null, end=_Null, name=None, attr=None, out=None, **kwargs)¶

Slices a contiguous region of the array.

Note

crop is deprecated. Use slice instead.

This function returns a sliced continuous region of the array between the indices given by begin and end.

For an input array of n dimensions, slice operation with begin=(b_0, b_1...b_n-1) indices and end=(e_1, e_2, ... e_n) indices will result in an array with the shape (e_1-b_0, ..., e_n-b_n-1).

The resulting array’s k-th dimension contains elements from the k-th dimension of the input array with the open range [b_k, e_k).

For an input array of non-default storage type(e.g. csr or row_sparse), it only supports slicing on the first dimension.

Example:

x = [[  1.,   2.,   3.,   4.],
     [  5.,   6.,   7.,   8.],
     [  9.,  10.,  11.,  12.]]

slice(x, begin=(0,1), end=(2,4)) = [[ 2.,  3.,  4.],
                                   [ 6.,  7.,  8.]]

Defined in src/operator/tensor/matrix_op.cc:L278

Parameters:	data (Symbol) – Source input begin (Shape(tuple), required) – starting indices for the slice operation, supports negative indices. end (Shape(tuple), required) – ending indices for the slice operation, supports negative indices. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.sqrt(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise square-root value of the input.

\[\textrm{sqrt}(x) = \sqrt{x}\]

Example:

sqrt([4, 9, 16]) = [2, 3, 4]

The storage type of sqrt output depends upon the input storage type:

sqrt(default) = default

sqrt(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L508

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.square(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns element-wise squared value of the input.

\[square(x) = x^2\]

Example:

square([2, 3, 4]) = [4, 9, 16]

The storage type of square output depends upon the input storage type:

square(default) = default

square(row_sparse) = row_sparse

square(csr) = csr

Defined in src/operator/tensor/elemwise_unary_op.cc:L485

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.stop_gradient(data=None, name=None, attr=None, out=None, **kwargs)¶

Stops gradient computation.

Stops the accumulated gradient of the inputs from flowing through this operator in the backward direction. In other words, this operator prevents the contribution of its inputs to be taken into account for computing gradients.

Example:

v1 = [1, 2]
v2 = [0, 1]
a = Variable('a')
b = Variable('b')
b_stop_grad = stop_gradient(3 * b)
loss = MakeLoss(b_stop_grad + a)

executor = loss.simple_bind(ctx=cpu(), a=(1,2), b=(1,2))
executor.forward(is_train=True, a=v1, b=v2)
executor.outputs
[ 1.  5.]

executor.backward()
executor.grad_arrays
[ 0.  0.]
[ 1.  1.]

Defined in src/operator/tensor/elemwise_unary_op.cc:L128

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.tan(data=None, name=None, attr=None, out=None, **kwargs)¶

Computes the element-wise tangent of the input array.

The input should be in radians (\(2\pi\) rad equals 360 degrees).

\[tan([0, \pi/4, \pi/2]) = [0, 1, -inf]\]

The storage type of tan output depends upon the input storage type:

tan(default) = default

tan(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L713

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.tanh(data=None, name=None, attr=None, out=None, **kwargs)¶

Returns the hyperbolic tangent of the input array, computed element-wise.

\[tanh(x) = sinh(x) / cosh(x)\]

The storage type of tanh output depends upon the input storage type:

tanh(default) = default

tanh(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L864

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.trunc(data=None, name=None, attr=None, out=None, **kwargs)¶

Return the element-wise truncated value of the input.

The truncated value of the scalar x is the nearest integer i which is closer to zero than x is. In short, the fractional part of the signed number x is discarded.

Example:

trunc([-2.1, -1.9, 1.5, 1.9, 2.1]) = [-2., -1.,  1.,  1.,  2.]

The storage type of trunc output depends upon the input storage type:

trunc(default) = default

trunc(row_sparse) = row_sparse

Defined in src/operator/tensor/elemwise_unary_op.cc:L448

Parameters:	data (Symbol) – The input array. name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol

mxnet.symbol.sparse.zeros_like(data=None, name=None, attr=None, out=None, **kwargs)¶

Return an array of zeros with the same shape and type as the input array.

The storage type of zeros_like output depends on the storage type of the input

zeros_like(row_sparse) = row_sparse
zeros_like(csr) = csr
zeros_like(default) = default

Examples:

x = [[ 1.,  1.,  1.],
     [ 1.,  1.,  1.]]

zeros_like(x) = [[ 0.,  0.,  0.],
                 [ 0.,  0.,  0.]]

Parameters:	data (Symbol) – The input name (string, optional.) – Name of the resulting symbol.
Returns:	The result symbol.
Return type:	Symbol