| mx.apply |
Apply symbol to the inputs. |
| mx.callback.early.stop |
Early stop with different conditions |
| mx.callback.log.speedometer |
Calculate the training speed |
| mx.callback.log.train.metric |
Log training metric each period |
| mx.callback.save.checkpoint |
Save checkpoint to files each period iteration. |
| mx.cpu |
Create a mxnet CPU context. |
| mx.ctx.default |
Set/Get default context for array creation. |
| mx.exec.backward |
Peform an backward on the executors This function will MUTATE the state of exec |
| mx.exec.forward |
Peform an forward on the executors This function will MUTATE the state of exec |
| mx.exec.update.arg.arrays |
Update the executors with new arrays This function will MUTATE the state of exec |
| mx.exec.update.aux.arrays |
Update the executors with new arrays This function will MUTATE the state of exec |
| mx.exec.update.grad.arrays |
Update the executors with new arrays This function will MUTATE the state of exec |
| mx.gpu |
Create a mxnet GPU context. |
| mx.infer.rnn |
Inference of RNN model |
| mx.infer.rnn.one |
Inference for one-to-one fusedRNN (CUDA) models |
| mx.infer.rnn.one.unroll |
Inference for one-to-one unroll models |
| mx.init.create |
Create initialization of argument like arg.array |
| mx.init.internal.default |
Internal default value initialization scheme. |
| mx.init.normal |
Create a initializer that initialize the weight with normal(0, sd) |
| mx.init.uniform |
Create a initializer that initialize the weight with uniform [-scale, scale] |
| mx.init.Xavier |
Xavier initializer |
| mx.io.arrayiter |
Create MXDataIter compatible iterator from R's array |
| mx.io.bucket.iter |
Create Bucket Iter |
| mx.io.CSVIter |
Returns the CSV file iterator. |
| mx.io.extract |
Extract a certain field from DataIter. |
| mx.io.ImageDetRecordIter |
Create iterator for image detection dataset packed in recordio. |
| mx.io.ImageRecordInt8Iter |
Iterating on image RecordIO files |
| mx.io.ImageRecordIter |
Iterates on image RecordIO files |
| mx.io.ImageRecordIter_v1 |
Iterating on image RecordIO files |
| mx.io.ImageRecordUInt8Iter |
Iterating on image RecordIO files |
| mx.io.ImageRecordUInt8Iter_v1 |
Iterating on image RecordIO files |
| mx.io.LibSVMIter |
Returns the LibSVM iterator which returns data with 'csr' storage type. This iterator is experimental and should be used with care. |
| mx.io.MNISTIter |
Iterating on the MNIST dataset. |
| mx.kv.create |
Create a mxnet KVStore. |
| mx.lr_scheduler.FactorScheduler |
Learning rate scheduler. Reduction based on a factor value. |
| mx.lr_scheduler.MultiFactorScheduler |
Multifactor learning rate scheduler. Reduction based on a factor value at different steps. |
| mx.metric.accuracy |
Accuracy metric for classification |
| mx.metric.custom |
Helper function to create a customized metric |
| mx.metric.logistic_acc |
Accuracy metric for logistic regression |
| mx.metric.logloss |
LogLoss metric for logistic regression |
| mx.metric.mae |
MAE (Mean Absolute Error) metric for regression |
| mx.metric.mse |
MSE (Mean Squared Error) metric for regression |
| mx.metric.Perplexity |
Perplexity metric for language model |
| mx.metric.rmse |
RMSE (Root Mean Squared Error) metric for regression |
| mx.metric.rmsle |
RMSLE (Root Mean Squared Logarithmic Error) metric for regression |
| mx.metric.top_k_accuracy |
Top-k accuracy metric for classification |
| mx.mlp |
Convenience interface for multiple layer perceptron |
| mx.model.buckets |
Train RNN with bucket support |
| mx.model.FeedForward.create |
Create a MXNet Feedforward neural net model with the specified training. |
| mx.model.init.params |
Parameter initialization |
| mx.model.load |
Load model checkpoint from file. |
| mx.model.save |
Save model checkpoint into file. |
| mx.nd.abs |
Returns element-wise absolute value of the input. |
| mx.nd.Activation |
Applies an activation function element-wise to the input. |
| mx.nd.adam.update |
Update function for Adam optimizer. Adam is seen as a generalization of AdaGrad. |
| mx.nd.add.n |
Adds all input arguments element-wise. |
| mx.nd.all.finite |
Check if all the float numbers in the array are finite (used for AMP) |
| mx.nd.amp.cast |
Cast function between low precision float/FP32 used by AMP. |
| mx.nd.amp.multicast |
Cast function used by AMP, that casts its inputs to the common widest type. |
| mx.nd.arccos |
Returns element-wise inverse cosine of the input array. |
| mx.nd.arccosh |
Returns the element-wise inverse hyperbolic cosine of the input array, \ computed element-wise. |
| mx.nd.arcsin |
Returns element-wise inverse sine of the input array. |
| mx.nd.arcsinh |
Returns the element-wise inverse hyperbolic sine of the input array, \ computed element-wise. |
| mx.nd.arctan |
Returns element-wise inverse tangent of the input array. |
| mx.nd.arctanh |
Returns the element-wise inverse hyperbolic tangent of the input array, \ computed element-wise. |
| mx.nd.argmax |
Returns indices of the maximum values along an axis. |
| mx.nd.argmax.channel |
Returns argmax indices of each channel from the input array. |
| mx.nd.argmin |
Returns indices of the minimum values along an axis. |
| mx.nd.argsort |
Returns the indices that would sort an input array along the given axis. |
| mx.nd.array |
Create a new 'mx.ndarray' that copies the content from src on ctx. |
| mx.nd.batch.dot |
Batchwise dot product. |
| mx.nd.batch.take |
Takes elements from a data batch. |
| mx.nd.BatchNorm |
Batch normalization. |
| mx.nd.BatchNorm.v1 |
Batch normalization. |
| mx.nd.BilinearSampler |
Applies bilinear sampling to input feature map. |
| mx.nd.BlockGrad |
Stops gradient computation. |
| mx.nd.broadcast.add |
Returns element-wise sum of the input arrays with broadcasting. |
| mx.nd.broadcast.axes |
Broadcasts the input array over particular axes. |
| mx.nd.broadcast.axis |
Broadcasts the input array over particular axes. |
| mx.nd.broadcast.div |
Returns element-wise division of the input arrays with broadcasting. |
| mx.nd.broadcast.equal |
Returns the result of element-wise **equal to** (==) comparison operation with broadcasting. |
| mx.nd.broadcast.greater |
Returns the result of element-wise **greater than** (>) comparison operation with broadcasting. |
| mx.nd.broadcast.greater.equal |
Returns the result of element-wise **greater than or equal to** (>=) comparison operation with broadcasting. |
| mx.nd.broadcast.hypot |
Returns the hypotenuse of a right angled triangle, given its "legs" with broadcasting. |
| mx.nd.broadcast.lesser |
Returns the result of element-wise **lesser than** (<) comparison operation with broadcasting. |
| mx.nd.broadcast.lesser.equal |
Returns the result of element-wise **lesser than or equal to** (<=) comparison operation with broadcasting. |
| mx.nd.broadcast.like |
Broadcasts lhs to have the same shape as rhs. |
| mx.nd.broadcast.logical.and |
Returns the result of element-wise **logical and** with broadcasting. |
| mx.nd.broadcast.logical.or |
Returns the result of element-wise **logical or** with broadcasting. |
| mx.nd.broadcast.logical.xor |
Returns the result of element-wise **logical xor** with broadcasting. |
| mx.nd.broadcast.maximum |
Returns element-wise maximum of the input arrays with broadcasting. |
| mx.nd.broadcast.minimum |
Returns element-wise minimum of the input arrays with broadcasting. |
| mx.nd.broadcast.minus |
Returns element-wise difference of the input arrays with broadcasting. |
| mx.nd.broadcast.mod |
Returns element-wise modulo of the input arrays with broadcasting. |
| mx.nd.broadcast.mul |
Returns element-wise product of the input arrays with broadcasting. |
| mx.nd.broadcast.not.equal |
Returns the result of element-wise **not equal to** (!=) comparison operation with broadcasting. |
| mx.nd.broadcast.plus |
Returns element-wise sum of the input arrays with broadcasting. |
| mx.nd.broadcast.power |
Returns result of first array elements raised to powers from second array, element-wise with broadcasting. |
| mx.nd.broadcast.sub |
Returns element-wise difference of the input arrays with broadcasting. |
| mx.nd.broadcast.to |
Broadcasts the input array to a new shape. |
| mx.nd.Cast |
Casts all elements of the input to a new type. |
| mx.nd.cast |
Casts all elements of the input to a new type. |
| mx.nd.cast.storage |
Casts tensor storage type to the new type. |
| mx.nd.cbrt |
Returns element-wise cube-root value of the input. |
| mx.nd.ceil |
Returns element-wise ceiling of the input. |
| mx.nd.choose.element.0index |
Picks elements from an input array according to the input indices along the given axis. |
| mx.nd.clip |
Clips (limits) the values in an array. Given an interval, values outside the interval are clipped to the interval edges. Clipping "x" between 'a_min' and 'a_max' would be:: .. math:: clip(x, a_min, a_max) = \max(\min(x, a_max), a_min)) Example:: x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] clip(x,1,8) = [ 1., 1., 2., 3., 4., 5., 6., 7., 8., 8.] The storage type of "clip" output depends on storage types of inputs and the a_min, a_max \ parameter values: - clip(default) = default - clip(row_sparse, a_min <= 0, a_max >= 0) = row_sparse - clip(csr, a_min <= 0, a_max >= 0) = csr - clip(row_sparse, a_min < 0, a_max < 0) = default - clip(row_sparse, a_min > 0, a_max > 0) = default - clip(csr, a_min < 0, a_max < 0) = csr - clip(csr, a_min > 0, a_max > 0) = csr |
| mx.nd.col2im |
Combining the output column matrix of im2col back to image array. |
| mx.nd.Concat |
Joins input arrays along a given axis. |
| mx.nd.concat |
Joins input arrays along a given axis. |
| mx.nd.Convolution |
Compute *N*-D convolution on *(N+2)*-D input. |
| mx.nd.Convolution.v1 |
This operator is DEPRECATED. Apply convolution to input then add a bias. |
| mx.nd.copyto |
Generate an mx.ndarray object on ctx, with data copied from src |
| mx.nd.Correlation |
Applies correlation to inputs. |
| mx.nd.cos |
Computes the element-wise cosine of the input array. |
| mx.nd.cosh |
Returns the hyperbolic cosine of the input array, computed element-wise. |
| mx.nd.Crop |
.. note:: 'Crop' is deprecated. Use 'slice' instead. |
| mx.nd.crop |
Slices a region of the array. .. note:: "crop" is deprecated. Use "slice" instead. This function returns a sliced array between the indices given by 'begin' and 'end' with the corresponding 'step'. For an input array of "shape=(d_0, d_1, ..., d_n-1)", slice operation with "begin=(b_0, b_1...b_m-1)", "end=(e_0, e_1, ..., e_m-1)", and "step=(s_0, s_1, ..., s_m-1)", where m <= n, results in an array with the shape "(|e_0-b_0|/|s_0|, ..., |e_m-1-b_m-1|/|s_m-1|, d_m, ..., d_n-1)". The resulting array's *k*-th dimension contains elements from the *k*-th dimension of the input array starting from index "b_k" (inclusive) with step "s_k" until reaching "e_k" (exclusive). If the *k*-th elements are 'None' in the sequence of 'begin', 'end', and 'step', the following rule will be used to set default values. If 's_k' is 'None', set 's_k=1'. If 's_k > 0', set 'b_k=0', 'e_k=d_k'; else, set 'b_k=d_k-1', 'e_k=-1'. The storage type of "slice" output depends on storage types of inputs - slice(csr) = csr - otherwise, "slice" generates output with default storage .. note:: When input data storage type is csr, it only supports step=(), or step=(None,), or step=(1,) to generate a csr output. For other step parameter values, it falls back to slicing a dense tensor. 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.]] slice(x, begin=(None, 0), end=(None, 3), step=(-1, 2)) = [[9., 11.], [5., 7.], [1., 3.]] |
| mx.nd.ctc.loss |
Connectionist Temporal Classification Loss. |
| mx.nd.CTCLoss |
Connectionist Temporal Classification Loss. |
| mx.nd.cumsum |
Return the cumulative sum of the elements along a given axis. |
| mx.nd.Custom |
Apply a custom operator implemented in a frontend language (like Python). |
| mx.nd.Deconvolution |
Computes 1D or 2D transposed convolution (aka fractionally strided convolution) of the input tensor. This operation can be seen as the gradient of Convolution operation with respect to its input. Convolution usually reduces the size of the input. Transposed convolution works the other way, going from a smaller input to a larger output while preserving the connectivity pattern. |
| mx.nd.degrees |
Converts each element of the input array from radians to degrees. |
| mx.nd.depth.to.space |
Rearranges(permutes) data from depth into blocks of spatial data. Similar to ONNX DepthToSpace operator: https://github.com/onnx/onnx/blob/master/docs/Operators.md#DepthToSpace. The output is a new tensor where the values from depth dimension are moved in spatial blocks to height and width dimension. The reverse of this operation is "space_to_depth". .. math:: \begingather* x \prime = reshape(x, [N, block\_size, block\_size, C / (block\_size ^ 2), H * block\_size, W * block\_size]) \ x \prime \prime = transpose(x \prime, [0, 3, 4, 1, 5, 2]) \ y = reshape(x \prime \prime, [N, C / (block\_size ^ 2), H * block\_size, W * block\_size]) \endgather* where :math:'x' is an input tensor with default layout as :math:'[N, C, H, W]': [batch, channels, height, width] and :math:'y' is the output tensor of layout :math:'[N, C / (block\_size ^ 2), H * block\_size, W * block\_size]' Example:: x = [[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]], [[18, 19, 20], [21, 22, 23]]]] depth_to_space(x, 2) = [[[[0, 6, 1, 7, 2, 8], [12, 18, 13, 19, 14, 20], [3, 9, 4, 10, 5, 11], [15, 21, 16, 22, 17, 23]]]] |
| mx.nd.diag |
Extracts a diagonal or constructs a diagonal array. |
| mx.nd.dot |
Dot product of two arrays. |
| mx.nd.Dropout |
Applies dropout operation to input array. |
| mx.nd.ElementWiseSum |
Adds all input arguments element-wise. |
| mx.nd.elemwise.add |
Adds arguments element-wise. |
| mx.nd.elemwise.div |
Divides arguments element-wise. |
| mx.nd.elemwise.mul |
Multiplies arguments element-wise. |
| mx.nd.elemwise.sub |
Subtracts arguments element-wise. |
| mx.nd.Embedding |
Maps integer indices to vector representations (embeddings). |
| mx.nd.erf |
Returns element-wise gauss error function of the input. |
| mx.nd.erfinv |
Returns element-wise inverse gauss error function of the input. |
| mx.nd.exp |
Returns element-wise exponential value of the input. |
| mx.nd.expand.dims |
Inserts a new axis of size 1 into the array shape For example, given "x" with shape "(2,3,4)", then "expand_dims(x, axis=1)" will return a new array with shape "(2,1,3,4)". |
| mx.nd.expm1 |
Returns "exp(x) - 1" computed element-wise on the input. |
| mx.nd.fill.element.0index |
Fill one element of each line(row for python, column for R/Julia) in lhs according to index indicated by rhs and values indicated by mhs. This function assume rhs uses 0-based index. |
| mx.nd.fix |
Returns element-wise rounded value to the nearest \ integer towards zero of the input. |
| mx.nd.Flatten |
Flattens the input array into a 2-D array by collapsing the higher dimensions. .. note:: 'Flatten' is deprecated. Use 'flatten' instead. For an input array with shape "(d1, d2, ..., dk)", 'flatten' operation reshapes the input array into an output array of shape "(d1, d2*...*dk)". Note that the behavior of this function is different from numpy.ndarray.flatten, which behaves similar to mxnet.ndarray.reshape((-1,)). Example:: x = [[ [1,2,3], [4,5,6], [7,8,9] ], [ [1,2,3], [4,5,6], [7,8,9] ]], flatten(x) = [[ 1., 2., 3., 4., 5., 6., 7., 8., 9.], [ 1., 2., 3., 4., 5., 6., 7., 8., 9.]] |
| mx.nd.flatten |
Flattens the input array into a 2-D array by collapsing the higher dimensions. .. note:: 'Flatten' is deprecated. Use 'flatten' instead. For an input array with shape "(d1, d2, ..., dk)", 'flatten' operation reshapes the input array into an output array of shape "(d1, d2*...*dk)". Note that the behavior of this function is different from numpy.ndarray.flatten, which behaves similar to mxnet.ndarray.reshape((-1,)). Example:: x = [[ [1,2,3], [4,5,6], [7,8,9] ], [ [1,2,3], [4,5,6], [7,8,9] ]], flatten(x) = [[ 1., 2., 3., 4., 5., 6., 7., 8., 9.], [ 1., 2., 3., 4., 5., 6., 7., 8., 9.]] |
| mx.nd.flip |
Reverses the order of elements along given axis while preserving array shape. Note: reverse and flip are equivalent. We use reverse in the following examples. Examples:: x = [[ 0., 1., 2., 3., 4.], [ 5., 6., 7., 8., 9.]] reverse(x, axis=0) = [[ 5., 6., 7., 8., 9.], [ 0., 1., 2., 3., 4.]] reverse(x, axis=1) = [[ 4., 3., 2., 1., 0.], [ 9., 8., 7., 6., 5.]] |
| mx.nd.floor |
Returns element-wise floor of the input. |
| mx.nd.ftml.update |
The FTML optimizer described in *FTML - Follow the Moving Leader in Deep Learning*, available at http://proceedings.mlr.press/v70/zheng17a/zheng17a.pdf. |
| mx.nd.ftrl.update |
Update function for Ftrl optimizer. Referenced from *Ad Click Prediction: a View from the Trenches*, available at http://dl.acm.org/citation.cfm?id=2488200. |
| mx.nd.FullyConnected |
Applies a linear transformation: :math:'Y = XW^T + b'. |
| mx.nd.gamma |
Returns the gamma function (extension of the factorial function \ to the reals), computed element-wise on the input array. |
| mx.nd.gammaln |
Returns element-wise log of the absolute value of the gamma function \ of the input. |
| mx.nd.gather.nd |
Gather elements or slices from 'data' and store to a tensor whose shape is defined by 'indices'. |
| mx.nd.GridGenerator |
Generates 2D sampling grid for bilinear sampling. |
| mx.nd.GroupNorm |
Group normalization. |
| mx.nd.hard.sigmoid |
Computes hard sigmoid of x element-wise. |
| mx.nd.identity |
Returns a copy of the input. |
| mx.nd.IdentityAttachKLSparseReg |
Apply a sparse regularization to the output a sigmoid activation function. |
| mx.nd.im2col |
Extract sliding blocks from input array. |
| mx.nd.InstanceNorm |
Applies instance normalization to the n-dimensional input array. |
| mx.nd.khatri.rao |
Computes the Khatri-Rao product of the input matrices. |
| mx.nd.L2Normalization |
Normalize the input array using the L2 norm. |
| mx.nd.lamb.update.phase1 |
Phase I of lamb update it performs the following operations and returns g:. |
| mx.nd.lamb.update.phase2 |
Phase II of lamb update it performs the following operations and updates grad. |
| mx.nd.LayerNorm |
Layer normalization. |
| mx.nd.LeakyReLU |
Applies Leaky rectified linear unit activation element-wise to the input. |
| mx.nd.linalg.det |
Compute the determinant of a matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.nd.linalg.extractdiag |
Extracts the diagonal entries of a square matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.nd.linalg.extracttrian |
Extracts a triangular sub-matrix from a square matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.nd.linalg.gelqf |
LQ factorization for general matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.nd.linalg.gemm |
Performs general matrix multiplication and accumulation. Input are tensors *A*, *B*, *C*, each of dimension *n >= 2* and having the same shape on the leading *n-2* dimensions. |
| mx.nd.linalg.gemm2 |
Performs general matrix multiplication. Input are tensors *A*, *B*, each of dimension *n >= 2* and having the same shape on the leading *n-2* dimensions. |
| mx.nd.linalg.inverse |
Compute the inverse of a matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.nd.linalg.makediag |
Constructs a square matrix with the input as diagonal. Input is a tensor *A* of dimension *n >= 1*. |
| mx.nd.linalg.maketrian |
Constructs a square matrix with the input representing a specific triangular sub-matrix. This is basically the inverse of *linalg.extracttrian*. Input is a tensor *A* of dimension *n >= 1*. |
| mx.nd.linalg.potrf |
Performs Cholesky factorization of a symmetric positive-definite matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.nd.linalg.potri |
Performs matrix inversion from a Cholesky factorization. Input is a tensor *A* of dimension *n >= 2*. |
| mx.nd.linalg.slogdet |
Compute the sign and log of the determinant of a matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.nd.linalg.sumlogdiag |
Computes the sum of the logarithms of the diagonal elements of a square matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.nd.linalg.syrk |
Multiplication of matrix with its transpose. Input is a tensor *A* of dimension *n >= 2*. |
| mx.nd.linalg.trmm |
Performs multiplication with a lower triangular matrix. Input are tensors *A*, *B*, each of dimension *n >= 2* and having the same shape on the leading *n-2* dimensions. |
| mx.nd.linalg.trsm |
Solves matrix equation involving a lower triangular matrix. Input are tensors *A*, *B*, each of dimension *n >= 2* and having the same shape on the leading *n-2* dimensions. |
| mx.nd.LinearRegressionOutput |
Computes and optimizes for squared loss during backward propagation. Just outputs "data" during forward propagation. |
| mx.nd.load |
Load an mx.nd.array object on disk |
| mx.nd.log |
Returns element-wise Natural logarithmic value of the input. |
| mx.nd.log.softmax |
Computes the log softmax of the input. This is equivalent to computing softmax followed by log. |
| mx.nd.log10 |
Returns element-wise Base-10 logarithmic value of the input. |
| mx.nd.log1p |
Returns element-wise "log(1 + x)" value of the input. |
| mx.nd.log2 |
Returns element-wise Base-2 logarithmic value of the input. |
| mx.nd.logical.not |
Returns the result of logical NOT (!) function |
| mx.nd.LogisticRegressionOutput |
Applies a logistic function to the input. |
| mx.nd.LRN |
Applies local response normalization to the input. |
| mx.nd.MAERegressionOutput |
Computes mean absolute error of the input. |
| mx.nd.make.loss |
Make your own loss function in network construction. |
| mx.nd.MakeLoss |
Make your own loss function in network construction. |
| mx.nd.max |
Computes the max of array elements over given axes. |
| mx.nd.max.axis |
Computes the max of array elements over given axes. |
| mx.nd.mean |
Computes the mean of array elements over given axes. |
| mx.nd.min |
Computes the min of array elements over given axes. |
| mx.nd.min.axis |
Computes the min of array elements over given axes. |
| mx.nd.moments |
Calculate the mean and variance of 'data'. |
| mx.nd.mp.lamb.update.phase1 |
Mixed Precision version of Phase I of lamb update it performs the following operations and returns g:. |
| mx.nd.mp.lamb.update.phase2 |
Mixed Precision version Phase II of lamb update it performs the following operations and updates grad. |
| mx.nd.mp.nag.mom.update |
Update function for multi-precision Nesterov Accelerated Gradient( NAG) optimizer. |
| mx.nd.mp.sgd.mom.update |
Updater function for multi-precision sgd optimizer |
| mx.nd.mp.sgd.update |
Updater function for multi-precision sgd optimizer |
| mx.nd.multi.all.finite |
Check if all the float numbers in all the arrays are finite (used for AMP) |
| mx.nd.multi.lars |
Compute the LARS coefficients of multiple weights and grads from their sums of square" |
| mx.nd.multi.mp.sgd.mom.update |
Momentum update function for multi-precision Stochastic Gradient Descent (SGD) optimizer. |
| mx.nd.multi.mp.sgd.update |
Update function for multi-precision Stochastic Gradient Descent (SDG) optimizer. |
| mx.nd.multi.sgd.mom.update |
Momentum update function for Stochastic Gradient Descent (SGD) optimizer. |
| mx.nd.multi.sgd.update |
Update function for Stochastic Gradient Descent (SDG) optimizer. |
| mx.nd.multi.sum.sq |
Compute the sums of squares of multiple arrays |
| mx.nd.nag.mom.update |
Update function for Nesterov Accelerated Gradient( NAG) optimizer. It updates the weights using the following formula, |
| mx.nd.nanprod |
Computes the product of array elements over given axes treating Not a Numbers ("NaN") as one. |
| mx.nd.nansum |
Computes the sum of array elements over given axes treating Not a Numbers ("NaN") as zero. |
| mx.nd.negative |
Numerical negative of the argument, element-wise. |
| mx.nd.norm |
Computes the norm on an NDArray. |
| mx.nd.normal |
Draw random samples from a normal (Gaussian) distribution. |
| mx.nd.one.hot |
Returns a one-hot array. |
| mx.nd.ones |
Generate an mx.ndarray object with ones |
| mx.nd.ones.like |
Return an array of ones with the same shape and type as the input array. |
| mx.nd.Pad |
Pads an input array with a constant or edge values of the array. |
| mx.nd.pad |
Pads an input array with a constant or edge values of the array. |
| mx.nd.pick |
Picks elements from an input array according to the input indices along the given axis. |
| mx.nd.Pooling |
Performs pooling on the input. |
| mx.nd.Pooling.v1 |
This operator is DEPRECATED. Perform pooling on the input. |
| mx.nd.preloaded.multi.mp.sgd.mom.update |
Momentum update function for multi-precision Stochastic Gradient Descent (SGD) optimizer. |
| mx.nd.preloaded.multi.mp.sgd.update |
Update function for multi-precision Stochastic Gradient Descent (SDG) optimizer. |
| mx.nd.preloaded.multi.sgd.mom.update |
Momentum update function for Stochastic Gradient Descent (SGD) optimizer. |
| mx.nd.preloaded.multi.sgd.update |
Update function for Stochastic Gradient Descent (SDG) optimizer. |
| mx.nd.prod |
Computes the product of array elements over given axes. |
| mx.nd.radians |
Converts each element of the input array from degrees to radians. |
| mx.nd.random.exponential |
Draw random samples from an exponential distribution. |
| mx.nd.random.gamma |
Draw random samples from a gamma distribution. |
| mx.nd.random.generalized.negative.binomial |
Draw random samples from a generalized negative binomial distribution. |
| mx.nd.random.negative.binomial |
Draw random samples from a negative binomial distribution. |
| mx.nd.random.normal |
Draw random samples from a normal (Gaussian) distribution. |
| mx.nd.random.pdf.dirichlet |
Computes the value of the PDF of *sample* of Dirichlet distributions with parameter *alpha*. |
| mx.nd.random.pdf.exponential |
Computes the value of the PDF of *sample* of exponential distributions with parameters *lam* (rate). |
| mx.nd.random.pdf.gamma |
Computes the value of the PDF of *sample* of gamma distributions with parameters *alpha* (shape) and *beta* (rate). |
| mx.nd.random.pdf.generalized.negative.binomial |
Computes the value of the PDF of *sample* of generalized negative binomial distributions with parameters *mu* (mean) and *alpha* (dispersion). This can be understood as a reparameterization of the negative binomial, where *k* = *1 / alpha* and *p* = *1 / (mu \* alpha + 1)*. |
| mx.nd.random.pdf.negative.binomial |
Computes the value of the PDF of samples of negative binomial distributions with parameters *k* (failure limit) and *p* (failure probability). |
| mx.nd.random.pdf.normal |
Computes the value of the PDF of *sample* of normal distributions with parameters *mu* (mean) and *sigma* (standard deviation). |
| mx.nd.random.pdf.poisson |
Computes the value of the PDF of *sample* of Poisson distributions with parameters *lam* (rate). |
| mx.nd.random.pdf.uniform |
Computes the value of the PDF of *sample* of uniform distributions on the intervals given by *[low,high)*. |
| mx.nd.random.poisson |
Draw random samples from a Poisson distribution. |
| mx.nd.random.randint |
Draw random samples from a discrete uniform distribution. |
| mx.nd.random.uniform |
Draw random samples from a uniform distribution. |
| mx.nd.ravel.multi.index |
Converts a batch of index arrays into an array of flat indices. The operator follows numpy conventions so a single multi index is given by a column of the input matrix. The leading dimension may be left unspecified by using -1 as placeholder. |
| mx.nd.rcbrt |
Returns element-wise inverse cube-root value of the input. |
| mx.nd.reciprocal |
Returns the reciprocal of the argument, element-wise. |
| mx.nd.relu |
Computes rectified linear activation. |
| mx.nd.repeat |
Repeats elements of an array. By default, "repeat" flattens the input array into 1-D and then repeats the elements:: x = [[ 1, 2], [ 3, 4]] repeat(x, repeats=2) = [ 1., 1., 2., 2., 3., 3., 4., 4.] The parameter "axis" specifies the axis along which to perform repeat:: repeat(x, repeats=2, axis=1) = [[ 1., 1., 2., 2.], [ 3., 3., 4., 4.]] repeat(x, repeats=2, axis=0) = [[ 1., 2.], [ 1., 2.], [ 3., 4.], [ 3., 4.]] repeat(x, repeats=2, axis=-1) = [[ 1., 1., 2., 2.], [ 3., 3., 4., 4.]] |
| mx.nd.reset.arrays |
Set to zero multiple arrays |
| mx.nd.Reshape |
Reshapes the input array. .. note:: "Reshape" is deprecated, use "reshape" Given an array and a shape, this function returns a copy of the array in the new shape. The shape is a tuple of integers such as (2,3,4). The size of the new shape should be same as the size of the input array. Example:: reshape([1,2,3,4], shape=(2,2)) = [[1,2], [3,4]] 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). |
| mx.nd.reshape |
Reshapes the input array. .. note:: "Reshape" is deprecated, use "reshape" Given an array and a shape, this function returns a copy of the array in the new shape. The shape is a tuple of integers such as (2,3,4). The size of the new shape should be same as the size of the input array. Example:: reshape([1,2,3,4], shape=(2,2)) = [[1,2], [3,4]] 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). |
| mx.nd.reshape.like |
Reshape some or all dimensions of 'lhs' to have the same shape as some or all dimensions of 'rhs'. |
| mx.nd.reverse |
Reverses the order of elements along given axis while preserving array shape. Note: reverse and flip are equivalent. We use reverse in the following examples. Examples:: x = [[ 0., 1., 2., 3., 4.], [ 5., 6., 7., 8., 9.]] reverse(x, axis=0) = [[ 5., 6., 7., 8., 9.], [ 0., 1., 2., 3., 4.]] reverse(x, axis=1) = [[ 4., 3., 2., 1., 0.], [ 9., 8., 7., 6., 5.]] |
| mx.nd.rint |
Returns element-wise rounded value to the nearest integer of the input. |
| mx.nd.rmsprop.update |
Update function for 'RMSProp' optimizer. |
| mx.nd.rmspropalex.update |
Update function for RMSPropAlex optimizer. |
| mx.nd.RNN |
Applies recurrent layers to input data. Currently, vanilla RNN, LSTM and GRU are implemented, with both multi-layer and bidirectional support. |
| mx.nd.ROIPooling |
Performs region of interest(ROI) pooling on the input array. |
| mx.nd.round |
Returns element-wise rounded value to the nearest integer of the input. |
| mx.nd.rsqrt |
Returns element-wise inverse square-root value of the input. |
| mx.nd.sample.exponential |
Concurrent sampling from multiple exponential distributions with parameters lambda (rate). |
| mx.nd.sample.gamma |
Concurrent sampling from multiple gamma distributions with parameters *alpha* (shape) and *beta* (scale). |
| mx.nd.sample.generalized.negative.binomial |
Concurrent sampling from multiple generalized negative binomial distributions with parameters *mu* (mean) and *alpha* (dispersion). |
| mx.nd.sample.multinomial |
Concurrent sampling from multiple multinomial distributions. |
| mx.nd.sample.negative.binomial |
Concurrent sampling from multiple negative binomial distributions with parameters *k* (failure limit) and *p* (failure probability). |
| mx.nd.sample.normal |
Concurrent sampling from multiple normal distributions with parameters *mu* (mean) and *sigma* (standard deviation). |
| mx.nd.sample.poisson |
Concurrent sampling from multiple Poisson distributions with parameters lambda (rate). |
| mx.nd.sample.uniform |
Concurrent sampling from multiple uniform distributions on the intervals given by *[low,high)*. |
| mx.nd.save |
Save an mx.nd.array object |
| mx.nd.scatter.nd |
Scatters data into a new tensor according to indices. |
| mx.nd.SequenceLast |
Takes the last element of a sequence. |
| mx.nd.SequenceMask |
Sets all elements outside the sequence to a constant value. |
| mx.nd.SequenceReverse |
Reverses the elements of each sequence. |
| mx.nd.sgd.mom.update |
Momentum update function for Stochastic Gradient Descent (SGD) optimizer. |
| mx.nd.sgd.update |
Update function for Stochastic Gradient Descent (SGD) optimizer. |
| mx.nd.shape.array |
Returns a 1D int64 array containing the shape of data. |
| mx.nd.shuffle |
Randomly shuffle the elements. |
| mx.nd.sigmoid |
Computes sigmoid of x element-wise. |
| mx.nd.sign |
Returns element-wise sign of the input. |
| mx.nd.signsgd.update |
Update function for SignSGD optimizer. |
| mx.nd.signum.update |
SIGN momentUM (Signum) optimizer. |
| mx.nd.sin |
Computes the element-wise sine of the input array. |
| mx.nd.sinh |
Returns the hyperbolic sine of the input array, computed element-wise. |
| mx.nd.size.array |
Returns a 1D int64 array containing the size of data. |
| mx.nd.slice.axis |
Slices along a given axis. Returns an array slice along a given 'axis' starting from the 'begin' index to the 'end' index. Examples:: x = [[ 1., 2., 3., 4.], [ 5., 6., 7., 8.], [ 9., 10., 11., 12.]] slice_axis(x, axis=0, begin=1, end=3) = [[ 5., 6., 7., 8.], [ 9., 10., 11., 12.]] slice_axis(x, axis=1, begin=0, end=2) = [[ 1., 2.], [ 5., 6.], [ 9., 10.]] slice_axis(x, axis=1, begin=-3, end=-1) = [[ 2., 3.], [ 6., 7.], [ 10., 11.]] |
| mx.nd.slice.like |
Slices a region of the array like the shape of another array. This function is similar to "slice", however, the 'begin' are always '0's and 'end' of specific axes are inferred from the second input 'shape_like'. Given the second 'shape_like' input of "shape=(d_0, d_1, ..., d_n-1)", a "slice_like" operator with default empty 'axes', it performs the following operation: " out = slice(input, begin=(0, 0, ..., 0), end=(d_0, d_1, ..., d_n-1))". When 'axes' is not empty, it is used to speficy which axes are being sliced. Given a 4-d input data, "slice_like" operator with "axes=(0, 2, -1)" will perform the following operation: " out = slice(input, begin=(0, 0, 0, 0), end=(d_0, None, d_2, d_3))". Note that it is allowed to have first and second input with different dimensions, however, you have to make sure the 'axes' are specified and not exceeding the dimension limits. For example, given 'input_1' with "shape=(2,3,4,5)" and 'input_2' with "shape=(1,2,3)", it is not allowed to use: " out = slice_like(a, b)" because ndim of 'input_1' is 4, and ndim of 'input_2' is 3. The following is allowed in this situation: " out = slice_like(a, b, axes=(0, 2))" Example:: x = [[ 1., 2., 3., 4.], [ 5., 6., 7., 8.], [ 9., 10., 11., 12.]] y = [[ 0., 0., 0.], [ 0., 0., 0.]] slice_like(x, y) = [[ 1., 2., 3.] [ 5., 6., 7.]] slice_like(x, y, axes=(0, 1)) = [[ 1., 2., 3.] [ 5., 6., 7.]] slice_like(x, y, axes=(0)) = [[ 1., 2., 3., 4.] [ 5., 6., 7., 8.]] slice_like(x, y, axes=(-1)) = [[ 1., 2., 3.] [ 5., 6., 7.] [ 9., 10., 11.]] |
| mx.nd.SliceChannel |
Splits an array along a particular axis into multiple sub-arrays. |
| mx.nd.smooth.l1 |
Calculate Smooth L1 Loss(lhs, scalar) by summing |
| mx.nd.Softmax |
Computes the gradient of cross entropy loss with respect to softmax output. |
| mx.nd.softmax |
Applies the softmax function. |
| mx.nd.softmax.cross.entropy |
Calculate cross entropy of softmax output and one-hot label. |
| mx.nd.SoftmaxActivation |
Applies softmax activation to input. This is intended for internal layers. |
| mx.nd.SoftmaxOutput |
Computes the gradient of cross entropy loss with respect to softmax output. |
| mx.nd.softmin |
Applies the softmin function. |
| mx.nd.softsign |
Computes softsign of x element-wise. |
| mx.nd.sort |
Returns a sorted copy of an input array along the given axis. |
| mx.nd.space.to.depth |
Rearranges(permutes) blocks of spatial data into depth. Similar to ONNX SpaceToDepth operator: https://github.com/onnx/onnx/blob/master/docs/Operators.md#SpaceToDepth The output is a new tensor where the values from height and width dimension are moved to the depth dimension. The reverse of this operation is "depth_to_space". .. math:: \begingather* x \prime = reshape(x, [N, C, H / block\_size, block\_size, W / block\_size, block\_size]) \ x \prime \prime = transpose(x \prime, [0, 3, 5, 1, 2, 4]) \ y = reshape(x \prime \prime, [N, C * (block\_size ^ 2), H / block\_size, W / block\_size]) \endgather* where :math:'x' is an input tensor with default layout as :math:'[N, C, H, W]': [batch, channels, height, width] and :math:'y' is the output tensor of layout :math:'[N, C * (block\_size ^ 2), H / block\_size, W / block\_size]' Example:: x = [[[[0, 6, 1, 7, 2, 8], [12, 18, 13, 19, 14, 20], [3, 9, 4, 10, 5, 11], [15, 21, 16, 22, 17, 23]]]] space_to_depth(x, 2) = [[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]], [[18, 19, 20], [21, 22, 23]]]] |
| mx.nd.SpatialTransformer |
Applies a spatial transformer to input feature map. |
| mx.nd.split |
Splits an array along a particular axis into multiple sub-arrays. |
| mx.nd.sqrt |
Returns element-wise square-root value of the input. |
| mx.nd.square |
Returns element-wise squared value of the input. |
| mx.nd.squeeze |
Remove single-dimensional entries from the shape of an array. Same behavior of defining the output tensor shape as numpy.squeeze for the most of cases. See the following note for exception. Examples:: data = [[[0], [1], [2]]] squeeze(data) = [0, 1, 2] squeeze(data, axis=0) = [[0], [1], [2]] squeeze(data, axis=2) = [[0, 1, 2]] squeeze(data, axis=(0, 2)) = [0, 1, 2] .. Note:: The output of this operator will keep at least one dimension not removed. For example, squeeze([[[4]]]) = [4], while in numpy.squeeze, the output will become a scalar. |
| mx.nd.stack |
Join a sequence of arrays along a new axis. The axis parameter specifies the index of the new axis in the dimensions of the result. For example, if axis=0 it will be the first dimension and if axis=-1 it will be the last dimension. Examples:: x = [1, 2] y = [3, 4] stack(x, y) = [[1, 2], [3, 4]] stack(x, y, axis=1) = [[1, 3], [2, 4]] |
| mx.nd.stop.gradient |
Stops gradient computation. |
| mx.nd.sum |
Computes the sum of array elements over given axes. |
| mx.nd.sum.axis |
Computes the sum of array elements over given axes. |
| mx.nd.SVMOutput |
Computes support vector machine based transformation of the input. |
| mx.nd.swapaxes |
Interchanges two axes of an array. |
| mx.nd.SwapAxis |
Interchanges two axes of an array. |
| mx.nd.take |
Takes elements from an input array along the given axis. |
| mx.nd.tan |
Computes the element-wise tangent of the input array. |
| mx.nd.tanh |
Returns the hyperbolic tangent of the input array, computed element-wise. |
| mx.nd.tile |
Repeats the whole array multiple times. If "reps" has length *d*, and input array has dimension of *n*. There are three cases: - **n=d**. Repeat *i*-th dimension of the input by "reps[i]" times:: x = [[1, 2], [3, 4]] tile(x, reps=(2,3)) = [[ 1., 2., 1., 2., 1., 2.], [ 3., 4., 3., 4., 3., 4.], [ 1., 2., 1., 2., 1., 2.], [ 3., 4., 3., 4., 3., 4.]] - **n>d**. "reps" is promoted to length *n* by pre-pending 1's to it. Thus for an input shape "(2,3)", "repos=(2,)" is treated as "(1,2)":: tile(x, reps=(2,)) = [[ 1., 2., 1., 2.], [ 3., 4., 3., 4.]] - **n<d**. The input is promoted to be d-dimensional by prepending new axes. So a shape "(2,2)" array is promoted to "(1,2,2)" for 3-D replication:: tile(x, reps=(2,2,3)) = [[[ 1., 2., 1., 2., 1., 2.], [ 3., 4., 3., 4., 3., 4.], [ 1., 2., 1., 2., 1., 2.], [ 3., 4., 3., 4., 3., 4.]], [[ 1., 2., 1., 2., 1., 2.], [ 3., 4., 3., 4., 3., 4.], [ 1., 2., 1., 2., 1., 2.], [ 3., 4., 3., 4., 3., 4.]]] |
| mx.nd.topk |
Returns the indices of the top *k* elements in an input array along the given axis (by default). If ret_type is set to 'value' returns the value of top *k* elements (instead of indices). In case of ret_type = 'both', both value and index would be returned. The returned elements will be sorted. |
| mx.nd.transpose |
Permutes the dimensions of an array. Examples:: x = [[ 1, 2], [ 3, 4]] transpose(x) = [[ 1., 3.], [ 2., 4.]] x = [[[ 1., 2.], [ 3., 4.]], [[ 5., 6.], [ 7., 8.]]] transpose(x) = [[[ 1., 5.], [ 3., 7.]], [[ 2., 6.], [ 4., 8.]]] transpose(x, axes=(1,0,2)) = [[[ 1., 2.], [ 5., 6.]], [[ 3., 4.], [ 7., 8.]]] |
| mx.nd.trunc |
Return the element-wise truncated value of the input. |
| mx.nd.uniform |
Draw random samples from a uniform distribution. |
| mx.nd.unravel.index |
Converts an array of flat indices into a batch of index arrays. The operator follows numpy conventions so a single multi index is given by a column of the output matrix. The leading dimension may be left unspecified by using -1 as placeholder. |
| mx.nd.UpSampling |
Upsamples the given input data. |
| mx.nd.where |
Return the elements, either from x or y, depending on the condition. |
| mx.nd.zeros |
Generate an mx.nd.array object with zeros |
| mx.nd.zeros.like |
Return an array of zeros with the same shape, type and storage type as the input array. |
| mx.opt.adadelta |
Create an AdaDelta optimizer with respective parameters. |
| mx.opt.adagrad |
Create an AdaGrad optimizer with respective parameters. AdaGrad optimizer of Duchi et al., 2011, |
| mx.opt.adam |
Create an Adam optimizer with respective parameters. Adam optimizer as described in [King2014]. |
| mx.opt.create |
Create an optimizer by name and parameters |
| mx.opt.get.updater |
Get an updater closure that can take list of weight and gradient and return updated list of weight. |
| mx.opt.nag |
Create a Nesterov Accelerated SGD( NAG) optimizer. |
| mx.opt.rmsprop |
Create an RMSProp optimizer with respective parameters. Reference: Tieleman T, Hinton G. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude[J]. COURSERA: Neural Networks for Machine Learning, 2012, 4(2). The code follows: http://arxiv.org/pdf/1308.0850v5.pdf Eq(38) - Eq(45) by Alex Graves, 2013. |
| mx.opt.sgd |
Create an SGD optimizer with respective parameters. Perform SGD with momentum update |
| mx.profiler.config |
Set up the configuration of profiler. |
| mx.profiler.state |
Set up the profiler state to record operator. |
| mx.rnorm |
Generate nomal distribution with mean and sd. |
| mx.runif |
Generate uniform distribution in [low, high) with specified shape. |
| mx.serialize |
Serialize MXNet model into RData-compatiable format. |
| mx.set.seed |
Set the seed used by mxnet device-specific random number generators. |
| mx.simple.bind |
Simple bind the symbol to executor, with information from input shapes. |
| mx.symbol.abs |
abs:Returns element-wise absolute value of the input. |
| mx.symbol.Activation |
Activation:Applies an activation function element-wise to the input. |
| mx.symbol.adam_update |
adam_update:Update function for Adam optimizer. Adam is seen as a generalization of AdaGrad. |
| mx.symbol.add_n |
add_n:Adds all input arguments element-wise. |
| mx.symbol.all_finite |
all_finite:Check if all the float numbers in the array are finite (used for AMP) |
| mx.symbol.amp_cast |
amp_cast:Cast function between low precision float/FP32 used by AMP. |
| mx.symbol.amp_multicast |
amp_multicast:Cast function used by AMP, that casts its inputs to the common widest type. |
| mx.symbol.arccos |
arccos:Returns element-wise inverse cosine of the input array. |
| mx.symbol.arccosh |
arccosh:Returns the element-wise inverse hyperbolic cosine of the input array, \ computed element-wise. |
| mx.symbol.arcsin |
arcsin:Returns element-wise inverse sine of the input array. |
| mx.symbol.arcsinh |
arcsinh:Returns the element-wise inverse hyperbolic sine of the input array, \ computed element-wise. |
| mx.symbol.arctan |
arctan:Returns element-wise inverse tangent of the input array. |
| mx.symbol.arctanh |
arctanh:Returns the element-wise inverse hyperbolic tangent of the input array, \ computed element-wise. |
| mx.symbol.argmax |
argmax:Returns indices of the maximum values along an axis. |
| mx.symbol.argmax_channel |
argmax_channel:Returns argmax indices of each channel from the input array. |
| mx.symbol.argmin |
argmin:Returns indices of the minimum values along an axis. |
| mx.symbol.argsort |
argsort:Returns the indices that would sort an input array along the given axis. |
| mx.symbol.BatchNorm |
BatchNorm:Batch normalization. |
| mx.symbol.BatchNorm_v1 |
BatchNorm_v1:Batch normalization. |
| mx.symbol.batch_dot |
batch_dot:Batchwise dot product. |
| mx.symbol.batch_take |
batch_take:Takes elements from a data batch. |
| mx.symbol.BilinearSampler |
BilinearSampler:Applies bilinear sampling to input feature map. |
| mx.symbol.BlockGrad |
BlockGrad:Stops gradient computation. |
| mx.symbol.broadcast_add |
broadcast_add:Returns element-wise sum of the input arrays with broadcasting. |
| mx.symbol.broadcast_axes |
broadcast_axes:Broadcasts the input array over particular axes. |
| mx.symbol.broadcast_axis |
broadcast_axis:Broadcasts the input array over particular axes. |
| mx.symbol.broadcast_div |
broadcast_div:Returns element-wise division of the input arrays with broadcasting. |
| mx.symbol.broadcast_equal |
broadcast_equal:Returns the result of element-wise **equal to** (==) comparison operation with broadcasting. |
| mx.symbol.broadcast_greater |
broadcast_greater:Returns the result of element-wise **greater than** (>) comparison operation with broadcasting. |
| mx.symbol.broadcast_greater_equal |
broadcast_greater_equal:Returns the result of element-wise **greater than or equal to** (>=) comparison operation with broadcasting. |
| mx.symbol.broadcast_hypot |
broadcast_hypot: Returns the hypotenuse of a right angled triangle, given its "legs" with broadcasting. |
| mx.symbol.broadcast_lesser |
broadcast_lesser:Returns the result of element-wise **lesser than** (<) comparison operation with broadcasting. |
| mx.symbol.broadcast_lesser_equal |
broadcast_lesser_equal:Returns the result of element-wise **lesser than or equal to** (<=) comparison operation with broadcasting. |
| mx.symbol.broadcast_like |
broadcast_like:Broadcasts lhs to have the same shape as rhs. |
| mx.symbol.broadcast_logical_and |
broadcast_logical_and:Returns the result of element-wise **logical and** with broadcasting. |
| mx.symbol.broadcast_logical_or |
broadcast_logical_or:Returns the result of element-wise **logical or** with broadcasting. |
| mx.symbol.broadcast_logical_xor |
broadcast_logical_xor:Returns the result of element-wise **logical xor** with broadcasting. |
| mx.symbol.broadcast_maximum |
broadcast_maximum:Returns element-wise maximum of the input arrays with broadcasting. |
| mx.symbol.broadcast_minimum |
broadcast_minimum:Returns element-wise minimum of the input arrays with broadcasting. |
| mx.symbol.broadcast_minus |
broadcast_minus:Returns element-wise difference of the input arrays with broadcasting. |
| mx.symbol.broadcast_mod |
broadcast_mod:Returns element-wise modulo of the input arrays with broadcasting. |
| mx.symbol.broadcast_mul |
broadcast_mul:Returns element-wise product of the input arrays with broadcasting. |
| mx.symbol.broadcast_not_equal |
broadcast_not_equal:Returns the result of element-wise **not equal to** (!=) comparison operation with broadcasting. |
| mx.symbol.broadcast_plus |
broadcast_plus:Returns element-wise sum of the input arrays with broadcasting. |
| mx.symbol.broadcast_power |
broadcast_power:Returns result of first array elements raised to powers from second array, element-wise with broadcasting. |
| mx.symbol.broadcast_sub |
broadcast_sub:Returns element-wise difference of the input arrays with broadcasting. |
| mx.symbol.broadcast_to |
broadcast_to:Broadcasts the input array to a new shape. |
| mx.symbol.Cast |
Cast:Casts all elements of the input to a new type. |
| mx.symbol.cast |
cast:Casts all elements of the input to a new type. |
| mx.symbol.cast_storage |
cast_storage:Casts tensor storage type to the new type. |
| mx.symbol.cbrt |
cbrt:Returns element-wise cube-root value of the input. |
| mx.symbol.ceil |
ceil:Returns element-wise ceiling of the input. |
| mx.symbol.choose_element_0index |
choose_element_0index:Picks elements from an input array according to the input indices along the given axis. |
| mx.symbol.clip |
clip:Clips (limits) the values in an array. Given an interval, values outside the interval are clipped to the interval edges. Clipping "x" between 'a_min' and 'a_max' would be:: .. math:: clip(x, a_min, a_max) = \max(\min(x, a_max), a_min)) Example:: x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] clip(x,1,8) = [ 1., 1., 2., 3., 4., 5., 6., 7., 8., 8.] The storage type of "clip" output depends on storage types of inputs and the a_min, a_max \ parameter values: - clip(default) = default - clip(row_sparse, a_min <= 0, a_max >= 0) = row_sparse - clip(csr, a_min <= 0, a_max >= 0) = csr - clip(row_sparse, a_min < 0, a_max < 0) = default - clip(row_sparse, a_min > 0, a_max > 0) = default - clip(csr, a_min < 0, a_max < 0) = csr - clip(csr, a_min > 0, a_max > 0) = csr |
| mx.symbol.col2im |
col2im:Combining the output column matrix of im2col back to image array. |
| mx.symbol.Concat |
Perform an feature concat on channel dim (dim 1) over all the inputs. |
| mx.symbol.concat |
Perform an feature concat on channel dim (dim 1) over all the inputs. |
| mx.symbol.Convolution |
Convolution:Compute *N*-D convolution on *(N+2)*-D input. |
| mx.symbol.Convolution_v1 |
Convolution_v1:This operator is DEPRECATED. Apply convolution to input then add a bias. |
| mx.symbol.Correlation |
Correlation:Applies correlation to inputs. |
| mx.symbol.cos |
cos:Computes the element-wise cosine of the input array. |
| mx.symbol.cosh |
cosh:Returns the hyperbolic cosine of the input array, computed element-wise. |
| mx.symbol.Crop |
Crop: |
| mx.symbol.crop |
crop:Slices a region of the array. .. note:: "crop" is deprecated. Use "slice" instead. This function returns a sliced array between the indices given by 'begin' and 'end' with the corresponding 'step'. For an input array of "shape=(d_0, d_1, ..., d_n-1)", slice operation with "begin=(b_0, b_1...b_m-1)", "end=(e_0, e_1, ..., e_m-1)", and "step=(s_0, s_1, ..., s_m-1)", where m <= n, results in an array with the shape "(|e_0-b_0|/|s_0|, ..., |e_m-1-b_m-1|/|s_m-1|, d_m, ..., d_n-1)". The resulting array's *k*-th dimension contains elements from the *k*-th dimension of the input array starting from index "b_k" (inclusive) with step "s_k" until reaching "e_k" (exclusive). If the *k*-th elements are 'None' in the sequence of 'begin', 'end', and 'step', the following rule will be used to set default values. If 's_k' is 'None', set 's_k=1'. If 's_k > 0', set 'b_k=0', 'e_k=d_k'; else, set 'b_k=d_k-1', 'e_k=-1'. The storage type of "slice" output depends on storage types of inputs - slice(csr) = csr - otherwise, "slice" generates output with default storage .. note:: When input data storage type is csr, it only supports step=(), or step=(None,), or step=(1,) to generate a csr output. For other step parameter values, it falls back to slicing a dense tensor. 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.]] slice(x, begin=(None, 0), end=(None, 3), step=(-1, 2)) = [[9., 11.], [5., 7.], [1., 3.]] |
| mx.symbol.CTCLoss |
CTCLoss:Connectionist Temporal Classification Loss. |
| mx.symbol.ctc_loss |
ctc_loss:Connectionist Temporal Classification Loss. |
| mx.symbol.cumsum |
cumsum:Return the cumulative sum of the elements along a given axis. |
| mx.symbol.Custom |
Custom:Apply a custom operator implemented in a frontend language (like Python). |
| mx.symbol.Deconvolution |
Deconvolution:Computes 1D or 2D transposed convolution (aka fractionally strided convolution) of the input tensor. This operation can be seen as the gradient of Convolution operation with respect to its input. Convolution usually reduces the size of the input. Transposed convolution works the other way, going from a smaller input to a larger output while preserving the connectivity pattern. |
| mx.symbol.degrees |
degrees:Converts each element of the input array from radians to degrees. |
| mx.symbol.depth_to_space |
depth_to_space:Rearranges(permutes) data from depth into blocks of spatial data. Similar to ONNX DepthToSpace operator: https://github.com/onnx/onnx/blob/master/docs/Operators.md#DepthToSpace. The output is a new tensor where the values from depth dimension are moved in spatial blocks to height and width dimension. The reverse of this operation is "space_to_depth". .. math:: \begingather* x \prime = reshape(x, [N, block\_size, block\_size, C / (block\_size ^ 2), H * block\_size, W * block\_size]) \ x \prime \prime = transpose(x \prime, [0, 3, 4, 1, 5, 2]) \ y = reshape(x \prime \prime, [N, C / (block\_size ^ 2), H * block\_size, W * block\_size]) \endgather* where :math:'x' is an input tensor with default layout as :math:'[N, C, H, W]': [batch, channels, height, width] and :math:'y' is the output tensor of layout :math:'[N, C / (block\_size ^ 2), H * block\_size, W * block\_size]' Example:: x = [[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]], [[18, 19, 20], [21, 22, 23]]]] depth_to_space(x, 2) = [[[[0, 6, 1, 7, 2, 8], [12, 18, 13, 19, 14, 20], [3, 9, 4, 10, 5, 11], [15, 21, 16, 22, 17, 23]]]] |
| mx.symbol.diag |
diag:Extracts a diagonal or constructs a diagonal array. |
| mx.symbol.dot |
dot:Dot product of two arrays. |
| mx.symbol.Dropout |
Dropout:Applies dropout operation to input array. |
| mx.symbol.ElementWiseSum |
ElementWiseSum:Adds all input arguments element-wise. |
| mx.symbol.elemwise_add |
elemwise_add:Adds arguments element-wise. |
| mx.symbol.elemwise_div |
elemwise_div:Divides arguments element-wise. |
| mx.symbol.elemwise_mul |
elemwise_mul:Multiplies arguments element-wise. |
| mx.symbol.elemwise_sub |
elemwise_sub:Subtracts arguments element-wise. |
| mx.symbol.Embedding |
Embedding:Maps integer indices to vector representations (embeddings). |
| mx.symbol.erf |
erf:Returns element-wise gauss error function of the input. |
| mx.symbol.erfinv |
erfinv:Returns element-wise inverse gauss error function of the input. |
| mx.symbol.exp |
exp:Returns element-wise exponential value of the input. |
| mx.symbol.expand_dims |
expand_dims:Inserts a new axis of size 1 into the array shape For example, given "x" with shape "(2,3,4)", then "expand_dims(x, axis=1)" will return a new array with shape "(2,1,3,4)". |
| mx.symbol.expm1 |
expm1:Returns "exp(x) - 1" computed element-wise on the input. |
| mx.symbol.fill_element_0index |
fill_element_0index:Fill one element of each line(row for python, column for R/Julia) in lhs according to index indicated by rhs and values indicated by mhs. This function assume rhs uses 0-based index. |
| mx.symbol.fix |
fix:Returns element-wise rounded value to the nearest \ integer towards zero of the input. |
| mx.symbol.Flatten |
Flatten:Flattens the input array into a 2-D array by collapsing the higher dimensions. .. note:: 'Flatten' is deprecated. Use 'flatten' instead. For an input array with shape "(d1, d2, ..., dk)", 'flatten' operation reshapes the input array into an output array of shape "(d1, d2*...*dk)". Note that the behavior of this function is different from numpy.ndarray.flatten, which behaves similar to mxnet.ndarray.reshape((-1,)). Example:: x = [[ [1,2,3], [4,5,6], [7,8,9] ], [ [1,2,3], [4,5,6], [7,8,9] ]], flatten(x) = [[ 1., 2., 3., 4., 5., 6., 7., 8., 9.], [ 1., 2., 3., 4., 5., 6., 7., 8., 9.]] |
| mx.symbol.flatten |
flatten:Flattens the input array into a 2-D array by collapsing the higher dimensions. .. note:: 'Flatten' is deprecated. Use 'flatten' instead. For an input array with shape "(d1, d2, ..., dk)", 'flatten' operation reshapes the input array into an output array of shape "(d1, d2*...*dk)". Note that the behavior of this function is different from numpy.ndarray.flatten, which behaves similar to mxnet.ndarray.reshape((-1,)). Example:: x = [[ [1,2,3], [4,5,6], [7,8,9] ], [ [1,2,3], [4,5,6], [7,8,9] ]], flatten(x) = [[ 1., 2., 3., 4., 5., 6., 7., 8., 9.], [ 1., 2., 3., 4., 5., 6., 7., 8., 9.]] |
| mx.symbol.flip |
flip:Reverses the order of elements along given axis while preserving array shape. Note: reverse and flip are equivalent. We use reverse in the following examples. Examples:: x = [[ 0., 1., 2., 3., 4.], [ 5., 6., 7., 8., 9.]] reverse(x, axis=0) = [[ 5., 6., 7., 8., 9.], [ 0., 1., 2., 3., 4.]] reverse(x, axis=1) = [[ 4., 3., 2., 1., 0.], [ 9., 8., 7., 6., 5.]] |
| mx.symbol.floor |
floor:Returns element-wise floor of the input. |
| mx.symbol.ftml_update |
ftml_update:The FTML optimizer described in *FTML - Follow the Moving Leader in Deep Learning*, available at http://proceedings.mlr.press/v70/zheng17a/zheng17a.pdf. |
| mx.symbol.ftrl_update |
ftrl_update:Update function for Ftrl optimizer. Referenced from *Ad Click Prediction: a View from the Trenches*, available at http://dl.acm.org/citation.cfm?id=2488200. |
| mx.symbol.FullyConnected |
FullyConnected:Applies a linear transformation: :math:'Y = XW^T + b'. |
| mx.symbol.gamma |
gamma:Returns the gamma function (extension of the factorial function \ to the reals), computed element-wise on the input array. |
| mx.symbol.gammaln |
gammaln:Returns element-wise log of the absolute value of the gamma function \ of the input. |
| mx.symbol.gather_nd |
gather_nd:Gather elements or slices from 'data' and store to a tensor whose shape is defined by 'indices'. |
| mx.symbol.GridGenerator |
GridGenerator:Generates 2D sampling grid for bilinear sampling. |
| mx.symbol.Group |
Create a symbol that groups symbols together. |
| mx.symbol.GroupNorm |
GroupNorm:Group normalization. |
| mx.symbol.hard_sigmoid |
hard_sigmoid:Computes hard sigmoid of x element-wise. |
| mx.symbol.identity |
identity:Returns a copy of the input. |
| mx.symbol.IdentityAttachKLSparseReg |
IdentityAttachKLSparseReg:Apply a sparse regularization to the output a sigmoid activation function. |
| mx.symbol.im2col |
im2col:Extract sliding blocks from input array. |
| mx.symbol.infer.shape |
Inference the shape of arguments, outputs, and auxiliary states. |
| mx.symbol.InstanceNorm |
InstanceNorm:Applies instance normalization to the n-dimensional input array. |
| mx.symbol.khatri_rao |
khatri_rao:Computes the Khatri-Rao product of the input matrices. |
| mx.symbol.L2Normalization |
L2Normalization:Normalize the input array using the L2 norm. |
| mx.symbol.lamb_update_phase1 |
lamb_update_phase1:Phase I of lamb update it performs the following operations and returns g:. |
| mx.symbol.lamb_update_phase2 |
lamb_update_phase2:Phase II of lamb update it performs the following operations and updates grad. |
| mx.symbol.LayerNorm |
LayerNorm:Layer normalization. |
| mx.symbol.LeakyReLU |
LeakyReLU:Applies Leaky rectified linear unit activation element-wise to the input. |
| mx.symbol.linalg_det |
linalg_det:Compute the determinant of a matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.symbol.linalg_extractdiag |
linalg_extractdiag:Extracts the diagonal entries of a square matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.symbol.linalg_extracttrian |
linalg_extracttrian:Extracts a triangular sub-matrix from a square matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.symbol.linalg_gelqf |
linalg_gelqf:LQ factorization for general matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.symbol.linalg_gemm |
linalg_gemm:Performs general matrix multiplication and accumulation. Input are tensors *A*, *B*, *C*, each of dimension *n >= 2* and having the same shape on the leading *n-2* dimensions. |
| mx.symbol.linalg_gemm2 |
linalg_gemm2:Performs general matrix multiplication. Input are tensors *A*, *B*, each of dimension *n >= 2* and having the same shape on the leading *n-2* dimensions. |
| mx.symbol.linalg_inverse |
linalg_inverse:Compute the inverse of a matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.symbol.linalg_makediag |
linalg_makediag:Constructs a square matrix with the input as diagonal. Input is a tensor *A* of dimension *n >= 1*. |
| mx.symbol.linalg_maketrian |
linalg_maketrian:Constructs a square matrix with the input representing a specific triangular sub-matrix. This is basically the inverse of *linalg.extracttrian*. Input is a tensor *A* of dimension *n >= 1*. |
| mx.symbol.linalg_potrf |
linalg_potrf:Performs Cholesky factorization of a symmetric positive-definite matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.symbol.linalg_potri |
linalg_potri:Performs matrix inversion from a Cholesky factorization. Input is a tensor *A* of dimension *n >= 2*. |
| mx.symbol.linalg_slogdet |
linalg_slogdet:Compute the sign and log of the determinant of a matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.symbol.linalg_sumlogdiag |
linalg_sumlogdiag:Computes the sum of the logarithms of the diagonal elements of a square matrix. Input is a tensor *A* of dimension *n >= 2*. |
| mx.symbol.linalg_syrk |
linalg_syrk:Multiplication of matrix with its transpose. Input is a tensor *A* of dimension *n >= 2*. |
| mx.symbol.linalg_trmm |
linalg_trmm:Performs multiplication with a lower triangular matrix. Input are tensors *A*, *B*, each of dimension *n >= 2* and having the same shape on the leading *n-2* dimensions. |
| mx.symbol.linalg_trsm |
linalg_trsm:Solves matrix equation involving a lower triangular matrix. Input are tensors *A*, *B*, each of dimension *n >= 2* and having the same shape on the leading *n-2* dimensions. |
| mx.symbol.LinearRegressionOutput |
LinearRegressionOutput:Computes and optimizes for squared loss during backward propagation. Just outputs "data" during forward propagation. |
| mx.symbol.load |
Load an mx.symbol object |
| mx.symbol.load.json |
Load an mx.symbol object from a json string |
| mx.symbol.log |
log:Returns element-wise Natural logarithmic value of the input. |
| mx.symbol.log10 |
log10:Returns element-wise Base-10 logarithmic value of the input. |
| mx.symbol.log1p |
log1p:Returns element-wise "log(1 + x)" value of the input. |
| mx.symbol.log2 |
log2:Returns element-wise Base-2 logarithmic value of the input. |
| mx.symbol.logical_not |
logical_not:Returns the result of logical NOT (!) function |
| mx.symbol.LogisticRegressionOutput |
LogisticRegressionOutput:Applies a logistic function to the input. |
| mx.symbol.log_softmax |
log_softmax:Computes the log softmax of the input. This is equivalent to computing softmax followed by log. |
| mx.symbol.LRN |
LRN:Applies local response normalization to the input. |
| mx.symbol.MAERegressionOutput |
MAERegressionOutput:Computes mean absolute error of the input. |
| mx.symbol.MakeLoss |
MakeLoss:Make your own loss function in network construction. |
| mx.symbol.make_loss |
make_loss:Make your own loss function in network construction. |
| mx.symbol.max |
max:Computes the max of array elements over given axes. |
| mx.symbol.max_axis |
max_axis:Computes the max of array elements over given axes. |
| mx.symbol.mean |
mean:Computes the mean of array elements over given axes. |
| mx.symbol.moments |
moments: Calculate the mean and variance of 'data'. |
| mx.symbol.mp_lamb_update_phase1 |
mp_lamb_update_phase1:Mixed Precision version of Phase I of lamb update it performs the following operations and returns g:. |
| mx.symbol.mp_lamb_update_phase2 |
mp_lamb_update_phase2:Mixed Precision version Phase II of lamb update it performs the following operations and updates grad. |
| mx.symbol.mp_nag_mom_update |
mp_nag_mom_update:Update function for multi-precision Nesterov Accelerated Gradient( NAG) optimizer. |
| mx.symbol.mp_sgd_mom_update |
mp_sgd_mom_update:Updater function for multi-precision sgd optimizer |
| mx.symbol.mp_sgd_update |
mp_sgd_update:Updater function for multi-precision sgd optimizer |
| mx.symbol.multi_all_finite |
multi_all_finite:Check if all the float numbers in all the arrays are finite (used for AMP) |
| mx.symbol.multi_lars |
multi_lars:Compute the LARS coefficients of multiple weights and grads from their sums of square" |
| mx.symbol.multi_mp_sgd_mom_update |
multi_mp_sgd_mom_update:Momentum update function for multi-precision Stochastic Gradient Descent (SGD) optimizer. |
| mx.symbol.multi_mp_sgd_update |
multi_mp_sgd_update:Update function for multi-precision Stochastic Gradient Descent (SDG) optimizer. |
| mx.symbol.multi_sgd_mom_update |
multi_sgd_mom_update:Momentum update function for Stochastic Gradient Descent (SGD) optimizer. |
| mx.symbol.multi_sgd_update |
multi_sgd_update:Update function for Stochastic Gradient Descent (SDG) optimizer. |
| mx.symbol.multi_sum_sq |
multi_sum_sq:Compute the sums of squares of multiple arrays |
| mx.symbol.nag_mom_update |
nag_mom_update:Update function for Nesterov Accelerated Gradient( NAG) optimizer. It updates the weights using the following formula, |
| mx.symbol.nanprod |
nanprod:Computes the product of array elements over given axes treating Not a Numbers ("NaN") as one. |
| mx.symbol.nansum |
nansum:Computes the sum of array elements over given axes treating Not a Numbers ("NaN") as zero. |
| mx.symbol.negative |
negative:Numerical negative of the argument, element-wise. |
| mx.symbol.norm |
norm:Computes the norm on an NDArray. |
| mx.symbol.normal |
normal:Draw random samples from a normal (Gaussian) distribution. |
| mx.symbol.ones_like |
ones_like:Return an array of ones with the same shape and type as the input array. |
| mx.symbol.one_hot |
one_hot:Returns a one-hot array. |
| mx.symbol.Pad |
Pad:Pads an input array with a constant or edge values of the array. |
| mx.symbol.pad |
pad:Pads an input array with a constant or edge values of the array. |
| mx.symbol.pick |
pick:Picks elements from an input array according to the input indices along the given axis. |
| mx.symbol.Pooling |
Pooling:Performs pooling on the input. |
| mx.symbol.Pooling_v1 |
Pooling_v1:This operator is DEPRECATED. Perform pooling on the input. |
| mx.symbol.preloaded_multi_mp_sgd_mom_update |
preloaded_multi_mp_sgd_mom_update:Momentum update function for multi-precision Stochastic Gradient Descent (SGD) optimizer. |
| mx.symbol.preloaded_multi_mp_sgd_update |
preloaded_multi_mp_sgd_update:Update function for multi-precision Stochastic Gradient Descent (SDG) optimizer. |
| mx.symbol.preloaded_multi_sgd_mom_update |
preloaded_multi_sgd_mom_update:Momentum update function for Stochastic Gradient Descent (SGD) optimizer. |
| mx.symbol.preloaded_multi_sgd_update |
preloaded_multi_sgd_update:Update function for Stochastic Gradient Descent (SDG) optimizer. |
| mx.symbol.prod |
prod:Computes the product of array elements over given axes. |
| mx.symbol.radians |
radians:Converts each element of the input array from degrees to radians. |
| mx.symbol.random_exponential |
random_exponential:Draw random samples from an exponential distribution. |
| mx.symbol.random_gamma |
random_gamma:Draw random samples from a gamma distribution. |
| mx.symbol.random_generalized_negative_binomial |
random_generalized_negative_binomial:Draw random samples from a generalized negative binomial distribution. |
| mx.symbol.random_negative_binomial |
random_negative_binomial:Draw random samples from a negative binomial distribution. |
| mx.symbol.random_normal |
random_normal:Draw random samples from a normal (Gaussian) distribution. |
| mx.symbol.random_pdf_dirichlet |
random_pdf_dirichlet:Computes the value of the PDF of *sample* of Dirichlet distributions with parameter *alpha*. |
| mx.symbol.random_pdf_exponential |
random_pdf_exponential:Computes the value of the PDF of *sample* of exponential distributions with parameters *lam* (rate). |
| mx.symbol.random_pdf_gamma |
random_pdf_gamma:Computes the value of the PDF of *sample* of gamma distributions with parameters *alpha* (shape) and *beta* (rate). |
| mx.symbol.random_pdf_generalized_negative_binomial |
random_pdf_generalized_negative_binomial:Computes the value of the PDF of *sample* of generalized negative binomial distributions with parameters *mu* (mean) and *alpha* (dispersion). This can be understood as a reparameterization of the negative binomial, where *k* = *1 / alpha* and *p* = *1 / (mu \* alpha + 1)*. |
| mx.symbol.random_pdf_negative_binomial |
random_pdf_negative_binomial:Computes the value of the PDF of samples of negative binomial distributions with parameters *k* (failure limit) and *p* (failure probability). |
| mx.symbol.random_pdf_normal |
random_pdf_normal:Computes the value of the PDF of *sample* of normal distributions with parameters *mu* (mean) and *sigma* (standard deviation). |
| mx.symbol.random_pdf_poisson |
random_pdf_poisson:Computes the value of the PDF of *sample* of Poisson distributions with parameters *lam* (rate). |
| mx.symbol.random_pdf_uniform |
random_pdf_uniform:Computes the value of the PDF of *sample* of uniform distributions on the intervals given by *[low,high)*. |
| mx.symbol.random_poisson |
random_poisson:Draw random samples from a Poisson distribution. |
| mx.symbol.random_randint |
random_randint:Draw random samples from a discrete uniform distribution. |
| mx.symbol.random_uniform |
random_uniform:Draw random samples from a uniform distribution. |
| mx.symbol.ravel_multi_index |
ravel_multi_index:Converts a batch of index arrays into an array of flat indices. The operator follows numpy conventions so a single multi index is given by a column of the input matrix. The leading dimension may be left unspecified by using -1 as placeholder. |
| mx.symbol.rcbrt |
rcbrt:Returns element-wise inverse cube-root value of the input. |
| mx.symbol.reciprocal |
reciprocal:Returns the reciprocal of the argument, element-wise. |
| mx.symbol.relu |
relu:Computes rectified linear activation. |
| mx.symbol.repeat |
repeat:Repeats elements of an array. By default, "repeat" flattens the input array into 1-D and then repeats the elements:: x = [[ 1, 2], [ 3, 4]] repeat(x, repeats=2) = [ 1., 1., 2., 2., 3., 3., 4., 4.] The parameter "axis" specifies the axis along which to perform repeat:: repeat(x, repeats=2, axis=1) = [[ 1., 1., 2., 2.], [ 3., 3., 4., 4.]] repeat(x, repeats=2, axis=0) = [[ 1., 2.], [ 1., 2.], [ 3., 4.], [ 3., 4.]] repeat(x, repeats=2, axis=-1) = [[ 1., 1., 2., 2.], [ 3., 3., 4., 4.]] |
| mx.symbol.reset_arrays |
reset_arrays:Set to zero multiple arrays |
| mx.symbol.Reshape |
Reshape:Reshapes the input array. .. note:: "Reshape" is deprecated, use "reshape" Given an array and a shape, this function returns a copy of the array in the new shape. The shape is a tuple of integers such as (2,3,4). The size of the new shape should be same as the size of the input array. Example:: reshape([1,2,3,4], shape=(2,2)) = [[1,2], [3,4]] 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). |
| mx.symbol.reshape |
reshape:Reshapes the input array. .. note:: "Reshape" is deprecated, use "reshape" Given an array and a shape, this function returns a copy of the array in the new shape. The shape is a tuple of integers such as (2,3,4). The size of the new shape should be same as the size of the input array. Example:: reshape([1,2,3,4], shape=(2,2)) = [[1,2], [3,4]] 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). |
| mx.symbol.reshape_like |
reshape_like:Reshape some or all dimensions of 'lhs' to have the same shape as some or all dimensions of 'rhs'. |
| mx.symbol.reverse |
reverse:Reverses the order of elements along given axis while preserving array shape. Note: reverse and flip are equivalent. We use reverse in the following examples. Examples:: x = [[ 0., 1., 2., 3., 4.], [ 5., 6., 7., 8., 9.]] reverse(x, axis=0) = [[ 5., 6., 7., 8., 9.], [ 0., 1., 2., 3., 4.]] reverse(x, axis=1) = [[ 4., 3., 2., 1., 0.], [ 9., 8., 7., 6., 5.]] |
| mx.symbol.rint |
rint:Returns element-wise rounded value to the nearest integer of the input. |
| mx.symbol.rmspropalex_update |
rmspropalex_update:Update function for RMSPropAlex optimizer. |
| mx.symbol.rmsprop_update |
rmsprop_update:Update function for 'RMSProp' optimizer. |
| mx.symbol.RNN |
RNN:Applies recurrent layers to input data. Currently, vanilla RNN, LSTM and GRU are implemented, with both multi-layer and bidirectional support. |
| mx.symbol.ROIPooling |
ROIPooling:Performs region of interest(ROI) pooling on the input array. |
| mx.symbol.round |
round:Returns element-wise rounded value to the nearest integer of the input. |
| mx.symbol.rsqrt |
rsqrt:Returns element-wise inverse square-root value of the input. |
| mx.symbol.sample_exponential |
sample_exponential:Concurrent sampling from multiple exponential distributions with parameters lambda (rate). |
| mx.symbol.sample_gamma |
sample_gamma:Concurrent sampling from multiple gamma distributions with parameters *alpha* (shape) and *beta* (scale). |
| mx.symbol.sample_generalized_negative_binomial |
sample_generalized_negative_binomial:Concurrent sampling from multiple generalized negative binomial distributions with parameters *mu* (mean) and *alpha* (dispersion). |
| mx.symbol.sample_multinomial |
sample_multinomial:Concurrent sampling from multiple multinomial distributions. |
| mx.symbol.sample_negative_binomial |
sample_negative_binomial:Concurrent sampling from multiple negative binomial distributions with parameters *k* (failure limit) and *p* (failure probability). |
| mx.symbol.sample_normal |
sample_normal:Concurrent sampling from multiple normal distributions with parameters *mu* (mean) and *sigma* (standard deviation). |
| mx.symbol.sample_poisson |
sample_poisson:Concurrent sampling from multiple Poisson distributions with parameters lambda (rate). |
| mx.symbol.sample_uniform |
sample_uniform:Concurrent sampling from multiple uniform distributions on the intervals given by *[low,high)*. |
| mx.symbol.save |
Save an mx.symbol object |
| mx.symbol.scatter_nd |
scatter_nd:Scatters data into a new tensor according to indices. |
| mx.symbol.SequenceLast |
SequenceLast:Takes the last element of a sequence. |
| mx.symbol.SequenceMask |
SequenceMask:Sets all elements outside the sequence to a constant value. |
| mx.symbol.SequenceReverse |
SequenceReverse:Reverses the elements of each sequence. |
| mx.symbol.sgd_mom_update |
sgd_mom_update:Momentum update function for Stochastic Gradient Descent (SGD) optimizer. |
| mx.symbol.sgd_update |
sgd_update:Update function for Stochastic Gradient Descent (SGD) optimizer. |
| mx.symbol.shape_array |
shape_array:Returns a 1D int64 array containing the shape of data. |
| mx.symbol.shuffle |
shuffle:Randomly shuffle the elements. |
| mx.symbol.sigmoid |
sigmoid:Computes sigmoid of x element-wise. |
| mx.symbol.sign |
sign:Returns element-wise sign of the input. |
| mx.symbol.signsgd_update |
signsgd_update:Update function for SignSGD optimizer. |
| mx.symbol.signum_update |
signum_update:SIGN momentUM (Signum) optimizer. |
| mx.symbol.sin |
sin:Computes the element-wise sine of the input array. |
| mx.symbol.sinh |
sinh:Returns the hyperbolic sine of the input array, computed element-wise. |
| mx.symbol.size_array |
size_array:Returns a 1D int64 array containing the size of data. |
| mx.symbol.slice |
slice:Slices a region of the array. .. note:: "crop" is deprecated. Use "slice" instead. This function returns a sliced array between the indices given by 'begin' and 'end' with the corresponding 'step'. For an input array of "shape=(d_0, d_1, ..., d_n-1)", slice operation with "begin=(b_0, b_1...b_m-1)", "end=(e_0, e_1, ..., e_m-1)", and "step=(s_0, s_1, ..., s_m-1)", where m <= n, results in an array with the shape "(|e_0-b_0|/|s_0|, ..., |e_m-1-b_m-1|/|s_m-1|, d_m, ..., d_n-1)". The resulting array's *k*-th dimension contains elements from the *k*-th dimension of the input array starting from index "b_k" (inclusive) with step "s_k" until reaching "e_k" (exclusive). If the *k*-th elements are 'None' in the sequence of 'begin', 'end', and 'step', the following rule will be used to set default values. If 's_k' is 'None', set 's_k=1'. If 's_k > 0', set 'b_k=0', 'e_k=d_k'; else, set 'b_k=d_k-1', 'e_k=-1'. The storage type of "slice" output depends on storage types of inputs - slice(csr) = csr - otherwise, "slice" generates output with default storage .. note:: When input data storage type is csr, it only supports step=(), or step=(None,), or step=(1,) to generate a csr output. For other step parameter values, it falls back to slicing a dense tensor. 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.]] slice(x, begin=(None, 0), end=(None, 3), step=(-1, 2)) = [[9., 11.], [5., 7.], [1., 3.]] |
| mx.symbol.SliceChannel |
SliceChannel:Splits an array along a particular axis into multiple sub-arrays. |
| mx.symbol.slice_axis |
slice_axis:Slices along a given axis. Returns an array slice along a given 'axis' starting from the 'begin' index to the 'end' index. Examples:: x = [[ 1., 2., 3., 4.], [ 5., 6., 7., 8.], [ 9., 10., 11., 12.]] slice_axis(x, axis=0, begin=1, end=3) = [[ 5., 6., 7., 8.], [ 9., 10., 11., 12.]] slice_axis(x, axis=1, begin=0, end=2) = [[ 1., 2.], [ 5., 6.], [ 9., 10.]] slice_axis(x, axis=1, begin=-3, end=-1) = [[ 2., 3.], [ 6., 7.], [ 10., 11.]] |
| mx.symbol.slice_like |
slice_like:Slices a region of the array like the shape of another array. This function is similar to "slice", however, the 'begin' are always '0's and 'end' of specific axes are inferred from the second input 'shape_like'. Given the second 'shape_like' input of "shape=(d_0, d_1, ..., d_n-1)", a "slice_like" operator with default empty 'axes', it performs the following operation: " out = slice(input, begin=(0, 0, ..., 0), end=(d_0, d_1, ..., d_n-1))". When 'axes' is not empty, it is used to speficy which axes are being sliced. Given a 4-d input data, "slice_like" operator with "axes=(0, 2, -1)" will perform the following operation: " out = slice(input, begin=(0, 0, 0, 0), end=(d_0, None, d_2, d_3))". Note that it is allowed to have first and second input with different dimensions, however, you have to make sure the 'axes' are specified and not exceeding the dimension limits. For example, given 'input_1' with "shape=(2,3,4,5)" and 'input_2' with "shape=(1,2,3)", it is not allowed to use: " out = slice_like(a, b)" because ndim of 'input_1' is 4, and ndim of 'input_2' is 3. The following is allowed in this situation: " out = slice_like(a, b, axes=(0, 2))" Example:: x = [[ 1., 2., 3., 4.], [ 5., 6., 7., 8.], [ 9., 10., 11., 12.]] y = [[ 0., 0., 0.], [ 0., 0., 0.]] slice_like(x, y) = [[ 1., 2., 3.] [ 5., 6., 7.]] slice_like(x, y, axes=(0, 1)) = [[ 1., 2., 3.] [ 5., 6., 7.]] slice_like(x, y, axes=(0)) = [[ 1., 2., 3., 4.] [ 5., 6., 7., 8.]] slice_like(x, y, axes=(-1)) = [[ 1., 2., 3.] [ 5., 6., 7.] [ 9., 10., 11.]] |
| mx.symbol.smooth_l1 |
smooth_l1:Calculate Smooth L1 Loss(lhs, scalar) by summing |
| mx.symbol.Softmax |
Softmax:Computes the gradient of cross entropy loss with respect to softmax output. |
| mx.symbol.softmax |
softmax:Applies the softmax function. |
| mx.symbol.SoftmaxActivation |
SoftmaxActivation:Applies softmax activation to input. This is intended for internal layers. |
| mx.symbol.SoftmaxOutput |
SoftmaxOutput:Computes the gradient of cross entropy loss with respect to softmax output. |
| mx.symbol.softmax_cross_entropy |
softmax_cross_entropy:Calculate cross entropy of softmax output and one-hot label. |
| mx.symbol.softmin |
softmin:Applies the softmin function. |
| mx.symbol.softsign |
softsign:Computes softsign of x element-wise. |
| mx.symbol.sort |
sort:Returns a sorted copy of an input array along the given axis. |
| mx.symbol.space_to_depth |
space_to_depth:Rearranges(permutes) blocks of spatial data into depth. Similar to ONNX SpaceToDepth operator: https://github.com/onnx/onnx/blob/master/docs/Operators.md#SpaceToDepth The output is a new tensor where the values from height and width dimension are moved to the depth dimension. The reverse of this operation is "depth_to_space". .. math:: \begingather* x \prime = reshape(x, [N, C, H / block\_size, block\_size, W / block\_size, block\_size]) \ x \prime \prime = transpose(x \prime, [0, 3, 5, 1, 2, 4]) \ y = reshape(x \prime \prime, [N, C * (block\_size ^ 2), H / block\_size, W / block\_size]) \endgather* where :math:'x' is an input tensor with default layout as :math:'[N, C, H, W]': [batch, channels, height, width] and :math:'y' is the output tensor of layout :math:'[N, C * (block\_size ^ 2), H / block\_size, W / block\_size]' Example:: x = [[[[0, 6, 1, 7, 2, 8], [12, 18, 13, 19, 14, 20], [3, 9, 4, 10, 5, 11], [15, 21, 16, 22, 17, 23]]]] space_to_depth(x, 2) = [[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]], [[18, 19, 20], [21, 22, 23]]]] |
| mx.symbol.SpatialTransformer |
SpatialTransformer:Applies a spatial transformer to input feature map. |
| mx.symbol.split |
split:Splits an array along a particular axis into multiple sub-arrays. |
| mx.symbol.sqrt |
sqrt:Returns element-wise square-root value of the input. |
| mx.symbol.square |
square:Returns element-wise squared value of the input. |
| mx.symbol.squeeze |
squeeze:Remove single-dimensional entries from the shape of an array. Same behavior of defining the output tensor shape as numpy.squeeze for the most of cases. See the following note for exception. Examples:: data = [[[0], [1], [2]]] squeeze(data) = [0, 1, 2] squeeze(data, axis=0) = [[0], [1], [2]] squeeze(data, axis=2) = [[0, 1, 2]] squeeze(data, axis=(0, 2)) = [0, 1, 2] .. Note:: The output of this operator will keep at least one dimension not removed. For example, squeeze([[[4]]]) = [4], while in numpy.squeeze, the output will become a scalar. |
| mx.symbol.stack |
stack:Join a sequence of arrays along a new axis. The axis parameter specifies the index of the new axis in the dimensions of the result. For example, if axis=0 it will be the first dimension and if axis=-1 it will be the last dimension. Examples:: x = [1, 2] y = [3, 4] stack(x, y) = [[1, 2], [3, 4]] stack(x, y, axis=1) = [[1, 3], [2, 4]] |
| mx.symbol.stop_gradient |
stop_gradient:Stops gradient computation. |
| mx.symbol.sum |
sum:Computes the sum of array elements over given axes. |
| mx.symbol.sum_axis |
sum_axis:Computes the sum of array elements over given axes. |
| mx.symbol.SVMOutput |
SVMOutput:Computes support vector machine based transformation of the input. |
| mx.symbol.swapaxes |
swapaxes:Interchanges two axes of an array. |
| mx.symbol.SwapAxis |
SwapAxis:Interchanges two axes of an array. |
| mx.symbol.take |
take:Takes elements from an input array along the given axis. |
| mx.symbol.tan |
tan:Computes the element-wise tangent of the input array. |
| mx.symbol.tanh |
tanh:Returns the hyperbolic tangent of the input array, computed element-wise. |
| mx.symbol.tile |
tile:Repeats the whole array multiple times. If "reps" has length *d*, and input array has dimension of *n*. There are three cases: - **n=d**. Repeat *i*-th dimension of the input by "reps[i]" times:: x = [[1, 2], [3, 4]] tile(x, reps=(2,3)) = [[ 1., 2., 1., 2., 1., 2.], [ 3., 4., 3., 4., 3., 4.], [ 1., 2., 1., 2., 1., 2.], [ 3., 4., 3., 4., 3., 4.]] - **n>d**. "reps" is promoted to length *n* by pre-pending 1's to it. Thus for an input shape "(2,3)", "repos=(2,)" is treated as "(1,2)":: tile(x, reps=(2,)) = [[ 1., 2., 1., 2.], [ 3., 4., 3., 4.]] - **n<d**. The input is promoted to be d-dimensional by prepending new axes. So a shape "(2,2)" array is promoted to "(1,2,2)" for 3-D replication:: tile(x, reps=(2,2,3)) = [[[ 1., 2., 1., 2., 1., 2.], [ 3., 4., 3., 4., 3., 4.], [ 1., 2., 1., 2., 1., 2.], [ 3., 4., 3., 4., 3., 4.]], [[ 1., 2., 1., 2., 1., 2.], [ 3., 4., 3., 4., 3., 4.], [ 1., 2., 1., 2., 1., 2.], [ 3., 4., 3., 4., 3., 4.]]] |
| mx.symbol.topk |
topk:Returns the indices of the top *k* elements in an input array along the given axis (by default). If ret_type is set to 'value' returns the value of top *k* elements (instead of indices). In case of ret_type = 'both', both value and index would be returned. The returned elements will be sorted. |
| mx.symbol.transpose |
transpose:Permutes the dimensions of an array. Examples:: x = [[ 1, 2], [ 3, 4]] transpose(x) = [[ 1., 3.], [ 2., 4.]] x = [[[ 1., 2.], [ 3., 4.]], [[ 5., 6.], [ 7., 8.]]] transpose(x) = [[[ 1., 5.], [ 3., 7.]], [[ 2., 6.], [ 4., 8.]]] transpose(x, axes=(1,0,2)) = [[[ 1., 2.], [ 5., 6.]], [[ 3., 4.], [ 7., 8.]]] |
| mx.symbol.trunc |
trunc:Return the element-wise truncated value of the input. |
| mx.symbol.uniform |
uniform:Draw random samples from a uniform distribution. |
| mx.symbol.unravel_index |
unravel_index:Converts an array of flat indices into a batch of index arrays. The operator follows numpy conventions so a single multi index is given by a column of the output matrix. The leading dimension may be left unspecified by using -1 as placeholder. |
| mx.symbol.UpSampling |
UpSampling:Upsamples the given input data. |
| mx.symbol.Variable |
Create a symbolic variable with specified name. |
| mx.symbol.where |
where:Return the elements, either from x or y, depending on the condition. |
| mx.symbol.zeros_like |
zeros_like:Return an array of zeros with the same shape, type and storage type as the input array. |
| mx.unserialize |
Unserialize MXNet model from Robject. |
| mxnet |
MXNet: Flexible and Efficient GPU computing and Deep Learning. |
| mxnet.export |
Internal function to generate mxnet_generated.R Users do not need to call this function. |
![[R logo]](../../../doc/html/Rlogo.svg)
![[Up]](../../../doc/html/left.jpg)
![[Top]](../../../doc/html/up.jpg)