Math
ClipByAvgNorm
Clips tensor values to a maximum average L2-norm.
x (NUMERIC) - Input variable
clipValue - Value for clipping
dimensions - Dimensions to reduce over (Size: AtLeast(min=0))
EmbeddingLookup
Looks up ids in a list of embedding tensors.
x (NUMERIC) - Input tensor
indices (INT) - A Tensor containing the ids to be looked up.
PartitionMode - partition_mode == 0 - i.e. 'mod' , 1 - 'div'
MergeMaxIndex
Return array of max elements indices with along tensor dimensions
x (NUMERIC) - Input tensor
dataType - Data type - default = DataType.INT
abs
Elementwise absolute value operation: out = abs(x)
x (NUMERIC) - Input variable
acos
Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)
x (NUMERIC) - Input variable
acosh
Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)
x (NUMERIC) - Input variable
add
Pairwise addition operation, out = x + y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
x (NUMERIC) - Input variable
y (NUMERIC) - Input variable
add
Scalar add operation, out = in + scalar
x (NUMERIC) - Input variable
value - Scalar value for op
amax
Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))
in (NUMERIC) - Input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
amean
Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))
in (NUMERIC) - Input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
amin
Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))
in (NUMERIC) - Input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
and
Boolean AND operation: elementwise (x != 0) && (y != 0)
If x and y arrays have equal shape, the output shape is the same as these inputs.
Note: supports broadcasting if x and y have different shapes and are broadcastable.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
x (BOOL) - Input 1
y (BOOL) - Input 2
asin
Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)
x (NUMERIC) - Input variable
asinh
Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)
x (NUMERIC) - Input variable
asum
Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))
in (NUMERIC) - Input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
atan
Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)
x (NUMERIC) - Input variable
atan2
Elementwise atan (arctangent, inverse tangent) operation: out = atan2(x,y).
Similar to atan(y/x) but sigts of x and y are used to determine the location of the result
y (NUMERIC) - Input Y variable
x (NUMERIC) - Input X variable
atanh
Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)
x (NUMERIC) - Input variable
bitShift
Bit shift operation
x (NUMERIC) - input
shift (NUMERIC) - shift value
bitShiftRight
Right bit shift operation
x (NUMERIC) - Input tensor
shift (NUMERIC) - shift argument
bitShiftRotl
Cyclic bit shift operation
x (NUMERIC) - Input tensor
shift (NUMERIC) - shift argy=ument
bitShiftRotr
Cyclic right shift operation
x (NUMERIC) - Input tensor
shift (NUMERIC) - Shift argument
ceil
Element-wise ceiling function: out = ceil(x).
Rounds each value up to the nearest integer value (if not already an integer)
x (NUMERIC) - Input variable
clipByNorm
Clipping by L2 norm, optionally along dimension(s)
if l2Norm(x,dimension) < clipValue, then input is returned unmodifed
Otherwise, out[i] = in[i] * clipValue / l2Norm(in, dimensions) where each value is clipped according
to the corresponding l2Norm along the specified dimensions
x (NUMERIC) - Input variable
clipValue - Clipping value (maximum l2 norm)
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
clipByValue
Element-wise clipping function:
out[i] = in[i] if in[i] >= clipValueMin and in[i] <= clipValueMax
out[i] = clipValueMin if in[i] < clipValueMin
out[i] = clipValueMax if in[i] > clipValueMax
x (NUMERIC) - Input variable
clipValueMin - Minimum value for clipping
clipValueMax - Maximum value for clipping
confusionMatrix
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values. This version assumes the number of classes is 1 + max(max(labels), max(pred))
For example, if labels = [0, 1, 1] and predicted = [0, 2, 1] then output is:
[1, 0, 0]
[0, 1, 1]
[0, 0, 0]
labels (NUMERIC) - Labels - 1D array of integer values representing label values
pred (NUMERIC) - Predictions - 1D array of integer values representing predictions. Same length as labels
dataType - Data type
confusionMatrix
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.
For example, if labels = [0, 1, 1], predicted = [0, 2, 1], and numClasses=4 then output is:
[1, 0, 0, 0]
[0, 1, 1, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
labels (NUMERIC) - Labels - 1D array of integer values representing label values
pred (NUMERIC) - Predictions - 1D array of integer values representing predictions. Same length as labels
numClasses - Number of classes
confusionMatrix
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values. This version assumes the number of classes is 1 + max(max(labels), max(pred))
For example, if labels = [0, 1, 1], predicted = [0, 2, 1] and weights = [1, 2, 3]
[1, 0, 0]
[0, 3, 2]
[0, 0, 0]
labels (NUMERIC) - Labels - 1D array of integer values representing label values
pred (NUMERIC) - Predictions - 1D array of integer values representing predictions. Same length as labels
weights (NUMERIC) - Weights - 1D array of values (may be real/decimal) representing the weight/contribution of each prediction. Must be same length as both labels and predictions arrays
confusionMatrix
Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.
For example, if labels = [0, 1, 1], predicted = [0, 2, 1], numClasses = 4, and weights = [1, 2, 3]
[1, 0, 0, 0]
[0, 3, 2, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
labels (NUMERIC) - Labels - 1D array of integer values representing label values
pred (NUMERIC) - Predictions - 1D array of integer values representing predictions. Same length as labels
weights (NUMERIC) - Weights - 1D array of values (may be real/decimal) representing the weight/contribution of each prediction. Must be same length as both labels and predictions arrays
numClasses -
cos
Elementwise cosine operation: out = cos(x)
x (NUMERIC) - Input variable
cosh
Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)
x (NUMERIC) - Input variable
cosineDistance
Cosine distance reduction operation. The output contains the cosine distance for each
tensor/subset along the specified dimensions:
out = 1.0 - cosineSimilarity(x,y)
x (NUMERIC) - Input variable x
y (NUMERIC) - Input variable y
dimensions - Dimensions to calculate cosineDistance over (Size: AtLeast(min=0))
cosineSimilarity
Cosine similarity pairwise reduction operation. The output contains the cosine similarity for each tensor/subset
along the specified dimensions:
out = (sum_i x[i] y[i]) / ( sqrt(sum_i x[i]^2) sqrt(sum_i y[i]^2)
x (NUMERIC) - Input variable x
y (NUMERIC) - Input variable y
dimensions - Dimensions to calculate cosineSimilarity over (Size: AtLeast(min=0))
countNonZero
Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)
in (NUMERIC) - Input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
countZero
Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)
in (NUMERIC) - Input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
cross
Returns the pair-wise cross product of equal size arrays a and b: a x b = ||a||x||b|| sin(theta).
Can take rank 1 or above inputs (of equal shapes), but note that the last dimension must have dimension 3
a (NUMERIC) - First input
b (NUMERIC) - Second input
cube
Element-wise cube function: out = x^3
x (NUMERIC) - Input variable
diag
Returns an output variable with diagonal values equal to the specified values; off-diagonal values will be set to 0
For example, if input = [1,2,3], then output is given by:
[ 1, 0, 0]
[ 0, 2, 0]
[ 0, 0, 3]
Higher input ranks are also supported: if input has shape [a,...,R-1] then output[i,...,k,i,...,k] = input[i,...,k].
i.e., for input rank R, output has rank 2R
x (NUMERIC) - Input variable
diagPart
Extract the diagonal part from the input array.
If input is
[ 1, 0, 0]
[ 0, 2, 0]
[ 0, 0, 3]
then output is [1, 2, 3].
Supports higher dimensions: in general, out[i,...,k] = in[i,...,k,i,...,k]
x (NUMERIC) - Input variable
div
Pairwise division operation, out = x / y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
x (NUMERIC) - Input variable
y (NUMERIC) - Input variable
div
Scalar division operation, out = in / scalar
x (NUMERIC) - Input variable
value - Scalar value for op
entropy
Entropy reduction: -sum(x * log(x))
in (NUMERIC) - Input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
erf
Element-wise Gaussian error function - out = erf(in)
x (NUMERIC) - Input variable
erfc
Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)
x (NUMERIC) - Input variable
euclideanDistance
Euclidean distance (l2 norm, l2 distance) reduction operation. The output contains the Euclidean distance for each
tensor/subset along the specified dimensions:
out = sqrt( sum_i (x[i] - y[i])^2 )
x (NUMERIC) - Input variable x
y (NUMERIC) - Input variable y
dimensions - Dimensions to calculate euclideanDistance over (Size: AtLeast(min=0))
exp
Elementwise exponent function: out = exp(x) = 2.71828...^x
x (NUMERIC) - Input variable
expm1
Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^x
x (NUMERIC) - Input variable
eye
Generate an identity matrix with the specified number of rows and columns.
rows - Number of rows
eye
As per eye(String, int, int, DataType) but with the default datatype, Eye.DEFAULT_DTYPE
rows - Number of rows
cols - Number of columns
eye
Generate an identity matrix with the specified number of rows and columns
Example:
rows - Number of rows
cols - Number of columns
dataType - Data type
dimensions - (Size: AtLeast(min=0))
eye
As per eye(int, int) bit with the number of rows/columns specified as scalar INDArrays
rows (INT) - Number of rows
cols (INT) - Number of columns
eye
As per eye(String, int) but with the number of rows specified as a scalar INDArray
rows (INT) - Number of rows
firstIndex
First index reduction operation.
Returns a variable that contains the index of the first element that matches the specified condition (for each
slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1. This can be useful for later broadcast operations (such as subtracting
the mean along a dimension).
Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
keepDims = true: [a,1,c]
keepDims = false: [a,c]
in (NUMERIC) - Input variable
condition - Condition to check on input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=1))
keepDims - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensions - default = false
floor
Element-wise floor function: out = floor(x).
Rounds each value down to the nearest integer value (if not already an integer)
x (NUMERIC) - Input variable
floorDiv
Pairwise floor division operation, out = floor(x / y)
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
x (NUMERIC) - Input variable
y (NUMERIC) - Input variable
floorMod
Pairwise Modulus division operation
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
x (NUMERIC) - Input variable
y (NUMERIC) - Input variable
floorMod
Scalar floor modulus operation
x (NUMERIC) - Input variable
value - Scalar value for op
hammingDistance
Hamming distance reduction operation. The output contains the cosine distance for each
tensor/subset along the specified dimensions:
out = count( x[i] != y[i] )
x (NUMERIC) - Input variable x
y (NUMERIC) - Input variable y
dimensions - Dimensions to calculate hammingDistance over (Size: AtLeast(min=0))
iamax
Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)
in (NUMERIC) - Input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=1))
keepDims - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensions - default = false
iamin
Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)
in (NUMERIC) - Input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=1))
keepDims - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensions - default = false
isFinite
Is finite operation: elementwise isFinite(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or
value 0 otherwise
x (NUMERIC) - Input variable
isInfinite
Is infinite operation: elementwise isInfinite(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or
value 0 otherwise
x (NUMERIC) - Input variable
isMax
Is maximum operation: elementwise x == max(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or
value 0 otherwise
x (NUMERIC) - Input variable
isNaN
Is Not a Number operation: elementwise isNaN(x)
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or
value 0 otherwise
x (NUMERIC) - Input variable
isNonDecreasing
Is the array non decreasing?
An array is non-decreasing if for every valid i, x[i] <= x[i+1]. For Rank 2+ arrays, values are compared
in 'c' (row major) order
x (NUMERIC) - Input variable
isStrictlyIncreasing
Is the array strictly increasing?
An array is strictly increasing if for every valid i, x[i] < x[i+1]. For Rank 2+ arrays, values are compared
in 'c' (row major) order
x (NUMERIC) - Input variable
jaccardDistance
Jaccard similarity reduction operation. The output contains the Jaccard distance for each
x (NUMERIC) - Input variable x
y (NUMERIC) - Input variable y
dimensions - Dimensions to calculate jaccardDistance over (Size: AtLeast(min=0))
lastIndex
Last index reduction operation.
Returns a variable that contains the index of the last element that matches the specified condition (for each
slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1. This can be useful for later broadcast operations (such as subtracting
the mean along a dimension).
Example: if input has shape [a,b,c] and dimensions=[1] then output has shape:
keepDims = true: [a,1,c]
keepDims = false: [a,c]
in (NUMERIC) - Input variable
condition - Condition to check on input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=1))
keepDims - If true: keep the dimensions that are reduced on (as length 1). False: remove the reduction dimensions - default = false
listDiff
Calculates difference between inputs X and Y.
x (NUMERIC) - Input variable X
y (NUMERIC) - Input variable Y
log
Element-wise logarithm function (base e - natural logarithm): out = log(x)
x (NUMERIC) - Input variable
log
Element-wise logarithm function (with specified base): out = log_{base`(x)
x (NUMERIC) - Input variable
base - Logarithm base
log1p
Elementwise natural logarithm function: out = log_e (1 + x)
x (NUMERIC) - Input variable
logEntropy
Log entropy reduction: log(-sum(x * log(x)))
in (NUMERIC) - Input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
logSumExp
Log-sum-exp reduction (optionally along dimension).
Computes log(sum(exp(x))
input (NUMERIC) - Input variable
dimensions - Optional dimensions to reduce along (Size: AtLeast(min=0))
manhattanDistance
Manhattan distance (l1 norm, l1 distance) reduction operation. The output contains the Manhattan distance for each
tensor/subset along the specified dimensions:
out = sum_i abs(x[i]-y[i])
x (NUMERIC) - Input variable x
y (NUMERIC) - Input variable y
dimensions - Dimensions to calculate manhattanDistance over (Size: AtLeast(min=0))
matrixDeterminant
Matrix determinant op. For 2D input, this returns the standard matrix determinant.
For higher dimensional input with shape [..., m, m] the matrix determinant is returned for each
shape [m,m] sub-matrix.
in (NUMERIC) - Input
matrixInverse
Matrix inverse op. For 2D input, this returns the standard matrix inverse.
For higher dimensional input with shape [..., m, m] the matrix inverse is returned for each
shape [m,m] sub-matrix.
in (NUMERIC) - Input
max
Pairwise max operation, out = max(x, y)
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
x (NUMERIC) - First input variable, x
y (NUMERIC) - Second input variable, y
mergeAdd
Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition:
out = sum_i in[i]
inputs (NUMERIC) - Input variables
mergeAvg
Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation:
out = mean_i in[i]
inputs (NUMERIC) - Input variables
mergeMax
Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation:
out = max_i in[i]
inputs (NUMERIC) - Input variables
meshgrid
Broadcasts parameters for evaluation on an N-D grid.
inputs (NUMERIC) -
cartesian -
min
Pairwise max operation, out = min(x, y)
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
x (NUMERIC) - First input variable, x
y (NUMERIC) - Second input variable, y
mod
Pairwise modulus (remainder) operation, out = x % y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
x (NUMERIC) - Input variable
y (NUMERIC) - Input variable
moments
Calculate the mean and (population) variance for the input variable, for the specified axis
input (NUMERIC) - Input to calculate moments for
axes - Dimensions to perform calculation over (Size: AtLeast(min=0))
mul
Pairwise multiplication operation, out = x * y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
x (NUMERIC) - Input variable
y (NUMERIC) - Input variable
mul
Scalar multiplication operation, out = in * scalar
x (NUMERIC) - Input variable
value - Scalar value for op
neg
Elementwise negative operation: out = -x
x (NUMERIC) - Input variable
normalizeMoments
Calculate the mean and variance from the sufficient statistics
counts (NUMERIC) - Rank 0 (scalar) value with the total number of values used to calculate the sufficient statistics
means (NUMERIC) - Mean-value sufficient statistics: this is the SUM of all data values
variances (NUMERIC) - Variaance sufficient statistics: this is the squared sum of all data values
shift - Shift value, possibly 0, used when calculating the sufficient statistics (for numerical stability)
or
Boolean OR operation: elementwise (x != 0) || (y != 0)
If x and y arrays have equal shape, the output shape is the same as these inputs.
Note: supports broadcasting if x and y have different shapes and are broadcastable.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
x (BOOL) - Input 1
y (BOOL) - Input 2
pow
Element-wise power function: out = x^value
x (NUMERIC) - Input variable
value - Scalar value for op
pow
Element-wise (broadcastable) power function: out = x[i]^y[i]
x (NUMERIC) - Input variable
y (NUMERIC) - Power
rationalTanh
Rational Tanh Approximation elementwise function, as described in the paper:
Compact Convolutional Neural Network Cascade for Face Detection
This is a faster Tanh approximation
x (NUMERIC) - Input variable
rdiv
Pairwise reverse division operation, out = y / x
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
x (NUMERIC) - Input variable
y (NUMERIC) - Input variable
rdiv
Scalar reverse division operation, out = scalar / in
x (NUMERIC) - Input variable
value - Scalar value for op
reciprocal
Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]
x (NUMERIC) - Input variable
rectifiedTanh
Rectified tanh operation: max(0, tanh(in))
x (NUMERIC) - Input variable
round
Element-wise round function: out = round(x).
Rounds (up or down depending on value) to the nearest integer value.
x (NUMERIC) - Input variable
rsqrt
Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)
x (NUMERIC) - Input variable
rsub
Pairwise reverse subtraction operation, out = y - x
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
x (NUMERIC) - Input variable
y (NUMERIC) - Input variable
rsub
Scalar reverse subtraction operation, out = scalar - in
x (NUMERIC) - Input variable
value - Scalar value for op
setDiag
Set the diagonal value to the specified values
If input is
[ a, b, c]
[ d, e, f]
[ g, h, i]
and diag = [ 1, 2, 3] then output is
[ 1, b, c]
[ d, 2, f]
[ g, h, 3]
in (NUMERIC) - Input variable
diag (NUMERIC) - Diagonal
shannonEntropy
Shannon Entropy reduction: -sum(x * log2(x))
in (NUMERIC) - Input variable
dimensions - Dimensions to reduce over. If dimensions are not specified, full array reduction is performed (Size: AtLeast(min=0))
sign
Element-wise sign (signum) function:
out = -1 if in < 0
out = 0 if in = 0
out = 1 if in > 0
x (NUMERIC) - Input variable
sin
Elementwise sine operation: out = sin(x)
x (NUMERIC) - Input variable
sinh
Elementwise sinh (hyperbolic sine) operation: out = sinh(x)
x (NUMERIC) - Input variable
sqrt
Element-wise square root function: out = sqrt(x)
x (NUMERIC) - Input variable
square
Element-wise square function: out = x^2
x (NUMERIC) - Input variable
squaredDifference
Pairwise squared difference operation.
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
x (NUMERIC) - Input variable
y (NUMERIC) - Input variable
standardize
Standardize input variable along given axis
out = (x - mean) / stdev
with mean and stdev being calculated along the given dimension.
For example: given x as a mini batch of the shape [numExamples, exampleLength]:
use dimension 1 too use the statistics (mean, stdev) for each example
use dimension 0 if you want to use the statistics for each column across all examples
use dimensions 0,1 if you want to use the statistics across all columns and examples
x (NUMERIC) - Input variable
dimensions - (Size: AtLeast(min=1))
step
Elementwise step function:
out(x) = 1 if x >= cutoff
out(x) = 0 otherwise
x (NUMERIC) - Input variable
value - Scalar value for op
sub
Pairwise subtraction operation, out = x - y
Note: supports broadcasting if x and y have different shapes and are broadcastable.
For example, if X has shape [1,10] and Y has shape [5,10] then op(X,Y) has output shape [5,10]
Broadcast rules are the same as NumPy: https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html
x (NUMERIC) - Input variable
y (NUMERIC) - Input variable
sub
Scalar subtraction operation, out = in - scalar
x (NUMERIC) - Input variable
value - Scalar value for op
tan
Elementwise tangent operation: out = tan(x)
x (NUMERIC) - Input variable
tanh
Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)
x (NUMERIC) - Input variable
trace
Matrix trace operation
For rank 2 matrices, the output is a scalar vith the trace - i.e., sum of the main diagonal.
For higher rank inputs, output[a,b,c] = trace(in[a,b,c,:,:])
in (NUMERIC) - Input variable
xor
Boolean XOR (exclusive OR) operation: elementwise (x != 0) XOR (y != 0)
If x and y arrays have equal shape, the output shape is the same as these inputs.
Note: supports broadcasting if x and y have different shapes and are broadcastable.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.
x (BOOL) - Input 1
y (BOOL) - Input 2
zeroFraction
Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))
input (NUMERIC) - Input variable