Uses of Class
org.nd4j.autodiff.samediff.SDVariable
-
-
Uses of SDVariable in org.nd4j.autodiff.functions
Methods in org.nd4j.autodiff.functions that return SDVariable Modifier and Type Method Description SDVariableDifferentialFunction. arg()Return the first argumentSDVariableDifferentialFunction. arg(int num)Return the specified argument for this functionSDVariable[]DifferentialFunction. args()Return the arguments for a given functionSDVariableDifferentialFunction. larg()The left argument for this functionSDVariableDifferentialFunction. outputVariable()SDVariable[]DifferentialFunction. outputVariables()Return the output variables for this differential function.abstract SDVariable[]DifferentialFunction. outputVariables(String baseName)Return the output functions for this differential function.SDVariableDifferentialFunction. rarg()The right argument for this function.Methods in org.nd4j.autodiff.functions that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>DifferentialFunction. diff(List<SDVariable> i_v1)Perform automatic differentiation wrt the input variablesabstract List<SDVariable>DifferentialFunction. doDiff(List<SDVariable> f1)The actual implementation for automatic differentiation.List<SDVariable>DifferentialFunction. outputs()Methods in org.nd4j.autodiff.functions with parameters of type SDVariable Modifier and Type Method Description voidDifferentialFunction. replaceArg(int i, SDVariable newArg)Replace argument at the specified indexMethod parameters in org.nd4j.autodiff.functions with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>DifferentialFunction. diff(List<SDVariable> i_v1)Perform automatic differentiation wrt the input variablesabstract List<SDVariable>DifferentialFunction. doDiff(List<SDVariable> f1)The actual implementation for automatic differentiation.Constructors in org.nd4j.autodiff.functions with parameters of type SDVariable Constructor Description DifferentialFunction(SameDiff sameDiff, boolean inPlace, SDVariable[] args)Add the various arguments for this functionDifferentialFunction(SameDiff sameDiff, SDVariable[] args) -
Uses of SDVariable in org.nd4j.autodiff.listeners
Methods in org.nd4j.autodiff.listeners with parameters of type SDVariable Modifier and Type Method Description ListenerVariables.BuilderListenerVariables.Builder. evaluationVariables(@NonNull SDVariable... variables)Add required variables for evaluationListenerVariables.BuilderListenerVariables.Builder. inferenceVariables(@NonNull SDVariable... variables)Add required variables for inferenceListenerVariables.BuilderListenerVariables.Builder. requireVariables(@NonNull Operation op, @NonNull SDVariable... variables)Add required variables for the specified opListenerEvaluations.BuilderListenerEvaluations.Builder. trainEvaluation(@NonNull SDVariable variable, int labelIndex, @NonNull IEvaluation... evaluations)Add requested training evaluations for a parm/variableListenerVariables.BuilderListenerVariables.Builder. trainingVariables(@NonNull SDVariable... variables)Add required variables for trainingListenerEvaluations.BuilderListenerEvaluations.Builder. validationEvaluation(@NonNull SDVariable variable, int labelIndex, @NonNull IEvaluation... evaluations)Add requested validation evaluations for a parm/variableListenerVariables.BuilderListenerVariables.Builder. validationVariables(@NonNull SDVariable... variables)Add required variables for validation -
Uses of SDVariable in org.nd4j.autodiff.listeners.records
Methods in org.nd4j.autodiff.listeners.records with parameters of type SDVariable Modifier and Type Method Description <T extends IEvaluation>
TEvaluationRecord. evaluation(SDVariable param)Get the evaluation for a given param/variableIEvaluationEvaluationRecord. evaluation(SDVariable param, int index)Get the evaluation for param at the specified index<T extends IEvaluation<T>>
TEvaluationRecord. evaluation(SDVariable param, Class<T> evalClass)Get the evaluation of a given type, for a given param/variableList<IEvaluation>EvaluationRecord. evaluations(SDVariable param)Get evaluations for a given param/variabledoubleEvaluationRecord. getValue(SDVariable param, int index, IMetric metric)Get the metric's value for the evaluation for a given param/variable at the given indexdoubleEvaluationRecord. getValue(SDVariable param, IMetric metric)Get the metric's value for the evaluation of the metric's type, for a given param/variabledoubleLossCurve. lastMeanDelta(SDVariable loss)Return the loss delta between the last epoch and the one before it, for a given variable.floatLossCurve. lastMeanLoss(@NonNull SDVariable loss)Return the mean loss value for a given variable on the last epoch.float[]LossCurve. meanLoss(@NonNull SDVariable loss)Return all mean loss values for a given variablefloatLossCurve. meanLoss(@NonNull SDVariable loss, int epoch)Return the mean loss value for a given variable on a given epoch.List<IEvaluation>History. trainingEval(SDVariable param)Get the results of a training evaluation on a given parameter Only works if there is only one evaluation for param.List<IEvaluation>History. trainingEval(SDVariable param, int index)Get the results of a training evaluation on a given parameter at a given index Note that it returns all recorded evaluations.List<Double>History. trainingEval(SDVariable param, int index, IMetric metric)Get the results of a training evaluation on a given parameter at a given index, for a given metric Note that it returns all recorded evaluations.List<Double>History. trainingEval(SDVariable param, IMetric metric)Get the results of a training evaluation on a given parameter for a given metric Only works if there is only one evaluation with the given metric for paramList<IEvaluation>History. validationEval(SDVariable param)Get the results of a validation evaluation on a given parameter Only works if there is only one evaluation for param.List<IEvaluation>History. validationEval(SDVariable param, int index)Get the results of a validation evaluation on a given parameter at a given index Note that it returns all recorded evaluations.List<Double>History. validationEval(SDVariable param, int index, IMetric metric)Get the results of a validation evaluation on a given parameter at a given index, for a given metric Note that it returns all recorded evaluations.List<Double>History. validationEval(SDVariable param, IMetric metric)Get the results of a validation evaluation on a given parameter for a given metric Only works if there is only one evaluation with the given metric for param -
Uses of SDVariable in org.nd4j.autodiff.samediff
Methods in org.nd4j.autodiff.samediff with type parameters of type SDVariable Modifier and Type Method Description <X extends SDVariable>
XSameDiff. setupFunction(X function)Attempts to insert theDifferentialFunctionreference in to thisSameDiffinstance.Methods in org.nd4j.autodiff.samediff that return SDVariable Modifier and Type Method Description SDVariableSDVariable. add(double scalar)SDVariableSDVariable. add(String varName, double scalar)Scalar addition:out = this + scalar
Output variable has the same shape as the input variableSDVariableSDVariable. add(String name, SDVariable x)Addition operation: elementwisethis + x
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. add(SDVariable other)SDVariableSameDiff. addVariable(SDVariable variable)Add the specified variable to this SameDiff instanceSDVariableSDVariable. argmax(int... dimensions)SDVariableSDVariable. argmax(String name, boolean keepDims, int... dimensions)Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.SDVariableSDVariable. argmax(String name, int... dimensions)SDVariableSDVariable. argmin(int... dimensions)SDVariableSDVariable. argmin(String name, boolean keepDims, int... dimensions)Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.SDVariableSDVariable. argmin(String name, int... dimensions)static SDVariable[]ControlFlow. args(SDVariable maxIterations, SDVariable condIn, SDVariable startIterations, SDVariable[] extraArgs)Create the arguments used inControlFlow.condBody()andControlFlow.loopWithConditions(String[], String, SameDiff, SameDiff, String, SDVariable[], String[], String[])SDVariableSDVariable. assign(Number value)Return a variable with equal shape to the input, but all elements set to the specified valueSDVariableSDVariable. castTo(@NonNull DataType dataType)SDVariableSDVariable. castTo(String name, @NonNull DataType dataType)SDVariableSDVariable. clone(String name, SameDiff sd)SDVariableSDVariable. clone(SameDiff sd)SDVariableSameDiff. constant(boolean value)Create a new long scalar constant (rank 0) with the specified valueSDVariableSameDiff. constant(double value)Create a new double scalar constant (rank 0) with the specified value.
Constants are not modified by training/backprop.SDVariableSameDiff. constant(float value)Create a new float scalar constant (rank 0) with the specified value
Constants are not modified by training/backprop.SDVariableSameDiff. constant(int value)Create a new integer scalar constant (rank 0) with the specified valueSDVariableSameDiff. constant(long value)Create a new long scalar constant (rank 0) with the specified valueSDVariableSameDiff. constant(@NonNull INDArray constant)Create an SDVariable with a fixed/constant value, with a generated name
Constants are not modified by training/backprop.SDVariableSameDiff. constant(String name, boolean value)Create a new long scalar constant (rank 0) with the specified valueSDVariableSameDiff. constant(String name, double value)Create a new double scalar constant (rank 0) with the specified valueSDVariableSameDiff. constant(String name, float value)Create a new float scalar constant (rank 0) with the specified valueSDVariableSameDiff. constant(String name, int value)Create a new integer scalar constant (rank 0) with the specified valueSDVariableSameDiff. constant(String name, long value)Create a new long scalar constant (rank 0) with the specified valueSDVariableSameDiff. constant(String name, @NonNull INDArray constant)Create an SDVariable with a fixed/constant value
Constants are not modified by training/backprop.SDVariableSameDiff. constant(String name, DataType dataType, Number value)Create a new scalar constant (rank 0) with the specified value and datatypeSDVariableSameDiff. convertToConstant(@NonNull SDVariable variable)Convert the specified variable to a constant.SDVariableSDVariable. convertToConstant()Convert this variable to a constant.SDVariableSameDiff. convertToVariable(@NonNull SDVariable constant)Convert the specified variable to a VARIABLE type SDVariable.
This can only be done for constants and placeholders, not ARRAY type variables (which are usually network activations).SDVariableSDVariable. convertToVariable()Convert this variable to a VARIABLE type SDVariable.
This can only be done for constants and placeholders, not ARRAY type variables (which are usually network activations).SDVariableSameDiff. createSequence(String name, INDArray[] arrays)Creates a sequence variable based on the input arrays.SDVariableSameDiff. createSequence(INDArray[] arrays)Create a new sequence variable usingSameDiff.createSequence(String, INDArray[])SDVariable[]SameDiffFunctionDefinition. define(SameDiff sameDiff, Map<String,INDArray> inputs, SDVariable[] variableInputs)SDVariable[]SameDiffLambda. define(SameDiff sameDiff, SDVariable[] inputs)SDVariableSameDiffNoArgSingleLambda. define(SameDiff sameDiff)SDVariableSameDiffSingleLambda. define(SameDiff sameDiff, SDVariable[] inputs)SDVariableSDVariable. div(double scalar)SDVariableSDVariable. div(String varName, double scalar)Scalar division:out = this / scalar
Output variable has the same shape as the input variableSDVariableSDVariable. div(String name, SDVariable x)Division operation: elementwisethis / x
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. div(SDVariable x)SDVariableSDVariable. dot(String name, SDVariable other, int... dimensions)Matrix dot product: out = dot(this,other, dimensions)SDVariableSDVariable. dot(SDVariable other, int... dimensions)SDVariableSDVariable. dup()Create a new SDVariable, the contents of which is copied from this current variableSDVariableSDVariable. eq(double value)SDVariableSDVariable. eq(String name, double value)Equals operation: elementwisethis == value
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwiseSDVariableSDVariable. eq(String name, SDVariable other)Equal to operation: elementwisethis == y
If x and y arrays have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if x and y have different shapes and are broadcastable, the output shape is broadcast.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.SDVariableSDVariable. eq(SDVariable other)SDVariableSameDiffConditional. eval(SameDiff context, SameDiffFunctionDefinition body, SDVariable[] inputVars)SDVariableSDVariable. fdiv(String name, SDVariable x)Floor division operation: elementwisethis // x
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariable[]SameDiff. generateOutputVariableForOp(DifferentialFunction function)Generate the variables based on the given input op and return the output variable names.SDVariable[]SameDiff. generateOutputVariableForOp(DifferentialFunction function, String baseName, boolean isImport)Generate the variables based on the given input op and return the output variable names.SDVariableSDVariable. get(SDIndex... indices)Get a variable with content equal to a specified sub-array of this variable.
Can be used (for example) to get rows, columns, sub-matrices, etc.SDVariableSDVariable. get(SDVariable indices)Get a variable with content equal to a specified sub-array of this variable.
Can be used (for example) to get rows, columns, sub-matrices, etc.SDVariableSameDiff. getGradForVariable(String varName)Get the gradient for the variable with the specified name.
The gradient variable is the variable that represents the derivative of the loss function with respect to the output of this variable.SDVariableSDVariable. getGradient()The gradient variable is the variable that represents the derivative of the loss function with respect to the output of this variable.SDVariable[]SameDiff. getInputVariablesForOp(DifferentialFunction function)Get the input variable(s) for the specified differential functionSDVariable[]SameDiff. getOutputVariablesForOp(DifferentialFunction function)Get the output variable(s) for the specified differential functionSDVariableSameDiff. getVariable(String name)Get the variable based on the opNameSDVariableSDVariable. getView(SDIndex... indices)Get a variable with content equal to a specified sub-array of this variable.
Can be used (for example) to get rows, columns, sub-matrices, etc.SDVariableSameDiff. grad(String varName)Get the gradient for the variable with the specified variable name.SDVariableSDVariable. gradient()Alias for the gradient variable - same asgetGradient().SDVariableSDVariable. gt(double value)SDVariableSDVariable. gt(String name, double value)Greater than operation: elementwisethis > value
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwiseSDVariableSDVariable. gt(String name, SDVariable other)Greater than operation: elementwisethis > y
If x and y arrays have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if x and y have different shapes and are broadcastable, the output shape is broadcast.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.SDVariableSDVariable. gt(SDVariable other)SDVariableSDVariable. gte(double value)SDVariableSDVariable. gte(String name, double value)Greater than or equals operation: elementwisethis >= value
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwiseSDVariableSDVariable. gte(String name, SDVariable other)Greater than or equal to operation: elementwisethis >= y
If x and y arrays have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if x and y have different shapes and are broadcastable, the output shape is broadcast.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.SDVariableSDVariable. gte(SDVariable other)static SDVariableControlFlow. ifCond(SameDiff sameDiff, String outputName, String ifName, @NonNull SameDiffNoArgSingleLambda cond, @NonNull SameDiffNoArgSingleLambda trueBody, @NonNull SameDiffNoArgSingleLambda falseBody)Constructs a If statement using the tensorflow style control flow operations (Switch and Merge) If the result of cond is true, returns the result of trueBody, otherwise returns the result of falseBody Note that cond and body lambdas are only called once to construct the graph.SDVariableSameDiff. ifCond(@NonNull SameDiffNoArgSingleLambda cond, @NonNull SameDiffNoArgSingleLambda trueBody, @NonNull SameDiffNoArgSingleLambda falseBody)SDVariableSameDiff. ifCond(String ifName, @NonNull SameDiffNoArgSingleLambda cond, @NonNull SameDiffNoArgSingleLambda trueBody, @NonNull SameDiffNoArgSingleLambda falseBody)SDVariableSameDiff. ifCond(String outputName, String ifName, @NonNull SameDiffNoArgSingleLambda cond, @NonNull SameDiffNoArgSingleLambda trueBody, @NonNull SameDiffNoArgSingleLambda falseBody)Constructs a If statement using the tensorflow style control flow operations (Switch and Merge) If the result of cond is true, returns the result of trueBody, otherwise returns the result of falseBody Note that cond and body lambdas are only called once to construct the graph.static SDVariable[]ControlFlow. initializeLoopBody(String[] namesToUse, SameDiff loopBody, int maxIterations)Initializes the loop variables with default parameters.static SDVariable[]ControlFlow. initializeLoopBody(String[] namesToUse, SameDiff loopBody, int maxIterations, boolean extraCond)Initializes the loop variables with default parameters.SDVariableArgumentInterceptor. intercept(SDVariable argument)SDVariable[]SameDiff. invoke(String[] desiredOutputNames, Invoke.InvokeParams invokeParams)Invoke a sub graph and return the outputs aliased as outputs specified in the parent graph.SDVariable[]SameDiff. invoke(Invoke.InvokeParams invokeParams)Invoke a sub graph and return the outputs aliased as outputs specified in the parent graph.SDVariableSameDiff. invokeFunctionOn(String functionName, SameDiff with)SDVariableSameDiff. invokeGraphOn(SameDiff sameDiff)SDVariableSDVariable. length()Return the total number of elements in this arraystatic SDVariable[]ControlFlow. loopWithConditions(String[] outputVarNames, String loopName, SameDiff parent, SameDiff functionBody, String functionName, SDVariable[] loopVars, String[] functionBodyInputs, String[] functionBodyOutputs)Loop with conditions allows a user to provide a lambda to invoke any number of times.static SDVariable[]ControlFlow. loopWithConditions(ControlFlow.LoopParams loopParams)A simplified function usingControlFlow.LoopParamsinvoking the same function asControlFlow.loopWithConditions(String[], String, SameDiff, SameDiff, String, SDVariable[], String[], String[])SDVariable[]SameDiff. loopWithConditions(String[] outputNames, ControlFlow.LoopParams loopParams)Loop with conditions.SDVariable[]SameDiff. loopWithConditions(ControlFlow.LoopParams loopParams)Loop with conditions.SDVariableSDVariable. lt(double value)SDVariableSDVariable. lt(String name, double value)Less than operation: elementwisethis < value
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwiseSDVariableSDVariable. lt(String name, SDVariable other)Less than operation: elementwisethis < y
If x and y arrays have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if x and y have different shapes and are broadcastable, the output shape is broadcast.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.SDVariableSDVariable. lt(SDVariable other)SDVariableSDVariable. lte(double value)SDVariableSDVariable. lte(String name, double value)Less than or equals operation: elementwisethis <= value
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwiseSDVariableSDVariable. lte(String name, SDVariable other)Less than or equal to operation: elementwisethis <= y
If x and y arrays have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if x and y have different shapes and are broadcastable, the output shape is broadcast.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.SDVariableSDVariable. lte(SDVariable other)SDVariableSDVariable. max(boolean keepDims, int... dimensions)SDVariableSDVariable. max(int... dimensions)SDVariableSDVariable. max(String name, boolean keepDims, int... dimensions)Maximum array reduction operation, optionally along 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.SDVariableSDVariable. max(String name, int... dimensions)SDVariableSDVariable. mean(boolean keepDims, int... dimensions)SDVariableSDVariable. mean(int... dimensions)SDVariableSDVariable. mean(String name, boolean keepDims, int... dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDVariable. mean(String name, int... dimensions)SDVariableSDVariable. min(boolean keepDims, int... dimensions)SDVariableSDVariable. min(int... dimensions)SDVariableSDVariable. min(String name, boolean keepDims, int... dimensions)Minimum array reduction operation, optionally along specified dimensions.SDVariableSDVariable. min(String name, int... dimensions)SDVariableSDVariable. minus(double other)For Kotlin operator interopSDVariableSDVariable. minus(SDVariable other)For Kotlin operator interopSDVariableSDVariable. mmul(String name, SDVariable other)Matrix multiplication: out = mmul(this,other)SDVariableSDVariable. mmul(String name, SDVariable other, @NonNull MMulTranspose mMulTranspose)Matrix multiplication: out = mmul(this,other)SDVariableSDVariable. mmul(SDVariable other)SDVariableSDVariable. mod(String name, SDVariable x)Modulo operation: elementwisethis / x
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. mul(double scalar)SDVariableSDVariable. mul(String varName, double scalar)Scalar multiplication:out = this * scalar
Output variable has the same shape as the input variableSDVariableSDVariable. mul(String name, SDVariable x)Multiplication operation: elementwisethis * x
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. mul(SDVariable x)SDVariableSDVariable. neg()Negate op - returns a new variable with the values of the current variable negatedSDVariableSDVariable. neg(String name)Negate op - returns a new variable with the values of the current variable negatedSDVariableSDVariable. neq(double value)Seeneq(SDVariable)SDVariableSDVariable. neq(String name, double value)Not equals operation: elementwisethis != value
Returns an array with the same shape/size as the input, with values 1 where condition is satisfied, or value 0 otherwiseSDVariableSDVariable. neq(String name, SDVariable other)Not equal to operation: elementwisethis != y
If x and y arrays have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if x and y have different shapes and are broadcastable, the output shape is broadcast.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.SDVariableSDVariable. neq(SDVariable other)SDVariableSDVariable. norm1(boolean keepDims, int... dimensions)SDVariableSDVariable. norm1(int... dimensions)SDVariableSDVariable. norm1(String name, boolean keepDims, int... dimensions)Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i])
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.SDVariableSDVariable. norm1(String name, int... dimensions)SDVariableSDVariable. norm2(boolean keepDims, int... dimensions)SDVariableSDVariable. norm2(int... dimensions)SDVariableSDVariable. norm2(String name, boolean keepDims, int... dimensions)Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2)
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.SDVariableSDVariable. norm2(String name, int... dimensions)SDVariableSDVariable. normmax(boolean keepDims, int... dimensions)SDVariableSDVariable. normmax(int... dimensions)SDVariableSDVariable. normmax(String name, boolean keepDims, int... dimensions)Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the specified dimensions:
out = max(abs(x[i]))
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1.SDVariableSDVariable. normmax(String name, int... dimensions)SDVariableSameDiff. one(String name, int... shape)SDVariableSameDiff. one(String name, long... shape)SDVariableSameDiff. one(String name, DataType dataType, int... shape)Create a new variable with the specified shape, with all values initialized to 1.0.SDVariableSameDiff. one(String name, DataType dataType, long... shape)Create a new variable with the specified shape, with all values initialized to 1.0.SDVariableSDVariable. permute(int... dimensions)Permute the dimensions of the current variable according to the specified permutation indices.
Example: if the current variable has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]SDVariableSDVariable. permute(SDVariable dimensions)SDVariableSameDiff. placeHolder(@NonNull String name, DataType dataType, long... shape)Create a a placeholder variable.SDVariableSDVariable. plus(double other)For Kotlin operator interopSDVariableSDVariable. plus(SDVariable other)For Kotlin operator interopSDVariableSDVariable. pow(double scalar)SDVariableSDVariable. pow(String varName, double scalar)Scalar power operation:out = this ^ scalar
Output variable has the same shape as the input variableSDVariableSDVariable. prod(boolean keepDims, int... dimensions)SDVariableSDVariable. prod(int... dimensions)SDVariableSDVariable. prod(String name, boolean keepDims, int... dimensions)Product array reduction operation, optionally along 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.SDVariableSDVariable. prod(String name, int... dimensions)SDVariableSDVariable. put(SDVariable indices, SDVariable toPut, SDVariable putIndices)Get a variable with content equal to a specified sub-array of this variable.
Can be used (for example) to get rows, columns, sub-matrices, etc.SDVariableSDVariable. rank()Get the rank of this variable as a dynamic SDVariableSDVariableSDVariable. rdiv(double scalar)SDVariableSDVariable. rdiv(String varName, double scalar)Scalar reverse division:out = scalar / this
Output variable has the same shape as the input variableSDVariableSDVariable. rdiv(String name, SDVariable x)Reverse division operation: elementwisex / this
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. rdiv(SDVariable sameDiffVariable)SDVariableSDVariable. rename(String newName)Rename this variable to a new name.SDVariableSDVariable. reshape(int... newShape)Reshape the current variable to the specified shape.SDVariableSDVariable. reshape(long... newShape)Reshape the current variable to the specified shape.SDVariableSDVariable. reshape(String name, SDVariable newShape)Reshape the current variable to the specified (dynamic) shape.SDVariableSDVariable. reshape(SDVariable newShape)Reshape the current variable to the specified (dynamic) shape.SDVariableSDVariable. rsub(double scalar)SDVariableSDVariable. rsub(String varName, double scalar)Scalar reverse subtraction:out = scalar - this
Output variable has the same shape as the input variableSDVariableSDVariable. rsub(String name, SDVariable x)Reverse subtraction operation: elementwisex - this
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. rsub(SDVariable x)SDVariableSameDiff. scalar(String name, double value)Create a new double scalar (rank 0) SDVariable with the specified valueSDVariableSameDiff. scalar(String name, float value)Create a new float scalar (rank 0) SDVariable with the specified valueSDVariableSameDiff. scalar(String name, int value)Create a new integer scalar (rank 0) SDVariable with the specified valueSDVariableSameDiff. scalar(String name, long value)Create a new long scalar (rank 0) SDVariable with the specified valueSDVariableSameDiff. scalar(String name, DataType dataType, Number value)Create a new scalar (rank 0) SDVariable with the specified value and datatypeSDVariableSDVariable. setArray(INDArray array)Associate the specified array with this variableSDVariableSDVariable. shape()Get the shape of the array as a dynamic SDVariablestatic SDVariableSDVariable. sliceEnd(SDVariable input, SDVariable sliceIndexInput)SDVariableSDVariable. squaredDifference(String name, SDVariable x)Squared difference operation:(this - x)^2SDVariableSDVariable. squaredDifference(SDVariable x)SDVariableSDVariable. std(boolean biasCorrected, int... dimensions)SDVariableSDVariable. std(String name, boolean biasCorrected, boolean keepDims, int... dimensions)Stardard deviation array reduction operation, optionally along 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.SDVariableSDVariable. std(String name, boolean biasCorrected, int... dimensions)SDVariableSDVariable. sub(double scalar)SDVariableSDVariable. sub(String varName, double scalar)Scalar subtraction:out = this - scalar
Output variable has the same shape as the input variableSDVariableSDVariable. sub(String name, SDVariable x)Subtraction operation: elementwisethis - x
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. sub(SDVariable x)SDVariableSDVariable. sum(boolean keepDims, int... dimensions)SDVariableSDVariable. sum(int... dimensions)SDVariableSDVariable. sum(String name, boolean keepDims, int... dimensions)Sum array reduction operation, optionally along 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.SDVariableSDVariable. sum(String name, int... dimensions)SDVariableSDVariable. times(double other)For Kotlin operator interopSDVariableSDVariable. times(SDVariable other)For Kotlin operator interopSDVariable[]ControlFlow.LoopArgs. toArgs()SDVariableSameDiff. updateVariableNameAndReference(SameDiffOp opToRename, SDVariable varToUpdate, String newVarName)Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.SDVariableSameDiff. updateVariableNameAndReference(SameDiffOp opToRename, SDVariable varToUpdate, String newVarName, boolean exactName)Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.SDVariableSameDiff. updateVariableNameAndReference(SDVariable varToUpdate, String newVarName)Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.SDVariableSameDiff. updateVariableNameAndReference(SDVariable varToUpdate, String newVarName, boolean exactName)Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.SDVariable[]SameDiff. updateVariableNamesAndReferences(SDVariable[] variablesToUpdate, String[] newVariableNames)Updates the variable name property on the passed in variables, its reference in samediff, and returns the variable.SDVariableSameDiff. var(@NonNull String name, @NonNull VariableType variableType, WeightInitScheme weightInitScheme, DataType dataType, long... shape)Variable initialization with a specifiedWeightInitSchemeThis method creates VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.SDVariableSameDiff. var(@NonNull String name, @NonNull LongShapeDescriptor shape, WeightInitScheme weightInitScheme)Creates aSDVariablewith the given shape and name
The underlying array will be initialized using the specified weight initilization scheme
This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.SDVariableSameDiff. var(@NonNull String name, @NonNull WeightInitScheme weightInitScheme, @lombok.NonNull long... shape)Variable initialization with a specifiedWeightInitScheme.SDVariableSameDiff. var(@NonNull String name, @NonNull WeightInitScheme weightInitScheme, @NonNull DataType dataType, @lombok.NonNull long... shape)Variable initialization with a specifiedWeightInitSchemeThis method creates VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.SDVariableSameDiff. var(@NonNull SDVariable v)Initialize aSDVariablereference tying this variable to this samediff instance.SDVariableSameDiff. var(String name, int... shape)Creates aSDVariablewith the given shape and name
Any array will be generated with all zeros for the values.SDVariableSameDiff. var(String name, long... shape)Creates aSDVariablewith the given shape and name
Any array will be generated with all zeros for the values.SDVariableSameDiff. var(String name, @NonNull INDArray arr)Create anSDVariablewith the specified name, and associate the specified array with it
This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.SDVariableSameDiff. var(String name, DataType dataType, int... shape)Creates aSDVariablewith the given shape and name
Any array will be generated with all zeros for the valuesSDVariableSameDiff. var(String name, DataType dataType, long... shape)Creates aSDVariablewith the given shape and name
Any array will be generated with all zeros for the values
This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.SDVariableSameDiff. var(String name, LongShapeDescriptor shapeDesc)Creates aSDVariablewith the given shape and name
Any array will be generated with all zeros for the values
This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.SDVariableSameDiff. var(DataType dataType, int... shape)Creates aSDVariablewith the specified shape and a generated name
Any array will be generated with all zeros for the values
This method creates a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.SDVariableSameDiff. var(DataType dataType, long... shape)Creates aSDVariablewith the specified shape and a generated name
Any array will be generated with all zeros for the values
This method creates a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.SDVariableSameDiff. var(INDArray arr)Create anSDVariablewith a generated name, and assocate the specified array with it.
This is a VARIABLE type SDVariable - i.e., must be floating point, and is a trainable parameter.SDVariableSameDiff. var(WeightInitScheme weightInitScheme, DataType dataType, long... shape)Creates aSDVariablewith the specified shape and a generated name.static SDVariable[]ControlFlow. whileLoop(SameDiff sameDiff, String[] outputNames, String loopName, @NonNull SDVariable[] loopVars, @NonNull SameDiffSingleLambda cond, @NonNull SameDiffLambda body)Constructs a While loop using the tensorflow style control flow operations (Switch, Merge, Enter, Exit, and NextIteration)SDVariable[]SameDiff. whileLoop(@NonNull SDVariable[] loopVars, @NonNull SameDiffSingleLambda cond, @NonNull SameDiffLambda body)SDVariable[]SameDiff. whileLoop(String[] outputNames, String loopName, @NonNull SDVariable[] loopVars, @NonNull SameDiffSingleLambda cond, @NonNull SameDiffLambda body)Constructs a While loop using the tensorflow style control flow operations (Switch, Merge, Enter, Exit, and NextIteration) Repeatedly executes body on the loop variables and updates them with the results, until cond evaluates to false Note that cond and body lambdas are only called once to construct the graph.SDVariable[]SameDiff. whileLoop(String loopName, @NonNull SDVariable[] loopVars, @NonNull SameDiffSingleLambda cond, @NonNull SameDiffLambda body)SDVariableSameDiff. zero(String name, int... shape)SDVariableSameDiff. zero(String name, long... shape)SDVariableSameDiff. zero(String name, DataType dataType, int... shape)Create a new variable with the specified shape, with all values initialized to 0.SDVariableSameDiff. zero(String name, DataType dataType, long... shape)Create a new variable with the specified shape, with all values initialized to 0.Methods in org.nd4j.autodiff.samediff that return types with arguments of type SDVariable Modifier and Type Method Description Set<SDVariable>SameDiff. constants()Returns the constants in this graphList<SDVariable>SameDiff. getVariablesInScope(String scope)List<SDVariable>SameDiff. getVariablesInScope(NameScope scope)Gets all variables in a given name scope.Set<SDVariable>SameDiff. placeHolders()Returns the placeholders in this graphMap<String,SDVariable>SameDiff. variableMap()Return a copy of the internal variable mapList<SDVariable>SameDiff. variables()The list of all variables in the graphMethods in org.nd4j.autodiff.samediff with parameters of type SDVariable Modifier and Type Method Description SDVariableSDVariable. add(String name, SDVariable x)Addition operation: elementwisethis + x
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. add(SDVariable other)voidSameDiff. addArgsFor(SDVariable[] variables, DifferentialFunction function)Adds incoming arguments for the specified differential function to the graphvoidSDVariable. addControlDependency(SDVariable controlDependency)Add a control dependency for this variable on the specified variable.
Control dependencies can be used to enforce the execution order.voidSameDiff. addLossVariable(@NonNull SDVariable variable)voidSameDiff. addOutgoingFor(SDVariable[] variables, DifferentialFunction function)Adds outgoing arguments to the graph for the specified DifferentialFunction Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.SDVariableSameDiff. addVariable(SDVariable variable)Add the specified variable to this SameDiff instancestatic SDVariable[]ControlFlow. args(SDVariable maxIterations, SDVariable condIn, SDVariable startIterations, SDVariable[] extraArgs)Create the arguments used inControlFlow.condBody()andControlFlow.loopWithConditions(String[], String, SameDiff, SameDiff, String, SDVariable[], String[], String[])static ControlFlow.LoopLambdaArgsControlFlow. argsFromInputs(SDVariable[] inputs)CreateControlFlow.LoopLambdaArgsfrom the given arguments.voidSameDiff. assignArray(@NonNull INDArray arr, @NonNull SDVariable variable)Update the constant or variable type SDVariable with the values from the specified array.voidSameDiff. associateArrayWithVariable(INDArray arr, SDVariable variable)Associate the array with the given variable.SDVariableSameDiff. convertToConstant(@NonNull SDVariable variable)Convert the specified variable to a constant.SDVariableSameDiff. convertToVariable(@NonNull SDVariable constant)Convert the specified variable to a VARIABLE type SDVariable.
This can only be done for constants and placeholders, not ARRAY type variables (which are usually network activations).static SameDiffSDVariable. createLoopConcat(SDVariable relative, SDVariable indices)Create a graph that takes in the indices as a placeholder, loops over each element in the index vector and appends the slice to the end result.static SameDiffSDVariable. createLoopPut(SDVariable relative, SDVariable indices)Create a graph that takes in the indices as a placeholder, loops over each element in the index vector and appends the slice to the end result.SDVariable[]SameDiffFunctionDefinition. define(SameDiff sameDiff, Map<String,INDArray> inputs, SDVariable[] variableInputs)SDVariable[]SameDiffLambda. define(SameDiff sameDiff, SDVariable[] inputs)SDVariableSameDiffSingleLambda. define(SameDiff sameDiff, SDVariable[] inputs)SameDiffSameDiff. defineFunction(String function, SameDiffFunctionDefinition functionDefinition, SDVariable[] variables)SDVariableSDVariable. div(String name, SDVariable x)Division operation: elementwisethis / x
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. div(SDVariable x)SDVariableSDVariable. dot(String name, SDVariable other, int... dimensions)Matrix dot product: out = dot(this,other, dimensions)SDVariableSDVariable. dot(SDVariable other, int... dimensions)SDVariableSDVariable. eq(String name, SDVariable other)Equal to operation: elementwisethis == y
If x and y arrays have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if x and y have different shapes and are broadcastable, the output shape is broadcast.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.SDVariableSDVariable. eq(SDVariable other)SDVariableSameDiffConditional. eval(SameDiff context, SameDiffFunctionDefinition body, SDVariable[] inputVars)SDVariableSDVariable. fdiv(String name, SDVariable x)Floor division operation: elementwisethis // x
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. get(SDVariable indices)Get a variable with content equal to a specified sub-array of this variable.
Can be used (for example) to get rows, columns, sub-matrices, etc.SDVariableSDVariable. gt(String name, SDVariable other)Greater than operation: elementwisethis > y
If x and y arrays have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if x and y have different shapes and are broadcastable, the output shape is broadcast.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.SDVariableSDVariable. gt(SDVariable other)SDVariableSDVariable. gte(String name, SDVariable other)Greater than or equal to operation: elementwisethis >= y
If x and y arrays have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if x and y have different shapes and are broadcastable, the output shape is broadcast.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.SDVariableSDVariable. gte(SDVariable other)SDVariableArgumentInterceptor. intercept(SDVariable argument)static SDIndexSDIndex. interval(SDVariable begin, SDVariable end)Represents all elements begin to end (think get row from beginning to end) Note these are dynamic indices.static SDIndexSDIndex. interval(SDVariable begin, SDVariable strides, SDVariable end)Represents all elements begin to end (think get row from beginning to end) Note these are static indices.static SDIndexSDIndex. interval(SDVariable begin, SDVariable strides, SDVariable end, SDVariable inclusive)Represents all elements begin to end (think get row from beginning to end) Note these are static indices.static SDVariable[]ControlFlow. loopWithConditions(String[] outputVarNames, String loopName, SameDiff parent, SameDiff functionBody, String functionName, SDVariable[] loopVars, String[] functionBodyInputs, String[] functionBodyOutputs)Loop with conditions allows a user to provide a lambda to invoke any number of times.SDVariableSDVariable. lt(String name, SDVariable other)Less than operation: elementwisethis < y
If x and y arrays have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if x and y have different shapes and are broadcastable, the output shape is broadcast.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.SDVariableSDVariable. lt(SDVariable other)SDVariableSDVariable. lte(String name, SDVariable other)Less than or equal to operation: elementwisethis <= y
If x and y arrays have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if x and y have different shapes and are broadcastable, the output shape is broadcast.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.SDVariableSDVariable. lte(SDVariable other)SDVariableSDVariable. minus(SDVariable other)For Kotlin operator interopSDVariableSDVariable. mmul(String name, SDVariable other)Matrix multiplication: out = mmul(this,other)SDVariableSDVariable. mmul(String name, SDVariable other, @NonNull MMulTranspose mMulTranspose)Matrix multiplication: out = mmul(this,other)SDVariableSDVariable. mmul(SDVariable other)SDVariableSDVariable. mod(String name, SDVariable x)Modulo operation: elementwisethis / x
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. mul(String name, SDVariable x)Multiplication operation: elementwisethis * x
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. mul(SDVariable x)SDVariableSDVariable. neq(String name, SDVariable other)Not equal to operation: elementwisethis != y
If x and y arrays have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if x and y have different shapes and are broadcastable, the output shape is broadcast.
Returns an array with values 1 where condition is satisfied, or value 0 otherwise.SDVariableSDVariable. neq(SDVariable other)SDVariableSDVariable. permute(SDVariable dimensions)SDVariableSDVariable. plus(SDVariable other)For Kotlin operator interopstatic SDIndexSDIndex. point(SDVariable i)Represents all elements at a singular point in this dimension (think row or column) Note this is the SDVariable version.static SDIndexSDIndex. point(SDVariable i, boolean keepDim)Represents all elements at a singular point in this dimension (think row or column) This is a dynamic indexSDVariableSDVariable. put(SDVariable indices, SDVariable toPut, SDVariable putIndices)Get a variable with content equal to a specified sub-array of this variable.
Can be used (for example) to get rows, columns, sub-matrices, etc.SDVariableSDVariable. rdiv(String name, SDVariable x)Reverse division operation: elementwisex / this
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. rdiv(SDVariable sameDiffVariable)voidSameDiff. replaceArgFor(int i, @NonNull SDVariable newArg, @NonNull DifferentialFunction function)Replaces the argument at i with newArg for function Does not use (or remove) ArgumentInterceptor stuffSDVariableSDVariable. reshape(String name, SDVariable newShape)Reshape the current variable to the specified (dynamic) shape.SDVariableSDVariable. reshape(SDVariable newShape)Reshape the current variable to the specified (dynamic) shape.SDVariableSDVariable. rsub(String name, SDVariable x)Reverse subtraction operation: elementwisex - this
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. rsub(SDVariable x)voidSameDiff. setGradientForVariableName(String variableName, SDVariable variable)Assign a SDVariable to represent the gradient of the SDVariable with the specified namevoidSameDiff. setLossVariables(@NonNull SDVariable... lossVariables)static SDVariableSDVariable. sliceEnd(SDVariable input, SDVariable sliceIndexInput)SDVariableSDVariable. squaredDifference(String name, SDVariable x)Squared difference operation:(this - x)^2SDVariableSDVariable. squaredDifference(SDVariable x)SDVariableSDVariable. sub(String name, SDVariable x)Subtraction operation: elementwisethis - x
If this and x variables have equal shape, the output shape is the same as the inputs.
Supports broadcasting: if this and x have different shapes and are broadcastable, the output shape is broadcast.SDVariableSDVariable. sub(SDVariable x)TensorArraySameDiff. tensorArray(SDVariable tensorArrayToAccess)Create a new TensorArray.SDVariableSDVariable. times(SDVariable other)For Kotlin operator interopTrainingConfig.BuilderTrainingConfig.Builder. trainEvaluation(@NonNull SDVariable variable, int labelIndex, @NonNull IEvaluation... evaluations)Add requested History training evaluations for a parm/variable.SDVariableSameDiff. updateVariableNameAndReference(SameDiffOp opToRename, SDVariable varToUpdate, String newVarName)Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.SDVariableSameDiff. updateVariableNameAndReference(SameDiffOp opToRename, SDVariable varToUpdate, String newVarName, boolean exactName)Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.SDVariableSameDiff. updateVariableNameAndReference(SDVariable varToUpdate, String newVarName)Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.SDVariableSameDiff. updateVariableNameAndReference(SDVariable varToUpdate, String newVarName, boolean exactName)Updates the variable name property on the passed in variable, the reference in samediff, and returns the variable.SDVariable[]SameDiff. updateVariableNamesAndReferences(SDVariable[] variablesToUpdate, String[] newVariableNames)Updates the variable name property on the passed in variables, its reference in samediff, and returns the variable.TrainingConfig.BuilderTrainingConfig.Builder. validationEvaluation(@NonNull SDVariable variable, int labelIndex, @NonNull IEvaluation... evaluations)Add requested History validation evaluations for a parm/variable.SDVariableSameDiff. var(@NonNull SDVariable v)Initialize aSDVariablereference tying this variable to this samediff instance.static SDVariable[]ControlFlow. whileLoop(SameDiff sameDiff, String[] outputNames, String loopName, @NonNull SDVariable[] loopVars, @NonNull SameDiffSingleLambda cond, @NonNull SameDiffLambda body)Constructs a While loop using the tensorflow style control flow operations (Switch, Merge, Enter, Exit, and NextIteration)SDVariable[]SameDiff. whileLoop(@NonNull SDVariable[] loopVars, @NonNull SameDiffSingleLambda cond, @NonNull SameDiffLambda body)SDVariable[]SameDiff. whileLoop(String[] outputNames, String loopName, @NonNull SDVariable[] loopVars, @NonNull SameDiffSingleLambda cond, @NonNull SameDiffLambda body)Constructs a While loop using the tensorflow style control flow operations (Switch, Merge, Enter, Exit, and NextIteration) Repeatedly executes body on the loop variables and updates them with the results, until cond evaluates to false Note that cond and body lambdas are only called once to construct the graph.SDVariable[]SameDiff. whileLoop(String loopName, @NonNull SDVariable[] loopVars, @NonNull SameDiffSingleLambda cond, @NonNull SameDiffLambda body)Method parameters in org.nd4j.autodiff.samediff with type arguments of type SDVariable Modifier and Type Method Description voidSameDiff. convertToConstants(List<SDVariable> variables)Convert all of the specified variables to constants.voidSameDiff. convertToVariables(@NonNull List<SDVariable> constants)Convert the specified variables to VARIABLE type SDVariables.
This can only be done for constants and placeholders, not ARRAY type variables (which are usually network activations).Constructors in org.nd4j.autodiff.samediff with parameters of type SDVariable Constructor Description LoopLambdaArgs(SDVariable iterStart, SDVariable iterCount, SDVariable[] extraArgs, SDVariable condIn) -
Uses of SDVariable in org.nd4j.autodiff.samediff.config
Methods in org.nd4j.autodiff.samediff.config with parameters of type SDVariable Modifier and Type Method Description EvaluationConfigEvaluationConfig. evaluate(@NonNull SDVariable variable, int labelIndex, @NonNull IEvaluation... evaluations)EvaluationConfigEvaluationConfig. evaluate(@NonNull SDVariable variable, @NonNull IEvaluation... evaluations)BatchOutputConfigBatchOutputConfig. input(@NonNull SDVariable variable, @NonNull INDArray placeholder)EvaluationConfigEvaluationConfig. labelIndex(@NonNull SDVariable variable, int labelIndex)BatchOutputConfigBatchOutputConfig. output(@NonNull SDVariable... outputs)Add required outputsOutputConfigOutputConfig. output(@NonNull SDVariable... outputs)Add required outputs -
Uses of SDVariable in org.nd4j.autodiff.samediff.impl
Methods in org.nd4j.autodiff.samediff.impl that return SDVariable Modifier and Type Method Description SDVariableDefaultSameDiffConditional. eval(SameDiff context, SameDiffFunctionDefinition body, SDVariable[] inputVars)Methods in org.nd4j.autodiff.samediff.impl with parameters of type SDVariable Modifier and Type Method Description SDVariableDefaultSameDiffConditional. eval(SameDiff context, SameDiffFunctionDefinition body, SDVariable[] inputVars) -
Uses of SDVariable in org.nd4j.autodiff.samediff.internal
Fields in org.nd4j.autodiff.samediff.internal declared as SDVariable Modifier and Type Field Description protected SDVariableVariable. gradientprotected SDVariableVariable. variableMethods in org.nd4j.autodiff.samediff.internal with parameters of type SDVariable Modifier and Type Method Description protected INDArrayInferenceSession. getArray(SDVariable sdv, Collection<AbstractSession.VarId> opInputs, Collection<AbstractSession.VarId> allIterInputs) -
Uses of SDVariable in org.nd4j.autodiff.samediff.ops
Methods in org.nd4j.autodiff.samediff.ops that return SDVariable Modifier and Type Method Description SDVariableSDMath. abs(String name, SDVariable x)Elementwise absolute value operation: out = abs(x)SDVariableSDMath. abs(SDVariable x)Elementwise absolute value operation: out = abs(x)SDVariableSDLoss. absoluteDifference(String name, SDVariable label, SDVariable predictions, SDVariable weights)Absolute difference loss:sum_i abs( label[i] - predictions[i] )SDVariableSDLoss. absoluteDifference(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Absolute difference loss:sum_i abs( label[i] - predictions[i] )SDVariableSDLoss. absoluteDifference(SDVariable label, SDVariable predictions, SDVariable weights)Absolute difference loss:sum_i abs( label[i] - predictions[i] )SDVariableSDLoss. absoluteDifference(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Absolute difference loss:sum_i abs( label[i] - predictions[i] )SDVariableSDMath. acos(String name, SDVariable x)Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)SDVariableSDMath. acos(SDVariable x)Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)SDVariableSDMath. acosh(String name, SDVariable x)Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)SDVariableSDMath. acosh(SDVariable x)Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)SDVariableSDMath. add(String name, SDVariable x, double value)Scalar add operation, out = in + scalarSDVariableSDMath. add(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. add(SDVariable x, double value)Scalar add operation, out = in + scalarSDVariableSDMath. add(SDVariable x, SDVariable y)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.htmlSDVariableSDImage. adjustContrast(String name, SDVariable in, double factor)Adjusts contrast of RGB or grayscale images.SDVariableSDImage. adjustContrast(SDVariable in, double factor)Adjusts contrast of RGB or grayscale images.SDVariableSDImage. adjustHue(String name, SDVariable in, double delta)Adjust hue of RGB imageSDVariableSDImage. adjustHue(SDVariable in, double delta)Adjust hue of RGB imageSDVariableSDImage. adjustSaturation(String name, SDVariable in, double factor)Adjust saturation of RGB imagesSDVariableSDImage. adjustSaturation(SDVariable in, double factor)Adjust saturation of RGB imagesSDVariableSDBaseOps. all(String name, SDVariable x, int... dimensions)Boolean and array reduction operation, optionally along specified dimensionsSDVariableSDBaseOps. all(SDVariable x, int... dimensions)Boolean and array reduction operation, optionally along specified dimensionsSDVariableSDBitwise. and(String name, SDVariable x, SDVariable y)Bitwise AND operation.SDVariableSDBitwise. and(SDVariable x, SDVariable y)Bitwise AND operation.SDVariableSDMath. and(String name, SDVariable x, SDVariable y)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.SDVariableSDMath. and(SDVariable x, SDVariable y)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.SDVariableSDBaseOps. any(String name, SDVariable x, int... dimensions)Boolean or array reduction operation, optionally along specified dimensionsSDVariableSDBaseOps. any(SDVariable x, int... dimensions)Boolean or array reduction operation, optionally along specified dimensionsSDVariableSDBaseOps. argmax(String name, SDVariable in, boolean keepDims, int... dimensions)Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmax(String name, SDVariable in, int... dimensions)Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmax(SDVariable in, boolean keepDims, int... dimensions)Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmax(SDVariable in, int... dimensions)Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmin(String name, SDVariable in, boolean keepDims, int... dimensions)Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmin(String name, SDVariable in, int... dimensions)Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmin(SDVariable in, boolean keepDims, int... dimensions)Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmin(SDVariable in, int... dimensions)Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDMath. asin(String name, SDVariable x)Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)SDVariableSDMath. asin(SDVariable x)Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)SDVariableSDMath. asinh(String name, SDVariable x)Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)SDVariableSDMath. asinh(SDVariable x)Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)SDVariableSDBaseOps. assign(String name, SDVariable x, SDVariable y)Assign the contents of y to x.
Y must be broadcastable to x or the same shape.SDVariableSDBaseOps. assign(SDVariable x, SDVariable y)Assign the contents of y to x.
Y must be broadcastable to x or the same shape.SDVariableSDMath. asum(String name, SDVariable in, boolean keepDims, int... dimensions)Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))SDVariableSDMath. asum(String name, SDVariable in, int... dimensions)Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))SDVariableSDMath. asum(SDVariable in, boolean keepDims, int... dimensions)Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))SDVariableSDMath. asum(SDVariable in, int... dimensions)Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))SDVariableSDMath. atan(String name, SDVariable x)Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)SDVariableSDMath. atan(SDVariable x)Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)SDVariableSDMath. atan2(String name, SDVariable y, SDVariable x)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 resultSDVariableSDMath. atan2(SDVariable y, SDVariable x)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 resultSDVariableSDMath. atanh(String name, SDVariable x)Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)SDVariableSDMath. atanh(SDVariable x)Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)SDVariableSDCNN. avgPooling2d(String name, SDVariable input, Pooling2DConfig Pooling2DConfig)2D Convolution layer operation - average pooling 2dSDVariableSDCNN. avgPooling2d(SDVariable input, Pooling2DConfig Pooling2DConfig)2D Convolution layer operation - average pooling 2dSDVariableSDCNN. avgPooling3d(String name, SDVariable input, Pooling3DConfig Pooling3DConfig)3D convolution layer operation - average pooling 3dSDVariableSDCNN. avgPooling3d(SDVariable input, Pooling3DConfig Pooling3DConfig)3D convolution layer operation - average pooling 3dSDVariable[]SDBaseOps. batchMmul(String[] names, SDVariable[] inputsA, SDVariable... inputsB)Matrix multiply a batch of matrices.SDVariable[]SDBaseOps. batchMmul(String[] names, SDVariable[] inputsA, SDVariable[] inputsB, boolean transposeA, boolean transposeB)Matrix multiply a batch of matrices.SDVariable[]SDBaseOps. batchMmul(SDVariable[] inputsA, SDVariable... inputsB)Matrix multiply a batch of matrices.SDVariable[]SDBaseOps. batchMmul(SDVariable[] inputsA, SDVariable[] inputsB, boolean transposeA, boolean transposeB)Matrix multiply a batch of matrices.SDVariableSDNN. batchNorm(String name, SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, double epsilon, int... axis)SDVariableSDNN. batchNorm(SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, double epsilon, int... axis)SDVariableSDCNN. batchToSpace(String name, SDVariable x, int[] blocks, int[] croppingTop, int... croppingBottom)Convolution 2d layer batch to space operation on 4d input.
Reduces input batch dimension by rearranging data into a larger spatial dimensionsSDVariableSDCNN. batchToSpace(SDVariable x, int[] blocks, int[] croppingTop, int... croppingBottom)Convolution 2d layer batch to space operation on 4d input.
Reduces input batch dimension by rearranging data into a larger spatial dimensionsSDVariableSDRandom. bernoulli(double p, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a Bernoulli distribution,
with the specified probability.SDVariableSDRandom. bernoulli(String name, double p, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a Bernoulli distribution,
with the specified probability.SDVariableSDNN. biasAdd(String name, SDVariable input, SDVariable bias, boolean nchw)Bias addition operation: a special case of addition, typically used with CNN 4D activations and a 1D bias vectorSDVariableSDNN. biasAdd(SDVariable input, SDVariable bias, boolean nchw)Bias addition operation: a special case of addition, typically used with CNN 4D activations and a 1D bias vectorSDVariableSDRandom. binomial(int nTrials, double p, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a Binomial distribution,
with the specified number of trials and probability.SDVariableSDRandom. binomial(String name, int nTrials, double p, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a Binomial distribution,
with the specified number of trials and probability.SDVariableSDBitwise. bitRotl(String name, SDVariable x, SDVariable shift)Roll integer bits to the left, i.e.SDVariableSDBitwise. bitRotl(SDVariable x, SDVariable shift)Roll integer bits to the left, i.e.SDVariableSDBitwise. bitRotr(String name, SDVariable x, SDVariable shift)Roll integer bits to the right, i.e.SDVariableSDBitwise. bitRotr(SDVariable x, SDVariable shift)Roll integer bits to the right, i.e.SDVariableSDBitwise. bitsHammingDistance(String name, SDVariable x, SDVariable y)Bitwise Hamming distance reduction over all elements of both input arrays.
For example, if x=01100000 and y=1010000 then the bitwise Hamming distance is 2 (due to differences at positions 0 and 1)
Inputs must satisfy the following constraints:
Must be same types: isSameType(x, y)SDVariableSDBitwise. bitsHammingDistance(SDVariable x, SDVariable y)Bitwise Hamming distance reduction over all elements of both input arrays.
For example, if x=01100000 and y=1010000 then the bitwise Hamming distance is 2 (due to differences at positions 0 and 1)
Inputs must satisfy the following constraints:
Must be same types: isSameType(x, y)SDVariableSDBitwise. bitShift(String name, SDVariable x, SDVariable shift)Shift integer bits to the left, i.e.SDVariableSDBitwise. bitShift(SDVariable x, SDVariable shift)Shift integer bits to the left, i.e.SDVariableSDMath. bitShift(String name, SDVariable x, SDVariable shift)Bit shift operationSDVariableSDMath. bitShift(SDVariable x, SDVariable shift)Bit shift operationSDVariableSDBitwise. bitShiftRight(String name, SDVariable x, SDVariable shift)Shift integer bits to the right, i.e.SDVariableSDBitwise. bitShiftRight(SDVariable x, SDVariable shift)Shift integer bits to the right, i.e.SDVariableSDMath. bitShiftRight(String name, SDVariable x, SDVariable shift)Right bit shift operationSDVariableSDMath. bitShiftRight(SDVariable x, SDVariable shift)Right bit shift operationSDVariableSDMath. bitShiftRotl(String name, SDVariable x, SDVariable shift)Cyclic bit shift operationSDVariableSDMath. bitShiftRotl(SDVariable x, SDVariable shift)Cyclic bit shift operationSDVariableSDMath. bitShiftRotr(String name, SDVariable x, SDVariable shift)Cyclic right shift operationSDVariableSDMath. bitShiftRotr(SDVariable x, SDVariable shift)Cyclic right shift operationSDVariableSDBaseOps. castTo(String name, SDVariable arg, DataType datatype)Cast the array to a new datatype - for example, Integer -> FloatSDVariableSDBaseOps. castTo(SDVariable arg, DataType datatype)Cast the array to a new datatype - for example, Integer -> FloatSDVariableSDMath. ceil(String name, SDVariable x)Element-wise ceiling function: out = ceil(x).
Rounds each value up to the nearest integer value (if not already an integer)SDVariableSDMath. ceil(SDVariable x)Element-wise ceiling function: out = ceil(x).
Rounds each value up to the nearest integer value (if not already an integer)SDVariableSDLinalg. cholesky(String name, SDVariable input)Computes the Cholesky decomposition of one or more square matrices.SDVariableSDLinalg. cholesky(SDVariable input)Computes the Cholesky decomposition of one or more square matrices.SDVariableSDMath. clipByAvgNorm(String name, SDVariable x, double clipValue, int... dimensions)Clips tensor values to a maximum average L2-norm.SDVariableSDMath. clipByAvgNorm(SDVariable x, double clipValue, int... dimensions)Clips tensor values to a maximum average L2-norm.SDVariableSDBaseOps. clipByNorm(String name, SDVariable x, double clipValue)Returns a clipped ndarray such that the input is normalized so that its L2 norm
is <= the specified value.SDVariableSDBaseOps. clipByNorm(String name, SDVariable x, SDVariable clipValue, SDVariable dimensions)Returns a clipped ndarray such that the input is normalized so that its L2 norm
is <= the specified value.SDVariableSDBaseOps. clipByNorm(SDVariable x, double clipValue)Returns a clipped ndarray such that the input is normalized so that its L2 norm
is <= the specified value.SDVariableSDBaseOps. clipByNorm(SDVariable x, SDVariable clipValue, SDVariable dimensions)Returns a clipped ndarray such that the input is normalized so that its L2 norm
is <= the specified value.SDVariableSDMath. clipByNorm(String name, SDVariable x, double clipValue, int... dimensions)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 dimensionsSDVariableSDMath. clipByNorm(SDVariable x, double clipValue, int... dimensions)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 dimensionsSDVariableSDBaseOps. clipByValue(String name, SDVariable x, double clipValueMin, double clipValueMax)Return the clipped ndarray containing values no smaller or larger than the given min and max.SDVariableSDBaseOps. clipByValue(String name, SDVariable x, SDVariable clipValueMin, SDVariable clipValueMax)Return the clipped ndarray containing values no smaller or larger than the given min and max.SDVariableSDBaseOps. clipByValue(SDVariable x, double clipValueMin, double clipValueMax)Return the clipped ndarray containing values no smaller or larger than the given min and max.SDVariableSDBaseOps. clipByValue(SDVariable x, SDVariable clipValueMin, SDVariable clipValueMax)Return the clipped ndarray containing values no smaller or larger than the given min and max.SDVariableSDMath. clipByValue(String name, SDVariable x, double clipValueMin, double clipValueMax)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] > clipValueMaxSDVariableSDMath. clipByValue(SDVariable x, double clipValueMin, double clipValueMax)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] > clipValueMaxSDVariableSDCNN. col2Im(String name, SDVariable in, Conv2DConfig Conv2DConfig)col2im operation for use in 2D convolution operations.SDVariableSDCNN. col2Im(SDVariable in, Conv2DConfig Conv2DConfig)col2im operation for use in 2D convolution operations.SDVariableSDBaseOps. concat(int dimension, SDVariable... inputs)Concatenate a set of inputs along the specified dimension.
Note that inputs must have identical rank and identical dimensions, other than the dimension to stack on.
For example, if 2 inputs have shape [a, x, c] and [a, y, c] and dimension = 1, then the output has shape [a, x+y, c]
Inputs must satisfy the following constraints:
Input arrays must all be the same datatype: isSameType(inputs)SDVariableSDBaseOps. concat(String name, int dimension, SDVariable... inputs)Concatenate a set of inputs along the specified dimension.
Note that inputs must have identical rank and identical dimensions, other than the dimension to stack on.
For example, if 2 inputs have shape [a, x, c] and [a, y, c] and dimension = 1, then the output has shape [a, x+y, c]
Inputs must satisfy the following constraints:
Input arrays must all be the same datatype: isSameType(inputs)SDVariableSDMath. confusionMatrix(String name, SDVariable labels, SDVariable pred, int numClasses)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]SDVariableSDMath. confusionMatrix(String name, SDVariable labels, SDVariable pred, SDVariable weights)Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.SDVariableSDMath. confusionMatrix(String name, SDVariable labels, SDVariable pred, SDVariable weights, int numClasses)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]SDVariableSDMath. confusionMatrix(String name, SDVariable labels, SDVariable pred, DataType dataType)Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.SDVariableSDMath. confusionMatrix(SDVariable labels, SDVariable pred, int numClasses)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]SDVariableSDMath. confusionMatrix(SDVariable labels, SDVariable pred, SDVariable weights)Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.SDVariableSDMath. confusionMatrix(SDVariable labels, SDVariable pred, SDVariable weights, int numClasses)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]SDVariableSDMath. confusionMatrix(SDVariable labels, SDVariable pred, DataType dataType)Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.SDVariableSDCNN. conv1d(String name, SDVariable input, SDVariable weights, SDVariable bias, Conv1DConfig Conv1DConfig)Conv1d operation.SDVariableSDCNN. conv1d(String name, SDVariable input, SDVariable weights, Conv1DConfig Conv1DConfig)Conv1d operation.SDVariableSDCNN. conv1d(SDVariable input, SDVariable weights, SDVariable bias, Conv1DConfig Conv1DConfig)Conv1d operation.SDVariableSDCNN. conv1d(SDVariable input, SDVariable weights, Conv1DConfig Conv1DConfig)Conv1d operation.SDVariableSDCNN. conv2d(String name, SDVariable layerInput, SDVariable weights, SDVariable bias, Conv2DConfig Conv2DConfig)2D Convolution operation with optional biasSDVariableSDCNN. conv2d(String name, SDVariable layerInput, SDVariable weights, Conv2DConfig Conv2DConfig)2D Convolution operation with optional biasSDVariableSDCNN. conv2d(SDVariable layerInput, SDVariable weights, SDVariable bias, Conv2DConfig Conv2DConfig)2D Convolution operation with optional biasSDVariableSDCNN. conv2d(SDVariable layerInput, SDVariable weights, Conv2DConfig Conv2DConfig)2D Convolution operation with optional biasSDVariableSDCNN. conv3d(String name, SDVariable input, SDVariable weights, SDVariable bias, Conv3DConfig Conv3DConfig)Convolution 3D operation with optional biasSDVariableSDCNN. conv3d(String name, SDVariable input, SDVariable weights, Conv3DConfig Conv3DConfig)Convolution 3D operation with optional biasSDVariableSDCNN. conv3d(SDVariable input, SDVariable weights, SDVariable bias, Conv3DConfig Conv3DConfig)Convolution 3D operation with optional biasSDVariableSDCNN. conv3d(SDVariable input, SDVariable weights, Conv3DConfig Conv3DConfig)Convolution 3D operation with optional biasSDVariableSDMath. cos(String name, SDVariable x)Elementwise cosine operation: out = cos(x)SDVariableSDMath. cos(SDVariable x)Elementwise cosine operation: out = cos(x)SDVariableSDMath. cosh(String name, SDVariable x)Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)SDVariableSDMath. cosh(SDVariable x)Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)SDVariableSDLoss. cosineDistance(String name, SDVariable label, SDVariable predictions, SDVariable weights, int dimension)Cosine distance loss:1 - cosineSimilarity(x,y)or1 - sum_i label[i] * prediction[i], which is
equivalent to cosine distance when both the predictions and labels are normalized.
Note: This loss function assumes that both the predictions and labels are normalized to have unit l2 norm.
If this is not the case, you should normalize them first by dividing by norm2(String, SDVariable, boolean, int...)
along the cosine distance dimension (with keepDims=true).SDVariableSDLoss. cosineDistance(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, int dimension)Cosine distance loss:1 - cosineSimilarity(x,y)or1 - sum_i label[i] * prediction[i], which is
equivalent to cosine distance when both the predictions and labels are normalized.
Note: This loss function assumes that both the predictions and labels are normalized to have unit l2 norm.
If this is not the case, you should normalize them first by dividing by norm2(String, SDVariable, boolean, int...)
along the cosine distance dimension (with keepDims=true).SDVariableSDLoss. cosineDistance(SDVariable label, SDVariable predictions, SDVariable weights, int dimension)Cosine distance loss:1 - cosineSimilarity(x,y)or1 - sum_i label[i] * prediction[i], which is
equivalent to cosine distance when both the predictions and labels are normalized.
Note: This loss function assumes that both the predictions and labels are normalized to have unit l2 norm.
If this is not the case, you should normalize them first by dividing by norm2(String, SDVariable, boolean, int...)
along the cosine distance dimension (with keepDims=true).SDVariableSDLoss. cosineDistance(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, int dimension)Cosine distance loss:1 - cosineSimilarity(x,y)or1 - sum_i label[i] * prediction[i], which is
equivalent to cosine distance when both the predictions and labels are normalized.
Note: This loss function assumes that both the predictions and labels are normalized to have unit l2 norm.
If this is not the case, you should normalize them first by dividing by norm2(String, SDVariable, boolean, int...)
along the cosine distance dimension (with keepDims=true).SDVariableSDMath. cosineDistance(String name, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Cosine distance reduction operation.SDVariableSDMath. cosineDistance(String name, SDVariable x, SDVariable y, int... dimensions)Cosine distance reduction operation.SDVariableSDMath. cosineDistance(SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Cosine distance reduction operation.SDVariableSDMath. cosineDistance(SDVariable x, SDVariable y, int... dimensions)Cosine distance reduction operation.SDVariableSDMath. cosineSimilarity(String name, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Cosine similarity pairwise reduction operation.SDVariableSDMath. cosineSimilarity(String name, SDVariable x, SDVariable y, int... dimensions)Cosine similarity pairwise reduction operation.SDVariableSDMath. cosineSimilarity(SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Cosine similarity pairwise reduction operation.SDVariableSDMath. cosineSimilarity(SDVariable x, SDVariable y, int... dimensions)Cosine similarity pairwise reduction operation.SDVariableSDMath. countNonZero(String name, SDVariable in, boolean keepDims, int... dimensions)Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)SDVariableSDMath. countNonZero(String name, SDVariable in, int... dimensions)Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)SDVariableSDMath. countNonZero(SDVariable in, boolean keepDims, int... dimensions)Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)SDVariableSDMath. countNonZero(SDVariable in, int... dimensions)Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)SDVariableSDMath. countZero(String name, SDVariable in, boolean keepDims, int... dimensions)Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)SDVariableSDMath. countZero(String name, SDVariable in, int... dimensions)Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)SDVariableSDMath. countZero(SDVariable in, boolean keepDims, int... dimensions)Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)SDVariableSDMath. countZero(SDVariable in, int... dimensions)Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)SDVariableSDBaseOps. create(String name, SDVariable shape, DataType dataType)Return a newly created variable, with the specified shape and data type.SDVariableSDBaseOps. create(String name, SDVariable shape, DataType dataType, String order, boolean initialize)Return a newly created variable, with the specified shape and data type.SDVariableSDBaseOps. create(SDVariable shape, DataType dataType)Return a newly created variable, with the specified shape and data type.SDVariableSDBaseOps. create(SDVariable shape, DataType dataType, String order, boolean initialize)Return a newly created variable, with the specified shape and data type.SDVariableSDBaseOps. createView(String name, SDVariable input, SDVariable... indices)Return a newly created variable, with the specified shape and data type.SDVariableSDBaseOps. createView(SDVariable input, SDVariable... indices)Return a newly created variable, with the specified shape and data type.SDVariableSDNN. cReLU(String name, SDVariable x)Concatenates a ReLU which selects only the positive part of the activation with a ReLU which selects only the negative part of the activation.SDVariableSDNN. cReLU(SDVariable x)Concatenates a ReLU which selects only the positive part of the activation with a ReLU which selects only the negative part of the activation.SDVariableSDImage. cropAndResize(String name, SDVariable image, SDVariable cropBoxes, SDVariable boxIndices, SDVariable cropOutSize)Given an input image and some crop boxes, extract out the image subsets and resize them to the specified size.SDVariableSDImage. cropAndResize(String name, SDVariable image, SDVariable cropBoxes, SDVariable boxIndices, SDVariable cropOutSize, double extrapolationValue)Given an input image and some crop boxes, extract out the image subsets and resize them to the specified size.SDVariableSDImage. cropAndResize(SDVariable image, SDVariable cropBoxes, SDVariable boxIndices, SDVariable cropOutSize)Given an input image and some crop boxes, extract out the image subsets and resize them to the specified size.SDVariableSDImage. cropAndResize(SDVariable image, SDVariable cropBoxes, SDVariable boxIndices, SDVariable cropOutSize, double extrapolationValue)Given an input image and some crop boxes, extract out the image subsets and resize them to the specified size.SDVariableSDLinalg. cross(String name, SDVariable a, SDVariable b)Computes pairwise cross product.SDVariableSDLinalg. cross(SDVariable a, SDVariable b)Computes pairwise cross product.SDVariableSDMath. cross(String name, SDVariable a, SDVariable b)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 3SDVariableSDMath. cross(SDVariable a, SDVariable b)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 3SDVariableSDLoss. ctcLoss(String name, SDVariable targetLabels, SDVariable logitInput, SDVariable targetLabelLengths, SDVariable logitInputLengths)CTC Loss: Connectionist Temporal Classification Loss.SDVariableSDLoss. ctcLoss(SDVariable targetLabels, SDVariable logitInput, SDVariable targetLabelLengths, SDVariable logitInputLengths)CTC Loss: Connectionist Temporal Classification Loss.SDVariableSDMath. cube(String name, SDVariable x)Element-wise cube function: out = x^3SDVariableSDMath. cube(SDVariable x)Element-wise cube function: out = x^3SDVariableSDBaseOps. cumprod(String name, SDVariable in, boolean exclusive, boolean reverse, int... axis)Cumulative product operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a*b, a*b*c]
exclusive=true, reverse=false, [0, a, a*b]
exclusive=false, reverse=true: [a*b*c, b*c, c]
exclusive=true, reverse=true: [b*c, c, 0]SDVariableSDBaseOps. cumprod(String name, SDVariable in, int... axis)Cumulative product operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a*b, a*b*c]
exclusive=true, reverse=false, [0, a, a*b]
exclusive=false, reverse=true: [a*b*c, b*c, c]
exclusive=true, reverse=true: [b*c, c, 0]SDVariableSDBaseOps. cumprod(SDVariable in, boolean exclusive, boolean reverse, int... axis)Cumulative product operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a*b, a*b*c]
exclusive=true, reverse=false, [0, a, a*b]
exclusive=false, reverse=true: [a*b*c, b*c, c]
exclusive=true, reverse=true: [b*c, c, 0]SDVariableSDBaseOps. cumprod(SDVariable in, int... axis)Cumulative product operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a*b, a*b*c]
exclusive=true, reverse=false, [0, a, a*b]
exclusive=false, reverse=true: [a*b*c, b*c, c]
exclusive=true, reverse=true: [b*c, c, 0]SDVariableSDBaseOps. cumsum(String name, SDVariable in, boolean exclusive, boolean reverse, int... axis)Cumulative sum operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a+b, a+b+c]
exclusive=true, reverse=false, [0, a, a+b]
exclusive=false, reverse=true: [a+b+c, b+c, c]
exclusive=true, reverse=true: [b+c, c, 0]SDVariableSDBaseOps. cumsum(String name, SDVariable in, int... axis)Cumulative sum operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a+b, a+b+c]
exclusive=true, reverse=false, [0, a, a+b]
exclusive=false, reverse=true: [a+b+c, b+c, c]
exclusive=true, reverse=true: [b+c, c, 0]SDVariableSDBaseOps. cumsum(SDVariable in, boolean exclusive, boolean reverse, int... axis)Cumulative sum operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a+b, a+b+c]
exclusive=true, reverse=false, [0, a, a+b]
exclusive=false, reverse=true: [a+b+c, b+c, c]
exclusive=true, reverse=true: [b+c, c, 0]SDVariableSDBaseOps. cumsum(SDVariable in, int... axis)Cumulative sum operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a+b, a+b+c]
exclusive=true, reverse=false, [0, a, a+b]
exclusive=false, reverse=true: [a+b+c, b+c, c]
exclusive=true, reverse=true: [b+c, c, 0]SDVariableSDCNN. deconv2d(String name, SDVariable layerInput, SDVariable weights, SDVariable bias, DeConv2DConfig DeConv2DConfig)2D deconvolution operation with optional biasSDVariableSDCNN. deconv2d(String name, SDVariable layerInput, SDVariable weights, DeConv2DConfig DeConv2DConfig)2D deconvolution operation with optional biasSDVariableSDCNN. deconv2d(SDVariable layerInput, SDVariable weights, SDVariable bias, DeConv2DConfig DeConv2DConfig)2D deconvolution operation with optional biasSDVariableSDCNN. deconv2d(SDVariable layerInput, SDVariable weights, DeConv2DConfig DeConv2DConfig)2D deconvolution operation with optional biasSDVariableSDCNN. deconv3d(String name, SDVariable input, SDVariable weights, SDVariable bias, DeConv3DConfig DeConv3DConfig)3D CNN deconvolution operation with or without optional biasSDVariableSDCNN. deconv3d(String name, SDVariable input, SDVariable weights, DeConv3DConfig DeConv3DConfig)3D CNN deconvolution operation with or without optional biasSDVariableSDCNN. deconv3d(SDVariable input, SDVariable weights, SDVariable bias, DeConv3DConfig DeConv3DConfig)3D CNN deconvolution operation with or without optional biasSDVariableSDCNN. deconv3d(SDVariable input, SDVariable weights, DeConv3DConfig DeConv3DConfig)3D CNN deconvolution operation with or without optional biasSDVariableSDCNN. depthToSpace(String name, SDVariable x, int blockSize, DataFormat dataFormat)Convolution 2d layer batch to space operation on 4d input.
Reduces input channels dimension by rearranging data into a larger spatial dimensions
Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2]
= [mb, 2, 4, 4]SDVariableSDCNN. depthToSpace(SDVariable x, int blockSize, DataFormat dataFormat)Convolution 2d layer batch to space operation on 4d input.
Reduces input channels dimension by rearranging data into a larger spatial dimensions
Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2]
= [mb, 2, 4, 4]SDVariableSDCNN. depthWiseConv2d(String name, SDVariable layerInput, SDVariable depthWeights, SDVariable bias, Conv2DConfig Conv2DConfig)Depth-wise 2D convolution operation with optional biasSDVariableSDCNN. depthWiseConv2d(String name, SDVariable layerInput, SDVariable depthWeights, Conv2DConfig Conv2DConfig)Depth-wise 2D convolution operation with optional biasSDVariableSDCNN. depthWiseConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable bias, Conv2DConfig Conv2DConfig)Depth-wise 2D convolution operation with optional biasSDVariableSDCNN. depthWiseConv2d(SDVariable layerInput, SDVariable depthWeights, Conv2DConfig Conv2DConfig)Depth-wise 2D convolution operation with optional biasSDVariableSDLinalg. diag(String name, SDVariable input)Calculates diagonal tensor.SDVariableSDLinalg. diag(SDVariable input)Calculates diagonal tensor.SDVariableSDMath. diag(String name, SDVariable x)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 2RSDVariableSDMath. diag(SDVariable x)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 2RSDVariableSDLinalg. diag_part(String name, SDVariable input)Calculates diagonal tensor.SDVariableSDLinalg. diag_part(SDVariable input)Calculates diagonal tensor.SDVariableSDMath. diagPart(String name, SDVariable x)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]SDVariableSDMath. diagPart(SDVariable x)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]SDVariableSDCNN. dilation2D(String name, SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode)TODO doc stringSDVariableSDCNN. dilation2D(SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode)TODO doc stringSDVariableSDMath. div(String name, SDVariable x, double value)Scalar division operation, out = in / scalarSDVariableSDMath. div(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. div(SDVariable x, double value)Scalar division operation, out = in / scalarSDVariableSDMath. div(SDVariable x, SDVariable y)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.htmlSDVariableSDBaseOps. dot(String name, SDVariable x, SDVariable y, int... dimensions)Pairwise dot product reduction along dimension
output = sum(i=0 ...SDVariableSDBaseOps. dot(SDVariable x, SDVariable y, int... dimensions)Pairwise dot product reduction along dimension
output = sum(i=0 ...SDVariableSDNN. dotProductAttention(String name, SDVariable queries, SDVariable keys, SDVariable values, SDVariable mask, boolean scaled)This operation performs dot product attention on the given timeseries input with the given queries
out = sum(similarity(k_i, q) * v_i)
similarity(k, q) = softmax(k * q) where x * q is the dot product of x and q
Optionally with normalization step:
similarity(k, q) = softmax(k * q / sqrt(size(q))
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, p.SDVariableSDNN. dotProductAttention(SDVariable queries, SDVariable keys, SDVariable values, SDVariable mask, boolean scaled)This operation performs dot product attention on the given timeseries input with the given queries
out = sum(similarity(k_i, q) * v_i)
similarity(k, q) = softmax(k * q) where x * q is the dot product of x and q
Optionally with normalization step:
similarity(k, q) = softmax(k * q / sqrt(size(q))
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, p.SDVariableSDNN. dropout(String name, SDVariable input, double inputRetainProbability)Dropout operationSDVariableSDNN. dropout(SDVariable input, double inputRetainProbability)Dropout operationSDVariableSDNN. dropoutInverted(String name, SDVariable input, double p)Dropout inverted operation.SDVariableSDNN. dropoutInverted(SDVariable input, double p)Dropout inverted operation.SDVariable[]SDBaseOps. dynamicPartition(String[] names, SDVariable x, SDVariable partitions, int numPartitions)Dynamically partition the input variable values into the specified number of paritions, using the indices.
Example:SDVariable[]SDBaseOps. dynamicPartition(SDVariable x, SDVariable partitions, int numPartitions)Dynamically partition the input variable values into the specified number of paritions, using the indices.
Example:SDVariableSDBaseOps. dynamicStitch(String name, SDVariable[] indices, SDVariable... x)Dynamically merge the specified input arrays into a single array, using the specified indicesSDVariableSDBaseOps. dynamicStitch(SDVariable[] indices, SDVariable... x)Dynamically merge the specified input arrays into a single array, using the specified indicesSDVariable[]SDLinalg. eig(String[] names, SDVariable input)Calculates eigen valuesSDVariable[]SDLinalg. eig(SDVariable input)Calculates eigen valuesSDVariableSDNN. elu(String name, SDVariable x)Element-wise exponential linear unit (ELU) function:
out = x if x > 0
out = a * (exp(x) - 1) if x <= 0
with constant a = 1.0SDVariableSDNN. elu(SDVariable x)Element-wise exponential linear unit (ELU) function:
out = x if x > 0
out = a * (exp(x) - 1) if x <= 0
with constant a = 1.0SDVariableSDMath. embeddingLookup(String name, SDVariable x, SDVariable indices, PartitionMode PartitionMode)Looks up ids in a list of embedding tensors.SDVariableSDMath. embeddingLookup(SDVariable x, SDVariable indices, PartitionMode PartitionMode)Looks up ids in a list of embedding tensors.SDVariableSDMath. entropy(String name, SDVariable in, boolean keepDims, int... dimensions)Entropy reduction: -sum(x * log(x))SDVariableSDMath. entropy(String name, SDVariable in, int... dimensions)Entropy reduction: -sum(x * log(x))SDVariableSDMath. entropy(SDVariable in, boolean keepDims, int... dimensions)Entropy reduction: -sum(x * log(x))SDVariableSDMath. entropy(SDVariable in, int... dimensions)Entropy reduction: -sum(x * log(x))SDVariableSDBaseOps. eq(String name, SDVariable x, double y)Equals operation: elementwise x == y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. eq(String name, SDVariable x, SDVariable y)Equal to operation: elementwise x == y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. eq(SDVariable x, double y)Equals operation: elementwise x == y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. eq(SDVariable x, SDVariable y)Equal to operation: elementwise x == y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDMath. erf(String name, SDVariable x)Element-wise Gaussian error function - out = erf(in)SDVariableSDMath. erf(SDVariable x)Element-wise Gaussian error function - out = erf(in)SDVariableSDMath. erfc(String name, SDVariable x)Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)SDVariableSDMath. erfc(SDVariable x)Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)SDVariableSDMath. euclideanDistance(String name, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Euclidean distance (l2 norm, l2 distance) reduction operation.SDVariableSDMath. euclideanDistance(String name, SDVariable x, SDVariable y, int... dimensions)Euclidean distance (l2 norm, l2 distance) reduction operation.SDVariableSDMath. euclideanDistance(SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Euclidean distance (l2 norm, l2 distance) reduction operation.SDVariableSDMath. euclideanDistance(SDVariable x, SDVariable y, int... dimensions)Euclidean distance (l2 norm, l2 distance) reduction operation.SDVariableSDMath. exp(String name, SDVariable x)Elementwise exponent function: out = exp(x) = 2.71828...^xSDVariableSDMath. exp(SDVariable x)Elementwise exponent function: out = exp(x) = 2.71828...^xSDVariableSDBaseOps. expandDims(String name, SDVariable x, int axis)Reshape the input by adding a 1 at the specified location.
For example, if input has shape [a, b], then output shape is:
axis = 0: [1, a, b]
axis = 1: [a, 1, b]
axis = 2: [a, b, 1]SDVariableSDBaseOps. expandDims(SDVariable x, int axis)Reshape the input by adding a 1 at the specified location.
For example, if input has shape [a, b], then output shape is:
axis = 0: [1, a, b]
axis = 1: [a, 1, b]
axis = 2: [a, b, 1]SDVariableSDMath. expm1(String name, SDVariable x)Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^xSDVariableSDMath. expm1(SDVariable x)Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^xSDVariableSDRandom. exponential(double lambda, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a exponential distribution:
P(x) = lambda * exp(-lambda * x)
Inputs must satisfy the following constraints:
Must be positive: lambda > 0SDVariableSDRandom. exponential(String name, double lambda, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a exponential distribution:
P(x) = lambda * exp(-lambda * x)
Inputs must satisfy the following constraints:
Must be positive: lambda > 0SDVariableSDCNN. extractImagePatches(String name, SDVariable input, int kH, int kW, int sH, int sW, int rH, int rW, boolean sameMode)Extract image patchesSDVariableSDCNN. extractImagePatches(SDVariable input, int kH, int kW, int sH, int sW, int rH, int rW, boolean sameMode)Extract image patchesSDVariableSDImage. extractImagePatches(String name, SDVariable image, int[] kSizes, int[] strides, int[] rates, boolean sameMode)Given an input image, extract out image patches (of size kSizes - h x w) and place them in the depth dimension.SDVariableSDImage. extractImagePatches(SDVariable image, int[] kSizes, int[] strides, int[] rates, boolean sameMode)Given an input image, extract out image patches (of size kSizes - h x w) and place them in the depth dimension.SDVariableSDMath. eye(int rows)Generate an identity matrix with the specified number of rows and columns.SDVariableSDMath. eye(int rows, int cols)As per eye(String, int, int, DataType) but with the default datatype, Eye.DEFAULT_DTYPESDVariableSDMath. eye(int rows, int cols, DataType dataType, int... dimensions)Generate an identity matrix with the specified number of rows and columns
Example:SDVariableSDMath. eye(String name, int rows)Generate an identity matrix with the specified number of rows and columns.SDVariableSDMath. eye(String name, int rows, int cols)As per eye(String, int, int, DataType) but with the default datatype, Eye.DEFAULT_DTYPESDVariableSDMath. eye(String name, int rows, int cols, DataType dataType, int... dimensions)Generate an identity matrix with the specified number of rows and columns
Example:SDVariableSDMath. eye(String name, SDVariable rows)As per eye(String, int) but with the number of rows specified as a scalar INDArraySDVariableSDMath. eye(String name, SDVariable rows, SDVariable cols)As per eye(int, int) bit with the number of rows/columns specified as scalar INDArraysSDVariableSDMath. eye(SDVariable rows)As per eye(String, int) but with the number of rows specified as a scalar INDArraySDVariableSDMath. eye(SDVariable rows, SDVariable cols)As per eye(int, int) bit with the number of rows/columns specified as scalar INDArraysSDVariableSDBaseOps. fill(String name, SDVariable shape, DataType dataType, double value)Generate an output variable with the specified (dynamic) shape with all elements set to the specified valueSDVariableSDBaseOps. fill(SDVariable shape, DataType dataType, double value)Generate an output variable with the specified (dynamic) shape with all elements set to the specified valueSDVariableSDMath. firstIndex(String name, SDVariable in, Condition condition, boolean keepDims, int... dimensions)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.SDVariableSDMath. firstIndex(String name, SDVariable in, Condition condition, int... dimensions)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.SDVariableSDMath. firstIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)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.SDVariableSDMath. firstIndex(SDVariable in, Condition condition, int... dimensions)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.SDVariableSDBaseOps. flatten(String name, SDVariable... inputs)Return a flattened variable with the specified orderingSDVariableSDBaseOps. flatten(String name, SDVariable[] inputs, String order)Return a flattened variable with the specified orderingSDVariableSDBaseOps. flatten(SDVariable... inputs)Return a flattened variable with the specified orderingSDVariableSDBaseOps. flatten(SDVariable[] inputs, String order)Return a flattened variable with the specified orderingSDVariableSDMath. floor(String name, SDVariable x)Element-wise floor function: out = floor(x).
Rounds each value down to the nearest integer value (if not already an integer)SDVariableSDMath. floor(SDVariable x)Element-wise floor function: out = floor(x).
Rounds each value down to the nearest integer value (if not already an integer)SDVariableSDMath. floorDiv(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. floorDiv(SDVariable x, SDVariable y)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.htmlSDVariableSDMath. floorMod(String name, SDVariable x, double value)Scalar floor modulus operationSDVariableSDMath. floorMod(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. floorMod(SDVariable x, double value)Scalar floor modulus operationSDVariableSDMath. floorMod(SDVariable x, SDVariable y)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.htmlSDVariableSDBaseOps. gather(String name, SDVariable df, int[] indices, int axis)Gather slices from the input variable where the indices are specified as fixed int[] values.
Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.SDVariableSDBaseOps. gather(String name, SDVariable df, SDVariable indices, int axis)Gather slices from the input variable where the indices are specified as dynamic array values.
Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.SDVariableSDBaseOps. gather(SDVariable df, int[] indices, int axis)Gather slices from the input variable where the indices are specified as fixed int[] values.
Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.SDVariableSDBaseOps. gather(SDVariable df, SDVariable indices, int axis)Gather slices from the input variable where the indices are specified as dynamic array values.
Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.SDVariableSDBaseOps. gatherNd(String name, SDVariable df, SDVariable indices)Gather slices from df with shape specified by indices.SDVariableSDBaseOps. gatherNd(SDVariable df, SDVariable indices)Gather slices from df with shape specified by indices.SDVariableSDNN. gelu(String name, SDVariable x)GELU activation function - Gaussian Error Linear Units
For more details, see Gaussian Error Linear Units (GELUs) - https://arxiv.org/abs/1606.08415
This method uses the sigmoid approximationSDVariableSDNN. gelu(SDVariable x)GELU activation function - Gaussian Error Linear Units
For more details, see Gaussian Error Linear Units (GELUs) - https://arxiv.org/abs/1606.08415
This method uses the sigmoid approximationSDVariableSDRNN. gru(String name, SDVariable x, SDVariable hLast, SDVariable Wx, SDVariable Wh, SDVariable biases)The GRU operation.SDVariableSDRNN. gru(SDVariable x, SDVariable hLast, SDVariable Wx, SDVariable Wh, SDVariable biases)The GRU operation.SDVariable[]SDRNN. gruCell(String[] names, SDVariable x, SDVariable hLast, GRUWeights GRUWeights)The GRU cell.SDVariable[]SDRNN. gruCell(SDVariable x, SDVariable hLast, GRUWeights GRUWeights)The GRU cell.SDVariableSDBaseOps. gt(String name, SDVariable x, double y)Greater than operation: elementwise x > y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gt(String name, SDVariable x, SDVariable y)Greater than operation: elementwise x > y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gt(SDVariable x, double y)Greater than operation: elementwise x > y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gt(SDVariable x, SDVariable y)Greater than operation: elementwise x > y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gte(String name, SDVariable x, double y)Greater than or equals operation: elementwise x >= y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gte(String name, SDVariable x, SDVariable y)Greater than or equal to operation: elementwise x >= y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gte(SDVariable x, double y)Greater than or equals operation: elementwise x >= y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gte(SDVariable x, SDVariable y)Greater than or equal to operation: elementwise x >= y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDMath. hammingDistance(String name, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Hamming distance reduction operation.SDVariableSDMath. hammingDistance(String name, SDVariable x, SDVariable y, int... dimensions)Hamming distance reduction operation.SDVariableSDMath. hammingDistance(SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Hamming distance reduction operation.SDVariableSDMath. hammingDistance(SDVariable x, SDVariable y, int... dimensions)Hamming distance reduction operation.SDVariableSDNN. hardSigmoid(String name, SDVariable x)Element-wise hard sigmoid function:
out[i] = 0 if in[i] <= -2.5
out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5
out[i] = 1 if in[i] >= 2.5SDVariableSDNN. hardSigmoid(SDVariable x)Element-wise hard sigmoid function:
out[i] = 0 if in[i] <= -2.5
out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5
out[i] = 1 if in[i] >= 2.5SDVariableSDNN. hardTanh(String name, SDVariable x)Element-wise hard tanh function:
out[i] = -1 if in[i] <= -1
out[1] = in[i] if -1 < in[i] < 1
out[i] = 1 if in[i] >= 1SDVariableSDNN. hardTanh(SDVariable x)Element-wise hard tanh function:
out[i] = -1 if in[i] <= -1
out[1] = in[i] if -1 < in[i] < 1
out[i] = 1 if in[i] >= 1SDVariableSDNN. hardTanhDerivative(String name, SDVariable x)Derivative (dOut/dIn) of the element-wise hard Tanh function - hardTanh(INDArray)SDVariableSDNN. hardTanhDerivative(SDVariable x)Derivative (dOut/dIn) of the element-wise hard Tanh function - hardTanh(INDArray)SDVariableSDLoss. hingeLoss(String name, SDVariable label, SDVariable predictions, SDVariable weights)Hinge loss: a loss function used for training classifiers.
ImplementsL = max(0, 1 - t * predictions)where t is the label values after internally converting to {-1,1}
from the user specified {0,1}.SDVariableSDLoss. hingeLoss(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Hinge loss: a loss function used for training classifiers.
ImplementsL = max(0, 1 - t * predictions)where t is the label values after internally converting to {-1,1}
from the user specified {0,1}.SDVariableSDLoss. hingeLoss(SDVariable label, SDVariable predictions, SDVariable weights)Hinge loss: a loss function used for training classifiers.
ImplementsL = max(0, 1 - t * predictions)where t is the label values after internally converting to {-1,1}
from the user specified {0,1}.SDVariableSDLoss. hingeLoss(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Hinge loss: a loss function used for training classifiers.
ImplementsL = max(0, 1 - t * predictions)where t is the label values after internally converting to {-1,1}
from the user specified {0,1}.SDVariableSDImage. hsvToRgb(String name, SDVariable input)Converting image from HSV to RGB formatSDVariableSDImage. hsvToRgb(SDVariable input)Converting image from HSV to RGB formatSDVariableSDLoss. huberLoss(String name, SDVariable label, SDVariable predictions, SDVariable weights, double delta)Huber loss function, used for robust regression.SDVariableSDLoss. huberLoss(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double delta)Huber loss function, used for robust regression.SDVariableSDLoss. huberLoss(SDVariable label, SDVariable predictions, SDVariable weights, double delta)Huber loss function, used for robust regression.SDVariableSDLoss. huberLoss(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double delta)Huber loss function, used for robust regression.SDVariableSDMath. iamax(String name, SDVariable in, boolean keepDims, int... dimensions)Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)SDVariableSDMath. iamax(String name, SDVariable in, int... dimensions)Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)SDVariableSDMath. iamax(SDVariable in, boolean keepDims, int... dimensions)Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)SDVariableSDMath. iamax(SDVariable in, int... dimensions)Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)SDVariableSDMath. iamin(String name, SDVariable in, boolean keepDims, int... dimensions)Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)SDVariableSDMath. iamin(String name, SDVariable in, int... dimensions)Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)SDVariableSDMath. iamin(SDVariable in, boolean keepDims, int... dimensions)Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)SDVariableSDMath. iamin(SDVariable in, int... dimensions)Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)SDVariableSDBaseOps. identity(String name, SDVariable input)Elementwise identity operation: out = xSDVariableSDBaseOps. identity(SDVariable input)Elementwise identity operation: out = xSDVariableSDCNN. im2Col(String name, SDVariable in, Conv2DConfig Conv2DConfig)im2col operation for use in 2D convolution operations.SDVariableSDCNN. im2Col(SDVariable in, Conv2DConfig Conv2DConfig)im2col operation for use in 2D convolution operations.SDVariableSDImage. imageResize(String name, SDVariable input, SDVariable size, boolean preserveAspectRatio, boolean antialias, ImageResizeMethod ImageResizeMethod)Resize images to size using the specified method.SDVariableSDImage. imageResize(String name, SDVariable input, SDVariable size, ImageResizeMethod ImageResizeMethod)Resize images to size using the specified method.SDVariableSDImage. imageResize(SDVariable input, SDVariable size, boolean preserveAspectRatio, boolean antialias, ImageResizeMethod ImageResizeMethod)Resize images to size using the specified method.SDVariableSDImage. imageResize(SDVariable input, SDVariable size, ImageResizeMethod ImageResizeMethod)Resize images to size using the specified method.SDVariableSDBaseOps. invertPermutation(String name, SDVariable input)Compute the inverse permutation indices for a permutation operation
Example: if input is [2, 0, 1] then output is [1, 2, 0]
The idea is that x.permute(input).permute(invertPermutation(input)) == xSDVariableSDBaseOps. invertPermutation(SDVariable input)Compute the inverse permutation indices for a permutation operation
Example: if input is [2, 0, 1] then output is [1, 2, 0]
The idea is that x.permute(input).permute(invertPermutation(input)) == xSDVariableSDMath. isFinite(String name, SDVariable x)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 otherwiseSDVariableSDMath. isFinite(SDVariable x)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 otherwiseSDVariableSDMath. isInfinite(String name, SDVariable x)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 otherwiseSDVariableSDMath. isInfinite(SDVariable x)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 otherwiseSDVariableSDMath. isMax(String name, SDVariable x)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 otherwiseSDVariableSDMath. isMax(SDVariable x)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 otherwiseSDVariableSDMath. isNaN(String name, SDVariable x)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 otherwiseSDVariableSDMath. isNaN(SDVariable x)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 otherwiseSDVariableSDMath. isNonDecreasing(String name, SDVariable x)Is the array non decreasing?
An array is non-decreasing if for every valid i, x[i] <= x[i+1].SDVariableSDMath. isNonDecreasing(SDVariable x)Is the array non decreasing?
An array is non-decreasing if for every valid i, x[i] <= x[i+1].SDVariableSDBaseOps. isNumericTensor(String name, SDVariable x)Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1SDVariableSDBaseOps. isNumericTensor(SDVariable x)Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1SDVariableSDMath. isStrictlyIncreasing(String name, SDVariable x)Is the array strictly increasing?
An array is strictly increasing if for every valid i, x[i] < x[i+1].SDVariableSDMath. isStrictlyIncreasing(SDVariable x)Is the array strictly increasing?
An array is strictly increasing if for every valid i, x[i] < x[i+1].SDVariableSDMath. jaccardDistance(String name, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Jaccard similarity reduction operation.SDVariableSDMath. jaccardDistance(String name, SDVariable x, SDVariable y, int... dimensions)Jaccard similarity reduction operation.SDVariableSDMath. jaccardDistance(SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Jaccard similarity reduction operation.SDVariableSDMath. jaccardDistance(SDVariable x, SDVariable y, int... dimensions)Jaccard similarity reduction operation.SDVariableSDLoss. l2Loss(String name, SDVariable var)L2 loss: 1/2 * sum(x^2)SDVariableSDLoss. l2Loss(SDVariable var)L2 loss: 1/2 * sum(x^2)SDVariableSDMath. lastIndex(String name, SDVariable in, Condition condition, boolean keepDims, int... dimensions)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.SDVariableSDMath. lastIndex(String name, SDVariable in, Condition condition, int... dimensions)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.SDVariableSDMath. lastIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)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.SDVariableSDMath. lastIndex(SDVariable in, Condition condition, int... dimensions)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.SDVariableSDNN. layerNorm(String name, SDVariable input, SDVariable gain, boolean channelsFirst, int... dimensions)Apply Layer Normalization
y = gain * standardize(x) + biasSDVariableSDNN. layerNorm(String name, SDVariable input, SDVariable gain, SDVariable bias, boolean channelsFirst, int... dimensions)Apply Layer Normalization
y = gain * standardize(x) + biasSDVariableSDNN. layerNorm(SDVariable input, SDVariable gain, boolean channelsFirst, int... dimensions)Apply Layer Normalization
y = gain * standardize(x) + biasSDVariableSDNN. layerNorm(SDVariable input, SDVariable gain, SDVariable bias, boolean channelsFirst, int... dimensions)Apply Layer Normalization
y = gain * standardize(x) + biasSDVariableSDNN. leakyRelu(String name, SDVariable x, double alpha)Element-wise leaky ReLU function:
out = x if x >= 0.0
out = alpha * x if x < cutoff
Alpha value is most commonly set to 0.01SDVariableSDNN. leakyRelu(SDVariable x, double alpha)Element-wise leaky ReLU function:
out = x if x >= 0.0
out = alpha * x if x < cutoff
Alpha value is most commonly set to 0.01SDVariableSDNN. leakyReluDerivative(String name, SDVariable x, double alpha)Leaky ReLU derivative: dOut/dIn given input.SDVariableSDNN. leakyReluDerivative(SDVariable x, double alpha)Leaky ReLU derivative: dOut/dIn given input.SDVariableSDBitwise. leftShift(String name, SDVariable x, SDVariable y)Bitwise left shift operation.SDVariableSDBitwise. leftShift(SDVariable x, SDVariable y)Bitwise left shift operation.SDVariableSDBitwise. leftShiftCyclic(String name, SDVariable x, SDVariable y)Bitwise left cyclical shift operation.SDVariableSDBitwise. leftShiftCyclic(SDVariable x, SDVariable y)Bitwise left cyclical shift operation.SDVariableSDNN. linear(String name, SDVariable input, SDVariable weights, SDVariable bias)Linear layer operation: out = mmul(in,w) + bias
Note that bias array is optionalSDVariableSDNN. linear(SDVariable input, SDVariable weights, SDVariable bias)Linear layer operation: out = mmul(in,w) + bias
Note that bias array is optionalSDVariableSDBaseOps. linspace(String name, SDVariable start, SDVariable stop, SDVariable number, DataType dataType)Create a new 1d array with values evenly spaced between values 'start' and 'stop'
For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0]SDVariableSDBaseOps. linspace(String name, DataType dataType, double start, double stop, long number)Create a new 1d array with values evenly spaced between values 'start' and 'stop'
For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0]SDVariableSDBaseOps. linspace(SDVariable start, SDVariable stop, SDVariable number, DataType dataType)Create a new 1d array with values evenly spaced between values 'start' and 'stop'
For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0]SDVariableSDBaseOps. linspace(DataType dataType, double start, double stop, long number)Create a new 1d array with values evenly spaced between values 'start' and 'stop'
For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0]SDVariable[]SDMath. listDiff(String[] names, SDVariable x, SDVariable y)Calculates difference between inputs X and Y.SDVariable[]SDMath. listDiff(SDVariable x, SDVariable y)Calculates difference between inputs X and Y.SDVariableSDCNN. localResponseNormalization(String name, SDVariable input, LocalResponseNormalizationConfig LocalResponseNormalizationConfig)2D convolution layer operation - local response normalizationSDVariableSDCNN. localResponseNormalization(SDVariable input, LocalResponseNormalizationConfig LocalResponseNormalizationConfig)2D convolution layer operation - local response normalizationSDVariableSDMath. log(String name, SDVariable x)Element-wise logarithm function (base e - natural logarithm): out = log(x)SDVariableSDMath. log(String name, SDVariable x, double base)Element-wise logarithm function (with specified base): out = log_{base}(x)SDVariableSDMath. log(SDVariable x)Element-wise logarithm function (base e - natural logarithm): out = log(x)SDVariableSDMath. log(SDVariable x, double base)Element-wise logarithm function (with specified base): out = log_{base}(x)SDVariableSDMath. log1p(String name, SDVariable x)Elementwise natural logarithm function: out = log_e (1 + x)SDVariableSDMath. log1p(SDVariable x)Elementwise natural logarithm function: out = log_e (1 + x)SDVariableSDLinalg. logdet(String name, SDVariable input)Calculates log of determinant.SDVariableSDLinalg. logdet(SDVariable input)Calculates log of determinant.SDVariableSDMath. logEntropy(String name, SDVariable in, boolean keepDims, int... dimensions)Log entropy reduction: log(-sum(x * log(x)))SDVariableSDMath. logEntropy(String name, SDVariable in, int... dimensions)Log entropy reduction: log(-sum(x * log(x)))SDVariableSDMath. logEntropy(SDVariable in, boolean keepDims, int... dimensions)Log entropy reduction: log(-sum(x * log(x)))SDVariableSDMath. logEntropy(SDVariable in, int... dimensions)Log entropy reduction: log(-sum(x * log(x)))SDVariableSDLoss. logLoss(String name, SDVariable label, SDVariable predictions)Log loss, i.e., binary cross entropy loss, usually used for binary multi-label classification.SDVariableSDLoss. logLoss(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double epsilon)Log loss, i.e., binary cross entropy loss, usually used for binary multi-label classification.SDVariableSDLoss. logLoss(SDVariable label, SDVariable predictions)Log loss, i.e., binary cross entropy loss, usually used for binary multi-label classification.SDVariableSDLoss. logLoss(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double epsilon)Log loss, i.e., binary cross entropy loss, usually used for binary multi-label classification.SDVariableSDRandom. logNormal(double mean, double stddev, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a Log Normal distribution,
i.e.,log(x) ~ N(mean, stdev)SDVariableSDRandom. logNormal(String name, double mean, double stddev, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a Log Normal distribution,
i.e.,log(x) ~ N(mean, stdev)SDVariableSDLoss. logPoisson(String name, SDVariable label, SDVariable predictions, SDVariable weights, boolean full)Log poisson loss: a loss function used for training classifiers.
ImplementsL = exp(c) - z * cwhere c is log(predictions) and z is labels.SDVariableSDLoss. logPoisson(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, boolean full)Log poisson loss: a loss function used for training classifiers.
ImplementsL = exp(c) - z * cwhere c is log(predictions) and z is labels.SDVariableSDLoss. logPoisson(SDVariable label, SDVariable predictions, SDVariable weights, boolean full)Log poisson loss: a loss function used for training classifiers.
ImplementsL = exp(c) - z * cwhere c is log(predictions) and z is labels.SDVariableSDLoss. logPoisson(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, boolean full)Log poisson loss: a loss function used for training classifiers.
ImplementsL = exp(c) - z * cwhere c is log(predictions) and z is labels.SDVariableSDNN. logSigmoid(String name, SDVariable x)Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))SDVariableSDNN. logSigmoid(SDVariable x)Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))SDVariableSDNN. logSoftmax(String name, SDVariable x)Log softmax activationSDVariableSDNN. logSoftmax(String name, SDVariable x, int dimension)Log softmax activationSDVariableSDNN. logSoftmax(SDVariable x)Log softmax activationSDVariableSDNN. logSoftmax(SDVariable x, int dimension)Log softmax activationSDVariableSDMath. logSumExp(String name, SDVariable input, int... dimensions)Log-sum-exp reduction (optionally along dimension).
Computes log(sum(exp(x))SDVariableSDMath. logSumExp(SDVariable input, int... dimensions)Log-sum-exp reduction (optionally along dimension).
Computes log(sum(exp(x))SDVariableSDRNN. lstmblock(String name, SDVariable maxTSLength, SDVariable x, SDVariable cLast, SDVariable yLast, LSTMWeights LSTMWeights, LSTMConfiguration LSTMConfiguration)The LSTM blockSDVariableSDRNN. lstmblock(String name, SDVariable x, LSTMWeights LSTMWeights, LSTMConfiguration LSTMConfiguration)The LSTM blockSDVariableSDRNN. lstmblock(SDVariable maxTSLength, SDVariable x, SDVariable cLast, SDVariable yLast, LSTMWeights LSTMWeights, LSTMConfiguration LSTMConfiguration)The LSTM blockSDVariableSDRNN. lstmblock(SDVariable x, LSTMWeights LSTMWeights, LSTMConfiguration LSTMConfiguration)The LSTM blockSDVariable[]SDRNN. lstmCell(String[] names, SDVariable x, SDVariable cLast, SDVariable yLast, LSTMWeights LSTMWeights, LSTMConfiguration LSTMConfiguration)The LSTM cell.SDVariable[]SDRNN. lstmCell(SDVariable x, SDVariable cLast, SDVariable yLast, LSTMWeights LSTMWeights, LSTMConfiguration LSTMConfiguration)The LSTM cell.SDVariable[]SDRNN. lstmLayer(String[] names, SDVariable x, SDVariable cLast, SDVariable yLast, SDVariable maxTSLength, LSTMLayerWeights LSTMLayerWeights, LSTMLayerConfig LSTMLayerConfig)Long Short-Term Memory layer - Hochreiter 1997.
SUPPORTS following data formats:
for unidirectional:
TNS: shapes [timeLength, numExamples, inOutSize]
NST: shapes [numExamples, inOutSize, timeLength]
NTS: shapes [numExamples, timeLength, inOutSize]
for bidirectional:
T2NS: shapes [timeLength, 2, numExamples, inOutSize] (for ONNX)
SUPPORTS following direction modes:
FWD: forward
BWD: backward
BIDIR_SUM: bidirectional sum
BIDIR_CONCAT: bidirectional concat
BIDIR_EXTRA_DIM: bidirectional extra output dim (in conjunction with format dataFormat - T2NS)
You may use different gate configurations:
specify gate/cell/out aplha/beta and numbers of activations for gate/cell/out described in activations enum
("RELU","SIGMOID","AFFINE","LEAKY_RELU","THRESHHOLD_RELU","SCALED_TAHN","HARD_SIGMOID","ELU","SOFTSIGN","SOFTPLUS")
Also this layer supports MKLDNN (DNNL) and cuDNN accelerationSDVariable[]SDRNN. lstmLayer(String[] names, SDVariable x, LSTMLayerWeights LSTMLayerWeights, LSTMLayerConfig LSTMLayerConfig)Long Short-Term Memory layer - Hochreiter 1997.
SUPPORTS following data formats:
for unidirectional:
TNS: shapes [timeLength, numExamples, inOutSize]
NST: shapes [numExamples, inOutSize, timeLength]
NTS: shapes [numExamples, timeLength, inOutSize]
for bidirectional:
T2NS: shapes [timeLength, 2, numExamples, inOutSize] (for ONNX)
SUPPORTS following direction modes:
FWD: forward
BWD: backward
BIDIR_SUM: bidirectional sum
BIDIR_CONCAT: bidirectional concat
BIDIR_EXTRA_DIM: bidirectional extra output dim (in conjunction with format dataFormat - T2NS)
You may use different gate configurations:
specify gate/cell/out aplha/beta and numbers of activations for gate/cell/out described in activations enum
("RELU","SIGMOID","AFFINE","LEAKY_RELU","THRESHHOLD_RELU","SCALED_TAHN","HARD_SIGMOID","ELU","SOFTSIGN","SOFTPLUS")
Also this layer supports MKLDNN (DNNL) and cuDNN accelerationSDVariable[]SDRNN. lstmLayer(SDVariable x, SDVariable cLast, SDVariable yLast, SDVariable maxTSLength, LSTMLayerWeights LSTMLayerWeights, LSTMLayerConfig LSTMLayerConfig)Long Short-Term Memory layer - Hochreiter 1997.
SUPPORTS following data formats:
for unidirectional:
TNS: shapes [timeLength, numExamples, inOutSize]
NST: shapes [numExamples, inOutSize, timeLength]
NTS: shapes [numExamples, timeLength, inOutSize]
for bidirectional:
T2NS: shapes [timeLength, 2, numExamples, inOutSize] (for ONNX)
SUPPORTS following direction modes:
FWD: forward
BWD: backward
BIDIR_SUM: bidirectional sum
BIDIR_CONCAT: bidirectional concat
BIDIR_EXTRA_DIM: bidirectional extra output dim (in conjunction with format dataFormat - T2NS)
You may use different gate configurations:
specify gate/cell/out aplha/beta and numbers of activations for gate/cell/out described in activations enum
("RELU","SIGMOID","AFFINE","LEAKY_RELU","THRESHHOLD_RELU","SCALED_TAHN","HARD_SIGMOID","ELU","SOFTSIGN","SOFTPLUS")
Also this layer supports MKLDNN (DNNL) and cuDNN accelerationSDVariable[]SDRNN. lstmLayer(SDVariable x, LSTMLayerWeights LSTMLayerWeights, LSTMLayerConfig LSTMLayerConfig)Long Short-Term Memory layer - Hochreiter 1997.
SUPPORTS following data formats:
for unidirectional:
TNS: shapes [timeLength, numExamples, inOutSize]
NST: shapes [numExamples, inOutSize, timeLength]
NTS: shapes [numExamples, timeLength, inOutSize]
for bidirectional:
T2NS: shapes [timeLength, 2, numExamples, inOutSize] (for ONNX)
SUPPORTS following direction modes:
FWD: forward
BWD: backward
BIDIR_SUM: bidirectional sum
BIDIR_CONCAT: bidirectional concat
BIDIR_EXTRA_DIM: bidirectional extra output dim (in conjunction with format dataFormat - T2NS)
You may use different gate configurations:
specify gate/cell/out aplha/beta and numbers of activations for gate/cell/out described in activations enum
("RELU","SIGMOID","AFFINE","LEAKY_RELU","THRESHHOLD_RELU","SCALED_TAHN","HARD_SIGMOID","ELU","SOFTSIGN","SOFTPLUS")
Also this layer supports MKLDNN (DNNL) and cuDNN accelerationSDVariableSDLinalg. lstsq(String name, SDVariable matrix, SDVariable rhs, double l2_reguralizer)Solver for linear squares problems.SDVariableSDLinalg. lstsq(String name, SDVariable matrix, SDVariable rhs, double l2_reguralizer, boolean fast)Solver for linear squares problems.SDVariableSDLinalg. lstsq(SDVariable matrix, SDVariable rhs, double l2_reguralizer)Solver for linear squares problems.SDVariableSDLinalg. lstsq(SDVariable matrix, SDVariable rhs, double l2_reguralizer, boolean fast)Solver for linear squares problems.SDVariableSDBaseOps. lt(String name, SDVariable x, double y)Less than operation: elementwise x < y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lt(String name, SDVariable x, SDVariable y)Less than operation: elementwise x < y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lt(SDVariable x, double y)Less than operation: elementwise x < y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lt(SDVariable x, SDVariable y)Less than operation: elementwise x < y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lte(String name, SDVariable x, double y)Less than or equals operation: elementwise x <= y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lte(String name, SDVariable x, SDVariable y)Less than or equal to operation: elementwise x <= y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lte(SDVariable x, double y)Less than or equals operation: elementwise x <= y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lte(SDVariable x, SDVariable y)Less than or equal to operation: elementwise x <= y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDLinalg. lu(String name, SDVariable input)Computes LU decomposition.SDVariableSDLinalg. lu(SDVariable input)Computes LU decomposition.SDVariableSDMath. manhattanDistance(String name, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Manhattan distance (l1 norm, l1 distance) reduction operation.SDVariableSDMath. manhattanDistance(String name, SDVariable x, SDVariable y, int... dimensions)Manhattan distance (l1 norm, l1 distance) reduction operation.SDVariableSDMath. manhattanDistance(SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Manhattan distance (l1 norm, l1 distance) reduction operation.SDVariableSDMath. manhattanDistance(SDVariable x, SDVariable y, int... dimensions)Manhattan distance (l1 norm, l1 distance) reduction operation.SDVariableSDBaseOps. matchCondition(String name, SDVariable in, Condition condition)Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwiseSDVariableSDBaseOps. matchCondition(SDVariable in, Condition condition)Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwiseSDVariableSDBaseOps. matchConditionCount(String name, SDVariable in, Condition condition)Returns a count of the number of elements that satisfy the conditionSDVariableSDBaseOps. matchConditionCount(String name, SDVariable in, Condition condition, boolean keepDim, int... dimensions)Returns a count of the number of elements that satisfy the 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.SDVariableSDBaseOps. matchConditionCount(String name, SDVariable in, Condition condition, int... dimensions)Returns a count of the number of elements that satisfy the 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.SDVariableSDBaseOps. matchConditionCount(SDVariable in, Condition condition)Returns a count of the number of elements that satisfy the conditionSDVariableSDBaseOps. matchConditionCount(SDVariable in, Condition condition, boolean keepDim, int... dimensions)Returns a count of the number of elements that satisfy the 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.SDVariableSDBaseOps. matchConditionCount(SDVariable in, Condition condition, int... dimensions)Returns a count of the number of elements that satisfy the 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.SDVariableSDLinalg. matmul(String name, SDVariable a, SDVariable b)Performs matrix mutiplication on input tensors.SDVariableSDLinalg. matmul(SDVariable a, SDVariable b)Performs matrix mutiplication on input tensors.SDVariable[]SDLinalg. matrixBandPart(String[] names, SDVariable input, int minLower, int maxUpper)Copy a tensor setting outside a central band in each innermost matrix.SDVariable[]SDLinalg. matrixBandPart(SDVariable input, int minLower, int maxUpper)Copy a tensor setting outside a central band in each innermost matrix.SDVariableSDLinalg. matrixDeterminant(String name, SDVariable input)Calculates matrix determinant.SDVariableSDLinalg. matrixDeterminant(SDVariable input)Calculates matrix determinant.SDVariableSDMath. matrixDeterminant(String name, SDVariable in)Matrix determinant op.SDVariableSDMath. matrixDeterminant(SDVariable in)Matrix determinant op.SDVariableSDLinalg. matrixInverse(String name, SDVariable input)Inverts a matrixSDVariableSDLinalg. matrixInverse(SDVariable input)Inverts a matrixSDVariableSDMath. matrixInverse(String name, SDVariable in)Matrix inverse op.SDVariableSDMath. matrixInverse(SDVariable in)Matrix inverse op.SDVariableSDBaseOps. max(String name, SDVariable x, boolean keepDims, int... dimensions)Max array reduction operation, optionally along 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.SDVariableSDBaseOps. max(String name, SDVariable x, int... dimensions)Max array reduction operation, optionally along 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.SDVariableSDBaseOps. max(String name, SDVariable first, SDVariable second)Element-wise maximum operation: out[i] = max(first[i], second[i])
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.htmlSDVariableSDBaseOps. max(SDVariable x, boolean keepDims, int... dimensions)Max array reduction operation, optionally along 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.SDVariableSDBaseOps. max(SDVariable x, int... dimensions)Max array reduction operation, optionally along 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.SDVariableSDBaseOps. max(SDVariable first, SDVariable second)Element-wise maximum operation: out[i] = max(first[i], second[i])
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.htmlSDVariableSDMath. max(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. max(SDVariable x, SDVariable y)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.htmlSDVariableSDCNN. maxPooling2d(String name, SDVariable input, Pooling2DConfig Pooling2DConfig)2D Convolution layer operation - max pooling 2dSDVariableSDCNN. maxPooling2d(SDVariable input, Pooling2DConfig Pooling2DConfig)2D Convolution layer operation - max pooling 2dSDVariableSDCNN. maxPooling3d(String name, SDVariable input, Pooling3DConfig Pooling3DConfig)3D convolution layer operation - max pooling 3d operation.SDVariableSDCNN. maxPooling3d(SDVariable input, Pooling3DConfig Pooling3DConfig)3D convolution layer operation - max pooling 3d operation.SDVariable[]SDCNN. maxPoolWithArgmax(String[] names, SDVariable input, Pooling2DConfig Pooling2DConfig)2D Convolution layer operation - Max pooling on the input and outputs both max values and indicesSDVariable[]SDCNN. maxPoolWithArgmax(SDVariable input, Pooling2DConfig Pooling2DConfig)2D Convolution layer operation - Max pooling on the input and outputs both max values and indicesSDVariableSDBaseOps. mean(String name, SDVariable x, boolean keepDims, int... dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(String name, SDVariable x, int... dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(String name, SDVariable x, SDVariable dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(String name, SDVariable x, SDVariable dimensions, boolean keepDims)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(SDVariable x, boolean keepDims, int... dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(SDVariable x, int... dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(SDVariable x, SDVariable dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(SDVariable x, SDVariable dimensions, boolean keepDims)Mean (average) array reduction operation, optionally along 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.SDVariableSDMath. mean(String name, SDVariable in, boolean keepDims, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(String name, SDVariable in, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(String name, SDVariable in, SDVariable dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(SDVariable in, boolean keepDims, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(SDVariable in, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(SDVariable in, SDVariable dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(SDVariable in, SDVariable dimensions, boolean keepDims)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDLoss. meanPairwiseSquaredError(String name, SDVariable label, SDVariable predictions, SDVariable weights)Mean pairwise squared error.
MPWSE loss calculates the difference between pairs of consecutive elements in the predictions and labels arrays.
For example, if predictions = [p0, p1, p2] and labels are [l0, l1, l2] then MPWSE is:
[((p0-p1) - (l0-l1))^2 + ((p0-p2) - (l0-l2))^2 + ((p1-p2) - (l1-l2))^2] / 3SDVariableSDLoss. meanPairwiseSquaredError(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Mean pairwise squared error.
MPWSE loss calculates the difference between pairs of consecutive elements in the predictions and labels arrays.
For example, if predictions = [p0, p1, p2] and labels are [l0, l1, l2] then MPWSE is:
[((p0-p1) - (l0-l1))^2 + ((p0-p2) - (l0-l2))^2 + ((p1-p2) - (l1-l2))^2] / 3SDVariableSDLoss. meanPairwiseSquaredError(SDVariable label, SDVariable predictions, SDVariable weights)Mean pairwise squared error.
MPWSE loss calculates the difference between pairs of consecutive elements in the predictions and labels arrays.
For example, if predictions = [p0, p1, p2] and labels are [l0, l1, l2] then MPWSE is:
[((p0-p1) - (l0-l1))^2 + ((p0-p2) - (l0-l2))^2 + ((p1-p2) - (l1-l2))^2] / 3SDVariableSDLoss. meanPairwiseSquaredError(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Mean pairwise squared error.
MPWSE loss calculates the difference between pairs of consecutive elements in the predictions and labels arrays.
For example, if predictions = [p0, p1, p2] and labels are [l0, l1, l2] then MPWSE is:
[((p0-p1) - (l0-l1))^2 + ((p0-p2) - (l0-l2))^2 + ((p1-p2) - (l1-l2))^2] / 3SDVariableSDLoss. meanSquaredError(String name, SDVariable label, SDVariable predictions, SDVariable weights)Mean squared error loss function.SDVariableSDLoss. meanSquaredError(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Mean squared error loss function.SDVariableSDLoss. meanSquaredError(SDVariable label, SDVariable predictions, SDVariable weights)Mean squared error loss function.SDVariableSDLoss. meanSquaredError(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Mean squared error loss function.SDVariableSDBaseOps. merge(String name, SDVariable x, SDVariable y)The merge operation is a control operation that forwards the either of the inputs to the output, when
the first of them becomes available.SDVariableSDBaseOps. merge(SDVariable x, SDVariable y)The merge operation is a control operation that forwards the either of the inputs to the output, when
the first of them becomes available.SDVariableSDMath. mergeAdd(String name, SDVariable... inputs)Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition:
out = sum_i in[i]SDVariableSDMath. mergeAdd(SDVariable... inputs)Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition:
out = sum_i in[i]SDVariableSDMath. mergeAvg(String name, SDVariable... inputs)Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation:
out = mean_i in[i]SDVariableSDMath. mergeAvg(SDVariable... inputs)Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation:
out = mean_i in[i]SDVariableSDMath. mergeMax(String name, SDVariable... inputs)Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation:
out = max_i in[i]SDVariableSDMath. mergeMax(SDVariable... inputs)Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation:
out = max_i in[i]SDVariableSDMath. mergeMaxIndex(String name, SDVariable... x)Return array of max elements indices with along tensor dimensionsSDVariableSDMath. mergeMaxIndex(String name, SDVariable[] x, DataType dataType)Return array of max elements indices with along tensor dimensionsSDVariableSDMath. mergeMaxIndex(SDVariable... x)Return array of max elements indices with along tensor dimensionsSDVariableSDMath. mergeMaxIndex(SDVariable[] x, DataType dataType)Return array of max elements indices with along tensor dimensionsSDVariable[]SDMath. meshgrid(String[] names, SDVariable[] inputs, boolean cartesian)Broadcasts parameters for evaluation on an N-D grid.SDVariable[]SDMath. meshgrid(SDVariable[] inputs, boolean cartesian)Broadcasts parameters for evaluation on an N-D grid.SDVariableSDBaseOps. min(String name, SDVariable x, boolean keepDims, int... dimensions)Minimum array reduction operation, optionally along specified dimensions.SDVariableSDBaseOps. min(String name, SDVariable x, int... dimensions)Minimum array reduction operation, optionally along specified dimensions.SDVariableSDBaseOps. min(String name, SDVariable first, SDVariable second)Element-wise minimum operation: out[i] = min(first[i], second[i])
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.htmlSDVariableSDBaseOps. min(SDVariable x, boolean keepDims, int... dimensions)Minimum array reduction operation, optionally along specified dimensions.SDVariableSDBaseOps. min(SDVariable x, int... dimensions)Minimum array reduction operation, optionally along specified dimensions.SDVariableSDBaseOps. min(SDVariable first, SDVariable second)Element-wise minimum operation: out[i] = min(first[i], second[i])
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.htmlSDVariableSDMath. min(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. min(SDVariable x, SDVariable y)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.htmlSDVariableSDBaseOps. minMax(int datatype, int minOrMax)Return a scalar array reflecting the min or max value for a given data type.SDVariableSDBaseOps. minMax(String name, int datatype, int minOrMax)Return a scalar array reflecting the min or max value for a given data type.SDVariableSDBaseOps. mmul(String name, SDVariable x, SDVariable y)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDBaseOps. mmul(String name, SDVariable x, SDVariable y, boolean transposeX, boolean transposeY, boolean transposeZ)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDBaseOps. mmul(SDVariable x, SDVariable y)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDBaseOps. mmul(SDVariable x, SDVariable y, boolean transposeX, boolean transposeY, boolean transposeZ)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDLinalg. mmul(String name, SDVariable x, SDVariable y)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDLinalg. mmul(String name, SDVariable x, SDVariable y, boolean transposeX, boolean transposeY, boolean transposeZ)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDLinalg. mmul(SDVariable x, SDVariable y)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDLinalg. mmul(SDVariable x, SDVariable y, boolean transposeX, boolean transposeY, boolean transposeZ)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDMath. mod(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. mod(SDVariable x, SDVariable y)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.htmlSDVariable[]SDMath. moments(String[] names, SDVariable input, int[] axes, boolean keepDims)Calculate the mean and (population) variance for the input variable, for the specified axisSDVariable[]SDMath. moments(String[] names, SDVariable input, SDVariable axes, boolean keepDims)Calculate the mean and (population) variance for the input variable, for the specified axisSDVariable[]SDMath. moments(SDVariable input, int[] axes, boolean keepDims)Calculate the mean and (population) variance for the input variable, for the specified axisSDVariable[]SDMath. moments(SDVariable input, SDVariable axes, boolean keepDims)Calculate the mean and (population) variance for the input variable, for the specified axisSDVariableSDMath. mul(String name, SDVariable x, double value)Scalar multiplication operation, out = in * scalarSDVariableSDMath. mul(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. mul(SDVariable x, double value)Scalar multiplication operation, out = in * scalarSDVariableSDMath. mul(SDVariable x, SDVariable y)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.htmlSDVariableSDNN. multiHeadDotProductAttention(String name, SDVariable queries, SDVariable keys, SDVariable values, SDVariable Wq, SDVariable Wk, SDVariable Wv, SDVariable Wo, SDVariable mask, boolean scaled)This performs multi-headed dot product attention on the given timeseries input
out = concat(head_1, head_2, ..., head_n) * Wo
head_i = dot_product_attention(Wq_i*q, Wk_i*k, Wv_i*v)
Optionally with normalization when calculating the attention for each head.
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, pp.SDVariableSDNN. multiHeadDotProductAttention(SDVariable queries, SDVariable keys, SDVariable values, SDVariable Wq, SDVariable Wk, SDVariable Wv, SDVariable Wo, SDVariable mask, boolean scaled)This performs multi-headed dot product attention on the given timeseries input
out = concat(head_1, head_2, ..., head_n) * Wo
head_i = dot_product_attention(Wq_i*q, Wk_i*k, Wv_i*v)
Optionally with normalization when calculating the attention for each head.
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, pp.SDVariableSDMath. neg(String name, SDVariable x)Elementwise negative operation: out = -xSDVariableSDMath. neg(SDVariable x)Elementwise negative operation: out = -xSDVariableSDBaseOps. neq(String name, SDVariable x, double y)Not equals operation: elementwise x != y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. neq(String name, SDVariable x, SDVariable y)Not equal to operation: elementwise x != y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. neq(SDVariable x, double y)Not equals operation: elementwise x != y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. neq(SDVariable x, SDVariable y)Not equal to operation: elementwise x != y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDImage. nonMaxSuppression(String name, SDVariable boxes, SDVariable scores, int maxOutSize, double iouThreshold, double scoreThreshold)Greedily selects a subset of bounding boxes in descending order of scoreSDVariableSDImage. nonMaxSuppression(SDVariable boxes, SDVariable scores, int maxOutSize, double iouThreshold, double scoreThreshold)Greedily selects a subset of bounding boxes in descending order of scoreSDVariableSDBaseOps. norm1(String name, SDVariable x, boolean keepDims, int... dimensions)Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i])
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. norm1(String name, SDVariable x, int... dimensions)Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i])
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. norm1(SDVariable x, boolean keepDims, int... dimensions)Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i])
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. norm1(SDVariable x, int... dimensions)Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i])
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDMath. norm1(String name, SDVariable in, boolean keepDims, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. norm1(String name, SDVariable in, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. norm1(String name, SDVariable in, SDVariable dimensions)Sum of absolute differences.SDVariableSDMath. norm1(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Sum of absolute differences.SDVariableSDMath. norm1(SDVariable in, boolean keepDims, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. norm1(SDVariable in, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. norm1(SDVariable in, SDVariable dimensions)Sum of absolute differences.SDVariableSDMath. norm1(SDVariable in, SDVariable dimensions, boolean keepDims)Sum of absolute differences.SDVariableSDBaseOps. norm2(String name, SDVariable x, boolean keepDims, int... dimensions)Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. norm2(String name, SDVariable x, int... dimensions)Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. norm2(SDVariable x, boolean keepDims, int... dimensions)Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. norm2(SDVariable x, int... dimensions)Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDMath. norm2(String name, SDVariable in, boolean keepDims, int... dimensions)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(String name, SDVariable in, int... dimensions)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(String name, SDVariable in, SDVariable dimensions)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(SDVariable in, boolean keepDims, int... dimensions)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(SDVariable in, int... dimensions)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(SDVariable in, SDVariable dimensions)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(SDVariable in, SDVariable dimensions, boolean keepDims)Euclidean norm: euclidean distance of a vector from the originSDVariableSDRandom. normal(double mean, double stddev, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a Gaussian (normal) distribution,
N(mean, stdev)SDVariableSDRandom. normal(String name, double mean, double stddev, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a Gaussian (normal) distribution,
N(mean, stdev)SDVariable[]SDMath. normalizeMoments(String[] names, SDVariable counts, SDVariable means, SDVariable variances, double shift)Calculate the mean and variance from the sufficient statisticsSDVariable[]SDMath. normalizeMoments(SDVariable counts, SDVariable means, SDVariable variances, double shift)Calculate the mean and variance from the sufficient statisticsSDVariableSDRandom. normalTruncated(double mean, double stddev, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a Gaussian (normal) distribution,
N(mean, stdev).SDVariableSDRandom. normalTruncated(String name, double mean, double stddev, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a Gaussian (normal) distribution,
N(mean, stdev).SDVariableSDBaseOps. normmax(String name, SDVariable x, boolean keepDims, int... dimensions)Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the
specified dimensions:
out = max(abs(x[i]))
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. normmax(String name, SDVariable x, int... dimensions)Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the
specified dimensions:
out = max(abs(x[i]))
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. normmax(SDVariable x, boolean keepDims, int... dimensions)Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the
specified dimensions:
out = max(abs(x[i]))
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. normmax(SDVariable x, int... dimensions)Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the
specified dimensions:
out = max(abs(x[i]))
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDMath. normMax(String name, SDVariable in, boolean keepDims, int... dimensions)Differences between max absolute valueSDVariableSDMath. normMax(String name, SDVariable in, int... dimensions)Differences between max absolute valueSDVariableSDMath. normMax(String name, SDVariable in, SDVariable dimensions)Differences between max absolute valueSDVariableSDMath. normMax(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Differences between max absolute valueSDVariableSDMath. normMax(SDVariable in, boolean keepDims, int... dimensions)Differences between max absolute valueSDVariableSDMath. normMax(SDVariable in, int... dimensions)Differences between max absolute valueSDVariableSDMath. normMax(SDVariable in, SDVariable dimensions)Differences between max absolute valueSDVariableSDMath. normMax(SDVariable in, SDVariable dimensions, boolean keepDims)Differences between max absolute valueSDVariableSDBaseOps. oneHot(String name, SDVariable indices, int depth)Convert the array to a one-hot array with values 0 and 1 for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth],
with out[i, ..., j, in[i,...,j]] = 1 with other values being set to 0
see oneHot(SDVariable, int, int, double, double)SDVariableSDBaseOps. oneHot(String name, SDVariable indices, int depth, int axis, double on, double off)Convert the array to a one-hot array with values and for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth],
with {out[i, ..., j, in[i,...,j]] with other values being set toSDVariableSDBaseOps. oneHot(String name, SDVariable indices, int depth, int axis, double on, double off, DataType dataType)Convert the array to a one-hot array with values and for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth],
with {out[i, ..., j, in[i,...,j]] with other values being set toSDVariableSDBaseOps. oneHot(SDVariable indices, int depth)Convert the array to a one-hot array with values 0 and 1 for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth],
with out[i, ..., j, in[i,...,j]] = 1 with other values being set to 0
see oneHot(SDVariable, int, int, double, double)SDVariableSDBaseOps. oneHot(SDVariable indices, int depth, int axis, double on, double off)Convert the array to a one-hot array with values and for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth],
with {out[i, ..., j, in[i,...,j]] with other values being set toSDVariableSDBaseOps. oneHot(SDVariable indices, int depth, int axis, double on, double off, DataType dataType)Convert the array to a one-hot array with values and for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth],
with {out[i, ..., j, in[i,...,j]] with other values being set toSDVariableSDBaseOps. onesLike(String name, SDVariable input)Return a variable of all 1s, with the same shape as the input variable.SDVariableSDBaseOps. onesLike(String name, SDVariable input, DataType dataType)As per onesLike(String, SDVariable) but the output datatype may be specifiedSDVariableSDBaseOps. onesLike(SDVariable input)Return a variable of all 1s, with the same shape as the input variable.SDVariableSDBaseOps. onesLike(SDVariable input, DataType dataType)As per onesLike(String, SDVariable) but the output datatype may be specifiedSDVariableSDBitwise. or(String name, SDVariable x, SDVariable y)Bitwise OR operation.SDVariableSDBitwise. or(SDVariable x, SDVariable y)Bitwise OR operation.SDVariableSDMath. or(String name, SDVariable x, SDVariable y)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.SDVariableSDMath. or(SDVariable x, SDVariable y)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.SDVariableSDImage. pad(String name, SDVariable input, SDVariable padding, Mode Mode, double padValue)Pads an image according to the given padding typeSDVariableSDImage. pad(SDVariable input, SDVariable padding, Mode Mode, double padValue)Pads an image according to the given padding typeSDVariableSDNN. pad(String name, SDVariable input, SDVariable padding, double constant)Padding operationSDVariableSDNN. pad(String name, SDVariable input, SDVariable padding, PadMode PadMode, double constant)Padding operationSDVariableSDNN. pad(SDVariable input, SDVariable padding, double constant)Padding operationSDVariableSDNN. pad(SDVariable input, SDVariable padding, PadMode PadMode, double constant)Padding operationSDVariableSDBaseOps. permute(String name, SDVariable x, int... dimensions)Array permutation operation: permute the dimensions according to the specified permutation indices.
Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]SDVariableSDBaseOps. permute(String name, SDVariable x, SDVariable dimensions)Array permutation operation: permute the dimensions according to the specified permutation indices.
Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]SDVariableSDBaseOps. permute(SDVariable x, int... dimensions)Array permutation operation: permute the dimensions according to the specified permutation indices.
Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]SDVariableSDBaseOps. permute(SDVariable x, SDVariable dimensions)Array permutation operation: permute the dimensions according to the specified permutation indices.
Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]SDVariableSDMath. pow(String name, SDVariable x, double value)Element-wise power function: out = x^valueSDVariableSDMath. pow(String name, SDVariable x, SDVariable y)Element-wise (broadcastable) power function: out = x[i]^y[i]SDVariableSDMath. pow(SDVariable x, double value)Element-wise power function: out = x^valueSDVariableSDMath. pow(SDVariable x, SDVariable y)Element-wise (broadcastable) power function: out = x[i]^y[i]SDVariableSDNN. preciseGelu(String name, SDVariable x)GELU activation function - Gaussian Error Linear Units
For more details, see Gaussian Error Linear Units (GELUs) - https://arxiv.org/abs/1606.08415
This method uses the precise methodSDVariableSDNN. preciseGelu(SDVariable x)GELU activation function - Gaussian Error Linear Units
For more details, see Gaussian Error Linear Units (GELUs) - https://arxiv.org/abs/1606.08415
This method uses the precise methodSDVariableSDNN. prelu(String name, SDVariable input, SDVariable alpha, int... sharedAxes)PReLU (Parameterized Rectified Linear Unit) operation.SDVariableSDNN. prelu(SDVariable input, SDVariable alpha, int... sharedAxes)PReLU (Parameterized Rectified Linear Unit) operation.SDVariableSDBaseOps. prod(String name, SDVariable x, boolean keepDims, int... dimensions)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(String name, SDVariable x, int... dimensions)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(String name, SDVariable x, SDVariable dimensions)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(String name, SDVariable x, SDVariable dimensions, boolean keepDims)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(SDVariable x, boolean keepDims, int... dimensions)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(SDVariable x, int... dimensions)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(SDVariable x, SDVariable dimensions)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(SDVariable x, SDVariable dimensions, boolean keepDims)Product array reduction operation, optionally along 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.SDVariableSDMath. prod(String name, SDVariable in, boolean keepDims, int... dimensions)The max of an array along each dimensionSDVariableSDMath. prod(String name, SDVariable in, int... dimensions)The max of an array along each dimensionSDVariableSDMath. prod(String name, SDVariable in, SDVariable dimensions)The product of an array long each dimensionSDVariableSDMath. prod(String name, SDVariable in, SDVariable dimensions, boolean keepDims)The product of an array long each dimensionSDVariableSDMath. prod(SDVariable in, boolean keepDims, int... dimensions)The max of an array along each dimensionSDVariableSDMath. prod(SDVariable in, int... dimensions)The max of an array along each dimensionSDVariableSDMath. prod(SDVariable in, SDVariable dimensions)The product of an array long each dimensionSDVariableSDMath. prod(SDVariable in, SDVariable dimensions, boolean keepDims)The product of an array long each dimensionSDVariable[]SDLinalg. qr(String[] names, SDVariable input)Computes the QR decompositions of input matrix.SDVariable[]SDLinalg. qr(String[] names, SDVariable input, boolean full)Computes the QR decompositions of input matrix.SDVariable[]SDLinalg. qr(SDVariable input)Computes the QR decompositions of input matrix.SDVariable[]SDLinalg. qr(SDVariable input, boolean full)Computes the QR decompositions of input matrix.SDVariableSDImage. randomCrop(String name, SDVariable input, SDVariable shape)Randomly crops imageSDVariableSDImage. randomCrop(SDVariable input, SDVariable shape)Randomly crops imageSDVariableSDBaseOps. range(double from, double to, double step, DataType dataType)Create a new variable with a 1d array, where the values start at from and increment by step
up to (but not including) limit.
For example, range(1.0, 3.0, 0.5) will return [1.0, 1.5, 2.0, 2.5]SDVariableSDBaseOps. range(String name, double from, double to, double step, DataType dataType)Create a new variable with a 1d array, where the values start at from and increment by step
up to (but not including) limit.
For example, range(1.0, 3.0, 0.5) will return [1.0, 1.5, 2.0, 2.5]SDVariableSDBaseOps. range(String name, SDVariable from, SDVariable to, SDVariable step, DataType dataType)Create a new variable with a 1d array, where the values start at from and increment by step
up to (but not including) limit.
For example, range(1.0, 3.0, 0.5) will return [1.0, 1.5, 2.0, 2.5]SDVariableSDBaseOps. range(SDVariable from, SDVariable to, SDVariable step, DataType dataType)Create a new variable with a 1d array, where the values start at from and increment by step
up to (but not including) limit.
For example, range(1.0, 3.0, 0.5) will return [1.0, 1.5, 2.0, 2.5]SDVariableSDBaseOps. rank(String name, SDVariable in)Returns the rank (number of dimensions, i.e., length(shape)) of the specified INDArray as a 0D scalar variableSDVariableSDBaseOps. rank(SDVariable in)Returns the rank (number of dimensions, i.e., length(shape)) of the specified INDArray as a 0D scalar variableSDVariableSDMath. rationalTanh(String name, SDVariable x)Rational Tanh Approximation elementwise function, as described in the paper:
Compact Convolutional Neural Network Cascade for Face Detection
This is a faster Tanh approximationSDVariableSDMath. rationalTanh(SDVariable x)Rational Tanh Approximation elementwise function, as described in the paper:
Compact Convolutional Neural Network Cascade for Face Detection
This is a faster Tanh approximationSDVariableSDMath. rdiv(String name, SDVariable x, double value)Scalar reverse division operation, out = scalar / inSDVariableSDMath. rdiv(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. rdiv(SDVariable x, double value)Scalar reverse division operation, out = scalar / inSDVariableSDMath. rdiv(SDVariable x, SDVariable y)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.htmlSDVariableSDMath. reciprocal(String name, SDVariable x)Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]SDVariableSDMath. reciprocal(SDVariable x)Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]SDVariableSDMath. rectifiedTanh(String name, SDVariable x)Rectified tanh operation: max(0, tanh(in))SDVariableSDMath. rectifiedTanh(SDVariable x)Rectified tanh operation: max(0, tanh(in))SDVariableSDMath. reduceAMax(String name, SDVariable in, boolean keepDims, int... dimensions)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(String name, SDVariable in, int... dimensions)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(String name, SDVariable in, SDVariable dimensions)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(SDVariable in, boolean keepDims, int... dimensions)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(SDVariable in, int... dimensions)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(SDVariable in, SDVariable dimensions)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(SDVariable in, SDVariable dimensions, boolean keepDims)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAmean(String name, SDVariable in, boolean keepDims, int... dimensions)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(String name, SDVariable in, int... dimensions)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(String name, SDVariable in, SDVariable dimensions)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(SDVariable in, boolean keepDims, int... dimensions)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(SDVariable in, int... dimensions)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(SDVariable in, SDVariable dimensions)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(SDVariable in, SDVariable dimensions, boolean keepDims)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmin(String name, SDVariable in, boolean keepDims, int... dimensions)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(String name, SDVariable in, int... dimensions)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(String name, SDVariable in, SDVariable dimensions)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(SDVariable in, boolean keepDims, int... dimensions)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(SDVariable in, int... dimensions)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(SDVariable in, SDVariable dimensions)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(SDVariable in, SDVariable dimensions, boolean keepDims)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceMax(String name, SDVariable in, boolean keepDims, int... dimensions)The max of an array along each dimensionSDVariableSDMath. reduceMax(String name, SDVariable in, int... dimensions)The max of an array along each dimensionSDVariableSDMath. reduceMax(String name, SDVariable in, SDVariable dimensions)The max of an array long each dimensionSDVariableSDMath. reduceMax(String name, SDVariable in, SDVariable dimensions, boolean keepDims)The max of an array long each dimensionSDVariableSDMath. reduceMax(SDVariable in, boolean keepDims, int... dimensions)The max of an array along each dimensionSDVariableSDMath. reduceMax(SDVariable in, int... dimensions)The max of an array along each dimensionSDVariableSDMath. reduceMax(SDVariable in, SDVariable dimensions)The max of an array long each dimensionSDVariableSDMath. reduceMax(SDVariable in, SDVariable dimensions, boolean keepDims)The max of an array long each dimensionSDVariableSDMath. reduceMin(String name, SDVariable in, boolean keepDims, int... dimensions)The minimum of an array along each dimensionSDVariableSDMath. reduceMin(String name, SDVariable in, int... dimensions)The minimum of an array along each dimensionSDVariableSDMath. reduceMin(String name, SDVariable in, SDVariable dimensions)The minimum of an array long each dimensionSDVariableSDMath. reduceMin(String name, SDVariable in, SDVariable dimensions, boolean keepDims)The minimum of an array long each dimensionSDVariableSDMath. reduceMin(SDVariable in, boolean keepDims, int... dimensions)The minimum of an array along each dimensionSDVariableSDMath. reduceMin(SDVariable in, int... dimensions)The minimum of an array along each dimensionSDVariableSDMath. reduceMin(SDVariable in, SDVariable dimensions)The minimum of an array long each dimensionSDVariableSDMath. reduceMin(SDVariable in, SDVariable dimensions, boolean keepDims)The minimum of an array long each dimensionSDVariableSDNN. relu(String name, SDVariable x, double cutoff)Element-wise rectified linear function with specified cutoff:
out[i] = in[i] if in[i] >= cutoff
out[i] = 0 otherwiseSDVariableSDNN. relu(SDVariable x, double cutoff)Element-wise rectified linear function with specified cutoff:
out[i] = in[i] if in[i] >= cutoff
out[i] = 0 otherwiseSDVariableSDNN. relu6(String name, SDVariable x, double cutoff)Element-wise "rectified linear 6" function with specified cutoff:
out[i] = min(max(in, cutoff), 6)SDVariableSDNN. relu6(SDVariable x, double cutoff)Element-wise "rectified linear 6" function with specified cutoff:
out[i] = min(max(in, cutoff), 6)SDVariableSDNN. reluLayer(String name, SDVariable input, SDVariable weights, SDVariable bias)ReLU (Rectified Linear Unit) layer operation: out = relu(mmul(in,w) + bias)
Note that bias array is optionalSDVariableSDNN. reluLayer(SDVariable input, SDVariable weights, SDVariable bias)ReLU (Rectified Linear Unit) layer operation: out = relu(mmul(in,w) + bias)
Note that bias array is optionalSDVariableSDBaseOps. repeat(String name, SDVariable input, SDVariable repeats, int axis)A tensor with the shape of input minus the specified axis with elements repeated along the specified axis.SDVariableSDBaseOps. repeat(SDVariable input, SDVariable repeats, int axis)A tensor with the shape of input minus the specified axis with elements repeated along the specified axis.SDVariableSDBaseOps. replaceWhere(String name, SDVariable update, double value, Condition condition)Element-wise replace where condition:
out[i] = value if condition(update[i]) is satisfied, or
out[i] = update[i] if condition(update[i]) is NOT satisfiedSDVariableSDBaseOps. replaceWhere(String name, SDVariable update, SDVariable from, Condition condition)Element-wise replace where condition:
out[i] = from[i] if condition(update[i]) is satisfied, or
out[i] = update[i] if condition(update[i]) is NOT satisfiedSDVariableSDBaseOps. replaceWhere(SDVariable update, double value, Condition condition)Element-wise replace where condition:
out[i] = value if condition(update[i]) is satisfied, or
out[i] = update[i] if condition(update[i]) is NOT satisfiedSDVariableSDBaseOps. replaceWhere(SDVariable update, SDVariable from, Condition condition)Element-wise replace where condition:
out[i] = from[i] if condition(update[i]) is satisfied, or
out[i] = update[i] if condition(update[i]) is NOT satisfiedSDVariableSDBaseOps. reshape(String name, SDVariable x, long... shape)Reshape the input variable to the specified (fixed) shape.SDVariableSDBaseOps. reshape(String name, SDVariable x, SDVariable shape)Reshape the input variable to the specified (fixed) shape.SDVariableSDBaseOps. reshape(SDVariable x, long... shape)Reshape the input variable to the specified (fixed) shape.SDVariableSDBaseOps. reshape(SDVariable x, SDVariable shape)Reshape the input variable to the specified (fixed) shape.SDVariableSDImage. resizeBiCubic(String name, SDVariable input, SDVariable size, boolean alignCorners, boolean alignPixelCenters)Resize images to size using the specified method.SDVariableSDImage. resizeBiCubic(SDVariable input, SDVariable size, boolean alignCorners, boolean alignPixelCenters)Resize images to size using the specified method.SDVariableSDImage. resizeBiLinear(String name, SDVariable input, int height, int width, boolean alignCorners, boolean halfPixelCenters)Resize images to size using the specified method.SDVariableSDImage. resizeBiLinear(SDVariable input, int height, int width, boolean alignCorners, boolean halfPixelCenters)Resize images to size using the specified method.SDVariableSDBaseOps. reverse(String name, SDVariable x, int... dimensions)Reverse the values of an array for the specified dimensions
If input is:
[ 1, 2, 3]
[ 4, 5, 6]
then
reverse(in, 0):
[3, 2, 1]
[6, 5, 4]
reverse(in, 1):
[4, 5, 6]
[1, 2 3]SDVariableSDBaseOps. reverse(SDVariable x, int... dimensions)Reverse the values of an array for the specified dimensions
If input is:
[ 1, 2, 3]
[ 4, 5, 6]
then
reverse(in, 0):
[3, 2, 1]
[6, 5, 4]
reverse(in, 1):
[4, 5, 6]
[1, 2 3]SDVariableSDBaseOps. reverseSequence(String name, SDVariable x, SDVariable seq_lengths)Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversedSDVariableSDBaseOps. reverseSequence(String name, SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim)Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversedSDVariableSDBaseOps. reverseSequence(SDVariable x, SDVariable seq_lengths)Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversedSDVariableSDBaseOps. reverseSequence(SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim)Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversedSDVariableSDImage. rgbToHsv(String name, SDVariable input)Converting array from HSV to RGB formatSDVariableSDImage. rgbToHsv(SDVariable input)Converting array from HSV to RGB formatSDVariableSDImage. rgbToYiq(String name, SDVariable input)Converting array from RGB to YIQ formatSDVariableSDImage. rgbToYiq(SDVariable input)Converting array from RGB to YIQ formatSDVariableSDImage. rgbToYuv(String name, SDVariable input)Converting array from RGB to YUV formatSDVariableSDImage. rgbToYuv(SDVariable input)Converting array from RGB to YUV formatSDVariableSDBitwise. rightShift(String name, SDVariable x, SDVariable y)Bitwise right shift operation.SDVariableSDBitwise. rightShift(SDVariable x, SDVariable y)Bitwise right shift operation.SDVariableSDBitwise. rightShiftCyclic(String name, SDVariable x, SDVariable y)Bitwise right cyclical shift operation.SDVariableSDBitwise. rightShiftCyclic(SDVariable x, SDVariable y)Bitwise right cyclical shift operation.SDVariableSDMath. round(String name, SDVariable x)Element-wise round function: out = round(x).
Rounds (up or down depending on value) to the nearest integer value.SDVariableSDMath. round(SDVariable x)Element-wise round function: out = round(x).
Rounds (up or down depending on value) to the nearest integer value.SDVariableSDMath. rsqrt(String name, SDVariable x)Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)SDVariableSDMath. rsqrt(SDVariable x)Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)SDVariableSDMath. rsub(String name, SDVariable x, double value)Scalar reverse subtraction operation, out = scalar - inSDVariableSDMath. rsub(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. rsub(SDVariable x, double value)Scalar reverse subtraction operation, out = scalar - inSDVariableSDMath. rsub(SDVariable x, SDVariable y)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.htmlSDVariableSDBaseOps. scalarFloorMod(String name, SDVariable in, double value)Element-wise scalar floor modulus operation: out = floorMod(in, value).
i.e., returns the remainder after division by 'value'SDVariableSDBaseOps. scalarFloorMod(SDVariable in, double value)Element-wise scalar floor modulus operation: out = floorMod(in, value).
i.e., returns the remainder after division by 'value'SDVariableSDBaseOps. scalarMax(String name, SDVariable in, double value)Element-wise scalar maximum operation: out = max(in, value)SDVariableSDBaseOps. scalarMax(SDVariable in, double value)Element-wise scalar maximum operation: out = max(in, value)SDVariableSDBaseOps. scalarMin(String name, SDVariable in, double value)Element-wise scalar minimum operation: out = min(in, value)SDVariableSDBaseOps. scalarMin(SDVariable in, double value)Element-wise scalar minimum operation: out = min(in, value)SDVariableSDBaseOps. scalarSet(String name, SDVariable in, double set)Return a variable with equal shape to the input, but all elements set to value 'set'SDVariableSDBaseOps. scalarSet(SDVariable in, double set)Return a variable with equal shape to the input, but all elements set to value 'set'SDVariableSDBaseOps. scatterAdd(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter addition operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterAdd(SDVariable ref, SDVariable indices, SDVariable updates)Scatter addition operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterDiv(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter division operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterDiv(SDVariable ref, SDVariable indices, SDVariable updates)Scatter division operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterMax(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter max operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterMax(SDVariable ref, SDVariable indices, SDVariable updates)Scatter max operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterMin(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter min operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterMin(SDVariable ref, SDVariable indices, SDVariable updates)Scatter min operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterMul(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter multiplication operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterMul(SDVariable ref, SDVariable indices, SDVariable updates)Scatter multiplication operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterSub(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter subtraction operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterSub(SDVariable ref, SDVariable indices, SDVariable updates)Scatter subtraction operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterUpdate(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter update operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterUpdate(SDVariable ref, SDVariable indices, SDVariable updates)Scatter update operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. segmentMax(String name, SDVariable data, SDVariable segmentIds)Segment max operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentMax(SDVariable data, SDVariable segmentIds)Segment max operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentMean(String name, SDVariable data, SDVariable segmentIds)Segment mean operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentMean(SDVariable data, SDVariable segmentIds)Segment mean operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentMin(String name, SDVariable data, SDVariable segmentIds)Segment min operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentMin(SDVariable data, SDVariable segmentIds)Segment min operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentProd(String name, SDVariable data, SDVariable segmentIds)Segment product operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentProd(SDVariable data, SDVariable segmentIds)Segment product operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentSum(String name, SDVariable data, SDVariable segmentIds)Segment sum operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentSum(SDVariable data, SDVariable segmentIds)Segment sum operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDNN. selu(String name, SDVariable x)Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks
out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0
Uses default scale and alpha values.SDVariableSDNN. selu(SDVariable x)Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks
out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0
Uses default scale and alpha values.SDVariableSDCNN. separableConv2d(String name, SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, SDVariable bias, Conv2DConfig Conv2DConfig)Separable 2D convolution operation with optional biasSDVariableSDCNN. separableConv2d(String name, SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, Conv2DConfig Conv2DConfig)Separable 2D convolution operation with optional biasSDVariableSDCNN. separableConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, SDVariable bias, Conv2DConfig Conv2DConfig)Separable 2D convolution operation with optional biasSDVariableSDCNN. separableConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, Conv2DConfig Conv2DConfig)Separable 2D convolution operation with optional biasSDVariableSDBaseOps. sequenceMask(String name, SDVariable lengths, int maxLen, DataType dataType)Generate a sequence mask (with values 0 or 1) based on the specified lengths
Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0)SDVariableSDBaseOps. sequenceMask(String name, SDVariable lengths, SDVariable maxLen, DataType dataType)Generate a sequence mask (with values 0 or 1) based on the specified lengths
Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0)SDVariableSDBaseOps. sequenceMask(String name, SDVariable lengths, DataType dataType)see sequenceMask(String, SDVariable, SDVariable, DataType)SDVariableSDBaseOps. sequenceMask(SDVariable lengths, int maxLen, DataType dataType)Generate a sequence mask (with values 0 or 1) based on the specified lengths
Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0)SDVariableSDBaseOps. sequenceMask(SDVariable lengths, SDVariable maxLen, DataType dataType)Generate a sequence mask (with values 0 or 1) based on the specified lengths
Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0)SDVariableSDBaseOps. sequenceMask(SDVariable lengths, DataType dataType)see sequenceMask(String, SDVariable, SDVariable, DataType)SDVariableSDMath. setDiag(String name, SDVariable in, SDVariable diag)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]SDVariableSDMath. setDiag(SDVariable in, SDVariable diag)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]SDVariable[]SDBaseOps. setShape(String[] names, SDVariable input, SDVariable shape)Sets an inplace shape on the passed in input.SDVariable[]SDBaseOps. setShape(SDVariable input, SDVariable shape)Sets an inplace shape on the passed in input.SDVariableSDMath. shannonEntropy(String name, SDVariable in, boolean keepDims, int... dimensions)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(String name, SDVariable in, int... dimensions)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(String name, SDVariable in, SDVariable dimensions)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(SDVariable in, boolean keepDims, int... dimensions)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(SDVariable in, int... dimensions)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(SDVariable in, SDVariable dimensions)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(SDVariable in, SDVariable dimensions, boolean keepDims)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDBaseOps. shape(String name, SDVariable input)Returns the shape of the specified INDArray as a 1D INDArraySDVariableSDBaseOps. shape(SDVariable input)Returns the shape of the specified INDArray as a 1D INDArraySDVariableSDNN. sigmoid(String name, SDVariable x)Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))SDVariableSDNN. sigmoid(SDVariable x)Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))SDVariableSDLoss. sigmoidCrossEntropy(String name, SDVariable label, SDVariable predictionLogits, SDVariable weights)Sigmoid cross entropy: applies the sigmoid activation function on the input logits (input "pre-sigmoid preductions")
and implements the binary cross entropy loss function.SDVariableSDLoss. sigmoidCrossEntropy(String name, SDVariable label, SDVariable predictionLogits, SDVariable weights, LossReduce lossReduce, double labelSmoothing)Sigmoid cross entropy: applies the sigmoid activation function on the input logits (input "pre-sigmoid preductions")
and implements the binary cross entropy loss function.SDVariableSDLoss. sigmoidCrossEntropy(SDVariable label, SDVariable predictionLogits, SDVariable weights)Sigmoid cross entropy: applies the sigmoid activation function on the input logits (input "pre-sigmoid preductions")
and implements the binary cross entropy loss function.SDVariableSDLoss. sigmoidCrossEntropy(SDVariable label, SDVariable predictionLogits, SDVariable weights, LossReduce lossReduce, double labelSmoothing)Sigmoid cross entropy: applies the sigmoid activation function on the input logits (input "pre-sigmoid preductions")
and implements the binary cross entropy loss function.SDVariableSDNN. sigmoidDerivative(String name, SDVariable x, SDVariable wrt)Element-wise sigmoid function derivative: dL/dIn given input and dL/dOutSDVariableSDNN. sigmoidDerivative(SDVariable x, SDVariable wrt)Element-wise sigmoid function derivative: dL/dIn given input and dL/dOutSDVariableSDMath. sign(String name, SDVariable x)Element-wise sign (signum) function:
out = -1 if in < 0
out = 0 if in = 0
out = 1 if in > 0SDVariableSDMath. sign(SDVariable x)Element-wise sign (signum) function:
out = -1 if in < 0
out = 0 if in = 0
out = 1 if in > 0SDVariableSDMath. sin(String name, SDVariable x)Elementwise sine operation: out = sin(x)SDVariableSDMath. sin(SDVariable x)Elementwise sine operation: out = sin(x)SDVariableSDMath. sinh(String name, SDVariable x)Elementwise sinh (hyperbolic sine) operation: out = sinh(x)SDVariableSDMath. sinh(SDVariable x)Elementwise sinh (hyperbolic sine) operation: out = sinh(x)SDVariableSDBaseOps. size(String name, SDVariable in)Returns the size (number of elements, i.e., prod(shape)) of the specified INDArray as a 0D scalar variableSDVariableSDBaseOps. size(SDVariable in)Returns the size (number of elements, i.e., prod(shape)) of the specified INDArray as a 0D scalar variableSDVariableSDBaseOps. sizeAt(String name, SDVariable in, int dimension)Returns a rank 0 (scalar) variable for the size of the specified dimension.
For example, if X has shape [10,20,30] then sizeAt(X,1)=20.SDVariableSDBaseOps. sizeAt(SDVariable in, int dimension)Returns a rank 0 (scalar) variable for the size of the specified dimension.
For example, if X has shape [10,20,30] then sizeAt(X,1)=20.SDVariableSDBaseOps. slice(String name, SDVariable input, int[] begin, int... size)Get a subset of the specified input, by specifying the first element and the size of the array.
For example, if input is:
[a, b, c]
[d, e, f]
then slice(input, begin=[0,1], size=[2,1] will return:
[b]
[e]
Note that for each dimension i, begin[i] + size[i] <= input.size(i)SDVariableSDBaseOps. slice(String name, SDVariable input, SDVariable begin, SDVariable size)Get a subset of the specified input, by specifying the first element and the size of the array.
For example, if input is:
[a, b, c]
[d, e, f]
then slice(input, begin=[0,1], size=[2,1] will return:
[b]
[e]
Note that for each dimension i, begin[i] + size[i] <= input.size(i)SDVariableSDBaseOps. slice(SDVariable input, int[] begin, int... size)Get a subset of the specified input, by specifying the first element and the size of the array.
For example, if input is:
[a, b, c]
[d, e, f]
then slice(input, begin=[0,1], size=[2,1] will return:
[b]
[e]
Note that for each dimension i, begin[i] + size[i] <= input.size(i)SDVariableSDBaseOps. slice(SDVariable input, SDVariable begin, SDVariable size)Get a subset of the specified input, by specifying the first element and the size of the array.
For example, if input is:
[a, b, c]
[d, e, f]
then slice(input, begin=[0,1], size=[2,1] will return:
[b]
[e]
Note that for each dimension i, begin[i] + size[i] <= input.size(i)SDVariableSDNN. softmax(String name, SDVariable x)Softmax activation, along the specified dimensionSDVariableSDNN. softmax(String name, SDVariable x, int dimension)Softmax activation, along the specified dimensionSDVariableSDNN. softmax(SDVariable x)Softmax activation, along the specified dimensionSDVariableSDNN. softmax(SDVariable x, int dimension)Softmax activation, along the specified dimensionSDVariableSDLoss. softmaxCrossEntropy(String name, SDVariable oneHotLabels, SDVariable logitPredictions, SDVariable weights)Applies the softmax activation function to the input, then implement multi-class cross entropy:
-sum_classes label[i] * log(p[c])wherep = softmax(logits)
If LossReduce#NONE is used, returned shape is [numExamples] out for [numExamples, numClasses] predicitons/labels;
otherwise, the output is a scalar.SDVariableSDLoss. softmaxCrossEntropy(String name, SDVariable oneHotLabels, SDVariable logitPredictions, SDVariable weights, LossReduce lossReduce, double labelSmoothing)Applies the softmax activation function to the input, then implement multi-class cross entropy:
-sum_classes label[i] * log(p[c])wherep = softmax(logits)
If LossReduce#NONE is used, returned shape is [numExamples] out for [numExamples, numClasses] predicitons/labels;
otherwise, the output is a scalar.SDVariableSDLoss. softmaxCrossEntropy(SDVariable oneHotLabels, SDVariable logitPredictions, SDVariable weights)Applies the softmax activation function to the input, then implement multi-class cross entropy:
-sum_classes label[i] * log(p[c])wherep = softmax(logits)
If LossReduce#NONE is used, returned shape is [numExamples] out for [numExamples, numClasses] predicitons/labels;
otherwise, the output is a scalar.SDVariableSDLoss. softmaxCrossEntropy(SDVariable oneHotLabels, SDVariable logitPredictions, SDVariable weights, LossReduce lossReduce, double labelSmoothing)Applies the softmax activation function to the input, then implement multi-class cross entropy:
-sum_classes label[i] * log(p[c])wherep = softmax(logits)
If LossReduce#NONE is used, returned shape is [numExamples] out for [numExamples, numClasses] predicitons/labels;
otherwise, the output is a scalar.SDVariableSDNN. softmaxDerivative(String name, SDVariable x, SDVariable wrt, int dimension)Softmax derivative functionSDVariableSDNN. softmaxDerivative(SDVariable x, SDVariable wrt, int dimension)Softmax derivative functionSDVariableSDNN. softplus(String name, SDVariable x)Element-wise softplus function: out = log(exp(x) + 1)SDVariableSDNN. softplus(SDVariable x)Element-wise softplus function: out = log(exp(x) + 1)SDVariableSDNN. softsign(String name, SDVariable x)Element-wise softsign function: out = x / (abs(x) + 1)SDVariableSDNN. softsign(SDVariable x)Element-wise softsign function: out = x / (abs(x) + 1)SDVariableSDNN. softsignDerivative(String name, SDVariable x)Element-wise derivative (dOut/dIn) of the softsign function softsign(INDArray)SDVariableSDNN. softsignDerivative(SDVariable x)Element-wise derivative (dOut/dIn) of the softsign function softsign(INDArray)SDVariableSDLinalg. solve(String name, SDVariable matrix, SDVariable rhs)Solver for systems of linear equations.SDVariableSDLinalg. solve(String name, SDVariable matrix, SDVariable rhs, boolean adjoint)Solver for systems of linear equations.SDVariableSDLinalg. solve(SDVariable matrix, SDVariable rhs)Solver for systems of linear equations.SDVariableSDLinalg. solve(SDVariable matrix, SDVariable rhs, boolean adjoint)Solver for systems of linear equations.SDVariableSDCNN. spaceToBatch(String name, SDVariable x, int[] blocks, int[] paddingTop, int... paddingBottom)Convolution 2d layer space to batch operation on 4d input.
Increases input batch dimension by rearranging data from spatial dimensions into batch dimensionSDVariableSDCNN. spaceToBatch(SDVariable x, int[] blocks, int[] paddingTop, int... paddingBottom)Convolution 2d layer space to batch operation on 4d input.
Increases input batch dimension by rearranging data from spatial dimensions into batch dimensionSDVariableSDCNN. spaceToDepth(String name, SDVariable x, int blockSize, DataFormat dataFormat)Convolution 2d layer space to depth operation on 4d input.
Increases input channels (reduced spatial dimensions) by rearranging data into a larger channels dimension
Example: if input has shape [mb, 2, 4, 4] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2]
= [mb, 2, 4, 4]SDVariableSDCNN. spaceToDepth(SDVariable x, int blockSize, DataFormat dataFormat)Convolution 2d layer space to depth operation on 4d input.
Increases input channels (reduced spatial dimensions) by rearranging data into a larger channels dimension
Example: if input has shape [mb, 2, 4, 4] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2]
= [mb, 2, 4, 4]SDVariableSDLoss. sparseSoftmaxCrossEntropy(String name, SDVariable logits, SDVariable labels)As per softmaxCrossEntropy(String, SDVariable, SDVariable, LossReduce) but the labels variable
is represented as an integer array instead of the equivalent one-hot array.
i.e., if logits are rank N, then labels have rank N-1SDVariableSDLoss. sparseSoftmaxCrossEntropy(SDVariable logits, SDVariable labels)As per softmaxCrossEntropy(String, SDVariable, SDVariable, LossReduce) but the labels variable
is represented as an integer array instead of the equivalent one-hot array.
i.e., if logits are rank N, then labels have rank N-1SDVariableSDBaseOps. sparseToDense(String name, SDVariable indices, SDVariable shape, SDVariable values)Create a dense matrix equivalent of a sparse matrix based on the given input.SDVariableSDBaseOps. sparseToDense(String name, SDVariable indices, SDVariable shape, SDVariable values, SDVariable defaultValue)Create a dense matrix equivalent of a sparse matrix based on the given input.SDVariableSDBaseOps. sparseToDense(SDVariable indices, SDVariable shape, SDVariable values)Create a dense matrix equivalent of a sparse matrix based on the given input.SDVariableSDBaseOps. sparseToDense(SDVariable indices, SDVariable shape, SDVariable values, SDVariable defaultValue)Create a dense matrix equivalent of a sparse matrix based on the given input.SDVariable[]SDBaseOps. split(String[] names, SDVariable input, int numSplit, int splitDim)Split a value in to a list of ndarrays.SDVariable[]SDBaseOps. split(String[] names, SDVariable input, SDVariable numSplit, int splitDim)Split a value in to a list of ndarrays.SDVariable[]SDBaseOps. split(SDVariable input, int numSplit, int splitDim)Split a value in to a list of ndarrays.SDVariable[]SDBaseOps. split(SDVariable input, SDVariable numSplit, int splitDim)Split a value in to a list of ndarrays.SDVariable[]SDBaseOps. splitV(String[] names, SDVariable input, SDVariable sizes, int numSplit, int splitDim)Split a value in to a list of ndarrays with varying sizes
according to the sizes parameter.SDVariable[]SDBaseOps. splitV(SDVariable input, SDVariable sizes, int numSplit, int splitDim)Split a value in to a list of ndarrays with varying sizes
according to the sizes parameter.SDVariableSDMath. sqrt(String name, SDVariable x)Element-wise square root function: out = sqrt(x)SDVariableSDMath. sqrt(SDVariable x)Element-wise square root function: out = sqrt(x)SDVariableSDMath. square(String name, SDVariable x)Element-wise square function: out = x^2SDVariableSDMath. square(SDVariable x)Element-wise square function: out = x^2SDVariableSDMath. squaredDifference(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. squaredDifference(SDVariable x, SDVariable y)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.htmlSDVariableSDBaseOps. squaredNorm(String name, SDVariable x, boolean keepDims, int... dimensions)Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. squaredNorm(String name, SDVariable x, int... dimensions)Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. squaredNorm(SDVariable x, boolean keepDims, int... dimensions)Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. squaredNorm(SDVariable x, int... dimensions)Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDMath. squaredNorm(String name, SDVariable in, boolean keepDims, int... dimensions)Sum of squared differences.SDVariableSDMath. squaredNorm(String name, SDVariable in, int... dimensions)Sum of squared differences.SDVariableSDMath. squaredNorm(String name, SDVariable in, SDVariable dimensions)Sum of squared differences.SDVariableSDMath. squaredNorm(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Sum of squared differences.SDVariableSDMath. squaredNorm(SDVariable in, boolean keepDims, int... dimensions)Sum of squared differences.SDVariableSDMath. squaredNorm(SDVariable in, int... dimensions)Sum of squared differences.SDVariableSDMath. squaredNorm(SDVariable in, SDVariable dimensions)Sum of squared differences.SDVariableSDMath. squaredNorm(SDVariable in, SDVariable dimensions, boolean keepDims)Sum of squared differences.SDVariableSDBaseOps. squeeze(String name, SDVariable x, int axis)Remove a single dimension of size 1.
For example, if input has shape [a,b,1,c] then squeeze(input, 2) returns an array of shape [a,b,c]SDVariableSDBaseOps. squeeze(SDVariable x, int axis)Remove a single dimension of size 1.
For example, if input has shape [a,b,1,c] then squeeze(input, 2) returns an array of shape [a,b,c]SDVariableSDRNN. sru(String name, SDVariable x, SDVariable initialC, SDVariable mask, SRUWeights SRUWeights)The SRU layer.SDVariableSDRNN. sru(String name, SDVariable x, SDVariable initialC, SRUWeights SRUWeights)The SRU layer.SDVariableSDRNN. sru(SDVariable x, SDVariable initialC, SDVariable mask, SRUWeights SRUWeights)The SRU layer.SDVariableSDRNN. sru(SDVariable x, SDVariable initialC, SRUWeights SRUWeights)The SRU layer.SDVariableSDRNN. sruCell(String name, SDVariable x, SDVariable cLast, SRUWeights SRUWeights)The SRU layer.SDVariableSDRNN. sruCell(SDVariable x, SDVariable cLast, SRUWeights SRUWeights)The SRU layer.SDVariableSDBaseOps. stack(int axis, SDVariable... values)Stack a set of N INDArray of rank X into one rank X+1 variable.
If inputs have shape [a,b,c] then output has shape:
axis = 0: [N,a,b,c]
axis = 1: [a,N,b,c]
axis = 2: [a,b,N,c]
axis = 3: [a,b,c,N]
see unstack(String[], SDVariable, int, int)SDVariableSDBaseOps. stack(String name, int axis, SDVariable... values)Stack a set of N INDArray of rank X into one rank X+1 variable.
If inputs have shape [a,b,c] then output has shape:
axis = 0: [N,a,b,c]
axis = 1: [a,N,b,c]
axis = 2: [a,b,N,c]
axis = 3: [a,b,c,N]
see unstack(String[], SDVariable, int, int)SDVariableSDBaseOps. standardDeviation(String name, SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)Standard deviation array reduction operation, optionally along 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.SDVariableSDBaseOps. standardDeviation(String name, SDVariable x, boolean biasCorrected, int... dimensions)Standard deviation array reduction operation, optionally along 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.SDVariableSDBaseOps. standardDeviation(SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)Standard deviation array reduction operation, optionally along 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.SDVariableSDBaseOps. standardDeviation(SDVariable x, boolean biasCorrected, int... dimensions)Standard deviation array reduction operation, optionally along 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.SDVariableSDMath. standardize(String name, SDVariable x, int... dimensions)Standardize input variable along given axisSDVariableSDMath. standardize(SDVariable x, int... dimensions)Standardize input variable along given axisSDVariableSDMath. step(String name, SDVariable x, double value)Elementwise step function:
out(x) = 1 if x >= cutoff
out(x) = 0 otherwiseSDVariableSDMath. step(SDVariable x, double value)Elementwise step function:
out(x) = 1 if x >= cutoff
out(x) = 0 otherwiseSDVariableSDBaseOps. stridedSlice(String name, SDVariable in, long[] begin, long[] end, long... strides)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(String name, SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(String name, SDVariable in, SDVariable begin, SDVariable end, SDVariable strides)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(String name, SDVariable in, SDVariable begin, SDVariable end, SDVariable strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(SDVariable in, long[] begin, long[] end, long... strides)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(SDVariable in, SDVariable begin, SDVariable end, SDVariable strides)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(SDVariable in, SDVariable begin, SDVariable end, SDVariable strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDMath. sub(String name, SDVariable x, double value)Scalar subtraction operation, out = in - scalarSDVariableSDMath. sub(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. sub(SDVariable x, double value)Scalar subtraction operation, out = in - scalarSDVariableSDMath. sub(SDVariable x, SDVariable y)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.htmlSDVariableSDBaseOps. sum(String name, SDVariable x, boolean keepDims, int... dimensions)Sum array reduction operation, optionally along 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.SDVariableSDBaseOps. sum(String name, SDVariable x, int... dimensions)Sum array reduction operation, optionally along 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.SDVariableSDBaseOps. sum(SDVariable x, boolean keepDims, int... dimensions)Sum array reduction operation, optionally along 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.SDVariableSDBaseOps. sum(SDVariable x, int... dimensions)Sum array reduction operation, optionally along 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.SDVariableSDMath. sum(String name, SDVariable in, boolean keepDims, int... dimensions)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(String name, SDVariable in, int... dimensions)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(String name, SDVariable in, SDVariable dimensions)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(SDVariable in, boolean keepDims, int... dimensions)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(SDVariable in, int... dimensions)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(SDVariable in, SDVariable dimensions)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(SDVariable in, SDVariable dimensions, boolean keepDims)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDLinalg. svd(String name, SDVariable input, boolean fullUV, boolean computeUV)Calculates singular value decomposition.SDVariableSDLinalg. svd(String name, SDVariable input, boolean fullUV, boolean computeUV, int switchNum)Calculates singular value decomposition.SDVariableSDLinalg. svd(SDVariable input, boolean fullUV, boolean computeUV)Calculates singular value decomposition.SDVariableSDLinalg. svd(SDVariable input, boolean fullUV, boolean computeUV, int switchNum)Calculates singular value decomposition.SDVariableSDNN. swish(String name, SDVariable x)Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0
See: https://arxiv.org/abs/1710.05941SDVariableSDNN. swish(SDVariable x)Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0
See: https://arxiv.org/abs/1710.05941SDVariable[]SDBaseOps. switchOp(String[] names, SDVariable x, SDVariable predicate)Switch operation
Predicate - if false, values are output to left (first) branch/output; if true, to right (second) branch/outputSDVariable[]SDBaseOps. switchOp(SDVariable x, SDVariable predicate)Switch operation
Predicate - if false, values are output to left (first) branch/output; if true, to right (second) branch/outputSDVariableSDMath. tan(String name, SDVariable x)Elementwise tangent operation: out = tan(x)SDVariableSDMath. tan(SDVariable x)Elementwise tangent operation: out = tan(x)SDVariableSDMath. tanh(String name, SDVariable x)Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)SDVariableSDMath. tanh(SDVariable x)Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)SDVariableSDNN. tanh(String name, SDVariable x)Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)SDVariableSDNN. tanh(SDVariable x)Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)SDVariableSDBaseOps. tensorMmul(String name, SDVariable x, SDVariable y, int[] dimensionsX, int... dimensionsY)//TODO: Ops must be documented.SDVariableSDBaseOps. tensorMmul(String name, SDVariable x, SDVariable y, int[] dimensionsX, int[] dimensionsY, boolean transposeX, boolean transposeY, boolean transposeZ)//TODO: Ops must be documented.SDVariableSDBaseOps. tensorMmul(SDVariable x, SDVariable y, int[] dimensionsX, int... dimensionsY)//TODO: Ops must be documented.SDVariableSDBaseOps. tensorMmul(SDVariable x, SDVariable y, int[] dimensionsX, int[] dimensionsY, boolean transposeX, boolean transposeY, boolean transposeZ)//TODO: Ops must be documented.SDVariableSDBaseOps. tile(String name, SDVariable x, int... repeat)see tile(String, SDVariable, int...)SDVariableSDBaseOps. tile(String name, SDVariable x, SDVariable repeat)Repeat (tile) the input tensor the specified number of times.
For example, if input is
[1, 2]
[3, 4]
and repeat is [2, 3]
then output is
[1, 2, 1, 2, 1, 2]
[3, 4, 3, 4, 3, 4]
[1, 2, 1, 2, 1, 2]
[3, 4, 3, 4, 3, 4]SDVariableSDBaseOps. tile(SDVariable x, int... repeat)see tile(String, SDVariable, int...)SDVariableSDBaseOps. tile(SDVariable x, SDVariable repeat)Repeat (tile) the input tensor the specified number of times.
For example, if input is
[1, 2]
[3, 4]
and repeat is [2, 3]
then output is
[1, 2, 1, 2, 1, 2]
[3, 4, 3, 4, 3, 4]
[1, 2, 1, 2, 1, 2]
[3, 4, 3, 4, 3, 4]SDVariable[]SDNN. topK(String[] names, SDVariable input, double k, boolean sorted)Find values and indices for the largest k entries along the last dimension.SDVariable[]SDNN. topK(SDVariable input, double k, boolean sorted)Find values and indices for the largest k entries along the last dimension.SDVariableSDMath. trace(String name, SDVariable in)Matrix trace operation
For rank 2 matrices, the output is a scalar with the trace - i.e., sum of the main diagonal.
For higher rank inputs, output[a,b,c] = trace(in[a,b,c,:,:])SDVariableSDMath. trace(SDVariable in)Matrix trace operation
For rank 2 matrices, the output is a scalar with the trace - i.e., sum of the main diagonal.
For higher rank inputs, output[a,b,c] = trace(in[a,b,c,:,:])SDVariableSDBaseOps. transpose(String name, SDVariable x)Matrix transpose operation: If input has shape [a,b] output has shape [b,a]SDVariableSDBaseOps. transpose(SDVariable x)Matrix transpose operation: If input has shape [a,b] output has shape [b,a]SDVariableSDLinalg. tri(int row, int column)An array with ones at and below the given diagonal and zeros elsewhere.SDVariableSDLinalg. tri(String name, int row, int column)An array with ones at and below the given diagonal and zeros elsewhere.SDVariableSDLinalg. tri(String name, DataType dataType, int row, int column, int diagonal)An array with ones at and below the given diagonal and zeros elsewhere.SDVariableSDLinalg. tri(DataType dataType, int row, int column, int diagonal)An array with ones at and below the given diagonal and zeros elsewhere.SDVariableSDLinalg. triangularSolve(String name, SDVariable matrix, SDVariable rhs, boolean lower, boolean adjoint)Solver for systems of linear questions.SDVariableSDLinalg. triangularSolve(SDVariable matrix, SDVariable rhs, boolean lower, boolean adjoint)Solver for systems of linear questions.SDVariableSDLinalg. triu(String name, SDVariable input)Upper triangle of an array.SDVariableSDLinalg. triu(String name, SDVariable input, int diag)Upper triangle of an array.SDVariableSDLinalg. triu(SDVariable input)Upper triangle of an array.SDVariableSDLinalg. triu(SDVariable input, int diag)Upper triangle of an array.SDVariableSDRandom. uniform(double min, double max, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a uniform distribution,
U(min,max)SDVariableSDRandom. uniform(String name, double min, double max, DataType datatype, long... shape)Generate a new random INDArray, where values are randomly sampled according to a uniform distribution,
U(min,max)SDVariableSDBaseOps. unsortedSegmentMax(String name, SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment max operation.SDVariableSDBaseOps. unsortedSegmentMax(String name, SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment max operation.SDVariableSDBaseOps. unsortedSegmentMax(SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment max operation.SDVariableSDBaseOps. unsortedSegmentMax(SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment max operation.SDVariableSDBaseOps. unsortedSegmentMean(String name, SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment mean operation.SDVariableSDBaseOps. unsortedSegmentMean(String name, SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment mean operation.SDVariableSDBaseOps. unsortedSegmentMean(SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment mean operation.SDVariableSDBaseOps. unsortedSegmentMean(SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment mean operation.SDVariableSDBaseOps. unsortedSegmentMin(String name, SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment min operation.SDVariableSDBaseOps. unsortedSegmentMin(String name, SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment min operation.SDVariableSDBaseOps. unsortedSegmentMin(SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment min operation.SDVariableSDBaseOps. unsortedSegmentMin(SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment min operation.SDVariableSDBaseOps. unsortedSegmentProd(String name, SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment product operation.SDVariableSDBaseOps. unsortedSegmentProd(String name, SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment product operation.SDVariableSDBaseOps. unsortedSegmentProd(SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment product operation.SDVariableSDBaseOps. unsortedSegmentProd(SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment product operation.SDVariableSDBaseOps. unsortedSegmentSqrtN(String name, SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment sqrtN operation.SDVariableSDBaseOps. unsortedSegmentSqrtN(String name, SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment sqrtN operation.SDVariableSDBaseOps. unsortedSegmentSqrtN(SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment sqrtN operation.SDVariableSDBaseOps. unsortedSegmentSqrtN(SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment sqrtN operation.SDVariableSDBaseOps. unsortedSegmentSum(String name, SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment sum operation.SDVariableSDBaseOps. unsortedSegmentSum(String name, SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment sum operation.SDVariableSDBaseOps. unsortedSegmentSum(SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment sum operation.SDVariableSDBaseOps. unsortedSegmentSum(SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment sum operation.SDVariable[]SDBaseOps. unstack(String[] names, SDVariable value, int axis, int num)Unstack a variable of rank X into N rank X-1 variables by taking slices along the specified axis.
If input has shape [a,b,c] then output has shape:
axis = 0: [b,c]
axis = 1: [a,c]
axis = 2: [a,b]SDVariable[]SDBaseOps. unstack(SDVariable value, int axis, int num)Unstack a variable of rank X into N rank X-1 variables by taking slices along the specified axis.
If input has shape [a,b,c] then output has shape:
axis = 0: [b,c]
axis = 1: [a,c]
axis = 2: [a,b]SDVariableSDCNN. upsampling2d(String name, SDVariable input, int scale)Upsampling layer for 2D inputs.
scale is used for both height and width dimensions.SDVariableSDCNN. upsampling2d(String name, SDVariable input, int scaleH, int scaleW, boolean nchw)2D Convolution layer operation - Upsampling 2dSDVariableSDCNN. upsampling2d(SDVariable input, int scale)Upsampling layer for 2D inputs.
scale is used for both height and width dimensions.SDVariableSDCNN. upsampling2d(SDVariable input, int scaleH, int scaleW, boolean nchw)2D Convolution layer operation - Upsampling 2dSDVariableSDCNN. upsampling3d(String name, SDVariable input, boolean ncdhw, int scaleD, int scaleH, int scaleW)3D Convolution layer operation - Upsampling 3dSDVariableSDCNN. upsampling3d(SDVariable input, boolean ncdhw, int scaleD, int scaleH, int scaleW)3D Convolution layer operation - Upsampling 3dSDVariableSDBaseOps. variance(String name, SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)Variance array reduction operation, optionally along 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.SDVariableSDBaseOps. variance(String name, SDVariable x, boolean biasCorrected, int... dimensions)Variance array reduction operation, optionally along 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.SDVariableSDBaseOps. variance(SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)Variance array reduction operation, optionally along 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.SDVariableSDBaseOps. variance(SDVariable x, boolean biasCorrected, int... dimensions)Variance array reduction operation, optionally along 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.SDVariableSDBaseOps. where(String name, SDVariable condition)Returns elements that are true from the given condition array
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. where(String name, SDVariable x, SDVariable condition)Similar to numpy where, takes elements from x or y depending on whether the condition at a given element is true or false
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. where(String name, SDVariable x, SDVariable y, SDVariable condition)Similar to numpy where, takes elements from x or y depending on whether the condition at a given element is true or false
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. where(SDVariable condition)Returns elements that are true from the given condition array
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. where(SDVariable x, SDVariable condition)Similar to numpy where, takes elements from x or y depending on whether the condition at a given element is true or false
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. where(SDVariable x, SDVariable y, SDVariable condition)Similar to numpy where, takes elements from x or y depending on whether the condition at a given element is true or false
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. whereNumpy(String name, SDVariable x, SDVariable y, SDVariable condition)As implemented in numpy, Return elements chosen from x or y depending on condition.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. whereNumpy(SDVariable x, SDVariable y, SDVariable condition)As implemented in numpy, Return elements chosen from x or y depending on condition.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBitwise. xor(String name, SDVariable x, SDVariable y)Bitwise XOR operation (exclusive OR).SDVariableSDBitwise. xor(SDVariable x, SDVariable y)Bitwise XOR operation (exclusive OR).SDVariableSDMath. xor(String name, SDVariable x, SDVariable y)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.SDVariableSDMath. xor(SDVariable x, SDVariable y)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.SDVariableSDImage. yiqToRgb(String name, SDVariable input)Converting image from YIQ to RGB formatSDVariableSDImage. yiqToRgb(SDVariable input)Converting image from YIQ to RGB formatSDVariableSDImage. yuvToRgb(String name, SDVariable input)Converting image from YUV to RGB formatSDVariableSDImage. yuvToRgb(SDVariable input)Converting image from YUV to RGB formatSDVariableSDMath. zeroFraction(String name, SDVariable input)Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))SDVariableSDMath. zeroFraction(SDVariable input)Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))SDVariableSDBaseOps. zerosLike(String name, SDVariable input)Return a variable of all 0s, with the same shape as the input variable.SDVariableSDBaseOps. zerosLike(SDVariable input)Return a variable of all 0s, with the same shape as the input variable.Methods in org.nd4j.autodiff.samediff.ops with parameters of type SDVariable Modifier and Type Method Description SDVariableSDMath. abs(String name, SDVariable x)Elementwise absolute value operation: out = abs(x)SDVariableSDMath. abs(SDVariable x)Elementwise absolute value operation: out = abs(x)SDVariableSDLoss. absoluteDifference(String name, SDVariable label, SDVariable predictions, SDVariable weights)Absolute difference loss:sum_i abs( label[i] - predictions[i] )SDVariableSDLoss. absoluteDifference(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Absolute difference loss:sum_i abs( label[i] - predictions[i] )SDVariableSDLoss. absoluteDifference(SDVariable label, SDVariable predictions, SDVariable weights)Absolute difference loss:sum_i abs( label[i] - predictions[i] )SDVariableSDLoss. absoluteDifference(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Absolute difference loss:sum_i abs( label[i] - predictions[i] )SDVariableSDMath. acos(String name, SDVariable x)Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)SDVariableSDMath. acos(SDVariable x)Elementwise acos (arccosine, inverse cosine) operation: out = arccos(x)SDVariableSDMath. acosh(String name, SDVariable x)Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)SDVariableSDMath. acosh(SDVariable x)Elementwise acosh (inverse hyperbolic cosine) function: out = acosh(x)SDVariableSDMath. add(String name, SDVariable x, double value)Scalar add operation, out = in + scalarSDVariableSDMath. add(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. add(SDVariable x, double value)Scalar add operation, out = in + scalarSDVariableSDMath. add(SDVariable x, SDVariable y)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.htmlSDVariableSDImage. adjustContrast(String name, SDVariable in, double factor)Adjusts contrast of RGB or grayscale images.SDVariableSDImage. adjustContrast(SDVariable in, double factor)Adjusts contrast of RGB or grayscale images.SDVariableSDImage. adjustHue(String name, SDVariable in, double delta)Adjust hue of RGB imageSDVariableSDImage. adjustHue(SDVariable in, double delta)Adjust hue of RGB imageSDVariableSDImage. adjustSaturation(String name, SDVariable in, double factor)Adjust saturation of RGB imagesSDVariableSDImage. adjustSaturation(SDVariable in, double factor)Adjust saturation of RGB imagesSDVariableSDBaseOps. all(String name, SDVariable x, int... dimensions)Boolean and array reduction operation, optionally along specified dimensionsSDVariableSDBaseOps. all(SDVariable x, int... dimensions)Boolean and array reduction operation, optionally along specified dimensionsSDVariableSDBitwise. and(String name, SDVariable x, SDVariable y)Bitwise AND operation.SDVariableSDBitwise. and(SDVariable x, SDVariable y)Bitwise AND operation.SDVariableSDMath. and(String name, SDVariable x, SDVariable y)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.SDVariableSDMath. and(SDVariable x, SDVariable y)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.SDVariableSDBaseOps. any(String name, SDVariable x, int... dimensions)Boolean or array reduction operation, optionally along specified dimensionsSDVariableSDBaseOps. any(SDVariable x, int... dimensions)Boolean or array reduction operation, optionally along specified dimensionsSDVariableSDBaseOps. argmax(String name, SDVariable in, boolean keepDims, int... dimensions)Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmax(String name, SDVariable in, int... dimensions)Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmax(SDVariable in, boolean keepDims, int... dimensions)Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmax(SDVariable in, int... dimensions)Argmax array reduction operation, optionally along specified dimensions.
Output values are the index of the maximum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmin(String name, SDVariable in, boolean keepDims, int... dimensions)Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmin(String name, SDVariable in, int... dimensions)Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmin(SDVariable in, boolean keepDims, int... dimensions)Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. argmin(SDVariable in, int... dimensions)Argmin array reduction operation, optionally along specified dimensions.
Output values are the index of the minimum value of each slice along the specified dimension.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDMath. asin(String name, SDVariable x)Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)SDVariableSDMath. asin(SDVariable x)Elementwise asin (arcsin, inverse sine) operation: out = arcsin(x)SDVariableSDMath. asinh(String name, SDVariable x)Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)SDVariableSDMath. asinh(SDVariable x)Elementwise asinh (inverse hyperbolic sine) function: out = asinh(x)SDVariableSDBaseOps. assign(String name, SDVariable x, SDVariable y)Assign the contents of y to x.
Y must be broadcastable to x or the same shape.SDVariableSDBaseOps. assign(SDVariable x, SDVariable y)Assign the contents of y to x.
Y must be broadcastable to x or the same shape.SDVariableSDMath. asum(String name, SDVariable in, boolean keepDims, int... dimensions)Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))SDVariableSDMath. asum(String name, SDVariable in, int... dimensions)Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))SDVariableSDMath. asum(SDVariable in, boolean keepDims, int... dimensions)Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))SDVariableSDMath. asum(SDVariable in, int... dimensions)Absolute sum array reduction operation, optionally along specified dimensions: out = sum(abs(x))SDVariableSDMath. atan(String name, SDVariable x)Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)SDVariableSDMath. atan(SDVariable x)Elementwise atan (arctangent, inverse tangent) operation: out = arctangent(x)SDVariableSDMath. atan2(String name, SDVariable y, SDVariable x)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 resultSDVariableSDMath. atan2(SDVariable y, SDVariable x)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 resultSDVariableSDMath. atanh(String name, SDVariable x)Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)SDVariableSDMath. atanh(SDVariable x)Elementwise atanh (inverse hyperbolic tangent) function: out = atanh(x)SDVariableSDCNN. avgPooling2d(String name, SDVariable input, Pooling2DConfig Pooling2DConfig)2D Convolution layer operation - average pooling 2dSDVariableSDCNN. avgPooling2d(SDVariable input, Pooling2DConfig Pooling2DConfig)2D Convolution layer operation - average pooling 2dSDVariableSDCNN. avgPooling3d(String name, SDVariable input, Pooling3DConfig Pooling3DConfig)3D convolution layer operation - average pooling 3dSDVariableSDCNN. avgPooling3d(SDVariable input, Pooling3DConfig Pooling3DConfig)3D convolution layer operation - average pooling 3dSDVariable[]SDBaseOps. batchMmul(String[] names, SDVariable[] inputsA, SDVariable... inputsB)Matrix multiply a batch of matrices.SDVariable[]SDBaseOps. batchMmul(String[] names, SDVariable[] inputsA, SDVariable[] inputsB, boolean transposeA, boolean transposeB)Matrix multiply a batch of matrices.SDVariable[]SDBaseOps. batchMmul(SDVariable[] inputsA, SDVariable... inputsB)Matrix multiply a batch of matrices.SDVariable[]SDBaseOps. batchMmul(SDVariable[] inputsA, SDVariable[] inputsB, boolean transposeA, boolean transposeB)Matrix multiply a batch of matrices.SDVariableSDNN. batchNorm(String name, SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, double epsilon, int... axis)SDVariableSDNN. batchNorm(SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, double epsilon, int... axis)SDVariableSDCNN. batchToSpace(String name, SDVariable x, int[] blocks, int[] croppingTop, int... croppingBottom)Convolution 2d layer batch to space operation on 4d input.
Reduces input batch dimension by rearranging data into a larger spatial dimensionsSDVariableSDCNN. batchToSpace(SDVariable x, int[] blocks, int[] croppingTop, int... croppingBottom)Convolution 2d layer batch to space operation on 4d input.
Reduces input batch dimension by rearranging data into a larger spatial dimensionsSDVariableSDNN. biasAdd(String name, SDVariable input, SDVariable bias, boolean nchw)Bias addition operation: a special case of addition, typically used with CNN 4D activations and a 1D bias vectorSDVariableSDNN. biasAdd(SDVariable input, SDVariable bias, boolean nchw)Bias addition operation: a special case of addition, typically used with CNN 4D activations and a 1D bias vectorSDVariableSDBitwise. bitRotl(String name, SDVariable x, SDVariable shift)Roll integer bits to the left, i.e.SDVariableSDBitwise. bitRotl(SDVariable x, SDVariable shift)Roll integer bits to the left, i.e.SDVariableSDBitwise. bitRotr(String name, SDVariable x, SDVariable shift)Roll integer bits to the right, i.e.SDVariableSDBitwise. bitRotr(SDVariable x, SDVariable shift)Roll integer bits to the right, i.e.SDVariableSDBitwise. bitsHammingDistance(String name, SDVariable x, SDVariable y)Bitwise Hamming distance reduction over all elements of both input arrays.
For example, if x=01100000 and y=1010000 then the bitwise Hamming distance is 2 (due to differences at positions 0 and 1)
Inputs must satisfy the following constraints:
Must be same types: isSameType(x, y)SDVariableSDBitwise. bitsHammingDistance(SDVariable x, SDVariable y)Bitwise Hamming distance reduction over all elements of both input arrays.
For example, if x=01100000 and y=1010000 then the bitwise Hamming distance is 2 (due to differences at positions 0 and 1)
Inputs must satisfy the following constraints:
Must be same types: isSameType(x, y)SDVariableSDBitwise. bitShift(String name, SDVariable x, SDVariable shift)Shift integer bits to the left, i.e.SDVariableSDBitwise. bitShift(SDVariable x, SDVariable shift)Shift integer bits to the left, i.e.SDVariableSDMath. bitShift(String name, SDVariable x, SDVariable shift)Bit shift operationSDVariableSDMath. bitShift(SDVariable x, SDVariable shift)Bit shift operationSDVariableSDBitwise. bitShiftRight(String name, SDVariable x, SDVariable shift)Shift integer bits to the right, i.e.SDVariableSDBitwise. bitShiftRight(SDVariable x, SDVariable shift)Shift integer bits to the right, i.e.SDVariableSDMath. bitShiftRight(String name, SDVariable x, SDVariable shift)Right bit shift operationSDVariableSDMath. bitShiftRight(SDVariable x, SDVariable shift)Right bit shift operationSDVariableSDMath. bitShiftRotl(String name, SDVariable x, SDVariable shift)Cyclic bit shift operationSDVariableSDMath. bitShiftRotl(SDVariable x, SDVariable shift)Cyclic bit shift operationSDVariableSDMath. bitShiftRotr(String name, SDVariable x, SDVariable shift)Cyclic right shift operationSDVariableSDMath. bitShiftRotr(SDVariable x, SDVariable shift)Cyclic right shift operationSDVariableSDBaseOps. castTo(String name, SDVariable arg, DataType datatype)Cast the array to a new datatype - for example, Integer -> FloatSDVariableSDBaseOps. castTo(SDVariable arg, DataType datatype)Cast the array to a new datatype - for example, Integer -> FloatSDVariableSDMath. ceil(String name, SDVariable x)Element-wise ceiling function: out = ceil(x).
Rounds each value up to the nearest integer value (if not already an integer)SDVariableSDMath. ceil(SDVariable x)Element-wise ceiling function: out = ceil(x).
Rounds each value up to the nearest integer value (if not already an integer)SDVariableSDLinalg. cholesky(String name, SDVariable input)Computes the Cholesky decomposition of one or more square matrices.SDVariableSDLinalg. cholesky(SDVariable input)Computes the Cholesky decomposition of one or more square matrices.SDVariableSDMath. clipByAvgNorm(String name, SDVariable x, double clipValue, int... dimensions)Clips tensor values to a maximum average L2-norm.SDVariableSDMath. clipByAvgNorm(SDVariable x, double clipValue, int... dimensions)Clips tensor values to a maximum average L2-norm.SDVariableSDBaseOps. clipByNorm(String name, SDVariable x, double clipValue)Returns a clipped ndarray such that the input is normalized so that its L2 norm
is <= the specified value.SDVariableSDBaseOps. clipByNorm(String name, SDVariable x, SDVariable clipValue, SDVariable dimensions)Returns a clipped ndarray such that the input is normalized so that its L2 norm
is <= the specified value.SDVariableSDBaseOps. clipByNorm(SDVariable x, double clipValue)Returns a clipped ndarray such that the input is normalized so that its L2 norm
is <= the specified value.SDVariableSDBaseOps. clipByNorm(SDVariable x, SDVariable clipValue, SDVariable dimensions)Returns a clipped ndarray such that the input is normalized so that its L2 norm
is <= the specified value.SDVariableSDMath. clipByNorm(String name, SDVariable x, double clipValue, int... dimensions)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 dimensionsSDVariableSDMath. clipByNorm(SDVariable x, double clipValue, int... dimensions)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 dimensionsSDVariableSDBaseOps. clipByValue(String name, SDVariable x, double clipValueMin, double clipValueMax)Return the clipped ndarray containing values no smaller or larger than the given min and max.SDVariableSDBaseOps. clipByValue(String name, SDVariable x, SDVariable clipValueMin, SDVariable clipValueMax)Return the clipped ndarray containing values no smaller or larger than the given min and max.SDVariableSDBaseOps. clipByValue(SDVariable x, double clipValueMin, double clipValueMax)Return the clipped ndarray containing values no smaller or larger than the given min and max.SDVariableSDBaseOps. clipByValue(SDVariable x, SDVariable clipValueMin, SDVariable clipValueMax)Return the clipped ndarray containing values no smaller or larger than the given min and max.SDVariableSDMath. clipByValue(String name, SDVariable x, double clipValueMin, double clipValueMax)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] > clipValueMaxSDVariableSDMath. clipByValue(SDVariable x, double clipValueMin, double clipValueMax)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] > clipValueMaxSDVariableSDCNN. col2Im(String name, SDVariable in, Conv2DConfig Conv2DConfig)col2im operation for use in 2D convolution operations.SDVariableSDCNN. col2Im(SDVariable in, Conv2DConfig Conv2DConfig)col2im operation for use in 2D convolution operations.SDVariableSDBaseOps. concat(int dimension, SDVariable... inputs)Concatenate a set of inputs along the specified dimension.
Note that inputs must have identical rank and identical dimensions, other than the dimension to stack on.
For example, if 2 inputs have shape [a, x, c] and [a, y, c] and dimension = 1, then the output has shape [a, x+y, c]
Inputs must satisfy the following constraints:
Input arrays must all be the same datatype: isSameType(inputs)SDVariableSDBaseOps. concat(String name, int dimension, SDVariable... inputs)Concatenate a set of inputs along the specified dimension.
Note that inputs must have identical rank and identical dimensions, other than the dimension to stack on.
For example, if 2 inputs have shape [a, x, c] and [a, y, c] and dimension = 1, then the output has shape [a, x+y, c]
Inputs must satisfy the following constraints:
Input arrays must all be the same datatype: isSameType(inputs)SDVariableSDMath. confusionMatrix(String name, SDVariable labels, SDVariable pred, int numClasses)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]SDVariableSDMath. confusionMatrix(String name, SDVariable labels, SDVariable pred, SDVariable weights)Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.SDVariableSDMath. confusionMatrix(String name, SDVariable labels, SDVariable pred, SDVariable weights, int numClasses)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]SDVariableSDMath. confusionMatrix(String name, SDVariable labels, SDVariable pred, DataType dataType)Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.SDVariableSDMath. confusionMatrix(SDVariable labels, SDVariable pred, int numClasses)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]SDVariableSDMath. confusionMatrix(SDVariable labels, SDVariable pred, SDVariable weights)Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.SDVariableSDMath. confusionMatrix(SDVariable labels, SDVariable pred, SDVariable weights, int numClasses)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]SDVariableSDMath. confusionMatrix(SDVariable labels, SDVariable pred, DataType dataType)Compute the 2d confusion matrix of size [numClasses, numClasses] from a pair of labels and predictions, both of
which are represented as integer values.SDVariableSDCNN. conv1d(String name, SDVariable input, SDVariable weights, SDVariable bias, Conv1DConfig Conv1DConfig)Conv1d operation.SDVariableSDCNN. conv1d(String name, SDVariable input, SDVariable weights, Conv1DConfig Conv1DConfig)Conv1d operation.SDVariableSDCNN. conv1d(SDVariable input, SDVariable weights, SDVariable bias, Conv1DConfig Conv1DConfig)Conv1d operation.SDVariableSDCNN. conv1d(SDVariable input, SDVariable weights, Conv1DConfig Conv1DConfig)Conv1d operation.SDVariableSDCNN. conv2d(String name, SDVariable layerInput, SDVariable weights, SDVariable bias, Conv2DConfig Conv2DConfig)2D Convolution operation with optional biasSDVariableSDCNN. conv2d(String name, SDVariable layerInput, SDVariable weights, Conv2DConfig Conv2DConfig)2D Convolution operation with optional biasSDVariableSDCNN. conv2d(SDVariable layerInput, SDVariable weights, SDVariable bias, Conv2DConfig Conv2DConfig)2D Convolution operation with optional biasSDVariableSDCNN. conv2d(SDVariable layerInput, SDVariable weights, Conv2DConfig Conv2DConfig)2D Convolution operation with optional biasSDVariableSDCNN. conv3d(String name, SDVariable input, SDVariable weights, SDVariable bias, Conv3DConfig Conv3DConfig)Convolution 3D operation with optional biasSDVariableSDCNN. conv3d(String name, SDVariable input, SDVariable weights, Conv3DConfig Conv3DConfig)Convolution 3D operation with optional biasSDVariableSDCNN. conv3d(SDVariable input, SDVariable weights, SDVariable bias, Conv3DConfig Conv3DConfig)Convolution 3D operation with optional biasSDVariableSDCNN. conv3d(SDVariable input, SDVariable weights, Conv3DConfig Conv3DConfig)Convolution 3D operation with optional biasSDVariableSDMath. cos(String name, SDVariable x)Elementwise cosine operation: out = cos(x)SDVariableSDMath. cos(SDVariable x)Elementwise cosine operation: out = cos(x)SDVariableSDMath. cosh(String name, SDVariable x)Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)SDVariableSDMath. cosh(SDVariable x)Elementwise cosh (hyperbolic cosine) operation: out = cosh(x)SDVariableSDLoss. cosineDistance(String name, SDVariable label, SDVariable predictions, SDVariable weights, int dimension)Cosine distance loss:1 - cosineSimilarity(x,y)or1 - sum_i label[i] * prediction[i], which is
equivalent to cosine distance when both the predictions and labels are normalized.
Note: This loss function assumes that both the predictions and labels are normalized to have unit l2 norm.
If this is not the case, you should normalize them first by dividing by norm2(String, SDVariable, boolean, int...)
along the cosine distance dimension (with keepDims=true).SDVariableSDLoss. cosineDistance(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, int dimension)Cosine distance loss:1 - cosineSimilarity(x,y)or1 - sum_i label[i] * prediction[i], which is
equivalent to cosine distance when both the predictions and labels are normalized.
Note: This loss function assumes that both the predictions and labels are normalized to have unit l2 norm.
If this is not the case, you should normalize them first by dividing by norm2(String, SDVariable, boolean, int...)
along the cosine distance dimension (with keepDims=true).SDVariableSDLoss. cosineDistance(SDVariable label, SDVariable predictions, SDVariable weights, int dimension)Cosine distance loss:1 - cosineSimilarity(x,y)or1 - sum_i label[i] * prediction[i], which is
equivalent to cosine distance when both the predictions and labels are normalized.
Note: This loss function assumes that both the predictions and labels are normalized to have unit l2 norm.
If this is not the case, you should normalize them first by dividing by norm2(String, SDVariable, boolean, int...)
along the cosine distance dimension (with keepDims=true).SDVariableSDLoss. cosineDistance(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, int dimension)Cosine distance loss:1 - cosineSimilarity(x,y)or1 - sum_i label[i] * prediction[i], which is
equivalent to cosine distance when both the predictions and labels are normalized.
Note: This loss function assumes that both the predictions and labels are normalized to have unit l2 norm.
If this is not the case, you should normalize them first by dividing by norm2(String, SDVariable, boolean, int...)
along the cosine distance dimension (with keepDims=true).SDVariableSDMath. cosineDistance(String name, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Cosine distance reduction operation.SDVariableSDMath. cosineDistance(String name, SDVariable x, SDVariable y, int... dimensions)Cosine distance reduction operation.SDVariableSDMath. cosineDistance(SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Cosine distance reduction operation.SDVariableSDMath. cosineDistance(SDVariable x, SDVariable y, int... dimensions)Cosine distance reduction operation.SDVariableSDMath. cosineSimilarity(String name, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Cosine similarity pairwise reduction operation.SDVariableSDMath. cosineSimilarity(String name, SDVariable x, SDVariable y, int... dimensions)Cosine similarity pairwise reduction operation.SDVariableSDMath. cosineSimilarity(SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Cosine similarity pairwise reduction operation.SDVariableSDMath. cosineSimilarity(SDVariable x, SDVariable y, int... dimensions)Cosine similarity pairwise reduction operation.SDVariableSDMath. countNonZero(String name, SDVariable in, boolean keepDims, int... dimensions)Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)SDVariableSDMath. countNonZero(String name, SDVariable in, int... dimensions)Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)SDVariableSDMath. countNonZero(SDVariable in, boolean keepDims, int... dimensions)Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)SDVariableSDMath. countNonZero(SDVariable in, int... dimensions)Count non zero array reduction operation, optionally along specified dimensions: out = count(x != 0)SDVariableSDMath. countZero(String name, SDVariable in, boolean keepDims, int... dimensions)Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)SDVariableSDMath. countZero(String name, SDVariable in, int... dimensions)Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)SDVariableSDMath. countZero(SDVariable in, boolean keepDims, int... dimensions)Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)SDVariableSDMath. countZero(SDVariable in, int... dimensions)Count zero array reduction operation, optionally along specified dimensions: out = count(x == 0)SDVariableSDBaseOps. create(String name, SDVariable shape, DataType dataType)Return a newly created variable, with the specified shape and data type.SDVariableSDBaseOps. create(String name, SDVariable shape, DataType dataType, String order, boolean initialize)Return a newly created variable, with the specified shape and data type.SDVariableSDBaseOps. create(SDVariable shape, DataType dataType)Return a newly created variable, with the specified shape and data type.SDVariableSDBaseOps. create(SDVariable shape, DataType dataType, String order, boolean initialize)Return a newly created variable, with the specified shape and data type.SDVariableSDBaseOps. createView(String name, SDVariable input, SDVariable... indices)Return a newly created variable, with the specified shape and data type.SDVariableSDBaseOps. createView(SDVariable input, SDVariable... indices)Return a newly created variable, with the specified shape and data type.SDVariableSDNN. cReLU(String name, SDVariable x)Concatenates a ReLU which selects only the positive part of the activation with a ReLU which selects only the negative part of the activation.SDVariableSDNN. cReLU(SDVariable x)Concatenates a ReLU which selects only the positive part of the activation with a ReLU which selects only the negative part of the activation.SDVariableSDImage. cropAndResize(String name, SDVariable image, SDVariable cropBoxes, SDVariable boxIndices, SDVariable cropOutSize)Given an input image and some crop boxes, extract out the image subsets and resize them to the specified size.SDVariableSDImage. cropAndResize(String name, SDVariable image, SDVariable cropBoxes, SDVariable boxIndices, SDVariable cropOutSize, double extrapolationValue)Given an input image and some crop boxes, extract out the image subsets and resize them to the specified size.SDVariableSDImage. cropAndResize(SDVariable image, SDVariable cropBoxes, SDVariable boxIndices, SDVariable cropOutSize)Given an input image and some crop boxes, extract out the image subsets and resize them to the specified size.SDVariableSDImage. cropAndResize(SDVariable image, SDVariable cropBoxes, SDVariable boxIndices, SDVariable cropOutSize, double extrapolationValue)Given an input image and some crop boxes, extract out the image subsets and resize them to the specified size.SDVariableSDLinalg. cross(String name, SDVariable a, SDVariable b)Computes pairwise cross product.SDVariableSDLinalg. cross(SDVariable a, SDVariable b)Computes pairwise cross product.SDVariableSDMath. cross(String name, SDVariable a, SDVariable b)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 3SDVariableSDMath. cross(SDVariable a, SDVariable b)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 3SDVariableSDLoss. ctcLoss(String name, SDVariable targetLabels, SDVariable logitInput, SDVariable targetLabelLengths, SDVariable logitInputLengths)CTC Loss: Connectionist Temporal Classification Loss.SDVariableSDLoss. ctcLoss(SDVariable targetLabels, SDVariable logitInput, SDVariable targetLabelLengths, SDVariable logitInputLengths)CTC Loss: Connectionist Temporal Classification Loss.SDVariableSDMath. cube(String name, SDVariable x)Element-wise cube function: out = x^3SDVariableSDMath. cube(SDVariable x)Element-wise cube function: out = x^3SDVariableSDBaseOps. cumprod(String name, SDVariable in, boolean exclusive, boolean reverse, int... axis)Cumulative product operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a*b, a*b*c]
exclusive=true, reverse=false, [0, a, a*b]
exclusive=false, reverse=true: [a*b*c, b*c, c]
exclusive=true, reverse=true: [b*c, c, 0]SDVariableSDBaseOps. cumprod(String name, SDVariable in, int... axis)Cumulative product operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a*b, a*b*c]
exclusive=true, reverse=false, [0, a, a*b]
exclusive=false, reverse=true: [a*b*c, b*c, c]
exclusive=true, reverse=true: [b*c, c, 0]SDVariableSDBaseOps. cumprod(SDVariable in, boolean exclusive, boolean reverse, int... axis)Cumulative product operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a*b, a*b*c]
exclusive=true, reverse=false, [0, a, a*b]
exclusive=false, reverse=true: [a*b*c, b*c, c]
exclusive=true, reverse=true: [b*c, c, 0]SDVariableSDBaseOps. cumprod(SDVariable in, int... axis)Cumulative product operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a*b, a*b*c]
exclusive=true, reverse=false, [0, a, a*b]
exclusive=false, reverse=true: [a*b*c, b*c, c]
exclusive=true, reverse=true: [b*c, c, 0]SDVariableSDBaseOps. cumsum(String name, SDVariable in, boolean exclusive, boolean reverse, int... axis)Cumulative sum operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a+b, a+b+c]
exclusive=true, reverse=false, [0, a, a+b]
exclusive=false, reverse=true: [a+b+c, b+c, c]
exclusive=true, reverse=true: [b+c, c, 0]SDVariableSDBaseOps. cumsum(String name, SDVariable in, int... axis)Cumulative sum operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a+b, a+b+c]
exclusive=true, reverse=false, [0, a, a+b]
exclusive=false, reverse=true: [a+b+c, b+c, c]
exclusive=true, reverse=true: [b+c, c, 0]SDVariableSDBaseOps. cumsum(SDVariable in, boolean exclusive, boolean reverse, int... axis)Cumulative sum operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a+b, a+b+c]
exclusive=true, reverse=false, [0, a, a+b]
exclusive=false, reverse=true: [a+b+c, b+c, c]
exclusive=true, reverse=true: [b+c, c, 0]SDVariableSDBaseOps. cumsum(SDVariable in, int... axis)Cumulative sum operation.
For input: [ a, b, c], output is:
exclusive=false, reverse=false: [a, a+b, a+b+c]
exclusive=true, reverse=false, [0, a, a+b]
exclusive=false, reverse=true: [a+b+c, b+c, c]
exclusive=true, reverse=true: [b+c, c, 0]SDVariableSDCNN. deconv2d(String name, SDVariable layerInput, SDVariable weights, SDVariable bias, DeConv2DConfig DeConv2DConfig)2D deconvolution operation with optional biasSDVariableSDCNN. deconv2d(String name, SDVariable layerInput, SDVariable weights, DeConv2DConfig DeConv2DConfig)2D deconvolution operation with optional biasSDVariableSDCNN. deconv2d(SDVariable layerInput, SDVariable weights, SDVariable bias, DeConv2DConfig DeConv2DConfig)2D deconvolution operation with optional biasSDVariableSDCNN. deconv2d(SDVariable layerInput, SDVariable weights, DeConv2DConfig DeConv2DConfig)2D deconvolution operation with optional biasSDVariableSDCNN. deconv3d(String name, SDVariable input, SDVariable weights, SDVariable bias, DeConv3DConfig DeConv3DConfig)3D CNN deconvolution operation with or without optional biasSDVariableSDCNN. deconv3d(String name, SDVariable input, SDVariable weights, DeConv3DConfig DeConv3DConfig)3D CNN deconvolution operation with or without optional biasSDVariableSDCNN. deconv3d(SDVariable input, SDVariable weights, SDVariable bias, DeConv3DConfig DeConv3DConfig)3D CNN deconvolution operation with or without optional biasSDVariableSDCNN. deconv3d(SDVariable input, SDVariable weights, DeConv3DConfig DeConv3DConfig)3D CNN deconvolution operation with or without optional biasSDVariableSDCNN. depthToSpace(String name, SDVariable x, int blockSize, DataFormat dataFormat)Convolution 2d layer batch to space operation on 4d input.
Reduces input channels dimension by rearranging data into a larger spatial dimensions
Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2]
= [mb, 2, 4, 4]SDVariableSDCNN. depthToSpace(SDVariable x, int blockSize, DataFormat dataFormat)Convolution 2d layer batch to space operation on 4d input.
Reduces input channels dimension by rearranging data into a larger spatial dimensions
Example: if input has shape [mb, 8, 2, 2] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2]
= [mb, 2, 4, 4]SDVariableSDCNN. depthWiseConv2d(String name, SDVariable layerInput, SDVariable depthWeights, SDVariable bias, Conv2DConfig Conv2DConfig)Depth-wise 2D convolution operation with optional biasSDVariableSDCNN. depthWiseConv2d(String name, SDVariable layerInput, SDVariable depthWeights, Conv2DConfig Conv2DConfig)Depth-wise 2D convolution operation with optional biasSDVariableSDCNN. depthWiseConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable bias, Conv2DConfig Conv2DConfig)Depth-wise 2D convolution operation with optional biasSDVariableSDCNN. depthWiseConv2d(SDVariable layerInput, SDVariable depthWeights, Conv2DConfig Conv2DConfig)Depth-wise 2D convolution operation with optional biasSDVariableSDLinalg. diag(String name, SDVariable input)Calculates diagonal tensor.SDVariableSDLinalg. diag(SDVariable input)Calculates diagonal tensor.SDVariableSDMath. diag(String name, SDVariable x)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 2RSDVariableSDMath. diag(SDVariable x)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 2RSDVariableSDLinalg. diag_part(String name, SDVariable input)Calculates diagonal tensor.SDVariableSDLinalg. diag_part(SDVariable input)Calculates diagonal tensor.SDVariableSDMath. diagPart(String name, SDVariable x)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]SDVariableSDMath. diagPart(SDVariable x)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]SDVariableSDCNN. dilation2D(String name, SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode)TODO doc stringSDVariableSDCNN. dilation2D(SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode)TODO doc stringSDVariableSDMath. div(String name, SDVariable x, double value)Scalar division operation, out = in / scalarSDVariableSDMath. div(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. div(SDVariable x, double value)Scalar division operation, out = in / scalarSDVariableSDMath. div(SDVariable x, SDVariable y)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.htmlSDVariableSDBaseOps. dot(String name, SDVariable x, SDVariable y, int... dimensions)Pairwise dot product reduction along dimension
output = sum(i=0 ...SDVariableSDBaseOps. dot(SDVariable x, SDVariable y, int... dimensions)Pairwise dot product reduction along dimension
output = sum(i=0 ...SDVariableSDNN. dotProductAttention(String name, SDVariable queries, SDVariable keys, SDVariable values, SDVariable mask, boolean scaled)This operation performs dot product attention on the given timeseries input with the given queries
out = sum(similarity(k_i, q) * v_i)
similarity(k, q) = softmax(k * q) where x * q is the dot product of x and q
Optionally with normalization step:
similarity(k, q) = softmax(k * q / sqrt(size(q))
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, p.SDVariableSDNN. dotProductAttention(SDVariable queries, SDVariable keys, SDVariable values, SDVariable mask, boolean scaled)This operation performs dot product attention on the given timeseries input with the given queries
out = sum(similarity(k_i, q) * v_i)
similarity(k, q) = softmax(k * q) where x * q is the dot product of x and q
Optionally with normalization step:
similarity(k, q) = softmax(k * q / sqrt(size(q))
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, p.SDVariableSDNN. dropout(String name, SDVariable input, double inputRetainProbability)Dropout operationSDVariableSDNN. dropout(SDVariable input, double inputRetainProbability)Dropout operationSDVariableSDNN. dropoutInverted(String name, SDVariable input, double p)Dropout inverted operation.SDVariableSDNN. dropoutInverted(SDVariable input, double p)Dropout inverted operation.SDVariable[]SDBaseOps. dynamicPartition(String[] names, SDVariable x, SDVariable partitions, int numPartitions)Dynamically partition the input variable values into the specified number of paritions, using the indices.
Example:SDVariable[]SDBaseOps. dynamicPartition(SDVariable x, SDVariable partitions, int numPartitions)Dynamically partition the input variable values into the specified number of paritions, using the indices.
Example:SDVariableSDBaseOps. dynamicStitch(String name, SDVariable[] indices, SDVariable... x)Dynamically merge the specified input arrays into a single array, using the specified indicesSDVariableSDBaseOps. dynamicStitch(SDVariable[] indices, SDVariable... x)Dynamically merge the specified input arrays into a single array, using the specified indicesSDVariable[]SDLinalg. eig(String[] names, SDVariable input)Calculates eigen valuesSDVariable[]SDLinalg. eig(SDVariable input)Calculates eigen valuesSDVariableSDNN. elu(String name, SDVariable x)Element-wise exponential linear unit (ELU) function:
out = x if x > 0
out = a * (exp(x) - 1) if x <= 0
with constant a = 1.0SDVariableSDNN. elu(SDVariable x)Element-wise exponential linear unit (ELU) function:
out = x if x > 0
out = a * (exp(x) - 1) if x <= 0
with constant a = 1.0SDVariableSDMath. embeddingLookup(String name, SDVariable x, SDVariable indices, PartitionMode PartitionMode)Looks up ids in a list of embedding tensors.SDVariableSDMath. embeddingLookup(SDVariable x, SDVariable indices, PartitionMode PartitionMode)Looks up ids in a list of embedding tensors.SDVariableSDMath. entropy(String name, SDVariable in, boolean keepDims, int... dimensions)Entropy reduction: -sum(x * log(x))SDVariableSDMath. entropy(String name, SDVariable in, int... dimensions)Entropy reduction: -sum(x * log(x))SDVariableSDMath. entropy(SDVariable in, boolean keepDims, int... dimensions)Entropy reduction: -sum(x * log(x))SDVariableSDMath. entropy(SDVariable in, int... dimensions)Entropy reduction: -sum(x * log(x))SDVariableSDBaseOps. eq(String name, SDVariable x, double y)Equals operation: elementwise x == y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. eq(String name, SDVariable x, SDVariable y)Equal to operation: elementwise x == y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. eq(SDVariable x, double y)Equals operation: elementwise x == y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. eq(SDVariable x, SDVariable y)Equal to operation: elementwise x == y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDMath. erf(String name, SDVariable x)Element-wise Gaussian error function - out = erf(in)SDVariableSDMath. erf(SDVariable x)Element-wise Gaussian error function - out = erf(in)SDVariableSDMath. erfc(String name, SDVariable x)Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)SDVariableSDMath. erfc(SDVariable x)Element-wise complementary Gaussian error function - out = erfc(in) = 1 - erf(in)SDVariableSDMath. euclideanDistance(String name, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Euclidean distance (l2 norm, l2 distance) reduction operation.SDVariableSDMath. euclideanDistance(String name, SDVariable x, SDVariable y, int... dimensions)Euclidean distance (l2 norm, l2 distance) reduction operation.SDVariableSDMath. euclideanDistance(SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Euclidean distance (l2 norm, l2 distance) reduction operation.SDVariableSDMath. euclideanDistance(SDVariable x, SDVariable y, int... dimensions)Euclidean distance (l2 norm, l2 distance) reduction operation.SDVariableSDMath. exp(String name, SDVariable x)Elementwise exponent function: out = exp(x) = 2.71828...^xSDVariableSDMath. exp(SDVariable x)Elementwise exponent function: out = exp(x) = 2.71828...^xSDVariableSDBaseOps. expandDims(String name, SDVariable x, int axis)Reshape the input by adding a 1 at the specified location.
For example, if input has shape [a, b], then output shape is:
axis = 0: [1, a, b]
axis = 1: [a, 1, b]
axis = 2: [a, b, 1]SDVariableSDBaseOps. expandDims(SDVariable x, int axis)Reshape the input by adding a 1 at the specified location.
For example, if input has shape [a, b], then output shape is:
axis = 0: [1, a, b]
axis = 1: [a, 1, b]
axis = 2: [a, b, 1]SDVariableSDMath. expm1(String name, SDVariable x)Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^xSDVariableSDMath. expm1(SDVariable x)Elementwise 1.0 - exponent function: out = 1.0 - exp(x) = 1.0 - 2.71828...^xSDVariableSDCNN. extractImagePatches(String name, SDVariable input, int kH, int kW, int sH, int sW, int rH, int rW, boolean sameMode)Extract image patchesSDVariableSDCNN. extractImagePatches(SDVariable input, int kH, int kW, int sH, int sW, int rH, int rW, boolean sameMode)Extract image patchesSDVariableSDImage. extractImagePatches(String name, SDVariable image, int[] kSizes, int[] strides, int[] rates, boolean sameMode)Given an input image, extract out image patches (of size kSizes - h x w) and place them in the depth dimension.SDVariableSDImage. extractImagePatches(SDVariable image, int[] kSizes, int[] strides, int[] rates, boolean sameMode)Given an input image, extract out image patches (of size kSizes - h x w) and place them in the depth dimension.SDVariableSDMath. eye(String name, SDVariable rows)As per eye(String, int) but with the number of rows specified as a scalar INDArraySDVariableSDMath. eye(String name, SDVariable rows, SDVariable cols)As per eye(int, int) bit with the number of rows/columns specified as scalar INDArraysSDVariableSDMath. eye(SDVariable rows)As per eye(String, int) but with the number of rows specified as a scalar INDArraySDVariableSDMath. eye(SDVariable rows, SDVariable cols)As per eye(int, int) bit with the number of rows/columns specified as scalar INDArraysSDVariableSDBaseOps. fill(String name, SDVariable shape, DataType dataType, double value)Generate an output variable with the specified (dynamic) shape with all elements set to the specified valueSDVariableSDBaseOps. fill(SDVariable shape, DataType dataType, double value)Generate an output variable with the specified (dynamic) shape with all elements set to the specified valueSDVariableSDMath. firstIndex(String name, SDVariable in, Condition condition, boolean keepDims, int... dimensions)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.SDVariableSDMath. firstIndex(String name, SDVariable in, Condition condition, int... dimensions)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.SDVariableSDMath. firstIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)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.SDVariableSDMath. firstIndex(SDVariable in, Condition condition, int... dimensions)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.SDVariableSDBaseOps. flatten(String name, SDVariable... inputs)Return a flattened variable with the specified orderingSDVariableSDBaseOps. flatten(String name, SDVariable[] inputs, String order)Return a flattened variable with the specified orderingSDVariableSDBaseOps. flatten(SDVariable... inputs)Return a flattened variable with the specified orderingSDVariableSDBaseOps. flatten(SDVariable[] inputs, String order)Return a flattened variable with the specified orderingSDVariableSDMath. floor(String name, SDVariable x)Element-wise floor function: out = floor(x).
Rounds each value down to the nearest integer value (if not already an integer)SDVariableSDMath. floor(SDVariable x)Element-wise floor function: out = floor(x).
Rounds each value down to the nearest integer value (if not already an integer)SDVariableSDMath. floorDiv(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. floorDiv(SDVariable x, SDVariable y)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.htmlSDVariableSDMath. floorMod(String name, SDVariable x, double value)Scalar floor modulus operationSDVariableSDMath. floorMod(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. floorMod(SDVariable x, double value)Scalar floor modulus operationSDVariableSDMath. floorMod(SDVariable x, SDVariable y)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.htmlSDVariableSDBaseOps. gather(String name, SDVariable df, int[] indices, int axis)Gather slices from the input variable where the indices are specified as fixed int[] values.
Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.SDVariableSDBaseOps. gather(String name, SDVariable df, SDVariable indices, int axis)Gather slices from the input variable where the indices are specified as dynamic array values.
Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.SDVariableSDBaseOps. gather(SDVariable df, int[] indices, int axis)Gather slices from the input variable where the indices are specified as fixed int[] values.
Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.SDVariableSDBaseOps. gather(SDVariable df, SDVariable indices, int axis)Gather slices from the input variable where the indices are specified as dynamic array values.
Output shape is same as input shape, except for axis dimension, which has size equal to indices.length.SDVariableSDBaseOps. gatherNd(String name, SDVariable df, SDVariable indices)Gather slices from df with shape specified by indices.SDVariableSDBaseOps. gatherNd(SDVariable df, SDVariable indices)Gather slices from df with shape specified by indices.SDVariableSDNN. gelu(String name, SDVariable x)GELU activation function - Gaussian Error Linear Units
For more details, see Gaussian Error Linear Units (GELUs) - https://arxiv.org/abs/1606.08415
This method uses the sigmoid approximationSDVariableSDNN. gelu(SDVariable x)GELU activation function - Gaussian Error Linear Units
For more details, see Gaussian Error Linear Units (GELUs) - https://arxiv.org/abs/1606.08415
This method uses the sigmoid approximationSDVariableSDRNN. gru(String name, SDVariable x, SDVariable hLast, SDVariable Wx, SDVariable Wh, SDVariable biases)The GRU operation.SDVariableSDRNN. gru(SDVariable x, SDVariable hLast, SDVariable Wx, SDVariable Wh, SDVariable biases)The GRU operation.SDVariable[]SDRNN. gruCell(String[] names, SDVariable x, SDVariable hLast, GRUWeights GRUWeights)The GRU cell.SDVariable[]SDRNN. gruCell(SDVariable x, SDVariable hLast, GRUWeights GRUWeights)The GRU cell.SDVariableSDBaseOps. gt(String name, SDVariable x, double y)Greater than operation: elementwise x > y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gt(String name, SDVariable x, SDVariable y)Greater than operation: elementwise x > y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gt(SDVariable x, double y)Greater than operation: elementwise x > y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gt(SDVariable x, SDVariable y)Greater than operation: elementwise x > y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gte(String name, SDVariable x, double y)Greater than or equals operation: elementwise x >= y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gte(String name, SDVariable x, SDVariable y)Greater than or equal to operation: elementwise x >= y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gte(SDVariable x, double y)Greater than or equals operation: elementwise x >= y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. gte(SDVariable x, SDVariable y)Greater than or equal to operation: elementwise x >= y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDMath. hammingDistance(String name, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Hamming distance reduction operation.SDVariableSDMath. hammingDistance(String name, SDVariable x, SDVariable y, int... dimensions)Hamming distance reduction operation.SDVariableSDMath. hammingDistance(SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Hamming distance reduction operation.SDVariableSDMath. hammingDistance(SDVariable x, SDVariable y, int... dimensions)Hamming distance reduction operation.SDVariableSDNN. hardSigmoid(String name, SDVariable x)Element-wise hard sigmoid function:
out[i] = 0 if in[i] <= -2.5
out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5
out[i] = 1 if in[i] >= 2.5SDVariableSDNN. hardSigmoid(SDVariable x)Element-wise hard sigmoid function:
out[i] = 0 if in[i] <= -2.5
out[1] = 0.2*in[i]+0.5 if -2.5 < in[i] < 2.5
out[i] = 1 if in[i] >= 2.5SDVariableSDNN. hardTanh(String name, SDVariable x)Element-wise hard tanh function:
out[i] = -1 if in[i] <= -1
out[1] = in[i] if -1 < in[i] < 1
out[i] = 1 if in[i] >= 1SDVariableSDNN. hardTanh(SDVariable x)Element-wise hard tanh function:
out[i] = -1 if in[i] <= -1
out[1] = in[i] if -1 < in[i] < 1
out[i] = 1 if in[i] >= 1SDVariableSDNN. hardTanhDerivative(String name, SDVariable x)Derivative (dOut/dIn) of the element-wise hard Tanh function - hardTanh(INDArray)SDVariableSDNN. hardTanhDerivative(SDVariable x)Derivative (dOut/dIn) of the element-wise hard Tanh function - hardTanh(INDArray)SDVariableSDLoss. hingeLoss(String name, SDVariable label, SDVariable predictions, SDVariable weights)Hinge loss: a loss function used for training classifiers.
ImplementsL = max(0, 1 - t * predictions)where t is the label values after internally converting to {-1,1}
from the user specified {0,1}.SDVariableSDLoss. hingeLoss(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Hinge loss: a loss function used for training classifiers.
ImplementsL = max(0, 1 - t * predictions)where t is the label values after internally converting to {-1,1}
from the user specified {0,1}.SDVariableSDLoss. hingeLoss(SDVariable label, SDVariable predictions, SDVariable weights)Hinge loss: a loss function used for training classifiers.
ImplementsL = max(0, 1 - t * predictions)where t is the label values after internally converting to {-1,1}
from the user specified {0,1}.SDVariableSDLoss. hingeLoss(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Hinge loss: a loss function used for training classifiers.
ImplementsL = max(0, 1 - t * predictions)where t is the label values after internally converting to {-1,1}
from the user specified {0,1}.SDVariableSDImage. hsvToRgb(String name, SDVariable input)Converting image from HSV to RGB formatSDVariableSDImage. hsvToRgb(SDVariable input)Converting image from HSV to RGB formatSDVariableSDLoss. huberLoss(String name, SDVariable label, SDVariable predictions, SDVariable weights, double delta)Huber loss function, used for robust regression.SDVariableSDLoss. huberLoss(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double delta)Huber loss function, used for robust regression.SDVariableSDLoss. huberLoss(SDVariable label, SDVariable predictions, SDVariable weights, double delta)Huber loss function, used for robust regression.SDVariableSDLoss. huberLoss(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double delta)Huber loss function, used for robust regression.SDVariableSDMath. iamax(String name, SDVariable in, boolean keepDims, int... dimensions)Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)SDVariableSDMath. iamax(String name, SDVariable in, int... dimensions)Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)SDVariableSDMath. iamax(SDVariable in, boolean keepDims, int... dimensions)Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)SDVariableSDMath. iamax(SDVariable in, int... dimensions)Index of the max absolute value: argmax(abs(in))
see argmax(String, INDArray, boolean, int...)SDVariableSDMath. iamin(String name, SDVariable in, boolean keepDims, int... dimensions)Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)SDVariableSDMath. iamin(String name, SDVariable in, int... dimensions)Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)SDVariableSDMath. iamin(SDVariable in, boolean keepDims, int... dimensions)Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)SDVariableSDMath. iamin(SDVariable in, int... dimensions)Index of the min absolute value: argmin(abs(in))
see argmin(String, INDArray, boolean, int...)SDVariableSDBaseOps. identity(String name, SDVariable input)Elementwise identity operation: out = xSDVariableSDBaseOps. identity(SDVariable input)Elementwise identity operation: out = xSDVariableSDCNN. im2Col(String name, SDVariable in, Conv2DConfig Conv2DConfig)im2col operation for use in 2D convolution operations.SDVariableSDCNN. im2Col(SDVariable in, Conv2DConfig Conv2DConfig)im2col operation for use in 2D convolution operations.SDVariableSDImage. imageResize(String name, SDVariable input, SDVariable size, boolean preserveAspectRatio, boolean antialias, ImageResizeMethod ImageResizeMethod)Resize images to size using the specified method.SDVariableSDImage. imageResize(String name, SDVariable input, SDVariable size, ImageResizeMethod ImageResizeMethod)Resize images to size using the specified method.SDVariableSDImage. imageResize(SDVariable input, SDVariable size, boolean preserveAspectRatio, boolean antialias, ImageResizeMethod ImageResizeMethod)Resize images to size using the specified method.SDVariableSDImage. imageResize(SDVariable input, SDVariable size, ImageResizeMethod ImageResizeMethod)Resize images to size using the specified method.SDVariableSDBaseOps. invertPermutation(String name, SDVariable input)Compute the inverse permutation indices for a permutation operation
Example: if input is [2, 0, 1] then output is [1, 2, 0]
The idea is that x.permute(input).permute(invertPermutation(input)) == xSDVariableSDBaseOps. invertPermutation(SDVariable input)Compute the inverse permutation indices for a permutation operation
Example: if input is [2, 0, 1] then output is [1, 2, 0]
The idea is that x.permute(input).permute(invertPermutation(input)) == xSDVariableSDMath. isFinite(String name, SDVariable x)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 otherwiseSDVariableSDMath. isFinite(SDVariable x)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 otherwiseSDVariableSDMath. isInfinite(String name, SDVariable x)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 otherwiseSDVariableSDMath. isInfinite(SDVariable x)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 otherwiseSDVariableSDMath. isMax(String name, SDVariable x)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 otherwiseSDVariableSDMath. isMax(SDVariable x)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 otherwiseSDVariableSDMath. isNaN(String name, SDVariable x)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 otherwiseSDVariableSDMath. isNaN(SDVariable x)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 otherwiseSDVariableSDMath. isNonDecreasing(String name, SDVariable x)Is the array non decreasing?
An array is non-decreasing if for every valid i, x[i] <= x[i+1].SDVariableSDMath. isNonDecreasing(SDVariable x)Is the array non decreasing?
An array is non-decreasing if for every valid i, x[i] <= x[i+1].SDVariableSDBaseOps. isNumericTensor(String name, SDVariable x)Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1SDVariableSDBaseOps. isNumericTensor(SDVariable x)Is the director a numeric tensor? In the current version of ND4J/SameDiff, this always returns true/1static booleanSDValidation. isSameType(SDVariable[] x)static booleanSDValidation. isSameType(SDVariable x, SDVariable y)SDVariableSDMath. isStrictlyIncreasing(String name, SDVariable x)Is the array strictly increasing?
An array is strictly increasing if for every valid i, x[i] < x[i+1].SDVariableSDMath. isStrictlyIncreasing(SDVariable x)Is the array strictly increasing?
An array is strictly increasing if for every valid i, x[i] < x[i+1].SDVariableSDMath. jaccardDistance(String name, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Jaccard similarity reduction operation.SDVariableSDMath. jaccardDistance(String name, SDVariable x, SDVariable y, int... dimensions)Jaccard similarity reduction operation.SDVariableSDMath. jaccardDistance(SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Jaccard similarity reduction operation.SDVariableSDMath. jaccardDistance(SDVariable x, SDVariable y, int... dimensions)Jaccard similarity reduction operation.SDVariableSDLoss. l2Loss(String name, SDVariable var)L2 loss: 1/2 * sum(x^2)SDVariableSDLoss. l2Loss(SDVariable var)L2 loss: 1/2 * sum(x^2)SDVariableSDMath. lastIndex(String name, SDVariable in, Condition condition, boolean keepDims, int... dimensions)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.SDVariableSDMath. lastIndex(String name, SDVariable in, Condition condition, int... dimensions)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.SDVariableSDMath. lastIndex(SDVariable in, Condition condition, boolean keepDims, int... dimensions)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.SDVariableSDMath. lastIndex(SDVariable in, Condition condition, int... dimensions)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.SDVariableSDNN. layerNorm(String name, SDVariable input, SDVariable gain, boolean channelsFirst, int... dimensions)Apply Layer Normalization
y = gain * standardize(x) + biasSDVariableSDNN. layerNorm(String name, SDVariable input, SDVariable gain, SDVariable bias, boolean channelsFirst, int... dimensions)Apply Layer Normalization
y = gain * standardize(x) + biasSDVariableSDNN. layerNorm(SDVariable input, SDVariable gain, boolean channelsFirst, int... dimensions)Apply Layer Normalization
y = gain * standardize(x) + biasSDVariableSDNN. layerNorm(SDVariable input, SDVariable gain, SDVariable bias, boolean channelsFirst, int... dimensions)Apply Layer Normalization
y = gain * standardize(x) + biasSDVariableSDNN. leakyRelu(String name, SDVariable x, double alpha)Element-wise leaky ReLU function:
out = x if x >= 0.0
out = alpha * x if x < cutoff
Alpha value is most commonly set to 0.01SDVariableSDNN. leakyRelu(SDVariable x, double alpha)Element-wise leaky ReLU function:
out = x if x >= 0.0
out = alpha * x if x < cutoff
Alpha value is most commonly set to 0.01SDVariableSDNN. leakyReluDerivative(String name, SDVariable x, double alpha)Leaky ReLU derivative: dOut/dIn given input.SDVariableSDNN. leakyReluDerivative(SDVariable x, double alpha)Leaky ReLU derivative: dOut/dIn given input.SDVariableSDBitwise. leftShift(String name, SDVariable x, SDVariable y)Bitwise left shift operation.SDVariableSDBitwise. leftShift(SDVariable x, SDVariable y)Bitwise left shift operation.SDVariableSDBitwise. leftShiftCyclic(String name, SDVariable x, SDVariable y)Bitwise left cyclical shift operation.SDVariableSDBitwise. leftShiftCyclic(SDVariable x, SDVariable y)Bitwise left cyclical shift operation.SDVariableSDNN. linear(String name, SDVariable input, SDVariable weights, SDVariable bias)Linear layer operation: out = mmul(in,w) + bias
Note that bias array is optionalSDVariableSDNN. linear(SDVariable input, SDVariable weights, SDVariable bias)Linear layer operation: out = mmul(in,w) + bias
Note that bias array is optionalSDVariableSDBaseOps. linspace(String name, SDVariable start, SDVariable stop, SDVariable number, DataType dataType)Create a new 1d array with values evenly spaced between values 'start' and 'stop'
For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0]SDVariableSDBaseOps. linspace(SDVariable start, SDVariable stop, SDVariable number, DataType dataType)Create a new 1d array with values evenly spaced between values 'start' and 'stop'
For example, linspace(start=3.0, stop=4.0, number=3) will generate [3.0, 3.5, 4.0]SDVariable[]SDMath. listDiff(String[] names, SDVariable x, SDVariable y)Calculates difference between inputs X and Y.SDVariable[]SDMath. listDiff(SDVariable x, SDVariable y)Calculates difference between inputs X and Y.SDVariableSDCNN. localResponseNormalization(String name, SDVariable input, LocalResponseNormalizationConfig LocalResponseNormalizationConfig)2D convolution layer operation - local response normalizationSDVariableSDCNN. localResponseNormalization(SDVariable input, LocalResponseNormalizationConfig LocalResponseNormalizationConfig)2D convolution layer operation - local response normalizationSDVariableSDMath. log(String name, SDVariable x)Element-wise logarithm function (base e - natural logarithm): out = log(x)SDVariableSDMath. log(String name, SDVariable x, double base)Element-wise logarithm function (with specified base): out = log_{base}(x)SDVariableSDMath. log(SDVariable x)Element-wise logarithm function (base e - natural logarithm): out = log(x)SDVariableSDMath. log(SDVariable x, double base)Element-wise logarithm function (with specified base): out = log_{base}(x)SDVariableSDMath. log1p(String name, SDVariable x)Elementwise natural logarithm function: out = log_e (1 + x)SDVariableSDMath. log1p(SDVariable x)Elementwise natural logarithm function: out = log_e (1 + x)SDVariableSDLinalg. logdet(String name, SDVariable input)Calculates log of determinant.SDVariableSDLinalg. logdet(SDVariable input)Calculates log of determinant.SDVariableSDMath. logEntropy(String name, SDVariable in, boolean keepDims, int... dimensions)Log entropy reduction: log(-sum(x * log(x)))SDVariableSDMath. logEntropy(String name, SDVariable in, int... dimensions)Log entropy reduction: log(-sum(x * log(x)))SDVariableSDMath. logEntropy(SDVariable in, boolean keepDims, int... dimensions)Log entropy reduction: log(-sum(x * log(x)))SDVariableSDMath. logEntropy(SDVariable in, int... dimensions)Log entropy reduction: log(-sum(x * log(x)))SDVariableSDLoss. logLoss(String name, SDVariable label, SDVariable predictions)Log loss, i.e., binary cross entropy loss, usually used for binary multi-label classification.SDVariableSDLoss. logLoss(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double epsilon)Log loss, i.e., binary cross entropy loss, usually used for binary multi-label classification.SDVariableSDLoss. logLoss(SDVariable label, SDVariable predictions)Log loss, i.e., binary cross entropy loss, usually used for binary multi-label classification.SDVariableSDLoss. logLoss(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double epsilon)Log loss, i.e., binary cross entropy loss, usually used for binary multi-label classification.SDVariableSDLoss. logPoisson(String name, SDVariable label, SDVariable predictions, SDVariable weights, boolean full)Log poisson loss: a loss function used for training classifiers.
ImplementsL = exp(c) - z * cwhere c is log(predictions) and z is labels.SDVariableSDLoss. logPoisson(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, boolean full)Log poisson loss: a loss function used for training classifiers.
ImplementsL = exp(c) - z * cwhere c is log(predictions) and z is labels.SDVariableSDLoss. logPoisson(SDVariable label, SDVariable predictions, SDVariable weights, boolean full)Log poisson loss: a loss function used for training classifiers.
ImplementsL = exp(c) - z * cwhere c is log(predictions) and z is labels.SDVariableSDLoss. logPoisson(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce, boolean full)Log poisson loss: a loss function used for training classifiers.
ImplementsL = exp(c) - z * cwhere c is log(predictions) and z is labels.SDVariableSDNN. logSigmoid(String name, SDVariable x)Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))SDVariableSDNN. logSigmoid(SDVariable x)Element-wise sigmoid function: out[i] = log(sigmoid(in[i]))SDVariableSDNN. logSoftmax(String name, SDVariable x)Log softmax activationSDVariableSDNN. logSoftmax(String name, SDVariable x, int dimension)Log softmax activationSDVariableSDNN. logSoftmax(SDVariable x)Log softmax activationSDVariableSDNN. logSoftmax(SDVariable x, int dimension)Log softmax activationSDVariableSDMath. logSumExp(String name, SDVariable input, int... dimensions)Log-sum-exp reduction (optionally along dimension).
Computes log(sum(exp(x))SDVariableSDMath. logSumExp(SDVariable input, int... dimensions)Log-sum-exp reduction (optionally along dimension).
Computes log(sum(exp(x))SDVariableSDRNN. lstmblock(String name, SDVariable maxTSLength, SDVariable x, SDVariable cLast, SDVariable yLast, LSTMWeights LSTMWeights, LSTMConfiguration LSTMConfiguration)The LSTM blockSDVariableSDRNN. lstmblock(String name, SDVariable x, LSTMWeights LSTMWeights, LSTMConfiguration LSTMConfiguration)The LSTM blockSDVariableSDRNN. lstmblock(SDVariable maxTSLength, SDVariable x, SDVariable cLast, SDVariable yLast, LSTMWeights LSTMWeights, LSTMConfiguration LSTMConfiguration)The LSTM blockSDVariableSDRNN. lstmblock(SDVariable x, LSTMWeights LSTMWeights, LSTMConfiguration LSTMConfiguration)The LSTM blockSDVariable[]SDRNN. lstmCell(String[] names, SDVariable x, SDVariable cLast, SDVariable yLast, LSTMWeights LSTMWeights, LSTMConfiguration LSTMConfiguration)The LSTM cell.SDVariable[]SDRNN. lstmCell(SDVariable x, SDVariable cLast, SDVariable yLast, LSTMWeights LSTMWeights, LSTMConfiguration LSTMConfiguration)The LSTM cell.SDVariable[]SDRNN. lstmLayer(String[] names, SDVariable x, SDVariable cLast, SDVariable yLast, SDVariable maxTSLength, LSTMLayerWeights LSTMLayerWeights, LSTMLayerConfig LSTMLayerConfig)Long Short-Term Memory layer - Hochreiter 1997.
SUPPORTS following data formats:
for unidirectional:
TNS: shapes [timeLength, numExamples, inOutSize]
NST: shapes [numExamples, inOutSize, timeLength]
NTS: shapes [numExamples, timeLength, inOutSize]
for bidirectional:
T2NS: shapes [timeLength, 2, numExamples, inOutSize] (for ONNX)
SUPPORTS following direction modes:
FWD: forward
BWD: backward
BIDIR_SUM: bidirectional sum
BIDIR_CONCAT: bidirectional concat
BIDIR_EXTRA_DIM: bidirectional extra output dim (in conjunction with format dataFormat - T2NS)
You may use different gate configurations:
specify gate/cell/out aplha/beta and numbers of activations for gate/cell/out described in activations enum
("RELU","SIGMOID","AFFINE","LEAKY_RELU","THRESHHOLD_RELU","SCALED_TAHN","HARD_SIGMOID","ELU","SOFTSIGN","SOFTPLUS")
Also this layer supports MKLDNN (DNNL) and cuDNN accelerationSDVariable[]SDRNN. lstmLayer(String[] names, SDVariable x, LSTMLayerWeights LSTMLayerWeights, LSTMLayerConfig LSTMLayerConfig)Long Short-Term Memory layer - Hochreiter 1997.
SUPPORTS following data formats:
for unidirectional:
TNS: shapes [timeLength, numExamples, inOutSize]
NST: shapes [numExamples, inOutSize, timeLength]
NTS: shapes [numExamples, timeLength, inOutSize]
for bidirectional:
T2NS: shapes [timeLength, 2, numExamples, inOutSize] (for ONNX)
SUPPORTS following direction modes:
FWD: forward
BWD: backward
BIDIR_SUM: bidirectional sum
BIDIR_CONCAT: bidirectional concat
BIDIR_EXTRA_DIM: bidirectional extra output dim (in conjunction with format dataFormat - T2NS)
You may use different gate configurations:
specify gate/cell/out aplha/beta and numbers of activations for gate/cell/out described in activations enum
("RELU","SIGMOID","AFFINE","LEAKY_RELU","THRESHHOLD_RELU","SCALED_TAHN","HARD_SIGMOID","ELU","SOFTSIGN","SOFTPLUS")
Also this layer supports MKLDNN (DNNL) and cuDNN accelerationSDVariable[]SDRNN. lstmLayer(SDVariable x, SDVariable cLast, SDVariable yLast, SDVariable maxTSLength, LSTMLayerWeights LSTMLayerWeights, LSTMLayerConfig LSTMLayerConfig)Long Short-Term Memory layer - Hochreiter 1997.
SUPPORTS following data formats:
for unidirectional:
TNS: shapes [timeLength, numExamples, inOutSize]
NST: shapes [numExamples, inOutSize, timeLength]
NTS: shapes [numExamples, timeLength, inOutSize]
for bidirectional:
T2NS: shapes [timeLength, 2, numExamples, inOutSize] (for ONNX)
SUPPORTS following direction modes:
FWD: forward
BWD: backward
BIDIR_SUM: bidirectional sum
BIDIR_CONCAT: bidirectional concat
BIDIR_EXTRA_DIM: bidirectional extra output dim (in conjunction with format dataFormat - T2NS)
You may use different gate configurations:
specify gate/cell/out aplha/beta and numbers of activations for gate/cell/out described in activations enum
("RELU","SIGMOID","AFFINE","LEAKY_RELU","THRESHHOLD_RELU","SCALED_TAHN","HARD_SIGMOID","ELU","SOFTSIGN","SOFTPLUS")
Also this layer supports MKLDNN (DNNL) and cuDNN accelerationSDVariable[]SDRNN. lstmLayer(SDVariable x, LSTMLayerWeights LSTMLayerWeights, LSTMLayerConfig LSTMLayerConfig)Long Short-Term Memory layer - Hochreiter 1997.
SUPPORTS following data formats:
for unidirectional:
TNS: shapes [timeLength, numExamples, inOutSize]
NST: shapes [numExamples, inOutSize, timeLength]
NTS: shapes [numExamples, timeLength, inOutSize]
for bidirectional:
T2NS: shapes [timeLength, 2, numExamples, inOutSize] (for ONNX)
SUPPORTS following direction modes:
FWD: forward
BWD: backward
BIDIR_SUM: bidirectional sum
BIDIR_CONCAT: bidirectional concat
BIDIR_EXTRA_DIM: bidirectional extra output dim (in conjunction with format dataFormat - T2NS)
You may use different gate configurations:
specify gate/cell/out aplha/beta and numbers of activations for gate/cell/out described in activations enum
("RELU","SIGMOID","AFFINE","LEAKY_RELU","THRESHHOLD_RELU","SCALED_TAHN","HARD_SIGMOID","ELU","SOFTSIGN","SOFTPLUS")
Also this layer supports MKLDNN (DNNL) and cuDNN accelerationSDVariableSDLinalg. lstsq(String name, SDVariable matrix, SDVariable rhs, double l2_reguralizer)Solver for linear squares problems.SDVariableSDLinalg. lstsq(String name, SDVariable matrix, SDVariable rhs, double l2_reguralizer, boolean fast)Solver for linear squares problems.SDVariableSDLinalg. lstsq(SDVariable matrix, SDVariable rhs, double l2_reguralizer)Solver for linear squares problems.SDVariableSDLinalg. lstsq(SDVariable matrix, SDVariable rhs, double l2_reguralizer, boolean fast)Solver for linear squares problems.SDVariableSDBaseOps. lt(String name, SDVariable x, double y)Less than operation: elementwise x < y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lt(String name, SDVariable x, SDVariable y)Less than operation: elementwise x < y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lt(SDVariable x, double y)Less than operation: elementwise x < y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lt(SDVariable x, SDVariable y)Less than operation: elementwise x < y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lte(String name, SDVariable x, double y)Less than or equals operation: elementwise x <= y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lte(String name, SDVariable x, SDVariable y)Less than or equal to operation: elementwise x <= y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lte(SDVariable x, double y)Less than or equals operation: elementwise x <= y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. lte(SDVariable x, SDVariable y)Less than or equal to operation: elementwise x <= y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDLinalg. lu(String name, SDVariable input)Computes LU decomposition.SDVariableSDLinalg. lu(SDVariable input)Computes LU decomposition.SDVariableSDMath. manhattanDistance(String name, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Manhattan distance (l1 norm, l1 distance) reduction operation.SDVariableSDMath. manhattanDistance(String name, SDVariable x, SDVariable y, int... dimensions)Manhattan distance (l1 norm, l1 distance) reduction operation.SDVariableSDMath. manhattanDistance(SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int... dimensions)Manhattan distance (l1 norm, l1 distance) reduction operation.SDVariableSDMath. manhattanDistance(SDVariable x, SDVariable y, int... dimensions)Manhattan distance (l1 norm, l1 distance) reduction operation.SDVariableSDBaseOps. matchCondition(String name, SDVariable in, Condition condition)Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwiseSDVariableSDBaseOps. matchCondition(SDVariable in, Condition condition)Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwiseSDVariableSDBaseOps. matchConditionCount(String name, SDVariable in, Condition condition)Returns a count of the number of elements that satisfy the conditionSDVariableSDBaseOps. matchConditionCount(String name, SDVariable in, Condition condition, boolean keepDim, int... dimensions)Returns a count of the number of elements that satisfy the 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.SDVariableSDBaseOps. matchConditionCount(String name, SDVariable in, Condition condition, int... dimensions)Returns a count of the number of elements that satisfy the 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.SDVariableSDBaseOps. matchConditionCount(SDVariable in, Condition condition)Returns a count of the number of elements that satisfy the conditionSDVariableSDBaseOps. matchConditionCount(SDVariable in, Condition condition, boolean keepDim, int... dimensions)Returns a count of the number of elements that satisfy the 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.SDVariableSDBaseOps. matchConditionCount(SDVariable in, Condition condition, int... dimensions)Returns a count of the number of elements that satisfy the 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.SDVariableSDLinalg. matmul(String name, SDVariable a, SDVariable b)Performs matrix mutiplication on input tensors.SDVariableSDLinalg. matmul(SDVariable a, SDVariable b)Performs matrix mutiplication on input tensors.SDVariable[]SDLinalg. matrixBandPart(String[] names, SDVariable input, int minLower, int maxUpper)Copy a tensor setting outside a central band in each innermost matrix.SDVariable[]SDLinalg. matrixBandPart(SDVariable input, int minLower, int maxUpper)Copy a tensor setting outside a central band in each innermost matrix.SDVariableSDLinalg. matrixDeterminant(String name, SDVariable input)Calculates matrix determinant.SDVariableSDLinalg. matrixDeterminant(SDVariable input)Calculates matrix determinant.SDVariableSDMath. matrixDeterminant(String name, SDVariable in)Matrix determinant op.SDVariableSDMath. matrixDeterminant(SDVariable in)Matrix determinant op.SDVariableSDLinalg. matrixInverse(String name, SDVariable input)Inverts a matrixSDVariableSDLinalg. matrixInverse(SDVariable input)Inverts a matrixSDVariableSDMath. matrixInverse(String name, SDVariable in)Matrix inverse op.SDVariableSDMath. matrixInverse(SDVariable in)Matrix inverse op.SDVariableSDBaseOps. max(String name, SDVariable x, boolean keepDims, int... dimensions)Max array reduction operation, optionally along 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.SDVariableSDBaseOps. max(String name, SDVariable x, int... dimensions)Max array reduction operation, optionally along 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.SDVariableSDBaseOps. max(String name, SDVariable first, SDVariable second)Element-wise maximum operation: out[i] = max(first[i], second[i])
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.htmlSDVariableSDBaseOps. max(SDVariable x, boolean keepDims, int... dimensions)Max array reduction operation, optionally along 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.SDVariableSDBaseOps. max(SDVariable x, int... dimensions)Max array reduction operation, optionally along 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.SDVariableSDBaseOps. max(SDVariable first, SDVariable second)Element-wise maximum operation: out[i] = max(first[i], second[i])
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.htmlSDVariableSDMath. max(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. max(SDVariable x, SDVariable y)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.htmlSDVariableSDCNN. maxPooling2d(String name, SDVariable input, Pooling2DConfig Pooling2DConfig)2D Convolution layer operation - max pooling 2dSDVariableSDCNN. maxPooling2d(SDVariable input, Pooling2DConfig Pooling2DConfig)2D Convolution layer operation - max pooling 2dSDVariableSDCNN. maxPooling3d(String name, SDVariable input, Pooling3DConfig Pooling3DConfig)3D convolution layer operation - max pooling 3d operation.SDVariableSDCNN. maxPooling3d(SDVariable input, Pooling3DConfig Pooling3DConfig)3D convolution layer operation - max pooling 3d operation.SDVariable[]SDCNN. maxPoolWithArgmax(String[] names, SDVariable input, Pooling2DConfig Pooling2DConfig)2D Convolution layer operation - Max pooling on the input and outputs both max values and indicesSDVariable[]SDCNN. maxPoolWithArgmax(SDVariable input, Pooling2DConfig Pooling2DConfig)2D Convolution layer operation - Max pooling on the input and outputs both max values and indicesSDVariableSDBaseOps. mean(String name, SDVariable x, boolean keepDims, int... dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(String name, SDVariable x, int... dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(String name, SDVariable x, SDVariable dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(String name, SDVariable x, SDVariable dimensions, boolean keepDims)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(SDVariable x, boolean keepDims, int... dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(SDVariable x, int... dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(SDVariable x, SDVariable dimensions)Mean (average) array reduction operation, optionally along 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.SDVariableSDBaseOps. mean(SDVariable x, SDVariable dimensions, boolean keepDims)Mean (average) array reduction operation, optionally along 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.SDVariableSDMath. mean(String name, SDVariable in, boolean keepDims, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(String name, SDVariable in, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(String name, SDVariable in, SDVariable dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(SDVariable in, boolean keepDims, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(SDVariable in, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(SDVariable in, SDVariable dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. mean(SDVariable in, SDVariable dimensions, boolean keepDims)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDLoss. meanPairwiseSquaredError(String name, SDVariable label, SDVariable predictions, SDVariable weights)Mean pairwise squared error.
MPWSE loss calculates the difference between pairs of consecutive elements in the predictions and labels arrays.
For example, if predictions = [p0, p1, p2] and labels are [l0, l1, l2] then MPWSE is:
[((p0-p1) - (l0-l1))^2 + ((p0-p2) - (l0-l2))^2 + ((p1-p2) - (l1-l2))^2] / 3SDVariableSDLoss. meanPairwiseSquaredError(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Mean pairwise squared error.
MPWSE loss calculates the difference between pairs of consecutive elements in the predictions and labels arrays.
For example, if predictions = [p0, p1, p2] and labels are [l0, l1, l2] then MPWSE is:
[((p0-p1) - (l0-l1))^2 + ((p0-p2) - (l0-l2))^2 + ((p1-p2) - (l1-l2))^2] / 3SDVariableSDLoss. meanPairwiseSquaredError(SDVariable label, SDVariable predictions, SDVariable weights)Mean pairwise squared error.
MPWSE loss calculates the difference between pairs of consecutive elements in the predictions and labels arrays.
For example, if predictions = [p0, p1, p2] and labels are [l0, l1, l2] then MPWSE is:
[((p0-p1) - (l0-l1))^2 + ((p0-p2) - (l0-l2))^2 + ((p1-p2) - (l1-l2))^2] / 3SDVariableSDLoss. meanPairwiseSquaredError(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Mean pairwise squared error.
MPWSE loss calculates the difference between pairs of consecutive elements in the predictions and labels arrays.
For example, if predictions = [p0, p1, p2] and labels are [l0, l1, l2] then MPWSE is:
[((p0-p1) - (l0-l1))^2 + ((p0-p2) - (l0-l2))^2 + ((p1-p2) - (l1-l2))^2] / 3SDVariableSDLoss. meanSquaredError(String name, SDVariable label, SDVariable predictions, SDVariable weights)Mean squared error loss function.SDVariableSDLoss. meanSquaredError(String name, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Mean squared error loss function.SDVariableSDLoss. meanSquaredError(SDVariable label, SDVariable predictions, SDVariable weights)Mean squared error loss function.SDVariableSDLoss. meanSquaredError(SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)Mean squared error loss function.SDVariableSDBaseOps. merge(String name, SDVariable x, SDVariable y)The merge operation is a control operation that forwards the either of the inputs to the output, when
the first of them becomes available.SDVariableSDBaseOps. merge(SDVariable x, SDVariable y)The merge operation is a control operation that forwards the either of the inputs to the output, when
the first of them becomes available.SDVariableSDMath. mergeAdd(String name, SDVariable... inputs)Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition:
out = sum_i in[i]SDVariableSDMath. mergeAdd(SDVariable... inputs)Merge add function: merges an arbitrary number of equal shaped arrays using element-wise addition:
out = sum_i in[i]SDVariableSDMath. mergeAvg(String name, SDVariable... inputs)Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation:
out = mean_i in[i]SDVariableSDMath. mergeAvg(SDVariable... inputs)Merge average function: merges an arbitrary number of equal shaped arrays using element-wise mean operation:
out = mean_i in[i]SDVariableSDMath. mergeMax(String name, SDVariable... inputs)Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation:
out = max_i in[i]SDVariableSDMath. mergeMax(SDVariable... inputs)Merge max function: merges an arbitrary number of equal shaped arrays using element-wise maximum operation:
out = max_i in[i]SDVariableSDMath. mergeMaxIndex(String name, SDVariable... x)Return array of max elements indices with along tensor dimensionsSDVariableSDMath. mergeMaxIndex(String name, SDVariable[] x, DataType dataType)Return array of max elements indices with along tensor dimensionsSDVariableSDMath. mergeMaxIndex(SDVariable... x)Return array of max elements indices with along tensor dimensionsSDVariableSDMath. mergeMaxIndex(SDVariable[] x, DataType dataType)Return array of max elements indices with along tensor dimensionsSDVariable[]SDMath. meshgrid(String[] names, SDVariable[] inputs, boolean cartesian)Broadcasts parameters for evaluation on an N-D grid.SDVariable[]SDMath. meshgrid(SDVariable[] inputs, boolean cartesian)Broadcasts parameters for evaluation on an N-D grid.SDVariableSDBaseOps. min(String name, SDVariable x, boolean keepDims, int... dimensions)Minimum array reduction operation, optionally along specified dimensions.SDVariableSDBaseOps. min(String name, SDVariable x, int... dimensions)Minimum array reduction operation, optionally along specified dimensions.SDVariableSDBaseOps. min(String name, SDVariable first, SDVariable second)Element-wise minimum operation: out[i] = min(first[i], second[i])
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.htmlSDVariableSDBaseOps. min(SDVariable x, boolean keepDims, int... dimensions)Minimum array reduction operation, optionally along specified dimensions.SDVariableSDBaseOps. min(SDVariable x, int... dimensions)Minimum array reduction operation, optionally along specified dimensions.SDVariableSDBaseOps. min(SDVariable first, SDVariable second)Element-wise minimum operation: out[i] = min(first[i], second[i])
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.htmlSDVariableSDMath. min(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. min(SDVariable x, SDVariable y)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.htmlSDVariableSDBaseOps. mmul(String name, SDVariable x, SDVariable y)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDBaseOps. mmul(String name, SDVariable x, SDVariable y, boolean transposeX, boolean transposeY, boolean transposeZ)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDBaseOps. mmul(SDVariable x, SDVariable y)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDBaseOps. mmul(SDVariable x, SDVariable y, boolean transposeX, boolean transposeY, boolean transposeZ)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDLinalg. mmul(String name, SDVariable x, SDVariable y)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDLinalg. mmul(String name, SDVariable x, SDVariable y, boolean transposeX, boolean transposeY, boolean transposeZ)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDLinalg. mmul(SDVariable x, SDVariable y)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDLinalg. mmul(SDVariable x, SDVariable y, boolean transposeX, boolean transposeY, boolean transposeZ)Matrix multiplication: out = mmul(x,y)
Supports specifying transpose argument to perform operation such as mmul(a^T, b), etc.SDVariableSDMath. mod(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. mod(SDVariable x, SDVariable y)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.htmlSDVariable[]SDMath. moments(String[] names, SDVariable input, int[] axes, boolean keepDims)Calculate the mean and (population) variance for the input variable, for the specified axisSDVariable[]SDMath. moments(String[] names, SDVariable input, SDVariable axes, boolean keepDims)Calculate the mean and (population) variance for the input variable, for the specified axisSDVariable[]SDMath. moments(SDVariable input, int[] axes, boolean keepDims)Calculate the mean and (population) variance for the input variable, for the specified axisSDVariable[]SDMath. moments(SDVariable input, SDVariable axes, boolean keepDims)Calculate the mean and (population) variance for the input variable, for the specified axisSDVariableSDMath. mul(String name, SDVariable x, double value)Scalar multiplication operation, out = in * scalarSDVariableSDMath. mul(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. mul(SDVariable x, double value)Scalar multiplication operation, out = in * scalarSDVariableSDMath. mul(SDVariable x, SDVariable y)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.htmlSDVariableSDNN. multiHeadDotProductAttention(String name, SDVariable queries, SDVariable keys, SDVariable values, SDVariable Wq, SDVariable Wk, SDVariable Wv, SDVariable Wo, SDVariable mask, boolean scaled)This performs multi-headed dot product attention on the given timeseries input
out = concat(head_1, head_2, ..., head_n) * Wo
head_i = dot_product_attention(Wq_i*q, Wk_i*k, Wv_i*v)
Optionally with normalization when calculating the attention for each head.
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, pp.SDVariableSDNN. multiHeadDotProductAttention(SDVariable queries, SDVariable keys, SDVariable values, SDVariable Wq, SDVariable Wk, SDVariable Wv, SDVariable Wo, SDVariable mask, boolean scaled)This performs multi-headed dot product attention on the given timeseries input
out = concat(head_1, head_2, ..., head_n) * Wo
head_i = dot_product_attention(Wq_i*q, Wk_i*k, Wv_i*v)
Optionally with normalization when calculating the attention for each head.
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, pp.SDVariableSDMath. neg(String name, SDVariable x)Elementwise negative operation: out = -xSDVariableSDMath. neg(SDVariable x)Elementwise negative operation: out = -xSDVariableSDBaseOps. neq(String name, SDVariable x, double y)Not equals operation: elementwise x != y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. neq(String name, SDVariable x, SDVariable y)Not equal to operation: elementwise x != y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. neq(SDVariable x, double y)Not equals operation: elementwise x != y
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDBaseOps. neq(SDVariable x, SDVariable y)Not equal to operation: elementwise x != y
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.
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
Return boolean array with values true where satisfied, or false otherwise.SDVariableSDImage. nonMaxSuppression(String name, SDVariable boxes, SDVariable scores, int maxOutSize, double iouThreshold, double scoreThreshold)Greedily selects a subset of bounding boxes in descending order of scoreSDVariableSDImage. nonMaxSuppression(SDVariable boxes, SDVariable scores, int maxOutSize, double iouThreshold, double scoreThreshold)Greedily selects a subset of bounding boxes in descending order of scoreSDVariableSDBaseOps. norm1(String name, SDVariable x, boolean keepDims, int... dimensions)Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i])
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. norm1(String name, SDVariable x, int... dimensions)Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i])
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. norm1(SDVariable x, boolean keepDims, int... dimensions)Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i])
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. norm1(SDVariable x, int... dimensions)Norm1 (L1 norm) reduction operation: The output contains the L1 norm for each tensor/subset along the specified dimensions:
out = sum_i abs(x[i])
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDMath. norm1(String name, SDVariable in, boolean keepDims, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. norm1(String name, SDVariable in, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. norm1(String name, SDVariable in, SDVariable dimensions)Sum of absolute differences.SDVariableSDMath. norm1(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Sum of absolute differences.SDVariableSDMath. norm1(SDVariable in, boolean keepDims, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. norm1(SDVariable in, int... dimensions)Mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. norm1(SDVariable in, SDVariable dimensions)Sum of absolute differences.SDVariableSDMath. norm1(SDVariable in, SDVariable dimensions, boolean keepDims)Sum of absolute differences.SDVariableSDBaseOps. norm2(String name, SDVariable x, boolean keepDims, int... dimensions)Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. norm2(String name, SDVariable x, int... dimensions)Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. norm2(SDVariable x, boolean keepDims, int... dimensions)Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. norm2(SDVariable x, int... dimensions)Norm2 (L2 norm) reduction operation: The output contains the L2 norm for each tensor/subset along the specified dimensions:
out = sqrt(sum_i x[i]^2)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDMath. norm2(String name, SDVariable in, boolean keepDims, int... dimensions)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(String name, SDVariable in, int... dimensions)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(String name, SDVariable in, SDVariable dimensions)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(SDVariable in, boolean keepDims, int... dimensions)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(SDVariable in, int... dimensions)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(SDVariable in, SDVariable dimensions)Euclidean norm: euclidean distance of a vector from the originSDVariableSDMath. norm2(SDVariable in, SDVariable dimensions, boolean keepDims)Euclidean norm: euclidean distance of a vector from the originSDVariable[]SDMath. normalizeMoments(String[] names, SDVariable counts, SDVariable means, SDVariable variances, double shift)Calculate the mean and variance from the sufficient statisticsSDVariable[]SDMath. normalizeMoments(SDVariable counts, SDVariable means, SDVariable variances, double shift)Calculate the mean and variance from the sufficient statisticsSDVariableSDBaseOps. normmax(String name, SDVariable x, boolean keepDims, int... dimensions)Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the
specified dimensions:
out = max(abs(x[i]))
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. normmax(String name, SDVariable x, int... dimensions)Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the
specified dimensions:
out = max(abs(x[i]))
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. normmax(SDVariable x, boolean keepDims, int... dimensions)Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the
specified dimensions:
out = max(abs(x[i]))
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. normmax(SDVariable x, int... dimensions)Max norm (infinity norm) reduction operation: The output contains the max norm for each tensor/subset along the
specified dimensions:
out = max(abs(x[i]))
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDMath. normMax(String name, SDVariable in, boolean keepDims, int... dimensions)Differences between max absolute valueSDVariableSDMath. normMax(String name, SDVariable in, int... dimensions)Differences between max absolute valueSDVariableSDMath. normMax(String name, SDVariable in, SDVariable dimensions)Differences between max absolute valueSDVariableSDMath. normMax(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Differences between max absolute valueSDVariableSDMath. normMax(SDVariable in, boolean keepDims, int... dimensions)Differences between max absolute valueSDVariableSDMath. normMax(SDVariable in, int... dimensions)Differences between max absolute valueSDVariableSDMath. normMax(SDVariable in, SDVariable dimensions)Differences between max absolute valueSDVariableSDMath. normMax(SDVariable in, SDVariable dimensions, boolean keepDims)Differences between max absolute valueSDVariableSDBaseOps. oneHot(String name, SDVariable indices, int depth)Convert the array to a one-hot array with values 0 and 1 for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth],
with out[i, ..., j, in[i,...,j]] = 1 with other values being set to 0
see oneHot(SDVariable, int, int, double, double)SDVariableSDBaseOps. oneHot(String name, SDVariable indices, int depth, int axis, double on, double off)Convert the array to a one-hot array with values and for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth],
with {out[i, ..., j, in[i,...,j]] with other values being set toSDVariableSDBaseOps. oneHot(String name, SDVariable indices, int depth, int axis, double on, double off, DataType dataType)Convert the array to a one-hot array with values and for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth],
with {out[i, ..., j, in[i,...,j]] with other values being set toSDVariableSDBaseOps. oneHot(SDVariable indices, int depth)Convert the array to a one-hot array with values 0 and 1 for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth],
with out[i, ..., j, in[i,...,j]] = 1 with other values being set to 0
see oneHot(SDVariable, int, int, double, double)SDVariableSDBaseOps. oneHot(SDVariable indices, int depth, int axis, double on, double off)Convert the array to a one-hot array with values and for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth],
with {out[i, ..., j, in[i,...,j]] with other values being set toSDVariableSDBaseOps. oneHot(SDVariable indices, int depth, int axis, double on, double off, DataType dataType)Convert the array to a one-hot array with values and for each entry
If input has shape [ a, ..., n] then output has shape [ a, ..., n, depth],
with {out[i, ..., j, in[i,...,j]] with other values being set toSDVariableSDBaseOps. onesLike(String name, SDVariable input)Return a variable of all 1s, with the same shape as the input variable.SDVariableSDBaseOps. onesLike(String name, SDVariable input, DataType dataType)As per onesLike(String, SDVariable) but the output datatype may be specifiedSDVariableSDBaseOps. onesLike(SDVariable input)Return a variable of all 1s, with the same shape as the input variable.SDVariableSDBaseOps. onesLike(SDVariable input, DataType dataType)As per onesLike(String, SDVariable) but the output datatype may be specifiedSDVariableSDBitwise. or(String name, SDVariable x, SDVariable y)Bitwise OR operation.SDVariableSDBitwise. or(SDVariable x, SDVariable y)Bitwise OR operation.SDVariableSDMath. or(String name, SDVariable x, SDVariable y)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.SDVariableSDMath. or(SDVariable x, SDVariable y)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.SDVariableSDImage. pad(String name, SDVariable input, SDVariable padding, Mode Mode, double padValue)Pads an image according to the given padding typeSDVariableSDImage. pad(SDVariable input, SDVariable padding, Mode Mode, double padValue)Pads an image according to the given padding typeSDVariableSDNN. pad(String name, SDVariable input, SDVariable padding, double constant)Padding operationSDVariableSDNN. pad(String name, SDVariable input, SDVariable padding, PadMode PadMode, double constant)Padding operationSDVariableSDNN. pad(SDVariable input, SDVariable padding, double constant)Padding operationSDVariableSDNN. pad(SDVariable input, SDVariable padding, PadMode PadMode, double constant)Padding operationSDVariableSDBaseOps. permute(String name, SDVariable x, int... dimensions)Array permutation operation: permute the dimensions according to the specified permutation indices.
Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]SDVariableSDBaseOps. permute(String name, SDVariable x, SDVariable dimensions)Array permutation operation: permute the dimensions according to the specified permutation indices.
Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]SDVariableSDBaseOps. permute(SDVariable x, int... dimensions)Array permutation operation: permute the dimensions according to the specified permutation indices.
Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]SDVariableSDBaseOps. permute(SDVariable x, SDVariable dimensions)Array permutation operation: permute the dimensions according to the specified permutation indices.
Example: if input has shape [a,b,c] and dimensions = [2,0,1] the output has shape [c,a,b]SDVariableSDMath. pow(String name, SDVariable x, double value)Element-wise power function: out = x^valueSDVariableSDMath. pow(String name, SDVariable x, SDVariable y)Element-wise (broadcastable) power function: out = x[i]^y[i]SDVariableSDMath. pow(SDVariable x, double value)Element-wise power function: out = x^valueSDVariableSDMath. pow(SDVariable x, SDVariable y)Element-wise (broadcastable) power function: out = x[i]^y[i]SDVariableSDNN. preciseGelu(String name, SDVariable x)GELU activation function - Gaussian Error Linear Units
For more details, see Gaussian Error Linear Units (GELUs) - https://arxiv.org/abs/1606.08415
This method uses the precise methodSDVariableSDNN. preciseGelu(SDVariable x)GELU activation function - Gaussian Error Linear Units
For more details, see Gaussian Error Linear Units (GELUs) - https://arxiv.org/abs/1606.08415
This method uses the precise methodSDVariableSDNN. prelu(String name, SDVariable input, SDVariable alpha, int... sharedAxes)PReLU (Parameterized Rectified Linear Unit) operation.SDVariableSDNN. prelu(SDVariable input, SDVariable alpha, int... sharedAxes)PReLU (Parameterized Rectified Linear Unit) operation.SDVariableSDBaseOps. prod(String name, SDVariable x, boolean keepDims, int... dimensions)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(String name, SDVariable x, int... dimensions)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(String name, SDVariable x, SDVariable dimensions)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(String name, SDVariable x, SDVariable dimensions, boolean keepDims)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(SDVariable x, boolean keepDims, int... dimensions)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(SDVariable x, int... dimensions)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(SDVariable x, SDVariable dimensions)Product array reduction operation, optionally along 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.SDVariableSDBaseOps. prod(SDVariable x, SDVariable dimensions, boolean keepDims)Product array reduction operation, optionally along 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.SDVariableSDMath. prod(String name, SDVariable in, boolean keepDims, int... dimensions)The max of an array along each dimensionSDVariableSDMath. prod(String name, SDVariable in, int... dimensions)The max of an array along each dimensionSDVariableSDMath. prod(String name, SDVariable in, SDVariable dimensions)The product of an array long each dimensionSDVariableSDMath. prod(String name, SDVariable in, SDVariable dimensions, boolean keepDims)The product of an array long each dimensionSDVariableSDMath. prod(SDVariable in, boolean keepDims, int... dimensions)The max of an array along each dimensionSDVariableSDMath. prod(SDVariable in, int... dimensions)The max of an array along each dimensionSDVariableSDMath. prod(SDVariable in, SDVariable dimensions)The product of an array long each dimensionSDVariableSDMath. prod(SDVariable in, SDVariable dimensions, boolean keepDims)The product of an array long each dimensionSDVariable[]SDLinalg. qr(String[] names, SDVariable input)Computes the QR decompositions of input matrix.SDVariable[]SDLinalg. qr(String[] names, SDVariable input, boolean full)Computes the QR decompositions of input matrix.SDVariable[]SDLinalg. qr(SDVariable input)Computes the QR decompositions of input matrix.SDVariable[]SDLinalg. qr(SDVariable input, boolean full)Computes the QR decompositions of input matrix.SDVariableSDImage. randomCrop(String name, SDVariable input, SDVariable shape)Randomly crops imageSDVariableSDImage. randomCrop(SDVariable input, SDVariable shape)Randomly crops imageSDVariableSDBaseOps. range(String name, SDVariable from, SDVariable to, SDVariable step, DataType dataType)Create a new variable with a 1d array, where the values start at from and increment by step
up to (but not including) limit.
For example, range(1.0, 3.0, 0.5) will return [1.0, 1.5, 2.0, 2.5]SDVariableSDBaseOps. range(SDVariable from, SDVariable to, SDVariable step, DataType dataType)Create a new variable with a 1d array, where the values start at from and increment by step
up to (but not including) limit.
For example, range(1.0, 3.0, 0.5) will return [1.0, 1.5, 2.0, 2.5]SDVariableSDBaseOps. rank(String name, SDVariable in)Returns the rank (number of dimensions, i.e., length(shape)) of the specified INDArray as a 0D scalar variableSDVariableSDBaseOps. rank(SDVariable in)Returns the rank (number of dimensions, i.e., length(shape)) of the specified INDArray as a 0D scalar variableSDVariableSDMath. rationalTanh(String name, SDVariable x)Rational Tanh Approximation elementwise function, as described in the paper:
Compact Convolutional Neural Network Cascade for Face Detection
This is a faster Tanh approximationSDVariableSDMath. rationalTanh(SDVariable x)Rational Tanh Approximation elementwise function, as described in the paper:
Compact Convolutional Neural Network Cascade for Face Detection
This is a faster Tanh approximationSDVariableSDMath. rdiv(String name, SDVariable x, double value)Scalar reverse division operation, out = scalar / inSDVariableSDMath. rdiv(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. rdiv(SDVariable x, double value)Scalar reverse division operation, out = scalar / inSDVariableSDMath. rdiv(SDVariable x, SDVariable y)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.htmlSDVariableSDMath. reciprocal(String name, SDVariable x)Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]SDVariableSDMath. reciprocal(SDVariable x)Element-wise reciprocal (inverse) function: out[i] = 1 / in[i]SDVariableSDMath. rectifiedTanh(String name, SDVariable x)Rectified tanh operation: max(0, tanh(in))SDVariableSDMath. rectifiedTanh(SDVariable x)Rectified tanh operation: max(0, tanh(in))SDVariableSDMath. reduceAMax(String name, SDVariable in, boolean keepDims, int... dimensions)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(String name, SDVariable in, int... dimensions)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(String name, SDVariable in, SDVariable dimensions)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(SDVariable in, boolean keepDims, int... dimensions)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(SDVariable in, int... dimensions)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(SDVariable in, SDVariable dimensions)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAMax(SDVariable in, SDVariable dimensions, boolean keepDims)Absolute max array reduction operation, optionally along specified dimensions: out = max(abs(x))SDVariableSDMath. reduceAmean(String name, SDVariable in, boolean keepDims, int... dimensions)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(String name, SDVariable in, int... dimensions)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(String name, SDVariable in, SDVariable dimensions)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(SDVariable in, boolean keepDims, int... dimensions)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(SDVariable in, int... dimensions)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(SDVariable in, SDVariable dimensions)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmean(SDVariable in, SDVariable dimensions, boolean keepDims)Absolute mean array reduction operation, optionally along specified dimensions: out = mean(abs(x))SDVariableSDMath. reduceAmin(String name, SDVariable in, boolean keepDims, int... dimensions)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(String name, SDVariable in, int... dimensions)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(String name, SDVariable in, SDVariable dimensions)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(SDVariable in, boolean keepDims, int... dimensions)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(SDVariable in, int... dimensions)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(SDVariable in, SDVariable dimensions)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceAmin(SDVariable in, SDVariable dimensions, boolean keepDims)Absolute min array reduction operation, optionally along specified dimensions: out = min(abs(x))SDVariableSDMath. reduceMax(String name, SDVariable in, boolean keepDims, int... dimensions)The max of an array along each dimensionSDVariableSDMath. reduceMax(String name, SDVariable in, int... dimensions)The max of an array along each dimensionSDVariableSDMath. reduceMax(String name, SDVariable in, SDVariable dimensions)The max of an array long each dimensionSDVariableSDMath. reduceMax(String name, SDVariable in, SDVariable dimensions, boolean keepDims)The max of an array long each dimensionSDVariableSDMath. reduceMax(SDVariable in, boolean keepDims, int... dimensions)The max of an array along each dimensionSDVariableSDMath. reduceMax(SDVariable in, int... dimensions)The max of an array along each dimensionSDVariableSDMath. reduceMax(SDVariable in, SDVariable dimensions)The max of an array long each dimensionSDVariableSDMath. reduceMax(SDVariable in, SDVariable dimensions, boolean keepDims)The max of an array long each dimensionSDVariableSDMath. reduceMin(String name, SDVariable in, boolean keepDims, int... dimensions)The minimum of an array along each dimensionSDVariableSDMath. reduceMin(String name, SDVariable in, int... dimensions)The minimum of an array along each dimensionSDVariableSDMath. reduceMin(String name, SDVariable in, SDVariable dimensions)The minimum of an array long each dimensionSDVariableSDMath. reduceMin(String name, SDVariable in, SDVariable dimensions, boolean keepDims)The minimum of an array long each dimensionSDVariableSDMath. reduceMin(SDVariable in, boolean keepDims, int... dimensions)The minimum of an array along each dimensionSDVariableSDMath. reduceMin(SDVariable in, int... dimensions)The minimum of an array along each dimensionSDVariableSDMath. reduceMin(SDVariable in, SDVariable dimensions)The minimum of an array long each dimensionSDVariableSDMath. reduceMin(SDVariable in, SDVariable dimensions, boolean keepDims)The minimum of an array long each dimensionSDVariableSDNN. relu(String name, SDVariable x, double cutoff)Element-wise rectified linear function with specified cutoff:
out[i] = in[i] if in[i] >= cutoff
out[i] = 0 otherwiseSDVariableSDNN. relu(SDVariable x, double cutoff)Element-wise rectified linear function with specified cutoff:
out[i] = in[i] if in[i] >= cutoff
out[i] = 0 otherwiseSDVariableSDNN. relu6(String name, SDVariable x, double cutoff)Element-wise "rectified linear 6" function with specified cutoff:
out[i] = min(max(in, cutoff), 6)SDVariableSDNN. relu6(SDVariable x, double cutoff)Element-wise "rectified linear 6" function with specified cutoff:
out[i] = min(max(in, cutoff), 6)SDVariableSDNN. reluLayer(String name, SDVariable input, SDVariable weights, SDVariable bias)ReLU (Rectified Linear Unit) layer operation: out = relu(mmul(in,w) + bias)
Note that bias array is optionalSDVariableSDNN. reluLayer(SDVariable input, SDVariable weights, SDVariable bias)ReLU (Rectified Linear Unit) layer operation: out = relu(mmul(in,w) + bias)
Note that bias array is optionalSDVariableSDBaseOps. repeat(String name, SDVariable input, SDVariable repeats, int axis)A tensor with the shape of input minus the specified axis with elements repeated along the specified axis.SDVariableSDBaseOps. repeat(SDVariable input, SDVariable repeats, int axis)A tensor with the shape of input minus the specified axis with elements repeated along the specified axis.SDVariableSDBaseOps. replaceWhere(String name, SDVariable update, double value, Condition condition)Element-wise replace where condition:
out[i] = value if condition(update[i]) is satisfied, or
out[i] = update[i] if condition(update[i]) is NOT satisfiedSDVariableSDBaseOps. replaceWhere(String name, SDVariable update, SDVariable from, Condition condition)Element-wise replace where condition:
out[i] = from[i] if condition(update[i]) is satisfied, or
out[i] = update[i] if condition(update[i]) is NOT satisfiedSDVariableSDBaseOps. replaceWhere(SDVariable update, double value, Condition condition)Element-wise replace where condition:
out[i] = value if condition(update[i]) is satisfied, or
out[i] = update[i] if condition(update[i]) is NOT satisfiedSDVariableSDBaseOps. replaceWhere(SDVariable update, SDVariable from, Condition condition)Element-wise replace where condition:
out[i] = from[i] if condition(update[i]) is satisfied, or
out[i] = update[i] if condition(update[i]) is NOT satisfiedSDVariableSDBaseOps. reshape(String name, SDVariable x, long... shape)Reshape the input variable to the specified (fixed) shape.SDVariableSDBaseOps. reshape(String name, SDVariable x, SDVariable shape)Reshape the input variable to the specified (fixed) shape.SDVariableSDBaseOps. reshape(SDVariable x, long... shape)Reshape the input variable to the specified (fixed) shape.SDVariableSDBaseOps. reshape(SDVariable x, SDVariable shape)Reshape the input variable to the specified (fixed) shape.SDVariableSDImage. resizeBiCubic(String name, SDVariable input, SDVariable size, boolean alignCorners, boolean alignPixelCenters)Resize images to size using the specified method.SDVariableSDImage. resizeBiCubic(SDVariable input, SDVariable size, boolean alignCorners, boolean alignPixelCenters)Resize images to size using the specified method.SDVariableSDImage. resizeBiLinear(String name, SDVariable input, int height, int width, boolean alignCorners, boolean halfPixelCenters)Resize images to size using the specified method.SDVariableSDImage. resizeBiLinear(SDVariable input, int height, int width, boolean alignCorners, boolean halfPixelCenters)Resize images to size using the specified method.SDVariableSDBaseOps. reverse(String name, SDVariable x, int... dimensions)Reverse the values of an array for the specified dimensions
If input is:
[ 1, 2, 3]
[ 4, 5, 6]
then
reverse(in, 0):
[3, 2, 1]
[6, 5, 4]
reverse(in, 1):
[4, 5, 6]
[1, 2 3]SDVariableSDBaseOps. reverse(SDVariable x, int... dimensions)Reverse the values of an array for the specified dimensions
If input is:
[ 1, 2, 3]
[ 4, 5, 6]
then
reverse(in, 0):
[3, 2, 1]
[6, 5, 4]
reverse(in, 1):
[4, 5, 6]
[1, 2 3]SDVariableSDBaseOps. reverseSequence(String name, SDVariable x, SDVariable seq_lengths)Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversedSDVariableSDBaseOps. reverseSequence(String name, SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim)Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversedSDVariableSDBaseOps. reverseSequence(SDVariable x, SDVariable seq_lengths)Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversedSDVariableSDBaseOps. reverseSequence(SDVariable x, SDVariable seq_lengths, int seqDim, int batchDim)Reverse sequence op: for each slice along dimension seqDimension, the first seqLength values are reversedSDVariableSDImage. rgbToHsv(String name, SDVariable input)Converting array from HSV to RGB formatSDVariableSDImage. rgbToHsv(SDVariable input)Converting array from HSV to RGB formatSDVariableSDImage. rgbToYiq(String name, SDVariable input)Converting array from RGB to YIQ formatSDVariableSDImage. rgbToYiq(SDVariable input)Converting array from RGB to YIQ formatSDVariableSDImage. rgbToYuv(String name, SDVariable input)Converting array from RGB to YUV formatSDVariableSDImage. rgbToYuv(SDVariable input)Converting array from RGB to YUV formatSDVariableSDBitwise. rightShift(String name, SDVariable x, SDVariable y)Bitwise right shift operation.SDVariableSDBitwise. rightShift(SDVariable x, SDVariable y)Bitwise right shift operation.SDVariableSDBitwise. rightShiftCyclic(String name, SDVariable x, SDVariable y)Bitwise right cyclical shift operation.SDVariableSDBitwise. rightShiftCyclic(SDVariable x, SDVariable y)Bitwise right cyclical shift operation.SDVariableSDMath. round(String name, SDVariable x)Element-wise round function: out = round(x).
Rounds (up or down depending on value) to the nearest integer value.SDVariableSDMath. round(SDVariable x)Element-wise round function: out = round(x).
Rounds (up or down depending on value) to the nearest integer value.SDVariableSDMath. rsqrt(String name, SDVariable x)Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)SDVariableSDMath. rsqrt(SDVariable x)Element-wise reciprocal (inverse) of square root: out = 1.0 / sqrt(x)SDVariableSDMath. rsub(String name, SDVariable x, double value)Scalar reverse subtraction operation, out = scalar - inSDVariableSDMath. rsub(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. rsub(SDVariable x, double value)Scalar reverse subtraction operation, out = scalar - inSDVariableSDMath. rsub(SDVariable x, SDVariable y)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.htmlSDVariableSDBaseOps. scalarFloorMod(String name, SDVariable in, double value)Element-wise scalar floor modulus operation: out = floorMod(in, value).
i.e., returns the remainder after division by 'value'SDVariableSDBaseOps. scalarFloorMod(SDVariable in, double value)Element-wise scalar floor modulus operation: out = floorMod(in, value).
i.e., returns the remainder after division by 'value'SDVariableSDBaseOps. scalarMax(String name, SDVariable in, double value)Element-wise scalar maximum operation: out = max(in, value)SDVariableSDBaseOps. scalarMax(SDVariable in, double value)Element-wise scalar maximum operation: out = max(in, value)SDVariableSDBaseOps. scalarMin(String name, SDVariable in, double value)Element-wise scalar minimum operation: out = min(in, value)SDVariableSDBaseOps. scalarMin(SDVariable in, double value)Element-wise scalar minimum operation: out = min(in, value)SDVariableSDBaseOps. scalarSet(String name, SDVariable in, double set)Return a variable with equal shape to the input, but all elements set to value 'set'SDVariableSDBaseOps. scalarSet(SDVariable in, double set)Return a variable with equal shape to the input, but all elements set to value 'set'SDVariableSDBaseOps. scatterAdd(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter addition operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterAdd(SDVariable ref, SDVariable indices, SDVariable updates)Scatter addition operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterDiv(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter division operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterDiv(SDVariable ref, SDVariable indices, SDVariable updates)Scatter division operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterMax(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter max operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterMax(SDVariable ref, SDVariable indices, SDVariable updates)Scatter max operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterMin(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter min operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterMin(SDVariable ref, SDVariable indices, SDVariable updates)Scatter min operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterMul(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter multiplication operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterMul(SDVariable ref, SDVariable indices, SDVariable updates)Scatter multiplication operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterSub(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter subtraction operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterSub(SDVariable ref, SDVariable indices, SDVariable updates)Scatter subtraction operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterUpdate(String name, SDVariable ref, SDVariable indices, SDVariable updates)Scatter update operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. scatterUpdate(SDVariable ref, SDVariable indices, SDVariable updates)Scatter update operation.
If indices is rank 0 (a scalar), then out[index, ...] = out[index, ...] + op(updates[...])
If indices is rank 1 (a vector), then for each position i, out[indices[i], ...] = out[indices[i], ...] + op(updates[i, ...])
If indices is rank 2+, then for each position (i,...,k), out[indices[i], ..., indices[k], ...] = out[indices[i], ..., indices[k], ...] + op(updates[i, ..., k, ...])
Note that if multiple indices refer to the same location, the contributions from each is handled correctly.SDVariableSDBaseOps. segmentMax(String name, SDVariable data, SDVariable segmentIds)Segment max operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentMax(SDVariable data, SDVariable segmentIds)Segment max operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentMean(String name, SDVariable data, SDVariable segmentIds)Segment mean operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentMean(SDVariable data, SDVariable segmentIds)Segment mean operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentMin(String name, SDVariable data, SDVariable segmentIds)Segment min operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentMin(SDVariable data, SDVariable segmentIds)Segment min operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentProd(String name, SDVariable data, SDVariable segmentIds)Segment product operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentProd(SDVariable data, SDVariable segmentIds)Segment product operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentSum(String name, SDVariable data, SDVariable segmentIds)Segment sum operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDBaseOps. segmentSum(SDVariable data, SDVariable segmentIds)Segment sum operation.
If data = [3, 6, 1, 4, 9, 2, 8]
segmentIds = [0, 0, 1, 1, 1, 2, 2]
then output = [6, 9, 8] = [op(3,6), op(1,4,9), op(2,8)]
Note that the segment IDs must be sorted from smallest to largest segment.
See {unsortedSegment (String, SDVariable, SDVariable, int) ops
for the same op without this sorted requirementSDVariableSDNN. selu(String name, SDVariable x)Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks
out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0
Uses default scale and alpha values.SDVariableSDNN. selu(SDVariable x)Element-wise SeLU function - Scaled exponential Lineal Unit: see Self-Normalizing Neural Networks
out[i] = scale * alpha * (exp(in[i])-1) if in[i]>0, or 0 if in[i] <= 0
Uses default scale and alpha values.SDVariableSDCNN. separableConv2d(String name, SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, SDVariable bias, Conv2DConfig Conv2DConfig)Separable 2D convolution operation with optional biasSDVariableSDCNN. separableConv2d(String name, SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, Conv2DConfig Conv2DConfig)Separable 2D convolution operation with optional biasSDVariableSDCNN. separableConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, SDVariable bias, Conv2DConfig Conv2DConfig)Separable 2D convolution operation with optional biasSDVariableSDCNN. separableConv2d(SDVariable layerInput, SDVariable depthWeights, SDVariable pointWeights, Conv2DConfig Conv2DConfig)Separable 2D convolution operation with optional biasSDVariableSDBaseOps. sequenceMask(String name, SDVariable lengths, int maxLen, DataType dataType)Generate a sequence mask (with values 0 or 1) based on the specified lengths
Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0)SDVariableSDBaseOps. sequenceMask(String name, SDVariable lengths, SDVariable maxLen, DataType dataType)Generate a sequence mask (with values 0 or 1) based on the specified lengths
Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0)SDVariableSDBaseOps. sequenceMask(String name, SDVariable lengths, DataType dataType)see sequenceMask(String, SDVariable, SDVariable, DataType)SDVariableSDBaseOps. sequenceMask(SDVariable lengths, int maxLen, DataType dataType)Generate a sequence mask (with values 0 or 1) based on the specified lengths
Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0)SDVariableSDBaseOps. sequenceMask(SDVariable lengths, SDVariable maxLen, DataType dataType)Generate a sequence mask (with values 0 or 1) based on the specified lengths
Specifically, out[i, ..., k, j] = (j < lengths[i, ..., k] ? 1.0 : 0.0)SDVariableSDBaseOps. sequenceMask(SDVariable lengths, DataType dataType)see sequenceMask(String, SDVariable, SDVariable, DataType)SDVariableSDMath. setDiag(String name, SDVariable in, SDVariable diag)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]SDVariableSDMath. setDiag(SDVariable in, SDVariable diag)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]SDVariable[]SDBaseOps. setShape(String[] names, SDVariable input, SDVariable shape)Sets an inplace shape on the passed in input.SDVariable[]SDBaseOps. setShape(SDVariable input, SDVariable shape)Sets an inplace shape on the passed in input.SDVariableSDMath. shannonEntropy(String name, SDVariable in, boolean keepDims, int... dimensions)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(String name, SDVariable in, int... dimensions)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(String name, SDVariable in, SDVariable dimensions)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(SDVariable in, boolean keepDims, int... dimensions)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(SDVariable in, int... dimensions)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(SDVariable in, SDVariable dimensions)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDMath. shannonEntropy(SDVariable in, SDVariable dimensions, boolean keepDims)Shannon Entropy reduction: -sum(x * log2(x))SDVariableSDBaseOps. shape(String name, SDVariable input)Returns the shape of the specified INDArray as a 1D INDArraySDVariableSDBaseOps. shape(SDVariable input)Returns the shape of the specified INDArray as a 1D INDArraySDVariableSDNN. sigmoid(String name, SDVariable x)Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))SDVariableSDNN. sigmoid(SDVariable x)Element-wise sigmoid function: out[i] = 1.0/(1+exp(-in[i]))SDVariableSDLoss. sigmoidCrossEntropy(String name, SDVariable label, SDVariable predictionLogits, SDVariable weights)Sigmoid cross entropy: applies the sigmoid activation function on the input logits (input "pre-sigmoid preductions")
and implements the binary cross entropy loss function.SDVariableSDLoss. sigmoidCrossEntropy(String name, SDVariable label, SDVariable predictionLogits, SDVariable weights, LossReduce lossReduce, double labelSmoothing)Sigmoid cross entropy: applies the sigmoid activation function on the input logits (input "pre-sigmoid preductions")
and implements the binary cross entropy loss function.SDVariableSDLoss. sigmoidCrossEntropy(SDVariable label, SDVariable predictionLogits, SDVariable weights)Sigmoid cross entropy: applies the sigmoid activation function on the input logits (input "pre-sigmoid preductions")
and implements the binary cross entropy loss function.SDVariableSDLoss. sigmoidCrossEntropy(SDVariable label, SDVariable predictionLogits, SDVariable weights, LossReduce lossReduce, double labelSmoothing)Sigmoid cross entropy: applies the sigmoid activation function on the input logits (input "pre-sigmoid preductions")
and implements the binary cross entropy loss function.SDVariableSDNN. sigmoidDerivative(String name, SDVariable x, SDVariable wrt)Element-wise sigmoid function derivative: dL/dIn given input and dL/dOutSDVariableSDNN. sigmoidDerivative(SDVariable x, SDVariable wrt)Element-wise sigmoid function derivative: dL/dIn given input and dL/dOutSDVariableSDMath. sign(String name, SDVariable x)Element-wise sign (signum) function:
out = -1 if in < 0
out = 0 if in = 0
out = 1 if in > 0SDVariableSDMath. sign(SDVariable x)Element-wise sign (signum) function:
out = -1 if in < 0
out = 0 if in = 0
out = 1 if in > 0SDVariableSDMath. sin(String name, SDVariable x)Elementwise sine operation: out = sin(x)SDVariableSDMath. sin(SDVariable x)Elementwise sine operation: out = sin(x)SDVariableSDMath. sinh(String name, SDVariable x)Elementwise sinh (hyperbolic sine) operation: out = sinh(x)SDVariableSDMath. sinh(SDVariable x)Elementwise sinh (hyperbolic sine) operation: out = sinh(x)SDVariableSDBaseOps. size(String name, SDVariable in)Returns the size (number of elements, i.e., prod(shape)) of the specified INDArray as a 0D scalar variableSDVariableSDBaseOps. size(SDVariable in)Returns the size (number of elements, i.e., prod(shape)) of the specified INDArray as a 0D scalar variableSDVariableSDBaseOps. sizeAt(String name, SDVariable in, int dimension)Returns a rank 0 (scalar) variable for the size of the specified dimension.
For example, if X has shape [10,20,30] then sizeAt(X,1)=20.SDVariableSDBaseOps. sizeAt(SDVariable in, int dimension)Returns a rank 0 (scalar) variable for the size of the specified dimension.
For example, if X has shape [10,20,30] then sizeAt(X,1)=20.SDVariableSDBaseOps. slice(String name, SDVariable input, int[] begin, int... size)Get a subset of the specified input, by specifying the first element and the size of the array.
For example, if input is:
[a, b, c]
[d, e, f]
then slice(input, begin=[0,1], size=[2,1] will return:
[b]
[e]
Note that for each dimension i, begin[i] + size[i] <= input.size(i)SDVariableSDBaseOps. slice(String name, SDVariable input, SDVariable begin, SDVariable size)Get a subset of the specified input, by specifying the first element and the size of the array.
For example, if input is:
[a, b, c]
[d, e, f]
then slice(input, begin=[0,1], size=[2,1] will return:
[b]
[e]
Note that for each dimension i, begin[i] + size[i] <= input.size(i)SDVariableSDBaseOps. slice(SDVariable input, int[] begin, int... size)Get a subset of the specified input, by specifying the first element and the size of the array.
For example, if input is:
[a, b, c]
[d, e, f]
then slice(input, begin=[0,1], size=[2,1] will return:
[b]
[e]
Note that for each dimension i, begin[i] + size[i] <= input.size(i)SDVariableSDBaseOps. slice(SDVariable input, SDVariable begin, SDVariable size)Get a subset of the specified input, by specifying the first element and the size of the array.
For example, if input is:
[a, b, c]
[d, e, f]
then slice(input, begin=[0,1], size=[2,1] will return:
[b]
[e]
Note that for each dimension i, begin[i] + size[i] <= input.size(i)SDVariableSDNN. softmax(String name, SDVariable x)Softmax activation, along the specified dimensionSDVariableSDNN. softmax(String name, SDVariable x, int dimension)Softmax activation, along the specified dimensionSDVariableSDNN. softmax(SDVariable x)Softmax activation, along the specified dimensionSDVariableSDNN. softmax(SDVariable x, int dimension)Softmax activation, along the specified dimensionSDVariableSDLoss. softmaxCrossEntropy(String name, SDVariable oneHotLabels, SDVariable logitPredictions, SDVariable weights)Applies the softmax activation function to the input, then implement multi-class cross entropy:
-sum_classes label[i] * log(p[c])wherep = softmax(logits)
If LossReduce#NONE is used, returned shape is [numExamples] out for [numExamples, numClasses] predicitons/labels;
otherwise, the output is a scalar.SDVariableSDLoss. softmaxCrossEntropy(String name, SDVariable oneHotLabels, SDVariable logitPredictions, SDVariable weights, LossReduce lossReduce, double labelSmoothing)Applies the softmax activation function to the input, then implement multi-class cross entropy:
-sum_classes label[i] * log(p[c])wherep = softmax(logits)
If LossReduce#NONE is used, returned shape is [numExamples] out for [numExamples, numClasses] predicitons/labels;
otherwise, the output is a scalar.SDVariableSDLoss. softmaxCrossEntropy(SDVariable oneHotLabels, SDVariable logitPredictions, SDVariable weights)Applies the softmax activation function to the input, then implement multi-class cross entropy:
-sum_classes label[i] * log(p[c])wherep = softmax(logits)
If LossReduce#NONE is used, returned shape is [numExamples] out for [numExamples, numClasses] predicitons/labels;
otherwise, the output is a scalar.SDVariableSDLoss. softmaxCrossEntropy(SDVariable oneHotLabels, SDVariable logitPredictions, SDVariable weights, LossReduce lossReduce, double labelSmoothing)Applies the softmax activation function to the input, then implement multi-class cross entropy:
-sum_classes label[i] * log(p[c])wherep = softmax(logits)
If LossReduce#NONE is used, returned shape is [numExamples] out for [numExamples, numClasses] predicitons/labels;
otherwise, the output is a scalar.SDVariableSDNN. softmaxDerivative(String name, SDVariable x, SDVariable wrt, int dimension)Softmax derivative functionSDVariableSDNN. softmaxDerivative(SDVariable x, SDVariable wrt, int dimension)Softmax derivative functionSDVariableSDNN. softplus(String name, SDVariable x)Element-wise softplus function: out = log(exp(x) + 1)SDVariableSDNN. softplus(SDVariable x)Element-wise softplus function: out = log(exp(x) + 1)SDVariableSDNN. softsign(String name, SDVariable x)Element-wise softsign function: out = x / (abs(x) + 1)SDVariableSDNN. softsign(SDVariable x)Element-wise softsign function: out = x / (abs(x) + 1)SDVariableSDNN. softsignDerivative(String name, SDVariable x)Element-wise derivative (dOut/dIn) of the softsign function softsign(INDArray)SDVariableSDNN. softsignDerivative(SDVariable x)Element-wise derivative (dOut/dIn) of the softsign function softsign(INDArray)SDVariableSDLinalg. solve(String name, SDVariable matrix, SDVariable rhs)Solver for systems of linear equations.SDVariableSDLinalg. solve(String name, SDVariable matrix, SDVariable rhs, boolean adjoint)Solver for systems of linear equations.SDVariableSDLinalg. solve(SDVariable matrix, SDVariable rhs)Solver for systems of linear equations.SDVariableSDLinalg. solve(SDVariable matrix, SDVariable rhs, boolean adjoint)Solver for systems of linear equations.SDVariableSDCNN. spaceToBatch(String name, SDVariable x, int[] blocks, int[] paddingTop, int... paddingBottom)Convolution 2d layer space to batch operation on 4d input.
Increases input batch dimension by rearranging data from spatial dimensions into batch dimensionSDVariableSDCNN. spaceToBatch(SDVariable x, int[] blocks, int[] paddingTop, int... paddingBottom)Convolution 2d layer space to batch operation on 4d input.
Increases input batch dimension by rearranging data from spatial dimensions into batch dimensionSDVariableSDCNN. spaceToDepth(String name, SDVariable x, int blockSize, DataFormat dataFormat)Convolution 2d layer space to depth operation on 4d input.
Increases input channels (reduced spatial dimensions) by rearranging data into a larger channels dimension
Example: if input has shape [mb, 2, 4, 4] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2]
= [mb, 2, 4, 4]SDVariableSDCNN. spaceToDepth(SDVariable x, int blockSize, DataFormat dataFormat)Convolution 2d layer space to depth operation on 4d input.
Increases input channels (reduced spatial dimensions) by rearranging data into a larger channels dimension
Example: if input has shape [mb, 2, 4, 4] and block size is 2, then output size is [mb, 8/(2*2), 2*2, 2*2]
= [mb, 2, 4, 4]SDVariableSDLoss. sparseSoftmaxCrossEntropy(String name, SDVariable logits, SDVariable labels)As per softmaxCrossEntropy(String, SDVariable, SDVariable, LossReduce) but the labels variable
is represented as an integer array instead of the equivalent one-hot array.
i.e., if logits are rank N, then labels have rank N-1SDVariableSDLoss. sparseSoftmaxCrossEntropy(SDVariable logits, SDVariable labels)As per softmaxCrossEntropy(String, SDVariable, SDVariable, LossReduce) but the labels variable
is represented as an integer array instead of the equivalent one-hot array.
i.e., if logits are rank N, then labels have rank N-1SDVariableSDBaseOps. sparseToDense(String name, SDVariable indices, SDVariable shape, SDVariable values)Create a dense matrix equivalent of a sparse matrix based on the given input.SDVariableSDBaseOps. sparseToDense(String name, SDVariable indices, SDVariable shape, SDVariable values, SDVariable defaultValue)Create a dense matrix equivalent of a sparse matrix based on the given input.SDVariableSDBaseOps. sparseToDense(SDVariable indices, SDVariable shape, SDVariable values)Create a dense matrix equivalent of a sparse matrix based on the given input.SDVariableSDBaseOps. sparseToDense(SDVariable indices, SDVariable shape, SDVariable values, SDVariable defaultValue)Create a dense matrix equivalent of a sparse matrix based on the given input.SDVariable[]SDBaseOps. split(String[] names, SDVariable input, int numSplit, int splitDim)Split a value in to a list of ndarrays.SDVariable[]SDBaseOps. split(String[] names, SDVariable input, SDVariable numSplit, int splitDim)Split a value in to a list of ndarrays.SDVariable[]SDBaseOps. split(SDVariable input, int numSplit, int splitDim)Split a value in to a list of ndarrays.SDVariable[]SDBaseOps. split(SDVariable input, SDVariable numSplit, int splitDim)Split a value in to a list of ndarrays.SDVariable[]SDBaseOps. splitV(String[] names, SDVariable input, SDVariable sizes, int numSplit, int splitDim)Split a value in to a list of ndarrays with varying sizes
according to the sizes parameter.SDVariable[]SDBaseOps. splitV(SDVariable input, SDVariable sizes, int numSplit, int splitDim)Split a value in to a list of ndarrays with varying sizes
according to the sizes parameter.SDVariableSDMath. sqrt(String name, SDVariable x)Element-wise square root function: out = sqrt(x)SDVariableSDMath. sqrt(SDVariable x)Element-wise square root function: out = sqrt(x)SDVariableSDMath. square(String name, SDVariable x)Element-wise square function: out = x^2SDVariableSDMath. square(SDVariable x)Element-wise square function: out = x^2SDVariableSDMath. squaredDifference(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. squaredDifference(SDVariable x, SDVariable y)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.htmlSDVariableSDBaseOps. squaredNorm(String name, SDVariable x, boolean keepDims, int... dimensions)Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. squaredNorm(String name, SDVariable x, int... dimensions)Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. squaredNorm(SDVariable x, boolean keepDims, int... dimensions)Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. squaredNorm(SDVariable x, int... dimensions)Squared L2 norm: see norm2(String, SDVariable, boolean, int...)
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDMath. squaredNorm(String name, SDVariable in, boolean keepDims, int... dimensions)Sum of squared differences.SDVariableSDMath. squaredNorm(String name, SDVariable in, int... dimensions)Sum of squared differences.SDVariableSDMath. squaredNorm(String name, SDVariable in, SDVariable dimensions)Sum of squared differences.SDVariableSDMath. squaredNorm(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Sum of squared differences.SDVariableSDMath. squaredNorm(SDVariable in, boolean keepDims, int... dimensions)Sum of squared differences.SDVariableSDMath. squaredNorm(SDVariable in, int... dimensions)Sum of squared differences.SDVariableSDMath. squaredNorm(SDVariable in, SDVariable dimensions)Sum of squared differences.SDVariableSDMath. squaredNorm(SDVariable in, SDVariable dimensions, boolean keepDims)Sum of squared differences.SDVariableSDBaseOps. squeeze(String name, SDVariable x, int axis)Remove a single dimension of size 1.
For example, if input has shape [a,b,1,c] then squeeze(input, 2) returns an array of shape [a,b,c]SDVariableSDBaseOps. squeeze(SDVariable x, int axis)Remove a single dimension of size 1.
For example, if input has shape [a,b,1,c] then squeeze(input, 2) returns an array of shape [a,b,c]SDVariableSDRNN. sru(String name, SDVariable x, SDVariable initialC, SDVariable mask, SRUWeights SRUWeights)The SRU layer.SDVariableSDRNN. sru(String name, SDVariable x, SDVariable initialC, SRUWeights SRUWeights)The SRU layer.SDVariableSDRNN. sru(SDVariable x, SDVariable initialC, SDVariable mask, SRUWeights SRUWeights)The SRU layer.SDVariableSDRNN. sru(SDVariable x, SDVariable initialC, SRUWeights SRUWeights)The SRU layer.SDVariableSDRNN. sruCell(String name, SDVariable x, SDVariable cLast, SRUWeights SRUWeights)The SRU layer.SDVariableSDRNN. sruCell(SDVariable x, SDVariable cLast, SRUWeights SRUWeights)The SRU layer.SDVariableSDBaseOps. stack(int axis, SDVariable... values)Stack a set of N INDArray of rank X into one rank X+1 variable.
If inputs have shape [a,b,c] then output has shape:
axis = 0: [N,a,b,c]
axis = 1: [a,N,b,c]
axis = 2: [a,b,N,c]
axis = 3: [a,b,c,N]
see unstack(String[], SDVariable, int, int)SDVariableSDBaseOps. stack(String name, int axis, SDVariable... values)Stack a set of N INDArray of rank X into one rank X+1 variable.
If inputs have shape [a,b,c] then output has shape:
axis = 0: [N,a,b,c]
axis = 1: [a,N,b,c]
axis = 2: [a,b,N,c]
axis = 3: [a,b,c,N]
see unstack(String[], SDVariable, int, int)SDVariableSDBaseOps. standardDeviation(String name, SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)Standard deviation array reduction operation, optionally along 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.SDVariableSDBaseOps. standardDeviation(String name, SDVariable x, boolean biasCorrected, int... dimensions)Standard deviation array reduction operation, optionally along 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.SDVariableSDBaseOps. standardDeviation(SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)Standard deviation array reduction operation, optionally along 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.SDVariableSDBaseOps. standardDeviation(SDVariable x, boolean biasCorrected, int... dimensions)Standard deviation array reduction operation, optionally along 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.SDVariableSDMath. standardize(String name, SDVariable x, int... dimensions)Standardize input variable along given axisSDVariableSDMath. standardize(SDVariable x, int... dimensions)Standardize input variable along given axisSDVariableSDMath. step(String name, SDVariable x, double value)Elementwise step function:
out(x) = 1 if x >= cutoff
out(x) = 0 otherwiseSDVariableSDMath. step(SDVariable x, double value)Elementwise step function:
out(x) = 1 if x >= cutoff
out(x) = 0 otherwiseSDVariableSDBaseOps. stridedSlice(String name, SDVariable in, long[] begin, long[] end, long... strides)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(String name, SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(String name, SDVariable in, SDVariable begin, SDVariable end, SDVariable strides)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(String name, SDVariable in, SDVariable begin, SDVariable end, SDVariable strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(SDVariable in, long[] begin, long[] end, long... strides)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(SDVariable in, long[] begin, long[] end, long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(SDVariable in, SDVariable begin, SDVariable end, SDVariable strides)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDBaseOps. stridedSlice(SDVariable in, SDVariable begin, SDVariable end, SDVariable strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)Get a subset of the specified input, by specifying the first element, last element, and the strides.
For example, if input is:
[a, b, c]
[d, e, f]
[g, h, i]
then stridedSlice(input, begin=[0,1], end=[2,2], strides=[2,1], all masks = 0) will return:
[b, c]
[h, i]SDVariableSDMath. sub(String name, SDVariable x, double value)Scalar subtraction operation, out = in - scalarSDVariableSDMath. sub(String name, SDVariable x, SDVariable y)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.htmlSDVariableSDMath. sub(SDVariable x, double value)Scalar subtraction operation, out = in - scalarSDVariableSDMath. sub(SDVariable x, SDVariable y)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.htmlSDVariableSDBaseOps. sum(String name, SDVariable x, boolean keepDims, int... dimensions)Sum array reduction operation, optionally along 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.SDVariableSDBaseOps. sum(String name, SDVariable x, int... dimensions)Sum array reduction operation, optionally along 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.SDVariableSDBaseOps. sum(SDVariable x, boolean keepDims, int... dimensions)Sum array reduction operation, optionally along 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.SDVariableSDBaseOps. sum(SDVariable x, int... dimensions)Sum array reduction operation, optionally along 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.SDVariableSDMath. sum(String name, SDVariable in, boolean keepDims, int... dimensions)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(String name, SDVariable in, int... dimensions)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(String name, SDVariable in, SDVariable dimensions)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(String name, SDVariable in, SDVariable dimensions, boolean keepDims)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(SDVariable in, boolean keepDims, int... dimensions)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(SDVariable in, int... dimensions)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(SDVariable in, SDVariable dimensions)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDMath. sum(SDVariable in, SDVariable dimensions, boolean keepDims)Sum of an array, optionally along specified dimensions: out = sum(x))SDVariableSDLinalg. svd(String name, SDVariable input, boolean fullUV, boolean computeUV)Calculates singular value decomposition.SDVariableSDLinalg. svd(String name, SDVariable input, boolean fullUV, boolean computeUV, int switchNum)Calculates singular value decomposition.SDVariableSDLinalg. svd(SDVariable input, boolean fullUV, boolean computeUV)Calculates singular value decomposition.SDVariableSDLinalg. svd(SDVariable input, boolean fullUV, boolean computeUV, int switchNum)Calculates singular value decomposition.SDVariableSDNN. swish(String name, SDVariable x)Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0
See: https://arxiv.org/abs/1710.05941SDVariableSDNN. swish(SDVariable x)Element-wise "swish" function: out = x * sigmoid(b*x) with b=1.0
See: https://arxiv.org/abs/1710.05941SDVariable[]SDBaseOps. switchOp(String[] names, SDVariable x, SDVariable predicate)Switch operation
Predicate - if false, values are output to left (first) branch/output; if true, to right (second) branch/outputSDVariable[]SDBaseOps. switchOp(SDVariable x, SDVariable predicate)Switch operation
Predicate - if false, values are output to left (first) branch/output; if true, to right (second) branch/outputSDVariableSDMath. tan(String name, SDVariable x)Elementwise tangent operation: out = tan(x)SDVariableSDMath. tan(SDVariable x)Elementwise tangent operation: out = tan(x)SDVariableSDMath. tanh(String name, SDVariable x)Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)SDVariableSDMath. tanh(SDVariable x)Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)SDVariableSDNN. tanh(String name, SDVariable x)Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)SDVariableSDNN. tanh(SDVariable x)Elementwise tanh (hyperbolic tangent) operation: out = tanh(x)SDVariableSDBaseOps. tensorMmul(String name, SDVariable x, SDVariable y, int[] dimensionsX, int... dimensionsY)//TODO: Ops must be documented.SDVariableSDBaseOps. tensorMmul(String name, SDVariable x, SDVariable y, int[] dimensionsX, int[] dimensionsY, boolean transposeX, boolean transposeY, boolean transposeZ)//TODO: Ops must be documented.SDVariableSDBaseOps. tensorMmul(SDVariable x, SDVariable y, int[] dimensionsX, int... dimensionsY)//TODO: Ops must be documented.SDVariableSDBaseOps. tensorMmul(SDVariable x, SDVariable y, int[] dimensionsX, int[] dimensionsY, boolean transposeX, boolean transposeY, boolean transposeZ)//TODO: Ops must be documented.SDVariableSDBaseOps. tile(String name, SDVariable x, int... repeat)see tile(String, SDVariable, int...)SDVariableSDBaseOps. tile(String name, SDVariable x, SDVariable repeat)Repeat (tile) the input tensor the specified number of times.
For example, if input is
[1, 2]
[3, 4]
and repeat is [2, 3]
then output is
[1, 2, 1, 2, 1, 2]
[3, 4, 3, 4, 3, 4]
[1, 2, 1, 2, 1, 2]
[3, 4, 3, 4, 3, 4]SDVariableSDBaseOps. tile(SDVariable x, int... repeat)see tile(String, SDVariable, int...)SDVariableSDBaseOps. tile(SDVariable x, SDVariable repeat)Repeat (tile) the input tensor the specified number of times.
For example, if input is
[1, 2]
[3, 4]
and repeat is [2, 3]
then output is
[1, 2, 1, 2, 1, 2]
[3, 4, 3, 4, 3, 4]
[1, 2, 1, 2, 1, 2]
[3, 4, 3, 4, 3, 4]SDVariable[]SDNN. topK(String[] names, SDVariable input, double k, boolean sorted)Find values and indices for the largest k entries along the last dimension.SDVariable[]SDNN. topK(SDVariable input, double k, boolean sorted)Find values and indices for the largest k entries along the last dimension.SDVariableSDMath. trace(String name, SDVariable in)Matrix trace operation
For rank 2 matrices, the output is a scalar with the trace - i.e., sum of the main diagonal.
For higher rank inputs, output[a,b,c] = trace(in[a,b,c,:,:])SDVariableSDMath. trace(SDVariable in)Matrix trace operation
For rank 2 matrices, the output is a scalar with the trace - i.e., sum of the main diagonal.
For higher rank inputs, output[a,b,c] = trace(in[a,b,c,:,:])SDVariableSDBaseOps. transpose(String name, SDVariable x)Matrix transpose operation: If input has shape [a,b] output has shape [b,a]SDVariableSDBaseOps. transpose(SDVariable x)Matrix transpose operation: If input has shape [a,b] output has shape [b,a]SDVariableSDLinalg. triangularSolve(String name, SDVariable matrix, SDVariable rhs, boolean lower, boolean adjoint)Solver for systems of linear questions.SDVariableSDLinalg. triangularSolve(SDVariable matrix, SDVariable rhs, boolean lower, boolean adjoint)Solver for systems of linear questions.SDVariableSDLinalg. triu(String name, SDVariable input)Upper triangle of an array.SDVariableSDLinalg. triu(String name, SDVariable input, int diag)Upper triangle of an array.SDVariableSDLinalg. triu(SDVariable input)Upper triangle of an array.SDVariableSDLinalg. triu(SDVariable input, int diag)Upper triangle of an array.SDVariableSDBaseOps. unsortedSegmentMax(String name, SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment max operation.SDVariableSDBaseOps. unsortedSegmentMax(String name, SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment max operation.SDVariableSDBaseOps. unsortedSegmentMax(SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment max operation.SDVariableSDBaseOps. unsortedSegmentMax(SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment max operation.SDVariableSDBaseOps. unsortedSegmentMean(String name, SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment mean operation.SDVariableSDBaseOps. unsortedSegmentMean(String name, SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment mean operation.SDVariableSDBaseOps. unsortedSegmentMean(SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment mean operation.SDVariableSDBaseOps. unsortedSegmentMean(SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment mean operation.SDVariableSDBaseOps. unsortedSegmentMin(String name, SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment min operation.SDVariableSDBaseOps. unsortedSegmentMin(String name, SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment min operation.SDVariableSDBaseOps. unsortedSegmentMin(SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment min operation.SDVariableSDBaseOps. unsortedSegmentMin(SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment min operation.SDVariableSDBaseOps. unsortedSegmentProd(String name, SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment product operation.SDVariableSDBaseOps. unsortedSegmentProd(String name, SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment product operation.SDVariableSDBaseOps. unsortedSegmentProd(SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment product operation.SDVariableSDBaseOps. unsortedSegmentProd(SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment product operation.SDVariableSDBaseOps. unsortedSegmentSqrtN(String name, SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment sqrtN operation.SDVariableSDBaseOps. unsortedSegmentSqrtN(String name, SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment sqrtN operation.SDVariableSDBaseOps. unsortedSegmentSqrtN(SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment sqrtN operation.SDVariableSDBaseOps. unsortedSegmentSqrtN(SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment sqrtN operation.SDVariableSDBaseOps. unsortedSegmentSum(String name, SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment sum operation.SDVariableSDBaseOps. unsortedSegmentSum(String name, SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment sum operation.SDVariableSDBaseOps. unsortedSegmentSum(SDVariable data, SDVariable segmentIds, int numSegments)Unsorted segment sum operation.SDVariableSDBaseOps. unsortedSegmentSum(SDVariable data, SDVariable segmentIds, SDVariable numSegments)Unsorted segment sum operation.SDVariable[]SDBaseOps. unstack(String[] names, SDVariable value, int axis, int num)Unstack a variable of rank X into N rank X-1 variables by taking slices along the specified axis.
If input has shape [a,b,c] then output has shape:
axis = 0: [b,c]
axis = 1: [a,c]
axis = 2: [a,b]SDVariable[]SDBaseOps. unstack(SDVariable value, int axis, int num)Unstack a variable of rank X into N rank X-1 variables by taking slices along the specified axis.
If input has shape [a,b,c] then output has shape:
axis = 0: [b,c]
axis = 1: [a,c]
axis = 2: [a,b]SDVariableSDCNN. upsampling2d(String name, SDVariable input, int scale)Upsampling layer for 2D inputs.
scale is used for both height and width dimensions.SDVariableSDCNN. upsampling2d(String name, SDVariable input, int scaleH, int scaleW, boolean nchw)2D Convolution layer operation - Upsampling 2dSDVariableSDCNN. upsampling2d(SDVariable input, int scale)Upsampling layer for 2D inputs.
scale is used for both height and width dimensions.SDVariableSDCNN. upsampling2d(SDVariable input, int scaleH, int scaleW, boolean nchw)2D Convolution layer operation - Upsampling 2dSDVariableSDCNN. upsampling3d(String name, SDVariable input, boolean ncdhw, int scaleD, int scaleH, int scaleW)3D Convolution layer operation - Upsampling 3dSDVariableSDCNN. upsampling3d(SDVariable input, boolean ncdhw, int scaleD, int scaleH, int scaleW)3D Convolution layer operation - Upsampling 3dprotected static voidSDValidation. validateBool(String opName, String inputName, SDVariable v)Validate that the operation is being applied on a boolean type SDVariableprotected static voidSDValidation. validateBool(String opName, SDVariable v)Validate that the operation is being applied on a boolean type SDVariableprotected static voidSDValidation. validateBool(String opName, SDVariable v1, SDVariable v2)Validate that the operation is being applied on boolean SDVariablesprotected static voidSDValidation. validateFloatingPoint(String opName, String inputName, SDVariable v)Validate that the operation is being applied on a floating point type SDVariableprotected static voidSDValidation. validateFloatingPoint(String opName, SDVariable v)Validate that the operation is being applied on an floating point type SDVariableprotected static voidSDValidation. validateInteger(String opName, String inputName, SDVariable v)Validate that the operation is being applied on an integer type SDVariableprotected static voidSDValidation. validateInteger(String opName, String inputName, SDVariable[] vars)protected static voidSDValidation. validateInteger(String opName, SDVariable v)Validate that the operation is being applied on an integer type SDVariableprotected static voidSDValidation. validateNumerical(String opName, String inputName, SDVariable v)Validate that the operation is being applied on a numerical SDVariable (not boolean or utf8).protected static voidSDValidation. validateNumerical(String opName, String inputName, SDVariable[] vars)protected static voidSDValidation. validateNumerical(String opName, SDVariable v)Validate that the operation is being applied on a numerical SDVariable (not boolean or utf8).protected static voidSDValidation. validateNumerical(String opName, SDVariable v1, SDVariable v2)Validate that the operation is being applied on numerical SDVariables (not boolean or utf8).protected static voidSDValidation. validateSameType(String opName, boolean numericalOnly, SDVariable... vars)Validate that the operation is being applied on array with the exact same datatypes (which may optionally be restricted to numerical SDVariables only (not boolean or utf8))SDVariableSDBaseOps. variance(String name, SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)Variance array reduction operation, optionally along 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.SDVariableSDBaseOps. variance(String name, SDVariable x, boolean biasCorrected, int... dimensions)Variance array reduction operation, optionally along 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.SDVariableSDBaseOps. variance(SDVariable x, boolean biasCorrected, boolean keepDims, int... dimensions)Variance array reduction operation, optionally along 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.SDVariableSDBaseOps. variance(SDVariable x, boolean biasCorrected, int... dimensions)Variance array reduction operation, optionally along 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.SDVariableSDBaseOps. where(String name, SDVariable condition)Returns elements that are true from the given condition array
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. where(String name, SDVariable x, SDVariable condition)Similar to numpy where, takes elements from x or y depending on whether the condition at a given element is true or false
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. where(String name, SDVariable x, SDVariable y, SDVariable condition)Similar to numpy where, takes elements from x or y depending on whether the condition at a given element is true or false
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. where(SDVariable condition)Returns elements that are true from the given condition array
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. where(SDVariable x, SDVariable condition)Similar to numpy where, takes elements from x or y depending on whether the condition at a given element is true or false
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. where(SDVariable x, SDVariable y, SDVariable condition)Similar to numpy where, takes elements from x or y depending on whether the condition at a given element is true or false
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. whereNumpy(String name, SDVariable x, SDVariable y, SDVariable condition)As implemented in numpy, Return elements chosen from x or y depending on condition.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBaseOps. whereNumpy(SDVariable x, SDVariable y, SDVariable condition)As implemented in numpy, Return elements chosen from x or y depending on condition.
Note that if keepDims = true, the output variable has the same rank as the input variable,
with the reduced dimensions having size 1.SDVariableSDBitwise. xor(String name, SDVariable x, SDVariable y)Bitwise XOR operation (exclusive OR).SDVariableSDBitwise. xor(SDVariable x, SDVariable y)Bitwise XOR operation (exclusive OR).SDVariableSDMath. xor(String name, SDVariable x, SDVariable y)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.SDVariableSDMath. xor(SDVariable x, SDVariable y)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.SDVariableSDImage. yiqToRgb(String name, SDVariable input)Converting image from YIQ to RGB formatSDVariableSDImage. yiqToRgb(SDVariable input)Converting image from YIQ to RGB formatSDVariableSDImage. yuvToRgb(String name, SDVariable input)Converting image from YUV to RGB formatSDVariableSDImage. yuvToRgb(SDVariable input)Converting image from YUV to RGB formatSDVariableSDMath. zeroFraction(String name, SDVariable input)Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))SDVariableSDMath. zeroFraction(SDVariable input)Full array zero fraction array reduction operation, optionally along specified dimensions: out = (count(x == 0) / length(x))SDVariableSDBaseOps. zerosLike(String name, SDVariable input)Return a variable of all 0s, with the same shape as the input variable.SDVariableSDBaseOps. zerosLike(SDVariable input)Return a variable of all 0s, with the same shape as the input variable. -
Uses of SDVariable in org.nd4j.autodiff.samediff.serde
Method parameters in org.nd4j.autodiff.samediff.serde with type arguments of type SDVariable Modifier and Type Method Description static intFlatBuffersMapper. asFlatNode(@NonNull SameDiff sameDiff, @NonNull DifferentialFunction node, @NonNull com.google.flatbuffers.FlatBufferBuilder bufferBuilder, List<SDVariable> variables, Map<String,Integer> reverseMap, Map<String,Integer> forwardMap, Map<String,Integer> framesMap, AtomicInteger idCounter, Integer id) -
Uses of SDVariable in org.nd4j.autodiff.samediff.transform
Methods in org.nd4j.autodiff.samediff.transform that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>SubGraph. inputs()List<SDVariable>SubGraph. outputs()List<SDVariable>SubGraphProcessor. processSubgraph(SameDiff sd, SubGraph subGraph)Replace the subgraph, and return the new outputs that should replace the old outputs.
Note that the order of the outputs you return matters!
If the original outputs are [A,B,C] and you return output variables [X,Y,Z], then anywhere "A" was used as input will now use "X"; similarly Y replaces B, and Z replaces C. -
Uses of SDVariable in org.nd4j.autodiff.util
Methods in org.nd4j.autodiff.util that return SDVariable Modifier and Type Method Description static SDVariableSameDiffUtils. reductionBroadcastableWithOrigShape(int origRank, int[] reduceDims, SDVariable toExpand)Add 1s as required to the array make an array possible to be broadcast with the original (pre-reduce) array.static SDVariableSameDiffUtils. reductionBroadcastableWithOrigShape(SDVariable origInput, SDVariable axis, SDVariable toExpand)static SDVariableSameDiffUtils. reductionShape(SDVariable shape, SDVariable axis, boolean keepDim)Methods in org.nd4j.autodiff.util with parameters of type SDVariable Modifier and Type Method Description static ExternalErrorsFunctionSameDiffUtils. externalErrors(SameDiff sameDiff, Map<String,INDArray> externalGradients, SDVariable... inputs)static ExternalErrorsFunctionSameDiffUtils. externalErrors(SameDiff sameDiff, SDVariable[] inputs)static SDVariableSameDiffUtils. reductionBroadcastableWithOrigShape(int origRank, int[] reduceDims, SDVariable toExpand)Add 1s as required to the array make an array possible to be broadcast with the original (pre-reduce) array.static SDVariableSameDiffUtils. reductionBroadcastableWithOrigShape(SDVariable origInput, SDVariable axis, SDVariable toExpand)static SDVariableSameDiffUtils. reductionShape(SDVariable shape, SDVariable axis, boolean keepDim)static voidSameDiffUtils. validateDifferentialFunctionSameDiff(SameDiff sameDiff, SDVariable function, DifferentialFunction op) -
Uses of SDVariable in org.nd4j.autodiff.validation
Methods in org.nd4j.autodiff.validation with parameters of type SDVariable Modifier and Type Method Description TestCaseTestCase. expected(@NonNull SDVariable var, @NonNull INDArray output)Validate the output (forward pass) for a single variable using INDArray.equals(INDArray)TestCaseTestCase. expected(SDVariable var, Function<INDArray,String> validationFn) -
Uses of SDVariable in org.nd4j.imports.graphmapper
Methods in org.nd4j.imports.graphmapper that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>OpImportOverride. initFromTensorFlow(List<SDVariable> inputs, List<SDVariable> controlDepInputs, NODE_TYPE nodeDef, SameDiff initWith, Map<String,ATTR_TYPE> attributesForNode, GRAPH_TYPE graph)Initialize the operation and return its output variablesMethod parameters in org.nd4j.imports.graphmapper with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>OpImportOverride. initFromTensorFlow(List<SDVariable> inputs, List<SDVariable> controlDepInputs, NODE_TYPE nodeDef, SameDiff initWith, Map<String,ATTR_TYPE> attributesForNode, GRAPH_TYPE graph)Initialize the operation and return its output variables -
Uses of SDVariable in org.nd4j.linalg.activations
Methods in org.nd4j.linalg.activations that return SDVariable Modifier and Type Method Description SDVariableActivation. asSameDiff(String variableName, SameDiff sd, SDVariable input)Get the Activation as a SameDiff variableSDVariableActivation. asSameDiff(SameDiff sd, SDVariable input)Get the Activation as a SameDiff variableMethods in org.nd4j.linalg.activations with parameters of type SDVariable Modifier and Type Method Description SDVariableActivation. asSameDiff(String variableName, SameDiff sd, SDVariable input)Get the Activation as a SameDiff variableSDVariableActivation. asSameDiff(SameDiff sd, SDVariable input)Get the Activation as a SameDiff variable -
Uses of SDVariable in org.nd4j.linalg.api.ops
Fields in org.nd4j.linalg.api.ops declared as SDVariable Modifier and Type Field Description protected SDVariableBaseReduceOp. dimensionVariableprotected SDVariable[]DynamicCustomOp. outputVariablesMethods in org.nd4j.linalg.api.ops that return SDVariable Modifier and Type Method Description SDVariable[]BaseOp. outputVariables(String baseName)SDVariable[]DynamicCustomOp. outputVariables()SDVariable[]DynamicCustomOp. outputVariables(String baseName)protected static SDVariable[]DynamicCustomOp. wrapOrNull(SDVariable in)Methods in org.nd4j.linalg.api.ops that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>DynamicCustomOp. doDiff(List<SDVariable> f1)List<SDVariable>NoOp. doDiff(List<SDVariable> f1)Methods in org.nd4j.linalg.api.ops with parameters of type SDVariable Modifier and Type Method Description voidBaseOp. computeVariables(SDVariable[] newVars)Compute the output vars using this op and store them in the samediff instance.protected static SDVariable[]DynamicCustomOp. wrapOrNull(SDVariable in)Method parameters in org.nd4j.linalg.api.ops with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>DynamicCustomOp. doDiff(List<SDVariable> f1)List<SDVariable>NoOp. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops with parameters of type SDVariable Constructor Description BaseBroadcastBoolOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BaseBroadcastBoolOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BaseBroadcastBoolOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BaseBroadcastBoolOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BaseBroadcastBoolOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BaseBroadcastBoolOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BaseBroadcastOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BaseIndexAccumulation(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)BaseIndexAccumulation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, boolean keepDims, int[] dimensions)BaseReduceBoolOp(SameDiff sameDiff, SDVariable i_v)BaseReduceBoolOp(SameDiff sameDiff, SDVariable i_v, boolean keepDims)BaseReduceBoolOp(SameDiff sameDiff, SDVariable input, int... dimensions)BaseReduceBoolOp(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)BaseReduceBoolOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)BaseReduceBoolOp(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)BaseReduceBoolOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)BaseReduceBoolOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)BaseReduceBoolOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)BaseReduceFloatOp(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)BaseReduceFloatOp(SameDiff sameDiff, SDVariable i_v, boolean keepDims, SDVariable dimensions)BaseReduceFloatOp(SameDiff sameDiff, SDVariable input, int... dimensions)BaseReduceFloatOp(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)BaseReduceFloatOp(SameDiff sameDiff, SDVariable input, SDVariable dimensions)BaseReduceFloatOp(SameDiff sameDiff, SDVariable input, SDVariable dimensions, boolean keepDims)BaseReduceFloatOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)BaseReduceFloatOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)BaseReduceLongOp(SameDiff sameDiff, SDVariable i_v)BaseReduceLongOp(SameDiff sameDiff, SDVariable i_v, boolean keepDims)BaseReduceLongOp(SameDiff sameDiff, SDVariable input, int... dimensions)BaseReduceLongOp(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)BaseReduceLongOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)BaseReduceLongOp(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)BaseReduceLongOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)BaseReduceLongOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)BaseReduceLongOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)BaseReduceOp(SameDiff sameDiff, SDVariable i_v)BaseReduceOp(SameDiff sameDiff, SDVariable i_v, boolean keepDims)BaseReduceOp(SameDiff sameDiff, SDVariable i_v, int[] dimensions)BaseReduceOp(SameDiff sameDiff, SDVariable i_v, int[] dimensions, boolean keepDims)BaseReduceOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)BaseReduceOp(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)BaseReduceOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)BaseReduceOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)BaseReduceOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)BaseReduceSameOp(SameDiff sameDiff, SDVariable i_v)BaseReduceSameOp(SameDiff sameDiff, SDVariable i_v, boolean keepDims)BaseReduceSameOp(SameDiff sameDiff, SDVariable input, int... dimensions)BaseReduceSameOp(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)BaseReduceSameOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)BaseReduceSameOp(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)BaseReduceSameOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)BaseReduceSameOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)BaseReduceSameOp(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)BaseScalarBoolOp(SameDiff sameDiff, SDVariable i_v, Number scalar)BaseScalarBoolOp(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)BaseScalarBoolOp(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)BaseScalarBoolOp(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)BaseScalarOp(SameDiff sameDiff, @NonNull SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)BaseScalarOp(SameDiff sameDiff, SDVariable i_v, Number scalar)BaseScalarOp(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)BaseScalarOp(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)BaseTransformAnyOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)BaseTransformAnyOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)BaseTransformAnyOp(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)BaseTransformAnyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)BaseTransformAnyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)BaseTransformAnyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)BaseTransformBoolOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)BaseTransformBoolOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)BaseTransformBoolOp(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)BaseTransformBoolOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)BaseTransformBoolOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)BaseTransformBoolOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)BaseTransformFloatOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)BaseTransformFloatOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)BaseTransformFloatOp(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)BaseTransformOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)BaseTransformOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)BaseTransformOp(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)BaseTransformOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)BaseTransformOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)BaseTransformOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)BaseTransformSameOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)BaseTransformSameOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)BaseTransformSameOp(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)BaseTransformSameOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)BaseTransformSameOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)BaseTransformSameOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs)BaseTransformStrictOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)BaseTransformStrictOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, Object[] extraArgs)BaseTransformStrictOp(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs)BaseTransformStrictOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)BaseTransformStrictOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)DynamicCustomOp(String opName, SameDiff sameDiff, SDVariable[] args)DynamicCustomOp(String opName, SameDiff sameDiff, SDVariable[] args, boolean inPlace)Initialize this forSameDiffexecution Any extra int or float arguments for operations must be added to the respective TArguments or IArguments lists upon constructionDynamicCustomOp(SameDiff sameDiff, SDVariable arg)DynamicCustomOp(SameDiff sameDiff, SDVariable[] args)DynamicCustomOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)NoOp(SameDiff sd, SDVariable in) -
Uses of SDVariable in org.nd4j.linalg.api.ops.compat
Constructors in org.nd4j.linalg.api.ops.compat with parameters of type SDVariable Constructor Description CompatSparseToDense(SameDiff sd, SDVariable indices, SDVariable shape, SDVariable values)CompatSparseToDense(SameDiff sd, SDVariable indices, SDVariable shape, SDVariable values, SDVariable defaultValue) -
Uses of SDVariable in org.nd4j.linalg.api.ops.custom
Methods in org.nd4j.linalg.api.ops.custom that return SDVariable Modifier and Type Method Description SDVariable[]Invoke. outputVariables()Methods in org.nd4j.linalg.api.ops.custom that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>DivideNoNan. doDiff(List<SDVariable> f1)List<SDVariable>Eig. doDiff(List<SDVariable> f1)List<SDVariable>Flatten. doDiff(List<SDVariable> i_v)List<SDVariable>FusedBatchNorm. doDiff(List<SDVariable> f1)List<SDVariable>Triu. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.custom with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>DivideNoNan. doDiff(List<SDVariable> f1)List<SDVariable>Eig. doDiff(List<SDVariable> f1)List<SDVariable>Flatten. doDiff(List<SDVariable> i_v)List<SDVariable>FusedBatchNorm. doDiff(List<SDVariable> f1)List<SDVariable>Triu. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.custom with parameters of type SDVariable Constructor Description AdjustContrast(@NonNull SameDiff sameDiff, @NonNull SDVariable in, double factor)AdjustContrast(@NonNull SameDiff sameDiff, @NonNull SDVariable in, @NonNull SDVariable factor)AdjustHue(@NonNull SameDiff sameDiff, @NonNull SDVariable in, double factor)AdjustHue(@NonNull SameDiff sameDiff, @NonNull SDVariable in, @NonNull SDVariable factor)AdjustSaturation(@NonNull SameDiff sameDiff, @NonNull SDVariable in, double factor)AdjustSaturation(@NonNull SameDiff sameDiff, @NonNull SDVariable in, @NonNull SDVariable factor)BetaInc(@NonNull SameDiff sameDiff, @NonNull SDVariable a, @NonNull SDVariable b, @NonNull SDVariable x)BitCast(SameDiff sameDiff, SDVariable in, SDVariable dataType)CompareAndBitpack(SameDiff sameDiff, SDVariable threshold)Digamma(@NonNull SameDiff sameDiff, @NonNull SDVariable x)DivideNoNan(SameDiff sameDiff, SDVariable in1, SDVariable in2)DrawBoundingBoxes(SameDiff sameDiff, SDVariable boxes, SDVariable colors)Eig(SameDiff sameDiff, SDVariable arg)Eig(SameDiff sameDiff, SDVariable[] args)FakeQuantWithMinMaxVarsPerChannel(SameDiff sameDiff, SDVariable x, SDVariable min, SDVariable max, int num_bits, boolean narrow)Flatten(SameDiff sameDiff, char order, SDVariable... inputs)Flatten(SameDiff sd, SDVariable[] inputs, String order)Flatten(SameDiff sd, SDVariable input, String order)FusedBatchNorm(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable scale, @NonNull SDVariable offset, int dataFormat, int isTraining)FusedBatchNorm(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable scale, @NonNull SDVariable offset, @NonNull SDVariable dataFormat, @NonNull SDVariable isTraining)HsvToRgb(SameDiff sameDiff, SDVariable input)Igamma(@NonNull SameDiff sameDiff, @NonNull SDVariable n, @NonNull SDVariable x)Igammac(@NonNull SameDiff sameDiff, @NonNull SDVariable n, @NonNull SDVariable x)Lgamma(@NonNull SameDiff sameDiff, @NonNull SDVariable x)LinearSolve(SameDiff sameDiff, SDVariable a, SDVariable b, boolean adjoint)LinearSolve(SameDiff sameDiff, SDVariable a, SDVariable b, SDVariable adjoint)Logdet(SameDiff sameDiff, SDVariable input)Lstsq(@NonNull SameDiff sameDiff, @NonNull SDVariable matrix, @NonNull SDVariable rhs, double l2_regularizer, boolean fast)Lu(SameDiff sameDiff, SDVariable input)MatrixBandPart(@NonNull SameDiff sameDiff, @NonNull SDVariable input, int minLower, int maxUpper)MatrixBandPart(@NonNull SameDiff sameDiff, @NonNull SDVariable input, SDVariable minLower, SDVariable maxUpper)Polygamma(@NonNull SameDiff sameDiff, @NonNull SDVariable n, @NonNull SDVariable x)RandomCrop(@NonNull SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable shape)RgbToGrayscale(SameDiff sameDiff, SDVariable image)RgbToHsv(SameDiff sameDiff, SDVariable input)RgbToYiq(SameDiff sameDiff, SDVariable input)RgbToYuv(SameDiff sameDiff, SDVariable input)Roll(@NonNull SameDiff sameDiff, @NonNull SDVariable input, int shift)Roll(@NonNull SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable shift)Roll(@NonNull SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable shift, @NonNull SDVariable axes)ToggleBits(@NonNull SameDiff sameDiff, @NonNull SDVariable input)TriangularSolve(SameDiff sameDiff, SDVariable matrix, SDVariable rhs, boolean lower, boolean adjoint)TriangularSolve(SameDiff sameDiff, SDVariable matrix, SDVariable rhs, SDVariable lower, SDVariable adjoint)Triu(SameDiff sameDiff, SDVariable in)Triu(SameDiff sameDiff, SDVariable in, int diag)TriuBp(SameDiff sameDiff, SDVariable in, SDVariable grad)TriuBp(SameDiff sameDiff, SDVariable in, SDVariable grad, int diag)YiqToRgb(SameDiff sameDiff, SDVariable input)YuvToRgb(SameDiff sameDiff, SDVariable input) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.broadcast
Constructors in org.nd4j.linalg.api.ops.impl.broadcast with parameters of type SDVariable Constructor Description BiasAdd(SameDiff sameDiff, SDVariable input, SDVariable bias, boolean nchw)BiasAddGrad(SameDiff sameDiff, SDVariable input, SDVariable bias, SDVariable gradient, boolean nchw)BroadcastAddOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastAddOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastAddOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastAMax(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastAMax(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastAMax(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastAMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastAMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastAMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastAMin(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastAMin(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastAMin(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastAMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastAMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastAMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastCopyOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastCopyOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastCopyOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastCopyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastCopyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastCopyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastDivOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastDivOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastDivOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastGradientArgs(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastGradientArgs(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastGradientArgs(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastMax(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastMax(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastMax(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastMax(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastMin(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastMin(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastMin(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastMin(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastMulOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastMulOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastMulOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastMulOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastMulOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastMulOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastRDivOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastRDivOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastRDivOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastRDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastRDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastRDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastRSubOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastRSubOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastRSubOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastRSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastRSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastRSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastSubOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastSubOp(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastSubOp(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastTo(SameDiff sameDiff, SDVariable input, SDVariable shape) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.broadcast.bool
Methods in org.nd4j.linalg.api.ops.impl.broadcast.bool that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>BroadcastEqualTo. doDiff(List<SDVariable> f1)List<SDVariable>BroadcastGreaterThan. doDiff(List<SDVariable> f1)List<SDVariable>BroadcastGreaterThanOrEqual. doDiff(List<SDVariable> f1)List<SDVariable>BroadcastLessThan. doDiff(List<SDVariable> f1)List<SDVariable>BroadcastLessThanOrEqual. doDiff(List<SDVariable> f1)List<SDVariable>BroadcastNotEqual. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.broadcast.bool with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>BroadcastEqualTo. doDiff(List<SDVariable> f1)List<SDVariable>BroadcastGreaterThan. doDiff(List<SDVariable> f1)List<SDVariable>BroadcastGreaterThanOrEqual. doDiff(List<SDVariable> f1)List<SDVariable>BroadcastLessThan. doDiff(List<SDVariable> f1)List<SDVariable>BroadcastLessThanOrEqual. doDiff(List<SDVariable> f1)List<SDVariable>BroadcastNotEqual. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.impl.broadcast.bool with parameters of type SDVariable Constructor Description BroadcastEqualTo(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastEqualTo(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastEqualTo(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastGreaterThan(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastGreaterThan(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastGreaterThan(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastGreaterThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastGreaterThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastGreaterThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastLessThan(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastLessThan(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastLessThan(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastLessThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastLessThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastLessThan(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastLessThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastLessThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastLessThanOrEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs)BroadcastNotEqual(SameDiff sameDiff, SDVariable i_v, int[] dimension, boolean inPlace)BroadcastNotEqual(SameDiff sameDiff, SDVariable i_v, int[] dimension, Object[] extraArgs)BroadcastNotEqual(SameDiff sameDiff, SDVariable i_v, long[] shape, boolean inPlace, int[] dimension, Object[] extraArgs)BroadcastNotEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, int[] dimension)BroadcastNotEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension)BroadcastNotEqual(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[] dimension, Object[] extraArgs) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.controlflow
Constructors in org.nd4j.linalg.api.ops.impl.controlflow with parameters of type SDVariable Constructor Description Select(SameDiff sameDiff, SDVariable[] args)Select(SameDiff sameDiff, SDVariable[] args, boolean inPlace)Where(SameDiff sd, SDVariable condition)Where(SameDiff sameDiff, SDVariable[] args)Where(SameDiff sameDiff, SDVariable[] args, boolean inPlace)Where(SameDiff sd, SDVariable x, SDVariable condition)Where(SameDiff sd, SDVariable x, SDVariable y, SDVariable condition)WhereNumpy(SameDiff sameDiff, SDVariable[] args)WhereNumpy(SameDiff sameDiff, SDVariable[] args, boolean inPlace)WhereNumpy(SameDiff sd, SDVariable x, SDVariable y, SDVariable condition) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.controlflow.compat
Methods in org.nd4j.linalg.api.ops.impl.controlflow.compat that return SDVariable Modifier and Type Method Description SDVariable[]Exit. outputVariables()SDVariable[]LoopCond. outputVariables()SDVariable[]Switch. outputVariables()SDVariable[]While. outputVariables()Methods in org.nd4j.linalg.api.ops.impl.controlflow.compat that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>StopGradient. doDiff(List<SDVariable> gradients)Method parameters in org.nd4j.linalg.api.ops.impl.controlflow.compat with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>StopGradient. doDiff(List<SDVariable> gradients)Constructors in org.nd4j.linalg.api.ops.impl.controlflow.compat with parameters of type SDVariable Constructor Description BaseCompatOp(SameDiff sameDiff, SDVariable[] inputs)Enter(SameDiff sameDiff, String frameName, SDVariable input)Enter(SameDiff sameDiff, String frameName, SDVariable input, boolean isConstant)Enter(SameDiff sameDiff, SDVariable[] inputs)Exit(SameDiff sameDiff, SDVariable x)Merge(SameDiff sd, SDVariable... inputs)NextIteration(SameDiff sameDiff, SDVariable x)StopGradient(SameDiff sd, SDVariable in)Switch(SameDiff sameDiff, SDVariable input, SDVariable predicate)While(SameDiff sameDiff, String frameName, SDVariable input)While(SameDiff sameDiff, String frameName, SDVariable input, boolean isConstant)While(SameDiff sameDiff, SDVariable[] inputs) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.grid
Methods in org.nd4j.linalg.api.ops.impl.grid that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>FreeGridOp. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.grid with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>FreeGridOp. doDiff(List<SDVariable> f1) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.image
Methods in org.nd4j.linalg.api.ops.impl.image that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>CropAndResize. doDiff(List<SDVariable> f1)List<SDVariable>ExtractImagePatches. doDiff(List<SDVariable> f1)List<SDVariable>NonMaxSuppression. doDiff(List<SDVariable> i_v)List<SDVariable>NonMaxSuppressionV3. doDiff(List<SDVariable> i_v)List<SDVariable>NonMaxSuppressionWithOverlaps. doDiff(List<SDVariable> i_v)List<SDVariable>ResizeArea. doDiff(List<SDVariable> f1)List<SDVariable>ResizeBilinear. doDiff(List<SDVariable> f1)List<SDVariable>ResizeNearestNeighbor. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.image with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>CropAndResize. doDiff(List<SDVariable> f1)List<SDVariable>ExtractImagePatches. doDiff(List<SDVariable> f1)List<SDVariable>NonMaxSuppression. doDiff(List<SDVariable> i_v)List<SDVariable>NonMaxSuppressionV3. doDiff(List<SDVariable> i_v)List<SDVariable>NonMaxSuppressionWithOverlaps. doDiff(List<SDVariable> i_v)List<SDVariable>ResizeArea. doDiff(List<SDVariable> f1)List<SDVariable>ResizeBilinear. doDiff(List<SDVariable> f1)List<SDVariable>ResizeNearestNeighbor. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.impl.image with parameters of type SDVariable Constructor Description CropAndResize(@NonNull SameDiff sameDiff, @NonNull SDVariable image, @NonNull SDVariable cropBoxes, @NonNull SDVariable boxIndices, @NonNull SDVariable cropOutSize, @NonNull CropAndResize.Method method, double extrapolationValue)CropAndResize(@NonNull SameDiff sameDiff, SDVariable image, SDVariable cropBoxes, SDVariable boxIndices, SDVariable cropOutSize, double extrapolationValue)ExtractImagePatches(@NonNull SameDiff samediff, @NonNull SDVariable input, @lombok.NonNull int[] kSizes, @lombok.NonNull int[] strides, @lombok.NonNull int[] rates, boolean sameMode)ExtractImagePatches(@NonNull SameDiff samediff, @NonNull SDVariable input, int kH, int kW, int sH, int sW, int rH, int rW, boolean sameMode)ImageResize(@NonNull SameDiff sameDiff, @NonNull SDVariable in, @NonNull SDVariable size, boolean preserveAspectRatio, boolean antialias, ImageResizeMethod method)ImageResize(@NonNull SameDiff sameDiff, @NonNull SDVariable in, @NonNull SDVariable size, double bicubicCoefficient, boolean preserveAspectRatio, boolean antialias)NonMaxSuppression(SameDiff sameDiff, @NonNull SDVariable boxes, @NonNull SDVariable scores, @NonNull SDVariable maxOutSize, @NonNull SDVariable iouThreshold, @NonNull SDVariable scoreThreshold)NonMaxSuppression(SameDiff sameDiff, SDVariable boxes, SDVariable scores, int maxOutSize, double iouThreshold, double scoreThreshold)NonMaxSuppressionV3(SameDiff sameDiff, @NonNull SDVariable boxes, @NonNull SDVariable scores, @NonNull SDVariable maxOutSize, @NonNull SDVariable iouThreshold, @NonNull SDVariable scoreThreshold)NonMaxSuppressionWithOverlaps(SameDiff sameDiff, @NonNull SDVariable boxes, @NonNull SDVariable scores, @NonNull SDVariable maxOutSize, @NonNull SDVariable iouThreshold, @NonNull SDVariable scoreThreshold)NonMaxSuppressionWithOverlaps(SameDiff sameDiff, SDVariable boxes, SDVariable scores, int maxOutSize, double iouThreshold, double scoreThreshold)ResizeArea(@NonNull SameDiff sd, @NonNull SDVariable image, int height, int width, boolean alignCorners)ResizeBicubic(@NonNull SameDiff sameDiff, @NonNull SDVariable image, SDVariable size, boolean alignCorners, boolean alignPixelCenters)ResizeBilinear(@NonNull SameDiff sd, @NonNull SDVariable input, int height, int width, boolean alignCorners, boolean halfPixelCenters) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.indexaccum
Methods in org.nd4j.linalg.api.ops.impl.indexaccum that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>FirstIndex. doDiff(List<SDVariable> f1)List<SDVariable>LastIndex. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.indexaccum with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>FirstIndex. doDiff(List<SDVariable> f1)List<SDVariable>LastIndex. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.impl.indexaccum with parameters of type SDVariable Constructor Description FirstIndex(SameDiff sameDiff, SDVariable i_v, boolean keepDims, Condition condition, int... dimensions)FirstIndex(SameDiff sameDiff, SDVariable i_v, Condition condition, boolean keepDims, int... dimensions)LastIndex(SameDiff sameDiff, SDVariable i_v, boolean keepDims, Condition condition, int... dimensions)LastIndex(SameDiff sameDiff, SDVariable x, @NonNull Condition condition, int... dimensions)LastIndex(SameDiff sameDiff, SDVariable i_v, Condition condition, boolean keepDims, int... dimensions) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.indexaccum.custom
Constructors in org.nd4j.linalg.api.ops.impl.indexaccum.custom with parameters of type SDVariable Constructor Description ArgAmax(SameDiff sameDiff, SDVariable[] args, boolean keepDims)ArgAmax(SameDiff sameDiff, SDVariable[] args, boolean keepDims, int[] dimensions)ArgAmin(SameDiff sameDiff, SDVariable[] args, boolean keepDims)ArgAmin(SameDiff sameDiff, SDVariable[] args, boolean keepDims, int[] dimensions)ArgMax(String opName, SameDiff sameDiff, SDVariable[] args, boolean inPlace, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)ArgMax(String opName, SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)ArgMax(SameDiff sameDiff, SDVariable[] args, boolean keepDims)ArgMax(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex)ArgMax(SameDiff sameDiff, SDVariable[] args, boolean inPlace, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)ArgMax(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)ArgMax(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, int[] dimensions)ArgMax(SameDiff sameDiff, SDVariable[] args, boolean keepDims, int[] dimensions)ArgMax(SameDiff sameDiff, SDVariable arg, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)ArgMax(SameDiff sd, SDVariable in, boolean keepDims, int[] dimensions)ArgMin(String opName, SameDiff sameDiff, SDVariable[] args, boolean inPlace, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)ArgMin(String opName, SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)ArgMin(SameDiff sameDiff, SDVariable[] args, boolean keepDims)ArgMin(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex)ArgMin(SameDiff sameDiff, SDVariable[] args, boolean inPlace, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)ArgMin(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)ArgMin(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, int[] dimensions)ArgMin(SameDiff sameDiff, SDVariable[] args, boolean keepDims, int[] dimensions)ArgMin(SameDiff sameDiff, SDVariable arg, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)ArgMin(SameDiff sd, SDVariable in, boolean keepDims, int[] dimensions) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.layers
Methods in org.nd4j.linalg.api.ops.impl.layers that return SDVariable Modifier and Type Method Description SDVariable[]ExternalErrorsFunction. outputVariables(String baseName)Methods in org.nd4j.linalg.api.ops.impl.layers that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>ExternalErrorsFunction. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.layers with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>ExternalErrorsFunction. doDiff(List<SDVariable> f1)Constructor parameters in org.nd4j.linalg.api.ops.impl.layers with type arguments of type SDVariable Constructor Description ExternalErrorsFunction(SameDiff sd, List<SDVariable> inputs, Map<String,INDArray> gradients) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.layers.convolution
Constructors in org.nd4j.linalg.api.ops.impl.layers.convolution with parameters of type SDVariable Constructor Description AvgPooling2D(SameDiff sameDiff, SDVariable input, Pooling2DConfig config)AvgPooling3D(SameDiff sameDiff, SDVariable input, Pooling3DConfig config)BatchNorm(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputArrays, boolean inPlace, boolean applyGamma, boolean applyBeta, double epsilon, int[] axis)BatchNorm(SameDiff sameDiff, SDVariable input, SDVariable mean, SDVariable variance, SDVariable gamma, SDVariable beta, double epsilon, int[] axis)BatchNormDerivative(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputArrays, boolean inPlace, boolean applyGamma, boolean applyBeta, double epsilon, int[] axis)Col2Im(@NonNull SameDiff sd, @NonNull SDVariable input, @NonNull Conv2DConfig config)Col2Im(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputs, Conv2DConfig conv2DConfig)Conv1D(@NonNull SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable weights, SDVariable bias, @NonNull Conv1DConfig conv1DConfig)Conv1D(SameDiff sameDiff, SDVariable[] inputFunctions, Conv1DConfig config)Conv1DDerivative(@NonNull SameDiff sameDiff, @NonNull SDVariable[] inputs, @NonNull Conv1DConfig config)Conv1DDerivative(@NonNull SameDiff sd, @NonNull SDVariable input, @NonNull SDVariable weights, SDVariable bias, SDVariable gradOut, @NonNull Conv1DConfig config)Conv2D(@NonNull SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable weights, SDVariable bias, @NonNull Conv2DConfig conv2DConfig)Conv2D(SameDiff sameDiff, SDVariable[] inputFunctions, Conv2DConfig config)Conv2DDerivative(SameDiff sameDiff, SDVariable[] inputFunctions, Conv2DConfig config)Conv3D(@NonNull SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable weights, SDVariable bias, @NonNull Conv3DConfig config)Conv3D(SameDiff sameDiff, SDVariable[] inputFunctions, Conv3DConfig config)Conv3DDerivative(SameDiff sameDiff, SDVariable[] inputFunctions, Conv3DConfig conv3DConfig)DeConv2D(@NonNull SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable weights, SDVariable bias, DeConv2DConfig config)DeConv2D(SameDiff sameDiff, SDVariable[] inputs, DeConv2DConfig config)DeConv2DDerivative(SameDiff sameDiff, SDVariable[] inputs, DeConv2DConfig config)DeConv2DTF(SameDiff sameDiff, SDVariable[] inputs, DeConv2DConfig config)DeConv3D(SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable weights, @NonNull DeConv3DConfig config)DeConv3D(SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable weights, SDVariable bias, @NonNull DeConv3DConfig config)DeConv3DDerivative(SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable weights, SDVariable bias, SDVariable grad, DeConv3DConfig config)DeConv3DTF(@NonNull SameDiff sameDiff, @NonNull SDVariable shape, @NonNull SDVariable weights, @NonNull SDVariable input, @NonNull DeConv3DConfig config)DepthToSpace(SameDiff sameDiff, SDVariable[] args, int blockSize, DataFormat dataFormat)DepthToSpace(SameDiff sameDiff, SDVariable args, int blockSize, DataFormat dataFormat)DepthwiseConv2D(@NonNull SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable weights, SDVariable bias, @NonNull Conv2DConfig conv2DConfig)DepthwiseConv2D(SameDiff sameDiff, SDVariable[] inputFunctions, Conv2DConfig config)DepthwiseConv2DBp(@NonNull SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable weights, @NonNull SDVariable gradO, @NonNull Conv2DConfig config)DepthwiseConv2DBp(@NonNull SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable weights, SDVariable bias, @NonNull SDVariable gradO, @NonNull Conv2DConfig config)Im2col(SameDiff sameDiff, SDVariable[] inputFunctions, INDArray[] inputArrays, INDArray[] outputs, Conv2DConfig conv2DConfig)Im2col(SameDiff sd, SDVariable input, Conv2DConfig config)Im2colBp(SameDiff sameDiff, SDVariable i2cInput, SDVariable gradAtOutput, Conv2DConfig conv2DConfig)Im2colBp(SameDiff sd, SDVariable input, Conv2DConfig config)LocalResponseNormalization(SameDiff sameDiff, SDVariable[] inputFunctions, boolean inPlace, LocalResponseNormalizationConfig config)LocalResponseNormalization(SameDiff sameDiff, SDVariable input, LocalResponseNormalizationConfig config)LocalResponseNormalizationDerivative(SameDiff sameDiff, SDVariable[] inputFunctions, boolean inPlace, LocalResponseNormalizationConfig config)MaxPooling2D(SameDiff sameDiff, SDVariable input, Pooling2DConfig config)MaxPooling3D(SameDiff sameDiff, SDVariable input, Pooling3DConfig config)MaxPoolWithArgmax(SameDiff sameDiff, SDVariable input, Pooling2DConfig config)Pooling2D(SameDiff sameDiff, SDVariable[] inputs, Pooling2DConfig config)Pooling2DDerivative(SameDiff sameDiff, SDVariable[] inputs, Pooling2DConfig config)Pooling3D(SameDiff sameDiff, SDVariable[] inputs, INDArray[] inputArrays, INDArray[] outputs, boolean inPlace, Pooling3DConfig pooling3DConfig, Pooling3D.Pooling3DType type)Pooling3DDerivative(SameDiff sameDiff, SDVariable[] inputs, INDArray[] inputArrays, INDArray[] outputs, boolean inPlace, Pooling3DConfig pooling3DConfig, Pooling3D.Pooling3DType type)SConv2D(@NonNull SameDiff sameDiff, @NonNull SDVariable layerInput, @NonNull SDVariable depthWeights, SDVariable pointWeights, SDVariable bias, @NonNull Conv2DConfig conv2DConfig)SConv2D(SameDiff sameDiff, SDVariable[] inputFunctions, Conv2DConfig conv2DConfig)SConv2DDerivative(SameDiff sameDiff, SDVariable[] inputFunctions, Conv2DConfig conv2DConfig)SpaceToDepth(SameDiff sameDiff, SDVariable[] args, int blockSize, DataFormat dataFormat)SpaceToDepth(SameDiff sameDiff, SDVariable x, int blockSize, DataFormat dataFormat)Upsampling2d(SameDiff sameDiff, SDVariable input, boolean nchw, int scaleH, int scaleW)Upsampling2d(SameDiff sameDiff, SDVariable input, int scale)Upsampling2d(SameDiff sameDiff, SDVariable input, int scaleH, int scaleW, boolean nchw)Upsampling2dDerivative(SameDiff sameDiff, SDVariable input, SDVariable gradient, boolean nchw, int scaleH, int scaleW)Upsampling3d(SameDiff sameDiff, SDVariable input, boolean ncdhw, int scaleD, int scaleH, int scaleW)Upsampling3dBp(SameDiff sameDiff, SDVariable input, SDVariable grad0, boolean ncdhw) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.layers.recurrent
Methods in org.nd4j.linalg.api.ops.impl.layers.recurrent that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>GRU. doDiff(List<SDVariable> grads)List<SDVariable>GRUCell. doDiff(List<SDVariable> grads)List<SDVariable>LSTMBlock. doDiff(List<SDVariable> grads)List<SDVariable>LSTMBlockCell. doDiff(List<SDVariable> grads)List<SDVariable>LSTMLayer. doDiff(List<SDVariable> grads)Method parameters in org.nd4j.linalg.api.ops.impl.layers.recurrent with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>GRU. doDiff(List<SDVariable> grads)List<SDVariable>GRUCell. doDiff(List<SDVariable> grads)List<SDVariable>LSTMBlock. doDiff(List<SDVariable> grads)List<SDVariable>LSTMBlockCell. doDiff(List<SDVariable> grads)List<SDVariable>LSTMLayer. doDiff(List<SDVariable> grads)Constructors in org.nd4j.linalg.api.ops.impl.layers.recurrent with parameters of type SDVariable Constructor Description GRU(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable hI, @NonNull SDVariable Wx, @NonNull SDVariable Wh, @NonNull SDVariable biases)GRUBp(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable hI, @NonNull SDVariable Wx, @NonNull SDVariable Wh, @NonNull SDVariable biases, @NonNull SDVariable dLdh)GRUCell(SameDiff sameDiff, SDVariable x, SDVariable hLast, GRUWeights weights)LSTMBlock(@NonNull SameDiff sameDiff, SDVariable maxTSLength, SDVariable x, SDVariable cLast, SDVariable yLast, LSTMWeights weights, LSTMConfiguration configuration)LSTMBlockCell(SameDiff sameDiff, SDVariable x, SDVariable cLast, SDVariable yLast, LSTMWeights weights, LSTMConfiguration configuration)LSTMLayer(@NonNull SameDiff sameDiff, SDVariable x, SDVariable cLast, SDVariable yLast, SDVariable maxTSLength, LSTMLayerWeights weights, LSTMLayerConfig configuration)LSTMLayerBp(@NonNull SameDiff sameDiff, @NonNull SDVariable x, SDVariable cLast, SDVariable yLast, SDVariable maxTSLength, @NonNull LSTMLayerWeights weights, @NonNull LSTMLayerConfig configuration, SDVariable dLdh, SDVariable dLdhL, SDVariable dLdcL)SRU(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable initialC, SDVariable mask, @NonNull SRUWeights weights)SRUCell(SameDiff sameDiff, SDVariable x, SDVariable cLast, SRUWeights weights) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.layers.recurrent.config
Methods in org.nd4j.linalg.api.ops.impl.layers.recurrent.config that return SDVariable Modifier and Type Method Description SDVariable[]GRUCellConfiguration. args()SDVariable[]LSTMCellConfiguration. args() -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.layers.recurrent.outputs
Methods in org.nd4j.linalg.api.ops.impl.layers.recurrent.outputs that return SDVariable Modifier and Type Method Description SDVariableLSTMLayerOutputs. getLastOutput()SDVariableSRULayerOutputs. getLastOutput()Get y, the output of the cell, for the last time step.SDVariableLSTMLayerOutputs. getLastState()SDVariableSRULayerOutputs. getLastState()Get c, the state of the cell, for the last time step.SDVariableGRUCellOutputs. getOutput()Get h, the output of the cell.SDVariableLSTMCellOutputs. getOutput()Get y, the output of the cell.SDVariableLSTMLayerOutputs. getOutput()Get h, the output of the cell for all time steps.SDVariableSRUCellOutputs. getOutput()Get h, the output of the cell.SDVariableSRULayerOutputs. getOutput()Get h, the output of the cell.SDVariableLSTMCellOutputs. getState()Get c, the cell's state.SDVariableSRUCellOutputs. getState()Get c, the state of the cell.SDVariableSRULayerOutputs. getState()Get c, the state of the cell.Methods in org.nd4j.linalg.api.ops.impl.layers.recurrent.outputs that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>GRUCellOutputs. getAllOutputs()Get all outputs returned by the cell.List<SDVariable>LSTMCellOutputs. getAllOutputs()Get all outputs returned by the cell.List<SDVariable>SRUCellOutputs. getAllOutputs()Get all outputs returned by the cell.List<SDVariable>SRULayerOutputs. getAllOutputs()Get all outputs returned by the cell.Constructors in org.nd4j.linalg.api.ops.impl.layers.recurrent.outputs with parameters of type SDVariable Constructor Description GRUCellOutputs(SDVariable[] outputs)LSTMCellOutputs(SDVariable[] outputs)LSTMLayerOutputs(SDVariable[] outputs, LSTMLayerConfig lstmLayerConfig)SRUCellOutputs(SDVariable[] outputs)SRULayerOutputs(SDVariable[] outputs) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.layers.recurrent.weights
Methods in org.nd4j.linalg.api.ops.impl.layers.recurrent.weights that return SDVariable Modifier and Type Method Description SDVariable[]GRUWeights. args()SDVariable[]LSTMLayerWeights. args()SDVariable[]LSTMWeights. args()abstract SDVariable[]RNNWeights. args()SDVariable[]SRUWeights. args()SDVariable[]LSTMLayerWeights. argsWithInputs(SDVariable... inputs)SDVariable[]RNNWeights. argsWithInputs(SDVariable... inputs)Methods in org.nd4j.linalg.api.ops.impl.layers.recurrent.weights with parameters of type SDVariable Modifier and Type Method Description SDVariable[]LSTMLayerWeights. argsWithInputs(SDVariable... inputs)SDVariable[]RNNWeights. argsWithInputs(SDVariable... inputs) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.loss
Methods in org.nd4j.linalg.api.ops.impl.loss that return SDVariable Modifier and Type Method Description protected static SDVariableBaseLoss. getWeights(SameDiff sd, SDVariable weights, SDVariable predictions)Methods in org.nd4j.linalg.api.ops.impl.loss that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>AbsoluteDifferenceLoss. doDiff(List<SDVariable> grad)List<SDVariable>CosineDistanceLoss. doDiff(List<SDVariable> grad)List<SDVariable>CtcLoss. doDiff(List<SDVariable> grad)List<SDVariable>HingeLoss. doDiff(List<SDVariable> grad)List<SDVariable>HuberLoss. doDiff(List<SDVariable> grad)List<SDVariable>L2Loss. doDiff(List<SDVariable> grad)List<SDVariable>LogLoss. doDiff(List<SDVariable> grad)List<SDVariable>LogPoissonLoss. doDiff(List<SDVariable> grad)List<SDVariable>MeanPairwiseSquaredErrorLoss. doDiff(List<SDVariable> grad)List<SDVariable>MeanSquaredErrorLoss. doDiff(List<SDVariable> grad)List<SDVariable>SigmoidCrossEntropyLoss. doDiff(List<SDVariable> grad)List<SDVariable>SoftmaxCrossEntropyLoss. doDiff(List<SDVariable> grad)List<SDVariable>SoftmaxCrossEntropyWithLogitsLoss. doDiff(List<SDVariable> grad)List<SDVariable>SparseSoftmaxCrossEntropyLossWithLogits. doDiff(List<SDVariable> grad)Methods in org.nd4j.linalg.api.ops.impl.loss with parameters of type SDVariable Modifier and Type Method Description protected static SDVariableBaseLoss. getWeights(SameDiff sd, SDVariable weights, SDVariable predictions)Method parameters in org.nd4j.linalg.api.ops.impl.loss with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>AbsoluteDifferenceLoss. doDiff(List<SDVariable> grad)List<SDVariable>CosineDistanceLoss. doDiff(List<SDVariable> grad)List<SDVariable>CtcLoss. doDiff(List<SDVariable> grad)List<SDVariable>HingeLoss. doDiff(List<SDVariable> grad)List<SDVariable>HuberLoss. doDiff(List<SDVariable> grad)List<SDVariable>L2Loss. doDiff(List<SDVariable> grad)List<SDVariable>LogLoss. doDiff(List<SDVariable> grad)List<SDVariable>LogPoissonLoss. doDiff(List<SDVariable> grad)List<SDVariable>MeanPairwiseSquaredErrorLoss. doDiff(List<SDVariable> grad)List<SDVariable>MeanSquaredErrorLoss. doDiff(List<SDVariable> grad)List<SDVariable>SigmoidCrossEntropyLoss. doDiff(List<SDVariable> grad)List<SDVariable>SoftmaxCrossEntropyLoss. doDiff(List<SDVariable> grad)List<SDVariable>SoftmaxCrossEntropyWithLogitsLoss. doDiff(List<SDVariable> grad)List<SDVariable>SparseSoftmaxCrossEntropyLossWithLogits. doDiff(List<SDVariable> grad)Constructors in org.nd4j.linalg.api.ops.impl.loss with parameters of type SDVariable Constructor Description AbsoluteDifferenceLoss(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels)AbsoluteDifferenceLoss(SameDiff sameDiff, SDVariable label, SDVariable predictions, SDVariable weights, LossReduce lossReduce)BaseLoss(@NonNull SameDiff sameDiff, @NonNull LossReduce lossReduce, @NonNull SDVariable predictions, SDVariable weights, @NonNull SDVariable labels)CosineDistanceLoss(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels, int dimension)CosineDistanceLoss(SameDiff sameDiff, SDVariable labels, SDVariable predictions, SDVariable weights, LossReduce lossReduce, int dimension)CtcLoss(SameDiff sameDiff, SDVariable targetLabels, SDVariable logitInputs, SDVariable targetLabelLengths, SDVariable logitInputLengths)HingeLoss(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels)HingeLoss(SameDiff sameDiff, SDVariable labels, SDVariable predictions, SDVariable weights, LossReduce lossReduce)HuberLoss(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels, double delta)HuberLoss(SameDiff sameDiff, SDVariable labels, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double delta)L2Loss(SameDiff sameDiff, SDVariable var)LogLoss(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels, double epsilon)LogLoss(SameDiff sameDiff, SDVariable labels, SDVariable predictions, SDVariable weights, LossReduce lossReduce, double epsilon)LogPoissonLoss(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels)LogPoissonLoss(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels, boolean full)LogPoissonLoss(SameDiff sameDiff, SDVariable labels, SDVariable predictions, SDVariable weights, LossReduce lossReduce, boolean full)MeanPairwiseSquaredErrorLoss(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels)MeanPairwiseSquaredErrorLoss(SameDiff sameDiff, SDVariable labels, SDVariable predictions, SDVariable weights, LossReduce lossReduce)MeanSquaredErrorLoss(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels)MeanSquaredErrorLoss(SameDiff sameDiff, SDVariable labels, SDVariable predictions, SDVariable weights, LossReduce lossReduce)SigmoidCrossEntropyLoss(SameDiff sameDiff, LossReduce reductionMode, SDVariable logits, SDVariable weights, SDVariable labels)SigmoidCrossEntropyLoss(SameDiff sameDiff, LossReduce lossReduce, SDVariable logits, SDVariable weights, SDVariable labels, double labelSmoothing)SigmoidCrossEntropyLoss(SameDiff sameDiff, SDVariable labels, SDVariable logits, SDVariable weights, LossReduce lossReduce, double labelSmoothing)SoftmaxCrossEntropyLoss(SameDiff sameDiff, LossReduce lossReduce, SDVariable logits, SDVariable weights, SDVariable labels)SoftmaxCrossEntropyLoss(SameDiff sameDiff, LossReduce lossReduce, SDVariable logits, SDVariable weights, SDVariable labels, double labelSmoothing)SoftmaxCrossEntropyLoss(SameDiff sameDiff, SDVariable labels, SDVariable logits, SDVariable weights, LossReduce lossReduce, double labelSmoothing)SoftmaxCrossEntropyWithLogitsLoss(SameDiff sameDiff, SDVariable logits, SDVariable labels, int classesDim)SparseSoftmaxCrossEntropyLossWithLogits(@NonNull SameDiff sameDiff, @NonNull SDVariable logits, @NonNull SDVariable labels)WeightedCrossEntropyLoss(@NonNull SameDiff sameDiff, @NonNull LossReduce lossReduce, @NonNull SDVariable predictions, SDVariable weights, @NonNull SDVariable labels)WeightedCrossEntropyLoss(SameDiff sd, SDVariable targets, SDVariable inputs, SDVariable weights) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.loss.bp
Methods in org.nd4j.linalg.api.ops.impl.loss.bp that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>AbsoluteDifferenceLossBp. doDiff(List<SDVariable> grad)List<SDVariable>BaseLossBp. doDiff(List<SDVariable> grad)List<SDVariable>CtcLossBp. doDiff(List<SDVariable> grad)List<SDVariable>MeanPairwiseSquaredErrorLossBp. doDiff(List<SDVariable> grad)List<SDVariable>SoftmaxCrossEntropyWithLogitsLossBp. doDiff(List<SDVariable> grad)List<SDVariable>SparseSoftmaxCrossEntropyLossWithLogitsBp. doDiff(List<SDVariable> grad)Method parameters in org.nd4j.linalg.api.ops.impl.loss.bp with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>AbsoluteDifferenceLossBp. doDiff(List<SDVariable> grad)List<SDVariable>BaseLossBp. doDiff(List<SDVariable> grad)List<SDVariable>CtcLossBp. doDiff(List<SDVariable> grad)List<SDVariable>MeanPairwiseSquaredErrorLossBp. doDiff(List<SDVariable> grad)List<SDVariable>SoftmaxCrossEntropyWithLogitsLossBp. doDiff(List<SDVariable> grad)List<SDVariable>SparseSoftmaxCrossEntropyLossWithLogitsBp. doDiff(List<SDVariable> grad)Constructors in org.nd4j.linalg.api.ops.impl.loss.bp with parameters of type SDVariable Constructor Description AbsoluteDifferenceLossBp(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels)BaseLossBp(@NonNull SameDiff sameDiff, @NonNull LossReduce lossReduce, @NonNull SDVariable predictions, @NonNull SDVariable weights, @NonNull SDVariable labels)CosineDistanceLossBp(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels, int dimension)CtcLossBp(SameDiff sameDiff, SDVariable targetLabels, SDVariable logitInputs, SDVariable targetLabelLengths, SDVariable logitInputLengths)HingeLossBp(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels)HuberLossBp(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels, double delta)LogLossBp(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels, double epsilon)LogPoissonLossBp(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels)LogPoissonLossBp(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels, boolean full)MeanPairwiseSquaredErrorLossBp(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels)MeanSquaredErrorLossBp(SameDiff sameDiff, LossReduce lossReduce, SDVariable predictions, SDVariable weights, SDVariable labels)SigmoidCrossEntropyLossBp(SameDiff sameDiff, LossReduce lossReduce, SDVariable logits, SDVariable weights, SDVariable labels, double labelSmoothing)SoftmaxCrossEntropyLossBp(SameDiff sameDiff, LossReduce lossReduce, SDVariable logits, SDVariable weights, SDVariable labels, double labelSmoothing)SoftmaxCrossEntropyWithLogitsLossBp(SameDiff sameDiff, SDVariable logits, SDVariable labels, int classesDim)SparseSoftmaxCrossEntropyLossWithLogitsBp(SameDiff sameDiff, SDVariable logits, SDVariable labels) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.meta
Methods in org.nd4j.linalg.api.ops.impl.meta that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>InvertedPredicateMetaOp. doDiff(List<SDVariable> f1)List<SDVariable>PostulateMetaOp. doDiff(List<SDVariable> f1)List<SDVariable>PredicateMetaOp. doDiff(List<SDVariable> f1)List<SDVariable>ReduceMetaOp. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.meta with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>InvertedPredicateMetaOp. doDiff(List<SDVariable> f1)List<SDVariable>PostulateMetaOp. doDiff(List<SDVariable> f1)List<SDVariable>PredicateMetaOp. doDiff(List<SDVariable> f1)List<SDVariable>ReduceMetaOp. doDiff(List<SDVariable> f1) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.reduce
Methods in org.nd4j.linalg.api.ops.impl.reduce that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>Mmul. doDiff(List<SDVariable> gradients)List<SDVariable>MmulBp. doDiff(List<SDVariable> i_v1)List<SDVariable>Moments. doDiff(List<SDVariable> grad)List<SDVariable>SufficientStatistics. doDiff(List<SDVariable> grad)List<SDVariable>TensorMmul. doDiff(List<SDVariable> gradients)List<SDVariable>TensorMmulBp. doDiff(List<SDVariable> i_v1)List<SDVariable>ZeroFraction. doDiff(List<SDVariable> grad)Method parameters in org.nd4j.linalg.api.ops.impl.reduce with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>Mmul. doDiff(List<SDVariable> gradients)List<SDVariable>MmulBp. doDiff(List<SDVariable> i_v1)List<SDVariable>Moments. doDiff(List<SDVariable> grad)List<SDVariable>SufficientStatistics. doDiff(List<SDVariable> grad)List<SDVariable>TensorMmul. doDiff(List<SDVariable> gradients)List<SDVariable>TensorMmulBp. doDiff(List<SDVariable> i_v1)List<SDVariable>ZeroFraction. doDiff(List<SDVariable> grad)Constructors in org.nd4j.linalg.api.ops.impl.reduce with parameters of type SDVariable Constructor Description Mmul(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)Mmul(SameDiff sameDiff, SDVariable x, SDVariable y, boolean transposeX, boolean transposeY, boolean transposeZ)Mmul(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, MMulTranspose mt)MmulBp(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable eps)MmulBp(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable eps, MMulTranspose mt)Moments(SameDiff sameDiff, SDVariable input)Moments(SameDiff sameDiff, SDVariable input, int[] axes)Moments(SameDiff sd, SDVariable input, int[] axes, boolean keepDims)Moments(SameDiff sd, SDVariable input, SDVariable axes, boolean keepDims)NormalizeMoments(SameDiff sameDiff, SDVariable counts, SDVariable means, SDVariable variances)NormalizeMoments(SameDiff sameDiff, SDVariable counts, SDVariable means, SDVariable variances, double shift)SufficientStatistics(SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable axis, SDVariable shift)TensorMmul(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[][] dimensions)TensorMmul(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, int[][] dimensions, MMulTranspose mMulTranspose)TensorMmul(SameDiff sameDiff, SDVariable x, SDVariable y, int[] dimensionsX, int[] dimensionsY, boolean transposeX, boolean transposeY, boolean transposeZ)TensorMmulBp(SameDiff samediff, SDVariable x, SDVariable y, SDVariable gradAtOutput, int[][] axes)TensorMmulBp(SameDiff samediff, SDVariable x, SDVariable y, SDVariable gradAtOutput, int[] axesX, int[] axesY)ZeroFraction(SameDiff sameDiff, SDVariable input) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.reduce.bool
Methods in org.nd4j.linalg.api.ops.impl.reduce.bool that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>All. doDiff(List<SDVariable> f1)List<SDVariable>Any. doDiff(List<SDVariable> f1)List<SDVariable>IsInf. doDiff(List<SDVariable> i_v)List<SDVariable>IsNaN. doDiff(List<SDVariable> i_v)Method parameters in org.nd4j.linalg.api.ops.impl.reduce.bool with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>All. doDiff(List<SDVariable> f1)List<SDVariable>Any. doDiff(List<SDVariable> f1)List<SDVariable>IsInf. doDiff(List<SDVariable> i_v)List<SDVariable>IsNaN. doDiff(List<SDVariable> i_v)Constructors in org.nd4j.linalg.api.ops.impl.reduce.bool with parameters of type SDVariable Constructor Description All(SameDiff sameDiff, SDVariable i_v)All(SameDiff sameDiff, SDVariable i_v, boolean keepDims)All(SameDiff sameDiff, SDVariable i_v, int[] dimensions)All(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)All(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)All(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)All(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)All(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)All(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)Any(SameDiff sameDiff, SDVariable i_v)Any(SameDiff sameDiff, SDVariable i_v, boolean keepDims)Any(SameDiff sameDiff, SDVariable i_v, int[] dimensions)Any(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)Any(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)Any(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)Any(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)Any(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)Any(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)IsInf(SameDiff sameDiff, SDVariable i_v)IsInf(SameDiff sameDiff, SDVariable i_v, boolean keepDims)IsInf(SameDiff sameDiff, SDVariable i_v, int[] dims)IsInf(SameDiff sameDiff, SDVariable i_v, int[] dims, boolean keepDims)IsInf(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)IsInf(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)IsInf(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)IsInf(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)IsInf(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)IsNaN(SameDiff sameDiff, SDVariable i_v)IsNaN(SameDiff sameDiff, SDVariable i_v, boolean keepDims)IsNaN(SameDiff sameDiff, SDVariable i_v, int[] dims)IsNaN(SameDiff sameDiff, SDVariable i_v, int[] dims, boolean keepDims)IsNaN(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)IsNaN(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)IsNaN(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)IsNaN(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)IsNaN(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.reduce.bp
Constructors in org.nd4j.linalg.api.ops.impl.reduce.bp with parameters of type SDVariable Constructor Description BaseReductionBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)BaseReductionBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions)BaseReductionBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, int... dimensions)CumProdBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, boolean exclusive, boolean reverse, int... dimensions)CumProdBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean exclusive, boolean reverse, int... axis)CumProdBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions, boolean exclusive, boolean reverse)CumProdBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, boolean exclusive, boolean reverse, int... dimensions)CumSumBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, boolean exclusive, boolean reverse, int... dimensions)CumSumBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean exclusive, boolean reverse, int... axis)CumSumBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions, boolean exclusive, boolean reverse)CumSumBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, boolean exclusive, boolean reverse, int... dimensions)DotBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)DotBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions)DotBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, int... dimensions)MaxBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)MaxBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions)MaxBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, int... dimensions)MeanBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)MeanBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions)MeanBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, int... dimensions)MinBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)MinBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions)MinBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, int... dimensions)Norm1Bp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)Norm1Bp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions)Norm1Bp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, int... dimensions)Norm2Bp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)Norm2Bp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions)Norm2Bp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, int... dimensions)NormMaxBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)NormMaxBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions)NormMaxBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, int... dimensions)PowBp(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable dLdz)ProdBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)ProdBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions)ProdBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, int... dimensions)SquaredNormBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)SquaredNormBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions)SquaredNormBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, int... dimensions)StandardDeviationBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean biasCorrected, boolean keepDims, int... dimensions)StandardDeviationBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions, boolean biasCorrected)StandardDeviationBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, boolean biasCorrected, int... dimensions)SumBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, int... dimensions)SumBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions)VarianceBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean biasCorrected, boolean keepDims, int... dimensions)VarianceBp(SameDiff sameDiff, SDVariable arg, SDVariable dLdVar, boolean keepDims, boolean biasCorrected, SDVariable dimensions)VarianceBp(SameDiff sameDiff, SDVariable origInput, SDVariable gradAtOutput, boolean keepDims, SDVariable dimensions, boolean biasCorrected)VarianceBp(SameDiff sameDiff, SDVariable origInput1, SDVariable origInput2, SDVariable gradAtOutput, boolean keepDims, boolean biasCorrected, int... dimensions) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.reduce.custom
Methods in org.nd4j.linalg.api.ops.impl.reduce.custom that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>BatchMmul. doDiff(List<SDVariable> grads)List<SDVariable>LogSumExp. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.reduce.custom with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>BatchMmul. doDiff(List<SDVariable> grads)List<SDVariable>LogSumExp. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.impl.reduce.custom with parameters of type SDVariable Constructor Description BaseDynamicCustomBoolReduction(String opName, SameDiff sameDiff, SDVariable[] args, boolean inPlace, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomBoolReduction(String opName, SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomBoolReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims)BaseDynamicCustomBoolReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex)BaseDynamicCustomBoolReduction(SameDiff sameDiff, SDVariable[] args, boolean inPlace, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomBoolReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomBoolReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, int[] dimensions)BaseDynamicCustomBoolReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, int[] dimensions)BaseDynamicCustomBoolReduction(SameDiff sameDiff, SDVariable arg, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomIndexReduction(String opName, SameDiff sameDiff, SDVariable[] args, boolean inPlace, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomIndexReduction(String opName, SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomIndexReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims)BaseDynamicCustomIndexReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex)BaseDynamicCustomIndexReduction(SameDiff sameDiff, SDVariable[] args, boolean inPlace, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomIndexReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomIndexReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, int[] dimensions)BaseDynamicCustomIndexReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, int[] dimensions)BaseDynamicCustomIndexReduction(SameDiff sameDiff, SDVariable arg, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomLongReduction(String opName, SameDiff sameDiff, SDVariable[] args, boolean inPlace, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomLongReduction(String opName, SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomLongReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims)BaseDynamicCustomLongReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex)BaseDynamicCustomLongReduction(SameDiff sameDiff, SDVariable[] args, boolean inPlace, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomLongReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomLongReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, int[] dimensions)BaseDynamicCustomLongReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, int[] dimensions)BaseDynamicCustomLongReduction(SameDiff sameDiff, SDVariable arg, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomReduction(String opName, SameDiff sameDiff, SDVariable[] args, boolean inPlace, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomReduction(String opName, SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims)BaseDynamicCustomReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex)BaseDynamicCustomReduction(SameDiff sameDiff, SDVariable[] args, boolean inPlace, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BaseDynamicCustomReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, boolean isComplex, int[] dimensions)BaseDynamicCustomReduction(SameDiff sameDiff, SDVariable[] args, boolean keepDims, int[] dimensions)BaseDynamicCustomReduction(SameDiff sameDiff, SDVariable arg, boolean keepDims, boolean isComplex, boolean isEmptyReduce, int[] dimensions)BatchMmul(SameDiff sameDiff, SDVariable[] matrices, boolean transposeA, boolean transposeB)BatchMmul(SameDiff sameDiff, SDVariable[] matricesA, SDVariable[] matricesB, boolean transposeA, boolean transposeB)LogSumExp(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)LogSumExp(SameDiff sameDiff, SDVariable i_v, int[] dimensions) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.reduce.floating
Methods in org.nd4j.linalg.api.ops.impl.reduce.floating that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>AMean. doDiff(List<SDVariable> f1)List<SDVariable>Entropy. doDiff(List<SDVariable> f1)List<SDVariable>LogEntropy. doDiff(List<SDVariable> f1)List<SDVariable>Mean. doDiff(List<SDVariable> i_v1)List<SDVariable>Norm1. doDiff(List<SDVariable> grad)List<SDVariable>Norm2. doDiff(List<SDVariable> grad)List<SDVariable>NormMax. doDiff(List<SDVariable> grad)List<SDVariable>ShannonEntropy. doDiff(List<SDVariable> f1)List<SDVariable>SquaredNorm. doDiff(List<SDVariable> grad)static List<SDVariable>Entropy. grad(SameDiff sd, SDVariable arg, SDVariable grad, int[] dimensions)Methods in org.nd4j.linalg.api.ops.impl.reduce.floating with parameters of type SDVariable Modifier and Type Method Description static List<SDVariable>Entropy. grad(SameDiff sd, SDVariable arg, SDVariable grad, int[] dimensions)Method parameters in org.nd4j.linalg.api.ops.impl.reduce.floating with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>AMean. doDiff(List<SDVariable> f1)List<SDVariable>Entropy. doDiff(List<SDVariable> f1)List<SDVariable>LogEntropy. doDiff(List<SDVariable> f1)List<SDVariable>Mean. doDiff(List<SDVariable> i_v1)List<SDVariable>Norm1. doDiff(List<SDVariable> grad)List<SDVariable>Norm2. doDiff(List<SDVariable> grad)List<SDVariable>NormMax. doDiff(List<SDVariable> grad)List<SDVariable>ShannonEntropy. doDiff(List<SDVariable> f1)List<SDVariable>SquaredNorm. doDiff(List<SDVariable> grad)Constructors in org.nd4j.linalg.api.ops.impl.reduce.floating with parameters of type SDVariable Constructor Description AMean(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)AMean(SameDiff sameDiff, SDVariable i_v, boolean keepDims, SDVariable dimensions)AMean(SameDiff sameDiff, SDVariable i_v, int[] dimensions)AMean(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)AMean(SameDiff sameDiff, SDVariable input, SDVariable dimensions)AMean(SameDiff sameDiff, SDVariable input, SDVariable dimensions, boolean keepDims)AMean(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)AMean(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)Entropy(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)Entropy(SameDiff sameDiff, SDVariable i_v, boolean keepDims, SDVariable dimensions)Entropy(SameDiff sameDiff, SDVariable i_v, int[] dimensions)Entropy(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)Entropy(SameDiff sameDiff, SDVariable input, SDVariable dimensions)Entropy(SameDiff sameDiff, SDVariable input, SDVariable dimensions, boolean keepDims)Entropy(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)Entropy(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)LogEntropy(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)LogEntropy(SameDiff sameDiff, SDVariable i_v, boolean keepDims, SDVariable dimensions)LogEntropy(SameDiff sameDiff, SDVariable i_v, int[] dimensions)LogEntropy(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)LogEntropy(SameDiff sameDiff, SDVariable input, SDVariable dimensions)LogEntropy(SameDiff sameDiff, SDVariable input, SDVariable dimensions, boolean keepDims)LogEntropy(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)LogEntropy(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)Mean(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)Mean(SameDiff sameDiff, SDVariable i_v, boolean keepDims, SDVariable dimensions)Mean(SameDiff sameDiff, SDVariable input, int... dimensions)Mean(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)Mean(SameDiff sameDiff, SDVariable input, SDVariable dimensions)Mean(SameDiff sameDiff, SDVariable input, SDVariable dimensions, boolean keepDims)Mean(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)Mean(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)Norm1(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)Norm1(SameDiff sameDiff, SDVariable i_v, boolean keepDims, SDVariable dimensions)Norm1(SameDiff sameDiff, SDVariable input, int... dimensions)Norm1(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)Norm1(SameDiff sameDiff, SDVariable input, SDVariable dimensions)Norm1(SameDiff sameDiff, SDVariable input, SDVariable dimensions, boolean keepDims)Norm1(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)Norm1(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)Norm2(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)Norm2(SameDiff sameDiff, SDVariable i_v, boolean keepDims, SDVariable dimensions)Norm2(SameDiff sameDiff, SDVariable input, int... dimensions)Norm2(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)Norm2(SameDiff sameDiff, SDVariable input, SDVariable dimensions)Norm2(SameDiff sameDiff, SDVariable input, SDVariable dimensions, boolean keepDims)Norm2(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)Norm2(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)NormMax(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)NormMax(SameDiff sameDiff, SDVariable i_v, boolean keepDims, SDVariable dimensions)NormMax(SameDiff sameDiff, SDVariable input, int... dimensions)NormMax(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)NormMax(SameDiff sameDiff, SDVariable input, SDVariable dimensions)NormMax(SameDiff sameDiff, SDVariable input, SDVariable dimensions, boolean keepDims)NormMax(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)NormMax(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)ShannonEntropy(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)ShannonEntropy(SameDiff sameDiff, SDVariable i_v, boolean keepDims, SDVariable dimensions)ShannonEntropy(SameDiff sameDiff, SDVariable i_v, int[] dimensions)ShannonEntropy(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)ShannonEntropy(SameDiff sameDiff, SDVariable input, SDVariable dimensions)ShannonEntropy(SameDiff sameDiff, SDVariable input, SDVariable dimensions, boolean keepDims)ShannonEntropy(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)ShannonEntropy(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)SquaredNorm(SameDiff sameDiff, SDVariable input, boolean keepDims, int... dimensions)SquaredNorm(SameDiff sameDiff, SDVariable i_v, boolean keepDims, SDVariable dimensions)SquaredNorm(SameDiff sameDiff, SDVariable input, int... dimensions)SquaredNorm(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)SquaredNorm(SameDiff sameDiff, SDVariable input, SDVariable dimensions)SquaredNorm(SameDiff sameDiff, SDVariable input, SDVariable dimensions, boolean keepDims)SquaredNorm(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)SquaredNorm(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.reduce.longer
Methods in org.nd4j.linalg.api.ops.impl.reduce.longer that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>CountNonZero. doDiff(List<SDVariable> f1)List<SDVariable>CountZero. doDiff(List<SDVariable> f1)List<SDVariable>MatchCondition. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.reduce.longer with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>CountNonZero. doDiff(List<SDVariable> f1)List<SDVariable>CountZero. doDiff(List<SDVariable> f1)List<SDVariable>MatchCondition. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.impl.reduce.longer with parameters of type SDVariable Constructor Description CountNonZero(SameDiff sameDiff, SDVariable i_v)CountNonZero(SameDiff sameDiff, SDVariable i_v, boolean keepDims)CountNonZero(SameDiff sd, SDVariable in, boolean keepDims, int[] dimensions)CountNonZero(SameDiff sameDiff, SDVariable input, int... dimensions)CountNonZero(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)CountNonZero(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)CountNonZero(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)CountNonZero(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)CountNonZero(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)CountNonZero(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)CountZero(SameDiff sameDiff, SDVariable i_v)CountZero(SameDiff sameDiff, SDVariable i_v, boolean keepDims)CountZero(SameDiff sd, SDVariable in, boolean keepDims, int[] dimensions)CountZero(SameDiff sameDiff, SDVariable input, int... dimensions)CountZero(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)CountZero(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)CountZero(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)CountZero(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)CountZero(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)CountZero(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)MatchCondition(SameDiff sameDiff, SDVariable i_v, boolean keepDims, double compare)MatchCondition(SameDiff sameDiff, SDVariable i_v, boolean keepDims, double compare, double eps)MatchCondition(SameDiff sameDiff, SDVariable i_v, boolean keepDims, double compare, double eps, int mode)MatchCondition(SameDiff sameDiff, SDVariable i_v, double compare)MatchCondition(SameDiff sameDiff, SDVariable i_v, double compare, double eps)MatchCondition(SameDiff sameDiff, SDVariable i_v, double compare, double eps, int mode)MatchCondition(SameDiff sameDiff, SDVariable input, double compare, double eps, int... dimensions)MatchCondition(SameDiff sameDiff, SDVariable input, double compare, double eps, int mode, int... dimensions)MatchCondition(SameDiff sameDiff, SDVariable input, double compare, int... dimensions)MatchCondition(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims, double compare)MatchCondition(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims, double compare, double eps)MatchCondition(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims, double compare, double eps, int mode)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims, double compare)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims, double compare, double eps)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims, double compare, double eps, int mode)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, double compare)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, double compare, double eps)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, double compare, double eps, int mode)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims, double compare)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims, double compare, double eps)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims, double compare, double eps, int mode)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, double compare)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, double compare, double eps)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, double compare, double eps, int mode)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions, double compare)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions, double compare, double eps)MatchCondition(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions, double compare, double eps, int mode)MatchCondition(SameDiff sameDiff, SDVariable in, Condition condition)MatchCondition(SameDiff sameDiff, SDVariable in, Condition condition, boolean keepDims, int... dimensions) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.reduce.same
Methods in org.nd4j.linalg.api.ops.impl.reduce.same that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>AMax. doDiff(List<SDVariable> f1)List<SDVariable>AMin. doDiff(List<SDVariable> f1)List<SDVariable>ASum. doDiff(List<SDVariable> f1)List<SDVariable>Max. doDiff(List<SDVariable> grad)List<SDVariable>Min. doDiff(List<SDVariable> grad)List<SDVariable>Prod. doDiff(List<SDVariable> grad)List<SDVariable>Sum. doDiff(List<SDVariable> i_v1)Method parameters in org.nd4j.linalg.api.ops.impl.reduce.same with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>AMax. doDiff(List<SDVariable> f1)List<SDVariable>AMin. doDiff(List<SDVariable> f1)List<SDVariable>ASum. doDiff(List<SDVariable> f1)List<SDVariable>Max. doDiff(List<SDVariable> grad)List<SDVariable>Min. doDiff(List<SDVariable> grad)List<SDVariable>Prod. doDiff(List<SDVariable> grad)List<SDVariable>Sum. doDiff(List<SDVariable> i_v1)Constructors in org.nd4j.linalg.api.ops.impl.reduce.same with parameters of type SDVariable Constructor Description AMax(SameDiff sameDiff, SDVariable i_v)AMax(SameDiff sameDiff, SDVariable i_v, boolean keepDims)AMax(SameDiff sd, SDVariable in, boolean keepDims, int[] dimensions)AMax(SameDiff sameDiff, SDVariable i_v, int[] dimensions)AMax(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)AMax(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)AMax(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)AMax(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)AMax(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)AMax(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)AMin(SameDiff sameDiff, SDVariable i_v)AMin(SameDiff sameDiff, SDVariable i_v, boolean keepDims)AMin(SameDiff sd, SDVariable in, boolean keepDims, int[] dimensions)AMin(SameDiff sameDiff, SDVariable i_v, int[] dimensions)AMin(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)AMin(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)AMin(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)AMin(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)AMin(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)AMin(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)ASum(SameDiff sameDiff, SDVariable i_v)ASum(SameDiff sameDiff, SDVariable i_v, boolean keepDims)ASum(SameDiff sd, SDVariable in, boolean keepDims, int[] dimensions)ASum(SameDiff sameDiff, SDVariable i_v, int[] dimensions)ASum(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)ASum(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)ASum(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)ASum(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)ASum(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)ASum(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)Max(SameDiff sameDiff, SDVariable i_v)Max(SameDiff sameDiff, SDVariable i_v, boolean keepDims)Max(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)Max(SameDiff sameDiff, SDVariable input, int... dimensions)Max(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)Max(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)Max(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)Max(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)Max(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)Max(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)Min(SameDiff sameDiff, SDVariable i_v)Min(SameDiff sameDiff, SDVariable i_v, boolean keepDims)Min(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)Min(SameDiff sameDiff, SDVariable input, int... dimensions)Min(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)Min(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)Min(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)Min(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)Min(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)Min(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)Prod(SameDiff sameDiff, SDVariable i_v)Prod(SameDiff sameDiff, SDVariable i_v, boolean keepDims)Prod(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)Prod(SameDiff sameDiff, SDVariable input, int... dimensions)Prod(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)Prod(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)Prod(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)Prod(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)Prod(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)Prod(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)Sum(SameDiff sameDiff, SDVariable i_v)Sum(SameDiff sameDiff, SDVariable i_v, boolean keepDims)Sum(SameDiff sameDiff, SDVariable i_v, boolean keepDims, int[] dimensions)Sum(SameDiff sameDiff, SDVariable input, int... dimensions)Sum(SameDiff sameDiff, SDVariable input, int[] dimensions, boolean keepDims)Sum(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)Sum(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims)Sum(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)Sum(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims)Sum(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.reduce3
Methods in org.nd4j.linalg.api.ops.impl.reduce3 that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>CosineDistance. doDiff(List<SDVariable> i_v1)List<SDVariable>CosineSimilarity. doDiff(List<SDVariable> i_v1)static List<SDVariable>CosineSimilarity. doDiff(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable gradOut, boolean keepDims, int... dimensions)List<SDVariable>Dot. doDiff(List<SDVariable> f1)List<SDVariable>EqualsWithEps. doDiff(List<SDVariable> f1)List<SDVariable>EuclideanDistance. doDiff(List<SDVariable> i_v1)List<SDVariable>HammingDistance. doDiff(List<SDVariable> f1)List<SDVariable>JaccardDistance. doDiff(List<SDVariable> f1)List<SDVariable>ManhattanDistance. doDiff(List<SDVariable> i_v1)Methods in org.nd4j.linalg.api.ops.impl.reduce3 with parameters of type SDVariable Modifier and Type Method Description static List<SDVariable>CosineSimilarity. doDiff(SameDiff sameDiff, SDVariable x, SDVariable y, SDVariable gradOut, boolean keepDims, int... dimensions)Method parameters in org.nd4j.linalg.api.ops.impl.reduce3 with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>CosineDistance. doDiff(List<SDVariable> i_v1)List<SDVariable>CosineSimilarity. doDiff(List<SDVariable> i_v1)List<SDVariable>Dot. doDiff(List<SDVariable> f1)List<SDVariable>EqualsWithEps. doDiff(List<SDVariable> f1)List<SDVariable>EuclideanDistance. doDiff(List<SDVariable> i_v1)List<SDVariable>HammingDistance. doDiff(List<SDVariable> f1)List<SDVariable>JaccardDistance. doDiff(List<SDVariable> f1)List<SDVariable>ManhattanDistance. doDiff(List<SDVariable> i_v1)Constructors in org.nd4j.linalg.api.ops.impl.reduce3 with parameters of type SDVariable Constructor Description BaseReduce3Op(SameDiff sameDiff, SDVariable i_v, int[] dimensions)BaseReduce3Op(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions)BaseReduce3Op(SameDiff sd, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int[] dimensions)BaseReduce3Op(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int... dimensions)BaseReduce3Op(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)CosineDistance(SameDiff sameDiff, SDVariable i_v, int[] dimensions)CosineDistance(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions)CosineDistance(SameDiff sd, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int[] dimensions)CosineDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int... dimensions)CosineDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)CosineSimilarity(SameDiff sameDiff, SDVariable i_v, int[] dimensions)CosineSimilarity(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions)CosineSimilarity(SameDiff sd, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int[] dimensions)CosineSimilarity(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)CosineSimilarity(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)Dot(SameDiff sameDiff, SDVariable i_v, int[] dimensions)Dot(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions)Dot(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int... dimensions)Dot(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)EqualsWithEps(SameDiff sameDiff, SDVariable i_v, int[] dimensions)EqualsWithEps(SameDiff sameDiff, SDVariable i_v, int[] dimensions, double eps)EqualsWithEps(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions)EqualsWithEps(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, double eps)EqualsWithEps(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, double eps, int... dimensions)EqualsWithEps(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int... dimensions)EqualsWithEps(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, double eps)EqualsWithEps(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)EqualsWithEps(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions, double eps)EuclideanDistance(SameDiff sameDiff, SDVariable i_v, int[] dimensions)EuclideanDistance(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions)EuclideanDistance(SameDiff sd, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int[] dimensions)EuclideanDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions)EuclideanDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)HammingDistance(SameDiff sameDiff, SDVariable i_v, int[] dimensions)HammingDistance(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions)HammingDistance(SameDiff sd, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int[] dimensions)HammingDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int... dimensions)HammingDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)JaccardDistance(SameDiff sameDiff, SDVariable i_v, int[] dimensions)JaccardDistance(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions)JaccardDistance(SameDiff sd, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int[] dimensions)JaccardDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int... dimensions)JaccardDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions)ManhattanDistance(SameDiff sameDiff, SDVariable i_v, int[] dimensions)ManhattanDistance(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions)ManhattanDistance(SameDiff sd, SDVariable x, SDVariable y, boolean keepDims, boolean isComplex, int[] dimensions)ManhattanDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int... dimensions)ManhattanDistance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.scalar
Constructors in org.nd4j.linalg.api.ops.impl.scalar with parameters of type SDVariable Constructor Description LeakyReLU(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double alpha)LeakyReLU(SameDiff sameDiff, SDVariable i_v, double alpha)LeakyReLU(SameDiff sameDiff, SDVariable i_v, Number scalar)LeakyReLU(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double alpha)LogX(SameDiff sameDiff, SDVariable i_v, double base)Pow(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double pow)Pow(SameDiff sameDiff, SDVariable i_v, double pow)Pow(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double pow)PowDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double pow)PRelu(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable alpha, @lombok.NonNull int... sharedAxes)RectifiedLinear(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double cutoff)RectifiedLinear(SameDiff sameDiff, SDVariable i_v, double cutoff)RectifiedLinearDerivative(SameDiff sd, SDVariable input, SDVariable gradient)Relu6(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double cutoff)Relu6(SameDiff sameDiff, SDVariable i_v, double cutoff)ReplaceNans(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double set)ReplaceNans(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, double set)ScalarAdd(@NonNull SameDiff sameDiff, @NonNull SDVariable i_v, Number scalar)ScalarAdd(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarAdd(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)ScalarAdd(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)ScalarDivision(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarDivision(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarFMod(SameDiff sd, SDVariable in, Number number)ScalarMax(SameDiff sd, SDVariable in, Number number)ScalarMin(SameDiff sd, SDVariable in, Number number)ScalarMultiplication(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarMultiplication(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarRemainder(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarRemainder(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarReverseDivision(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarReverseDivision(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarReverseSubtraction(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarReverseSubtraction(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarSet(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarSet(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarSubtraction(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarSubtraction(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)Step(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double cutoff)Step(SameDiff sameDiff, SDVariable i_v, double cutoff) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.scalar.comparison
Methods in org.nd4j.linalg.api.ops.impl.scalar.comparison that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>ScalarAnd. doDiff(List<SDVariable> f1)List<SDVariable>ScalarEps. doDiff(List<SDVariable> f1)List<SDVariable>ScalarEquals. doDiff(List<SDVariable> f1)List<SDVariable>ScalarGreaterThan. doDiff(List<SDVariable> f1)List<SDVariable>ScalarGreaterThanOrEqual. doDiff(List<SDVariable> f1)List<SDVariable>ScalarLessThan. doDiff(List<SDVariable> f1)List<SDVariable>ScalarLessThanOrEqual. doDiff(List<SDVariable> f1)List<SDVariable>ScalarNot. doDiff(List<SDVariable> f1)List<SDVariable>ScalarNotEquals. doDiff(List<SDVariable> f1)List<SDVariable>ScalarOr. doDiff(List<SDVariable> f1)List<SDVariable>ScalarSetValue. doDiff(List<SDVariable> f1)List<SDVariable>ScalarXor. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.scalar.comparison with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>ScalarAnd. doDiff(List<SDVariable> f1)List<SDVariable>ScalarEps. doDiff(List<SDVariable> f1)List<SDVariable>ScalarEquals. doDiff(List<SDVariable> f1)List<SDVariable>ScalarGreaterThan. doDiff(List<SDVariable> f1)List<SDVariable>ScalarGreaterThanOrEqual. doDiff(List<SDVariable> f1)List<SDVariable>ScalarLessThan. doDiff(List<SDVariable> f1)List<SDVariable>ScalarLessThanOrEqual. doDiff(List<SDVariable> f1)List<SDVariable>ScalarNot. doDiff(List<SDVariable> f1)List<SDVariable>ScalarNotEquals. doDiff(List<SDVariable> f1)List<SDVariable>ScalarOr. doDiff(List<SDVariable> f1)List<SDVariable>ScalarSetValue. doDiff(List<SDVariable> f1)List<SDVariable>ScalarXor. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.impl.scalar.comparison with parameters of type SDVariable Constructor Description ScalarAnd(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarAnd(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarEps(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarEps(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarEquals(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarEquals(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarGreaterThan(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarGreaterThan(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarGreaterThan(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)ScalarGreaterThan(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)ScalarGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)ScalarGreaterThanOrEqual(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)ScalarLessThan(SameDiff sameDiff, SDVariable i_v, double scalar)ScalarLessThan(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarLessThanOrEqual(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarNot(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarNot(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarNotEquals(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarNotEquals(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarOr(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarOr(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarSetValue(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarSetValue(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace)ScalarSetValue(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace, Object[] extraArgs)ScalarSetValue(SameDiff sameDiff, SDVariable i_v, Number scalar, Object[] extraArgs)ScalarXor(SameDiff sameDiff, SDVariable i_v, Number scalar)ScalarXor(SameDiff sameDiff, SDVariable i_v, Number scalar, boolean inPlace) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.scatter
Methods in org.nd4j.linalg.api.ops.impl.scatter that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>ScatterAdd. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterDiv. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterMax. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterMin. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterMul. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterNd. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterNdAdd. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterNdSub. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterNdUpdate. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterSub. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterUpdate. doDiff(List<SDVariable> gradOut)Method parameters in org.nd4j.linalg.api.ops.impl.scatter with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>ScatterAdd. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterDiv. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterMax. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterMin. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterMul. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterNd. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterNdAdd. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterNdSub. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterNdUpdate. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterSub. doDiff(List<SDVariable> gradOut)List<SDVariable>ScatterUpdate. doDiff(List<SDVariable> gradOut) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.shape
Methods in org.nd4j.linalg.api.ops.impl.shape that return SDVariable Modifier and Type Method Description static SDVariableCreateView. createAll(SameDiff sameDiff)SeeCreateView.createAll(SameDiff, String)for more informationstatic SDVariableCreateView. createAll(SameDiff sameDiff, String name)Create anSDVariablerepresenting anSDIndex.all()variable.static SDVariableCreateView. createInterval(SameDiff sameDiff, long start, long end, long stride, long inclusive)SeeCreateView.createInterval(SameDiff, String, long, long, long, long)for more information.static SDVariableCreateView. createInterval(SameDiff sameDiff, String name, long start, long end, long stride, long inclusive)Create an interval representingSDIndex.interval(Long, Long)static SDVariableCreateView. createInterval(SameDiff sameDiff, String name, SDVariable start, SDVariable end, SDVariable stride, SDVariable inclusive)Create an interval representingSDIndex.interval(Long, Long)static SDVariableCreateView. createInterval(SameDiff sameDiff, SDVariable intervalInputBegin, SDVariable intervalInputEnd, SDVariable intervalStrideInput, SDVariable inclusive)static SDVariableCreateView. createNewAxis(SameDiff sameDiff)SeeCreateView.createNewAxis(SameDiff,String)for more information.static SDVariableCreateView. createNewAxis(SameDiff sameDiff, String name)Create anSDVariablerepresenting a new axis which creates a new index of length 1 in the specified inputstatic SDVariableCreateView. createPoint(SameDiff sameDiff, long offset)SeeCreateView.createPoint(SameDiff,String,long)for mroe information.static SDVariableCreateView. createPoint(SameDiff sameDiff, String name, long offset)Create aSDVariablerepresenting a point array with the specified name.static SDVariableCreateView. createPoint(SameDiff sameDiff, String name, SDVariable offset)Create aSDVariablerepresenting a point array with the specified name.static SDVariableCreateView. createPoint(SameDiff sameDiff, SDVariable offset)SeeCreateView.createPoint(SameDiff,String,long)for mroe information.Methods in org.nd4j.linalg.api.ops.impl.shape with parameters of type SDVariable Modifier and Type Method Description static SDVariableCreateView. createInterval(SameDiff sameDiff, String name, SDVariable start, SDVariable end, SDVariable stride, SDVariable inclusive)Create an interval representingSDIndex.interval(Long, Long)static SDVariableCreateView. createInterval(SameDiff sameDiff, SDVariable intervalInputBegin, SDVariable intervalInputEnd, SDVariable intervalStrideInput, SDVariable inclusive)static SDVariableCreateView. createPoint(SameDiff sameDiff, String name, SDVariable offset)Create aSDVariablerepresenting a point array with the specified name.static SDVariableCreateView. createPoint(SameDiff sameDiff, SDVariable offset)SeeCreateView.createPoint(SameDiff,String,long)for mroe information.Constructors in org.nd4j.linalg.api.ops.impl.shape with parameters of type SDVariable Constructor Description BroadcastDynamicShape(SameDiff sameDiff, SDVariable in, SDVariable shape)Concat(SameDiff sameDiff, int concatDimension, SDVariable... inputs)Concat(SameDiff sameDiff, SDVariable[] inputs, int concatDimension)ConfusionMatrix(SameDiff sameDiff, SDVariable labels, SDVariable pred, Integer numClasses)ConfusionMatrix(SameDiff sameDiff, SDVariable labels, SDVariable pred, Integer numClasses, SDVariable weights)ConfusionMatrix(SameDiff sameDiff, SDVariable labels, SDVariable pred, SDVariable weights)ConfusionMatrix(SameDiff sameDiff, SDVariable labels, SDVariable pred, SDVariable weights, Integer numClasses)ConfusionMatrix(SameDiff sameDiff, SDVariable labels, SDVariable pred, SDVariable weights, DataType dataType)ConfusionMatrix(SameDiff sameDiff, SDVariable labels, SDVariable pred, DataType dataType)Create(String name, SameDiff sameDiff, SDVariable input, boolean initialize)Create(String name, SameDiff sameDiff, SDVariable input, char order, boolean initialize, DataType dataType)Create(SameDiff sd, SDVariable shape, DataType dataType)Create(SameDiff sd, SDVariable shape, DataType dataType, String order, boolean initialize)CreateView(SameDiff sameDiff, SDVariable[] args)CreateView(SameDiff sd, SDVariable input, SDVariable[] indices)Cross(SameDiff sameDiff, SDVariable[] args)Cross(SameDiff sameDiff, SDVariable a, SDVariable b)Diag(SameDiff sameDiff, SDVariable input)Diag(SameDiff sameDiff, SDVariable[] args, boolean inPlace)DiagPart(SameDiff sameDiff, SDVariable in)DiagPart(SameDiff sameDiff, SDVariable[] args, boolean inPlace)ExpandDims(SameDiff sameDiff, SDVariable[] args)ExpandDims(SameDiff sameDiff, SDVariable[] args, boolean inPlace)ExpandDims(SameDiff sameDiff, SDVariable[] args, int axis)ExpandDims(SameDiff sameDiff, SDVariable args, int axis)Eye(SameDiff sameDiff, SDVariable numRows)Eye(SameDiff sameDiff, SDVariable numRows, SDVariable numCols)Eye(SameDiff sameDiff, SDVariable numRows, SDVariable numCols, SDVariable batch_shape)Eye(SameDiff sameDiff, SDVariable numRows, SDVariable numCols, DataType dataType, int[] batchDimension)Flatten2D(SameDiff sameDiff, SDVariable i_v, long axis)Gather(SameDiff sameDiff, SDVariable df, int[] indices, int axis)Gather(SameDiff sameDiff, SDVariable input, int[] indices, int axis, boolean inPlace)Gather(SameDiff sameDiff, SDVariable df, SDVariable indices, int axis)Gather(SameDiff sameDiff, SDVariable input, SDVariable indices, int axis, boolean inPlace)GatherNd(SameDiff sameDiff, SDVariable input, SDVariable indices)Linspace(SameDiff sameDiff, SDVariable from, SDVariable to, SDVariable length, DataType dataType)MergeAvg(SameDiff sameDiff, SDVariable... inputs)MergeMax(SameDiff sameDiff, SDVariable... inputs)MergeMaxIndex(@NonNull SameDiff sameDiff, @NonNull SDVariable... inputs)MergeMaxIndex(@NonNull SameDiff sd, @NonNull SDVariable[] x, @NonNull DataType dataType)MergeSum(SameDiff sameDiff, SDVariable... inputs)MeshGrid(SameDiff sd, boolean cartesian, SDVariable... inputs)MeshGrid(SameDiff sd, SDVariable[] inputs, boolean cartesian)OneHot(SameDiff sameDiff, SDVariable indices, int depth)OneHot(SameDiff sameDiff, SDVariable indices, int depth, int axis, double on, double off, DataType dataType)OnesAs(String name, SameDiff sameDiff, SDVariable input)OnesAs(String name, SameDiff sameDiff, SDVariable input, DataType dataType)OnesAs(SameDiff sameDiff, SDVariable input)OnesAs(SameDiff sameDiff, SDVariable input, DataType dataType)OnesLike(String name, SameDiff sameDiff, SDVariable input)OnesLike(String name, SameDiff sameDiff, SDVariable input, DataType dataType)OnesLike(SameDiff sameDiff, SDVariable input)OnesLike(SameDiff sameDiff, SDVariable input, DataType dataType)ParallelStack(SameDiff sameDiff, SDVariable[] values)Permute(SameDiff sameDiff, SDVariable i_v, int... permuteDims)Permute(SameDiff sd, SDVariable input, SDVariable permuteDims)Rank(SameDiff sameDiff, SDVariable input)Rank(SameDiff sameDiff, SDVariable input, boolean inPlace)ReductionShape(@NonNull SameDiff sameDiff, @NonNull SDVariable shape, @NonNull SDVariable axis, boolean keepDims)Repeat(SameDiff sameDiff, SDVariable[] args, boolean inPlace, int axis)Repeat(SameDiff sameDiff, SDVariable[] args, int axis)Repeat(SameDiff sd, SDVariable input, SDVariable repeats, int axis)Reshape(SameDiff sameDiff, SDVariable i_v, long[] shape)Reshape(SameDiff sameDiff, SDVariable i_v, SDVariable shape)SequenceMask(SameDiff sameDiff, SDVariable input, int maxLen, DataType dataType)SequenceMask(SameDiff sameDiff, SDVariable input, SDVariable maxLen, DataType dataType)SequenceMask(SameDiff sameDiff, SDVariable input, DataType dataType)SetShape(SameDiff sameDiff, SDVariable input, SDVariable shape)SetShape(SameDiff sameDiff, SDVariable input, SDVariable shape, boolean inPlace)Shape(SameDiff sameDiff, SDVariable input)Shape(SameDiff sameDiff, SDVariable input, boolean inPlace)ShapeN(SameDiff sameDiff, SDVariable[] inputs, boolean inPlace)Size(SameDiff sameDiff, SDVariable input)SizeAt(SameDiff sameDiff, SDVariable input, int dimension)Slice(SameDiff sameDiff, @NonNull SDVariable input, @lombok.NonNull int[] begin, @lombok.NonNull int[] size)Slice(SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable begin, @NonNull SDVariable end)Split(SameDiff sameDiff, SDVariable input, int numSplit, int splitDim)Split(SameDiff sd, SDVariable input, SDVariable numSplit, int splitDim)SplitV(SameDiff sd, SDVariable input, SDVariable sizes, int numSplit, int splitDim)Squeeze(SameDiff sameDiff, SDVariable arg, int squeezeDims)Squeeze(SameDiff sameDiff, SDVariable arg, int[] squeezeDims)Stack(SameDiff sameDiff, SDVariable[] values, int axis)Stack(SameDiff sameDiff, SDVariable values, int axis)StridedSlice(SameDiff sameDiff, SDVariable in, @lombok.NonNull int[] begin, @lombok.NonNull int[] end, @lombok.NonNull int[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)StridedSlice(SameDiff sameDiff, SDVariable in, @lombok.NonNull long[] begin, @lombok.NonNull long[] end, @lombok.NonNull long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)StridedSlice(SameDiff sameDiff, SDVariable in, int[] begin, int[] end, int[] strides)StridedSlice(SameDiff sameDiff, SDVariable in, long[] begin, long[] end, long[] strides)StridedSlice(SameDiff sd, SDVariable in, SDVariable begin, SDVariable end, SDVariable strides)StridedSlice(SameDiff sd, SDVariable in, SDVariable begin, SDVariable end, SDVariable strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)Tile(SameDiff sameDiff, SDVariable i_v, int[] axis)Tile(SameDiff sameDiff, SDVariable i_v, SDVariable axis)Transpose(SameDiff sameDiff, SDVariable i_v)Transpose(SameDiff sameDiff, SDVariable in, int[] permuteDims)Transpose(SameDiff sameDiff, SDVariable in, SDVariable permuteDims)Unstack(SameDiff sameDiff, SDVariable value, int axis)Unstack(SameDiff sameDiff, SDVariable value, int axis, int num)ZerosLike(String name, SameDiff sameDiff, SDVariable input)ZerosLike(String name, SameDiff sameDiff, SDVariable input, boolean inPlace)ZerosLike(String name, SameDiff sameDiff, SDVariable input, boolean inPlace, DataType dataType)ZerosLike(String name, SameDiff sameDiff, SDVariable input, DataType dataType)ZerosLike(SameDiff sameDiff, SDVariable input) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.shape.bp
Methods in org.nd4j.linalg.api.ops.impl.shape.bp that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>SliceBp. doDiff(List<SDVariable> i_v)List<SDVariable>StridedSliceBp. doDiff(List<SDVariable> i_v)List<SDVariable>TileBp. doDiff(List<SDVariable> i_v)Method parameters in org.nd4j.linalg.api.ops.impl.shape.bp with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>SliceBp. doDiff(List<SDVariable> i_v)List<SDVariable>StridedSliceBp. doDiff(List<SDVariable> i_v)List<SDVariable>TileBp. doDiff(List<SDVariable> i_v)Constructors in org.nd4j.linalg.api.ops.impl.shape.bp with parameters of type SDVariable Constructor Description ConcatBp(@NonNull SameDiff sameDiff, int concatDimension, @NonNull SDVariable... inputsAndGrad)ConcatBp(@NonNull SameDiff sameDiff, @NonNull SDVariable... inputsGradAxis)MergeAvgBp(SameDiff sameDiff, @NonNull SDVariable[] inputs, @NonNull SDVariable gradO)MergeMaxBp(SameDiff sameDiff, @NonNull SDVariable[] inputs, @NonNull SDVariable gradO)SliceBp(SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable gradient, @lombok.NonNull int[] begin, @lombok.NonNull int[] size)SliceBp(SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable gradient, @NonNull SDVariable begin, @NonNull SDVariable size)StridedSliceBp(SameDiff sameDiff, @NonNull SDVariable in, @NonNull SDVariable grad, @lombok.NonNull long[] begin, @lombok.NonNull long[] end, @lombok.NonNull long[] strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)StridedSliceBp(SameDiff sameDiff, @NonNull SDVariable in, @NonNull SDVariable grad, @NonNull SDVariable begin, @NonNull SDVariable end, @NonNull SDVariable strides, int beginMask, int endMask, int ellipsisMask, int newAxisMask, int shrinkAxisMask)TileBp(SameDiff sameDiff, SDVariable in, SDVariable grad, int[] repeat)TileBp(SameDiff sameDiff, SDVariable in, SDVariable repeat, SDVariable grad) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.shape.tensorops
Fields in org.nd4j.linalg.api.ops.impl.shape.tensorops declared as SDVariable Modifier and Type Field Description protected SDVariableTensorArray. flowMethods in org.nd4j.linalg.api.ops.impl.shape.tensorops that return SDVariable Modifier and Type Method Description SDVariableTensorArray. concat(SDVariable flow)static SDVariableTensorArray. createEmpty(SameDiff sd, DataType dataType)Create an empty sequence with the specified data type.static SDVariableTensorArray. createEmpty(SameDiff sd, DataType dataType, String outputVarName)Create an empty sequence with the specified data type.static SDVariableTensorArray. createTensorArrayFrom(SameDiff sd, SDVariable[] inputs)Create anTensorArrayop from the given inputs, note this is the same as callingTensorArray.createTensorArrayFrom(SameDiff, SDVariable[],String)with null.static SDVariableTensorArray. createTensorArrayFrom(SameDiff sd, SDVariable[] inputs, String outputVarName)Create anTensorArrayop from the given inputsSDVariableTensorArray. gather(SDVariable flow, int... indices)SDVariableTensorArray. gather(SDVariable flow, SDVariable indices)SDVariableTensorArray. getVar()static SDVariableTensorArray. itemAtIndex(SameDiff sd, SDVariable[] inputs)Returns the item at the specified index in the specified list.static SDVariableTensorArray. itemAtIndex(SameDiff sd, SDVariable[] inputs, String outputVarName)Returns the item at the specified index in the specified list.SDVariableTensorArray. read(int index)SDVariableTensorArray. read(SDVariable index)SDVariableTensorArray. read(SDVariable from, SDVariable index)SDVariableTensorArray. remove(SDVariable value)SDVariableTensorArray. remove(SDVariable value, int idx)SDVariableTensorArray. remove(SDVariable value, SDVariable idx)static SDVariableTensorArray. removeFromTensorArray(SameDiff sameDiff, SDVariable inputSequence)Remove the last element from the relevantTensorArraystatic SDVariableTensorArray. removeFromTensorArray(SameDiff sameDiff, SDVariable inputSequence, SDVariable position)Remove an element from the relevantTensorArraystatic SDVariableTensorArray. removeFromTensorArray(SameDiff sameDiff, SDVariable inputSequence, SDVariable position, String outputVarName)Remove an element from the relevantTensorArraySDVariableTensorArray. scatter(SDVariable flow, SDVariable value, int... indices)SDVariableTensorArray. scatter(SDVariable flow, SDVariable value, SDVariable indices)SDVariableTensorArray. size(SDVariable value)static SDVariableTensorArray. sizeOfTensorArray(SameDiff sd, SDVariable sequence)Create an empty sequence with the specified data type.static SDVariableTensorArray. sizeOfTensorArray(SameDiff sd, SDVariable sequence, String outputVarName)Create an empty sequence with the specified data type.SDVariableTensorArray. stack(SDVariable flow)SDVariableTensorArray. unstack(SDVariable flow, SDVariable value)SDVariableTensorArray. write(SDVariable flow, int index, SDVariable value)SDVariableTensorArray. write(SDVariable flow, SDVariable index, SDVariable value)Methods in org.nd4j.linalg.api.ops.impl.shape.tensorops that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>BaseTensorOp. doDiff(List<SDVariable> f1)Methods in org.nd4j.linalg.api.ops.impl.shape.tensorops with parameters of type SDVariable Modifier and Type Method Description SDVariableTensorArray. concat(SDVariable flow)static SDVariableTensorArray. createTensorArrayFrom(SameDiff sd, SDVariable[] inputs)Create anTensorArrayop from the given inputs, note this is the same as callingTensorArray.createTensorArrayFrom(SameDiff, SDVariable[],String)with null.static SDVariableTensorArray. createTensorArrayFrom(SameDiff sd, SDVariable[] inputs, String outputVarName)Create anTensorArrayop from the given inputsSDVariableTensorArray. gather(SDVariable flow, int... indices)SDVariableTensorArray. gather(SDVariable flow, SDVariable indices)static TensorArrayTensorArray. getTensorArray(SameDiff sd, SDVariable sequenceVar)Get the associatedTensorArrayinstance related to this op.static SDVariableTensorArray. itemAtIndex(SameDiff sd, SDVariable[] inputs)Returns the item at the specified index in the specified list.static SDVariableTensorArray. itemAtIndex(SameDiff sd, SDVariable[] inputs, String outputVarName)Returns the item at the specified index in the specified list.SDVariableTensorArray. read(SDVariable index)SDVariableTensorArray. read(SDVariable from, SDVariable index)SDVariableTensorArray. remove(SDVariable value)SDVariableTensorArray. remove(SDVariable value, int idx)SDVariableTensorArray. remove(SDVariable value, SDVariable idx)static SDVariableTensorArray. removeFromTensorArray(SameDiff sameDiff, SDVariable inputSequence)Remove the last element from the relevantTensorArraystatic SDVariableTensorArray. removeFromTensorArray(SameDiff sameDiff, SDVariable inputSequence, SDVariable position)Remove an element from the relevantTensorArraystatic SDVariableTensorArray. removeFromTensorArray(SameDiff sameDiff, SDVariable inputSequence, SDVariable position, String outputVarName)Remove an element from the relevantTensorArraySDVariableTensorArray. scatter(SDVariable flow, SDVariable value, int... indices)SDVariableTensorArray. scatter(SDVariable flow, SDVariable value, SDVariable indices)SDVariableTensorArray. size(SDVariable value)static SDVariableTensorArray. sizeOfTensorArray(SameDiff sd, SDVariable sequence)Create an empty sequence with the specified data type.static SDVariableTensorArray. sizeOfTensorArray(SameDiff sd, SDVariable sequence, String outputVarName)Create an empty sequence with the specified data type.SDVariableTensorArray. stack(SDVariable flow)SDVariableTensorArray. unstack(SDVariable flow, SDVariable value)SDVariableTensorArray. write(SDVariable flow, int index, SDVariable value)SDVariableTensorArray. write(SDVariable flow, SDVariable index, SDVariable value)Method parameters in org.nd4j.linalg.api.ops.impl.shape.tensorops with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>BaseTensorOp. doDiff(List<SDVariable> f1) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.summarystats
Methods in org.nd4j.linalg.api.ops.impl.summarystats that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>StandardDeviation. doDiff(List<SDVariable> grad)List<SDVariable>Variance. doDiff(List<SDVariable> grad)Method parameters in org.nd4j.linalg.api.ops.impl.summarystats with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>StandardDeviation. doDiff(List<SDVariable> grad)List<SDVariable>Variance. doDiff(List<SDVariable> grad)Constructors in org.nd4j.linalg.api.ops.impl.summarystats with parameters of type SDVariable Constructor Description StandardDeviation(SameDiff sameDiff, SDVariable i_v, boolean biasCorrected, boolean keepDims, int[] dimensions)StandardDeviation(SameDiff sameDiff, SDVariable i_v, boolean keepDims, double mean)StandardDeviation(SameDiff sameDiff, SDVariable i_v, boolean keepDims, double mean, double bias)StandardDeviation(SameDiff sameDiff, SDVariable i_v, boolean keepDims, double mean, double bias, boolean biasCorrected)StandardDeviation(SameDiff sameDiff, SDVariable i_v, double mean)StandardDeviation(SameDiff sameDiff, SDVariable i_v, double mean, double bias)StandardDeviation(SameDiff sameDiff, SDVariable i_v, double mean, double bias, boolean biasCorrected)StandardDeviation(SameDiff sameDiff, SDVariable i_v, int[] dimensions, boolean keepDims, double mean)StandardDeviation(SameDiff sameDiff, SDVariable i_v, int[] dimensions, boolean keepDims, double mean, double bias)StandardDeviation(SameDiff sameDiff, SDVariable i_v, int[] dimensions, boolean keepDims, double mean, double bias, boolean biasCorrected)StandardDeviation(SameDiff sameDiff, SDVariable i_v, int[] dimensions, double mean)StandardDeviation(SameDiff sameDiff, SDVariable i_v, int[] dimensions, double mean, double bias)StandardDeviation(SameDiff sameDiff, SDVariable i_v, int[] dimensions, double mean, double bias, boolean biasCorrected)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims, double mean)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims, double mean, double bias)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims, double mean, double bias, boolean biasCorrected)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, double mean)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, double mean, double bias)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, double mean, double bias, boolean biasCorrected)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims, double mean)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims, double mean, double bias)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims, double mean, double bias, boolean biasCorrected)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, double mean)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, double mean, double bias)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, double mean, double bias, boolean biasCorrected)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions, double mean)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions, double mean, double bias)StandardDeviation(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions, double mean, double bias, boolean biasCorrected)Variance(SameDiff sameDiff, SDVariable i_v, boolean biasCorrected, boolean keepDims, int[] dimensions)Variance(SameDiff sameDiff, SDVariable i_v, boolean keepDims, double mean)Variance(SameDiff sameDiff, SDVariable i_v, boolean keepDims, double mean, double bias)Variance(SameDiff sameDiff, SDVariable i_v, boolean keepDims, double mean, double bias, boolean biasCorrected)Variance(SameDiff sameDiff, SDVariable i_v, double mean)Variance(SameDiff sameDiff, SDVariable i_v, double mean, double bias)Variance(SameDiff sameDiff, SDVariable i_v, double mean, double bias, boolean biasCorrected)Variance(SameDiff sameDiff, SDVariable i_v, int[] dimensions, boolean keepDims, double mean)Variance(SameDiff sameDiff, SDVariable i_v, int[] dimensions, boolean keepDims, double mean, double bias)Variance(SameDiff sameDiff, SDVariable i_v, int[] dimensions, boolean keepDims, double mean, double bias, boolean biasCorrected)Variance(SameDiff sameDiff, SDVariable i_v, int[] dimensions, double mean)Variance(SameDiff sameDiff, SDVariable i_v, int[] dimensions, double mean, double bias)Variance(SameDiff sameDiff, SDVariable i_v, int[] dimensions, double mean, double bias, boolean biasCorrected)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims, double mean)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims, double mean, double bias)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable dimensions, boolean keepDims, double mean, double bias, boolean biasCorrected)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, double mean)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, double mean, double bias)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, double mean, double bias, boolean biasCorrected)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims, double mean)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims, double mean, double bias)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, boolean keepDims, double mean, double bias, boolean biasCorrected)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, double mean)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, double mean, double bias)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, int[] dimensions, double mean, double bias, boolean biasCorrected)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions, double mean)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions, double mean, double bias)Variance(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2, SDVariable dimensions, double mean, double bias, boolean biasCorrected) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms
Methods in org.nd4j.linalg.api.ops.impl.transforms that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>Angle. doDiff(List<SDVariable> i_v)List<SDVariable>Assert. doDiff(List<SDVariable> f1)List<SDVariable>BinCount. doDiff(List<SDVariable> i_v)List<SDVariable>CheckNumerics. doDiff(List<SDVariable> f1)List<SDVariable>Cholesky. doDiff(List<SDVariable> f1)List<SDVariable>HistogramFixedWidth. doDiff(List<SDVariable> f1)List<SDVariable>IdentityN. doDiff(List<SDVariable> i_v)List<SDVariable>MaxOut. doDiff(List<SDVariable> f1)List<SDVariable>NthElement. doDiff(List<SDVariable> f1)List<SDVariable>Pad. doDiff(List<SDVariable> i_v)List<SDVariable>ReluLayer. doDiff(List<SDVariable> gradient)Method parameters in org.nd4j.linalg.api.ops.impl.transforms with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>Angle. doDiff(List<SDVariable> i_v)List<SDVariable>Assert. doDiff(List<SDVariable> f1)List<SDVariable>BinCount. doDiff(List<SDVariable> i_v)List<SDVariable>CheckNumerics. doDiff(List<SDVariable> f1)List<SDVariable>Cholesky. doDiff(List<SDVariable> f1)List<SDVariable>HistogramFixedWidth. doDiff(List<SDVariable> f1)List<SDVariable>IdentityN. doDiff(List<SDVariable> i_v)List<SDVariable>MaxOut. doDiff(List<SDVariable> f1)List<SDVariable>NthElement. doDiff(List<SDVariable> f1)List<SDVariable>Pad. doDiff(List<SDVariable> i_v)List<SDVariable>ReluLayer. doDiff(List<SDVariable> gradient)Constructors in org.nd4j.linalg.api.ops.impl.transforms with parameters of type SDVariable Constructor Description Angle(SameDiff sameDiff, SDVariable input)Assert(SameDiff sd, SDVariable x)BaseDynamicTransformOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)BinCount(SameDiff sd, SDVariable in, SDVariable weights, Integer minLength, Integer maxLength, DataType outputType)CheckNumerics(SameDiff sd, SDVariable input, SDVariable message)Cholesky(SameDiff sameDiff, SDVariable sdInput)HistogramFixedWidth(SameDiff sameDiff, SDVariable values, SDVariable valuesRange, SDVariable numBins)IdentityN(SameDiff sameDiff, SDVariable input)IdentityN(SameDiff sameDiff, SDVariable[] inputs)MaxOut(SameDiff sameDiff, SDVariable i_v, boolean inPlace, Number max)MaxOut(SameDiff sameDiff, SDVariable i_v, Object[] extraArgs, Number max)Pad(SameDiff sd, SDVariable in, SDVariable padding, double padValue)Pad(SameDiff sd, SDVariable input, SDVariable padding, Mode mode, double padValue)Pad(SameDiff sd, SDVariable in, SDVariable padding, PadMode mode, double padValue)Pad(SameDiff sd, SDVariable in, SDVariable padding, Pad.Mode mode, double padValue)ReluLayer(SameDiff sameDiff, SDVariable input, SDVariable weights, SDVariable bias) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.any
Methods in org.nd4j.linalg.api.ops.impl.transforms.any that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>Assign. doDiff(List<SDVariable> i_v)List<SDVariable>IsMax. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.transforms.any with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>Assign. doDiff(List<SDVariable> i_v)List<SDVariable>IsMax. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.impl.transforms.any with parameters of type SDVariable Constructor Description Assign(SameDiff sameDiff, SDVariable i_v, boolean inPlace)IsMax(SameDiff sameDiff, SDVariable i_v) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.bool
Methods in org.nd4j.linalg.api.ops.impl.transforms.bool that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>BooleanNot. doDiff(List<SDVariable> f1)List<SDVariable>IsFinite. doDiff(List<SDVariable> i_v)List<SDVariable>IsInf. doDiff(List<SDVariable> i_v)List<SDVariable>IsNaN. doDiff(List<SDVariable> i_v)List<SDVariable>MatchConditionTransform. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.transforms.bool with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>BooleanNot. doDiff(List<SDVariable> f1)List<SDVariable>IsFinite. doDiff(List<SDVariable> i_v)List<SDVariable>IsInf. doDiff(List<SDVariable> i_v)List<SDVariable>IsNaN. doDiff(List<SDVariable> i_v)List<SDVariable>MatchConditionTransform. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.impl.transforms.bool with parameters of type SDVariable Constructor Description BooleanNot(SameDiff sameDiff, SDVariable i_v)IsFinite(SameDiff sameDiff, SDVariable i_v)IsFinite(SameDiff sameDiff, SDVariable i_v, boolean inPlace)IsInf(SameDiff sameDiff, SDVariable i_v)IsInf(SameDiff sameDiff, SDVariable i_v, boolean inPlace)IsNaN(SameDiff sameDiff, SDVariable i_v)IsNaN(SameDiff sameDiff, SDVariable i_v, boolean inPlace)MatchConditionTransform(SameDiff sameDiff, SDVariable in, Condition condition) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.clip
Methods in org.nd4j.linalg.api.ops.impl.transforms.clip that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>ClipByAvgNorm. doDiff(List<SDVariable> grad)List<SDVariable>ClipByNorm. doDiff(List<SDVariable> grad)List<SDVariable>ClipByValue. doDiff(List<SDVariable> grad)Method parameters in org.nd4j.linalg.api.ops.impl.transforms.clip with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>ClipByAvgNorm. doDiff(List<SDVariable> grad)List<SDVariable>ClipByNorm. doDiff(List<SDVariable> grad)List<SDVariable>ClipByValue. doDiff(List<SDVariable> grad)Constructors in org.nd4j.linalg.api.ops.impl.transforms.clip with parameters of type SDVariable Constructor Description ClipByAvgNorm(SameDiff sameDiff, SDVariable x, double clipValue, int... dimensions)ClipByNorm(SameDiff sameDiff, SDVariable x, double clipValue, int... dimensions)ClipByNorm(SameDiff sd, SDVariable x, SDVariable clipValue, SDVariable dimensions)ClipByNormBp(SameDiff sameDiff, SDVariable x, SDVariable eps, double clipValue, int... dimensions)ClipByValue(SameDiff sameDiff, SDVariable x, double clipValueMin, double clipValueMax)ClipByValue(SameDiff sameDiff, SDVariable x, double clipValueMin, double clipValueMax, boolean inPlace)ClipByValue(SameDiff sd, SDVariable x, SDVariable clipValueMin, SDVariable clipValueMax) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.comparison
Methods in org.nd4j.linalg.api.ops.impl.transforms.comparison that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>CompareAndReplace. doDiff(List<SDVariable> grad)List<SDVariable>CompareAndSet. doDiff(List<SDVariable> gradient)List<SDVariable>Eps. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.transforms.comparison with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>CompareAndReplace. doDiff(List<SDVariable> grad)List<SDVariable>CompareAndSet. doDiff(List<SDVariable> gradient)List<SDVariable>Eps. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.impl.transforms.comparison with parameters of type SDVariable Constructor Description CompareAndReplace(SameDiff sameDiff, SDVariable to, SDVariable from, Condition condition)CompareAndSet(SameDiff sameDiff, SDVariable to, Number set, Condition condition)Eps(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)Eps(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)Eps(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, Object[] extraArgs) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.custom
Constructors in org.nd4j.linalg.api.ops.impl.transforms.custom with parameters of type SDVariable Constructor Description Assign(SameDiff sameDiff, SDVariable x, SDVariable y)ATan2(SameDiff sameDiff, SDVariable y, SDVariable x)BatchToSpace(SameDiff sameDiff, SDVariable[] args, int[] blocks, int[][] crops, boolean inPlace)BatchToSpace(SameDiff sameDiff, SDVariable x, int[] blocks, int[][] crops, boolean inPlace)BatchToSpace(SameDiff sameDiff, SDVariable x, int[] blocks, int[] croppingTop, int... croppingBottom)BatchToSpaceND(SameDiff sameDiff, SDVariable[] args, int[] blocks, int[][] crops, boolean inPlace)BitsHammingDistance(@NonNull SameDiff sd, @NonNull SDVariable x, @NonNull SDVariable y)BitwiseAnd(SameDiff sameDiff, SDVariable x, SDVariable y)BitwiseOr(SameDiff sameDiff, SDVariable x, SDVariable y)BitwiseXor(SameDiff sameDiff, SDVariable x, SDVariable y)Choose(String opName, SameDiff sameDiff, SDVariable[] args, boolean inPlace)Choose(SameDiff sameDiff, SDVariable[] args, Condition condition)CReLU(SameDiff sd, SDVariable input)CReluBp(SameDiff sd, SDVariable input, SDVariable epsilonNext)CumProd(SameDiff sameDiff, SDVariable x, boolean exclusive, boolean reverse, int... axis)CumProd(SameDiff sameDiff, SDVariable x, int... axis)CumSum(SameDiff sameDiff, SDVariable x, boolean exclusive, boolean reverse, int... axis)CumSum(SameDiff sameDiff, SDVariable x, int... axis)CyclicRShiftBits(SameDiff sameDiff, SDVariable x, SDVariable shift)CyclicShiftBits(SameDiff sameDiff, SDVariable x, SDVariable shift)Dilation2D(SameDiff sameDiff, SDVariable[] inputAndWeights, int[] strides, int[] rates, boolean isSameMode, boolean inPlace)Dilation2D(SameDiff sameDiff, SDVariable df, SDVariable weights, int[] strides, int[] rates, boolean isSameMode)DotProductAttention(SameDiff sameDiff, SDVariable queries, SDVariable keys, SDVariable values, SDVariable mask, boolean scaled, boolean withWeights)DotProductAttentionBp(SameDiff sameDiff, SDVariable queries, SDVariable keys, SDVariable values, SDVariable eps, SDVariable mask, boolean scaled)DynamicPartition(SameDiff sameDiff, SDVariable input, SDVariable[] partitions, int numPartitions)DynamicPartition(SameDiff sameDiff, SDVariable input, SDVariable partitions, int numPartitions)DynamicStitch(SameDiff sameDiff, SDVariable[] indices, SDVariable[] inputs)EqualTo(SameDiff sameDiff, SDVariable[] args, boolean inPlace)EqualTo(SameDiff sameDiff, SDVariable x, SDVariable y)FakeQuantWithMinMaxArgs(SameDiff sd, SDVariable input, float min, float max, boolean narrowRange, int numBits)FakeQuantWithMinMaxVars(SameDiff sd, SDVariable input, SDVariable min, SDVariable max, boolean narrowRange, int numBits)Fill(SameDiff sameDiff, SDVariable shape, DataType dtype, double value)GreaterThan(SameDiff sameDiff, SDVariable[] args, boolean inPlace)GreaterThan(SameDiff sameDiff, SDVariable x, SDVariable y)GreaterThanOrEqual(SameDiff sameDiff, SDVariable[] args, boolean inPlace)GreaterThanOrEqual(SameDiff sameDiff, SDVariable x, SDVariable y)InTopK(SameDiff sd, SDVariable predictions, SDVariable targets, int k)InvertPermutation(SameDiff sameDiff, SDVariable input)InvertPermutation(SameDiff sameDiff, SDVariable[] args, boolean inPlace)InvertPermutation(SameDiff sameDiff, SDVariable input, boolean inPlace)IsNonDecreasing(SameDiff sameDiff, SDVariable input)IsNonDecreasing(SameDiff sameDiff, SDVariable[] args)IsNonDecreasing(SameDiff sameDiff, SDVariable[] args, boolean inPlace)IsNumericTensor(SameDiff sameDiff, SDVariable args)IsNumericTensor(SameDiff sameDiff, SDVariable[] args, boolean inPlace)IsStrictlyIncreasing(SameDiff sameDiff, SDVariable input)IsStrictlyIncreasing(SameDiff sameDiff, SDVariable[] args, boolean inPlace)LayerNorm(@NonNull SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable gain, SDVariable bias, boolean channelsFirst, int... dimensions)LayerNorm(SameDiff sameDiff, SDVariable input, SDVariable gain, boolean channelsFirst, int... dimensions)LayerNormBp(@NonNull SameDiff sameDiff, @NonNull SDVariable input, @NonNull SDVariable gain, SDVariable bias, @NonNull SDVariable gradient, boolean channelsFirst, int... dimensions)LayerNormBp(SameDiff sameDiff, SDVariable input, SDVariable gain, SDVariable gradient, boolean channelsFirst, int... dimensions)LessThan(SameDiff sameDiff, SDVariable[] args, boolean inPlace)LessThan(SameDiff sameDiff, SDVariable x, SDVariable y)LessThanOrEqual(SameDiff sameDiff, SDVariable[] args, boolean inPlace)LessThanOrEqual(SameDiff sameDiff, SDVariable x, SDVariable y)ListDiff(@NonNull SameDiff sd, @NonNull SDVariable x, @NonNull SDVariable y)LogicalAnd(SameDiff sd, SDVariable in1, SDVariable in2)LogicalNot(SameDiff sd, SDVariable in1, SDVariable in2)LogicalOr(SameDiff sd, SDVariable in1, SDVariable in2)LogicalXor(SameDiff sd, SDVariable in1, SDVariable in2)LogMatrixDeterminant(SameDiff sameDiff, SDVariable in, boolean inPlace)LogSoftMax(SameDiff sameDiff, SDVariable i_v)LogSoftMax(SameDiff sameDiff, SDVariable i_v, int dimension)MatrixDeterminant(SameDiff sameDiff, SDVariable in)MatrixDeterminant(SameDiff sameDiff, SDVariable in, boolean inPlace)MatrixDiag(SameDiff sameDiff, SDVariable in, boolean inPlace)MatrixDiagPart(SameDiff sameDiff, SDVariable in, boolean inPlace)MatrixInverse(SameDiff sameDiff, SDVariable in)MatrixInverse(SameDiff sameDiff, SDVariable in, boolean inPlace)MatrixSetDiag(SameDiff sameDiff, SDVariable in, SDVariable diag)MatrixSetDiag(SameDiff sameDiff, SDVariable in, SDVariable diag, boolean inPlace)Max(SameDiff sameDiff, @NonNull SDVariable first, @NonNull SDVariable second)Max(SameDiff sameDiff, SDVariable[] args, boolean inPlace)MaximumBp(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable y, @NonNull SDVariable gradO)Min(SameDiff sameDiff, @NonNull SDVariable first, @NonNull SDVariable second)Min(SameDiff sameDiff, SDVariable[] args, boolean inPlace)MultiHeadDotProductAttention(SameDiff sameDiff, SDVariable queries, SDVariable keys, SDVariable values, SDVariable Wq, SDVariable Wk, SDVariable Wv, SDVariable Wo, SDVariable mask, boolean scaled, boolean withWeights)MultiHeadDotProductAttentionBp(SameDiff sameDiff, SDVariable queries, SDVariable keys, SDVariable values, SDVariable Wq, SDVariable Wk, SDVariable Wv, SDVariable Wo, SDVariable eps, SDVariable mask, boolean scaled)NotEqualTo(SameDiff sameDiff, SDVariable[] args, boolean inPlace)NotEqualTo(SameDiff sameDiff, SDVariable x, SDVariable y)Pow(SameDiff sameDiff, SDVariable x, SDVariable y)Qr(SameDiff sameDiff, SDVariable input, boolean fullMatrices)Reverse(@NonNull SameDiff sameDiff, @NonNull SDVariable i_v, @lombok.NonNull int... dimensions)ReverseBp(@NonNull SameDiff sameDiff, @NonNull SDVariable i_v, @NonNull SDVariable grad, @lombok.NonNull int... dimensions)ReverseSequence(SameDiff sameDiff, SDVariable i_v, SDVariable seqLengths)ReverseSequence(SameDiff sameDiff, SDVariable i_v, SDVariable seqLengths, int seqDim, int batchDim)RShiftBits(SameDiff sameDiff, SDVariable x, SDVariable y)ShiftBits(SameDiff sameDiff, SDVariable x, SDVariable y)SoftMax(SameDiff sameDiff, SDVariable[] args)SoftMax(SameDiff sameDiff, SDVariable[] args, boolean inPlace)SoftMax(SameDiff sameDiff, SDVariable[] args, int dimension)SoftMax(SameDiff sameDiff, SDVariable[] args, int dimension, boolean inPlace)SoftMax(SameDiff sameDiff, SDVariable x, int dimension)SpaceToBatch(SameDiff sameDiff, SDVariable[] args, int[] blocks, int[][] padding, boolean inPlace)SpaceToBatch(SameDiff sameDiff, SDVariable x, int[] blocks, int[] paddingTop, int... paddingBottom)SpaceToBatchND(SameDiff sameDiff, SDVariable[] args, int[] blocks, int[][] padding, boolean inPlace)Standardize(SameDiff sameDiff, SDVariable i_v, int... dimensions)StandardizeBp(SameDiff sameDiff, SDVariable i_v, SDVariable grad, int... dimensions)Svd(SameDiff sd, SDVariable input, boolean fullUV, boolean computeUv)Svd(SameDiff sd, SDVariable input, boolean fullUV, boolean computeUv, int switchNum)ThresholdRelu(SameDiff sd, SDVariable input, boolean inPlace, double cutoff)ThresholdRelu(SameDiff sd, SDVariable input, double cutoff)TopK(SameDiff sd, SDVariable input, double k, boolean sorted)TopK(SameDiff sd, SDVariable in, int k, boolean sorted)Trace(SameDiff sd, SDVariable in)Unique(SameDiff sd, SDVariable in)UniqueWithCounts(SameDiff sd, SDVariable in)XwPlusB(SameDiff sameDiff, SDVariable input, SDVariable weights, SDVariable bias)Zeta(SameDiff sameDiff, SDVariable x, SDVariable q) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.custom.segment
Methods in org.nd4j.linalg.api.ops.impl.transforms.custom.segment that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>SegmentMax. doDiff(List<SDVariable> gradients)List<SDVariable>SegmentMean. doDiff(List<SDVariable> gradients)List<SDVariable>SegmentMin. doDiff(List<SDVariable> gradients)List<SDVariable>SegmentProd. doDiff(List<SDVariable> gradients)List<SDVariable>SegmentSum. doDiff(List<SDVariable> gradients)Method parameters in org.nd4j.linalg.api.ops.impl.transforms.custom.segment with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>SegmentMax. doDiff(List<SDVariable> gradients)List<SDVariable>SegmentMean. doDiff(List<SDVariable> gradients)List<SDVariable>SegmentMin. doDiff(List<SDVariable> gradients)List<SDVariable>SegmentProd. doDiff(List<SDVariable> gradients)List<SDVariable>SegmentSum. doDiff(List<SDVariable> gradients)Constructors in org.nd4j.linalg.api.ops.impl.transforms.custom.segment with parameters of type SDVariable Constructor Description SegmentMax(SameDiff sameDiff, SDVariable data, SDVariable segmentIds)SegmentMean(SameDiff sameDiff, SDVariable data, SDVariable segmentIds)SegmentMin(SameDiff sameDiff, SDVariable data, SDVariable segmentIds)SegmentProd(SameDiff sameDiff, SDVariable data, SDVariable segmentIds)SegmentSum(SameDiff sameDiff, SDVariable data, SDVariable segmentIds) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.dtype
Methods in org.nd4j.linalg.api.ops.impl.transforms.dtype that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>Cast. doDiff(List<SDVariable> i_v)Method parameters in org.nd4j.linalg.api.ops.impl.transforms.dtype with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>Cast. doDiff(List<SDVariable> i_v)Constructors in org.nd4j.linalg.api.ops.impl.transforms.dtype with parameters of type SDVariable Constructor Description Cast(SameDiff sameDiff, SDVariable arg, @NonNull DataType dst) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.floating
Methods in org.nd4j.linalg.api.ops.impl.transforms.floating that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>RSqrt. doDiff(List<SDVariable> i_v)List<SDVariable>Sqrt. doDiff(List<SDVariable> i_v)List<SDVariable>SqrtM. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.transforms.floating with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>RSqrt. doDiff(List<SDVariable> i_v)List<SDVariable>Sqrt. doDiff(List<SDVariable> i_v)List<SDVariable>SqrtM. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.impl.transforms.floating with parameters of type SDVariable Constructor Description RSqrt(SameDiff sameDiff, SDVariable i_v)RSqrt(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Sqrt(SameDiff sameDiff, SDVariable i_v)Sqrt(SameDiff sameDiff, SDVariable i_v, boolean inPlace)SqrtM(SameDiff sameDiff, SDVariable arg)SqrtM(SameDiff sameDiff, SDVariable[] args) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.gradient
-
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.pairwise
Methods in org.nd4j.linalg.api.ops.impl.transforms.pairwise that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>BinaryMinimalRelativeError. doDiff(List<SDVariable> i_v1)List<SDVariable>BinaryRelativeError. doDiff(List<SDVariable> i_v1)List<SDVariable>RelativeError. doDiff(List<SDVariable> i_v1)List<SDVariable>Set. doDiff(List<SDVariable> i_v)Method parameters in org.nd4j.linalg.api.ops.impl.transforms.pairwise with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>BinaryMinimalRelativeError. doDiff(List<SDVariable> i_v1)List<SDVariable>BinaryRelativeError. doDiff(List<SDVariable> i_v1)List<SDVariable>RelativeError. doDiff(List<SDVariable> i_v1)List<SDVariable>Set. doDiff(List<SDVariable> i_v)Constructors in org.nd4j.linalg.api.ops.impl.transforms.pairwise with parameters of type SDVariable Constructor Description BinaryMinimalRelativeError(SameDiff sameDiff, SDVariable i_v, boolean inPlace)BinaryMinimalRelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)BinaryMinimalRelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)BinaryRelativeError(SameDiff sameDiff, SDVariable i_v, boolean inPlace)BinaryRelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)BinaryRelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)RelativeError(SameDiff sameDiff, SDVariable i_v, boolean inPlace)RelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)RelativeError(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)Set(SameDiff sameDiff, SDVariable i_v, boolean inPlace) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.pairwise.arithmetic
Constructors in org.nd4j.linalg.api.ops.impl.transforms.pairwise.arithmetic with parameters of type SDVariable Constructor Description AddOp(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable y)Axpy(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double p)Axpy(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace, double p)Axpy(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, double p)CopyOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)CopyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)CopyOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)DivOp(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable y)FloorDivOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)FloorDivOp(SameDiff sameDiff, SDVariable x, SDVariable y)FloorModOp(SameDiff sameDiff, SDVariable x, SDVariable y)FModOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)FModOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)FModOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)MergeAddOp(SameDiff sameDiff, SDVariable[] args)MergeAddOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)ModOp(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable y)MulOp(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable y)PowPairwise(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)PowPairwise(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)RDivOp(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable y)RealDivOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)RemainderOp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)RemainderOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)RemainderOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)RSubOp(SameDiff sameDiff, SDVariable[] args, boolean inPlace)RSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)RSubOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)SquaredDifferenceOp(SameDiff sameDiff, SDVariable x, SDVariable y)SquaredDifferenceOp(SameDiff sameDiff, SDVariable x, SDVariable y, boolean inPlace)SubOp(@NonNull SameDiff sameDiff, @NonNull SDVariable x, @NonNull SDVariable y)TruncateDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)TruncateDivOp(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.pairwise.arithmetic.bp
Methods in org.nd4j.linalg.api.ops.impl.transforms.pairwise.arithmetic.bp that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>BaseArithmeticBackpropOp. doDiff(List<SDVariable> i_v)List<SDVariable>SquaredDifferenceBpOp. doDiff(List<SDVariable> i_v1)Method parameters in org.nd4j.linalg.api.ops.impl.transforms.pairwise.arithmetic.bp with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>BaseArithmeticBackpropOp. doDiff(List<SDVariable> i_v)List<SDVariable>SquaredDifferenceBpOp. doDiff(List<SDVariable> i_v1) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.pairwise.bool
Methods in org.nd4j.linalg.api.ops.impl.transforms.pairwise.bool that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>And. doDiff(List<SDVariable> f1)List<SDVariable>Not. doDiff(List<SDVariable> f1)List<SDVariable>Or. doDiff(List<SDVariable> i_v)List<SDVariable>Xor. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.transforms.pairwise.bool with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>And. doDiff(List<SDVariable> f1)List<SDVariable>Not. doDiff(List<SDVariable> f1)List<SDVariable>Or. doDiff(List<SDVariable> i_v)List<SDVariable>Xor. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.impl.transforms.pairwise.bool with parameters of type SDVariable Constructor Description And(SameDiff sameDiff, SDVariable i_v, boolean inPlace)And(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double comparable)And(SameDiff sameDiff, SDVariable ix, SDVariable iy)Not(SameDiff sameDiff, SDVariable i_v)Or(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double comparable)Or(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)Or(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)Xor(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double comparable)Xor(SameDiff sameDiff, SDVariable ix, SDVariable iy) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.same
Methods in org.nd4j.linalg.api.ops.impl.transforms.same that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>Abs. doDiff(List<SDVariable> i_v)List<SDVariable>AMax. doDiff(List<SDVariable> f1)List<SDVariable>AMin. doDiff(List<SDVariable> f1)List<SDVariable>Ceil. doDiff(List<SDVariable> f1)List<SDVariable>Cube. doDiff(List<SDVariable> f1)List<SDVariable>Floor. doDiff(List<SDVariable> i_v)List<SDVariable>Identity. doDiff(List<SDVariable> i_v)List<SDVariable>Max. doDiff(List<SDVariable> f1)List<SDVariable>Min. doDiff(List<SDVariable> f1)List<SDVariable>Negative. doDiff(List<SDVariable> i_v)List<SDVariable>OneMinus. doDiff(List<SDVariable> f1)List<SDVariable>Reciprocal. doDiff(List<SDVariable> i_v1)List<SDVariable>Round. doDiff(List<SDVariable> f1)List<SDVariable>Sign. doDiff(List<SDVariable> i_v)List<SDVariable>Square. doDiff(List<SDVariable> i_v)List<SDVariable>TimesOneMinus. doDiff(List<SDVariable> f1)Method parameters in org.nd4j.linalg.api.ops.impl.transforms.same with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>Abs. doDiff(List<SDVariable> i_v)List<SDVariable>AMax. doDiff(List<SDVariable> f1)List<SDVariable>AMin. doDiff(List<SDVariable> f1)List<SDVariable>Ceil. doDiff(List<SDVariable> f1)List<SDVariable>Cube. doDiff(List<SDVariable> f1)List<SDVariable>Floor. doDiff(List<SDVariable> i_v)List<SDVariable>Identity. doDiff(List<SDVariable> i_v)List<SDVariable>Max. doDiff(List<SDVariable> f1)List<SDVariable>Min. doDiff(List<SDVariable> f1)List<SDVariable>Negative. doDiff(List<SDVariable> i_v)List<SDVariable>OneMinus. doDiff(List<SDVariable> f1)List<SDVariable>Reciprocal. doDiff(List<SDVariable> i_v1)List<SDVariable>Round. doDiff(List<SDVariable> f1)List<SDVariable>Sign. doDiff(List<SDVariable> i_v)List<SDVariable>Square. doDiff(List<SDVariable> i_v)List<SDVariable>TimesOneMinus. doDiff(List<SDVariable> f1)Constructors in org.nd4j.linalg.api.ops.impl.transforms.same with parameters of type SDVariable Constructor Description Abs(SameDiff sameDiff, SDVariable i_v)Abs(SameDiff sameDiff, SDVariable i_v, boolean inPlace)AMax(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)AMin(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)Ceil(SameDiff sameDiff, SDVariable i_v)Ceil(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Cube(SameDiff sameDiff, SDVariable i_v)Cube(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Floor(SameDiff sameDiff, SDVariable i_v)Floor(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Identity(SameDiff sd, SDVariable input)Max(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)Min(SameDiff sameDiff, SDVariable i_v, SDVariable i_v2)Negative(SameDiff sameDiff, SDVariable i_v)Negative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)OneMinus(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Reciprocal(SameDiff sameDiff, SDVariable in)Round(SameDiff sameDiff, SDVariable i_v)Round(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Sign(SameDiff sameDiff, SDVariable i_v)Sign(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Square(SameDiff sameDiff, SDVariable i_v)Square(SameDiff sameDiff, SDVariable i_v, boolean inPlace)TimesOneMinus(SameDiff sameDiff, SDVariable i_v, boolean inPlace) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.segment
Methods in org.nd4j.linalg.api.ops.impl.transforms.segment that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>UnsortedSegmentMax. doDiff(List<SDVariable> gradients)List<SDVariable>UnsortedSegmentMean. doDiff(List<SDVariable> gradients)List<SDVariable>UnsortedSegmentMin. doDiff(List<SDVariable> gradients)List<SDVariable>UnsortedSegmentProd. doDiff(List<SDVariable> gradients)List<SDVariable>UnsortedSegmentSqrtN. doDiff(List<SDVariable> gradients)List<SDVariable>UnsortedSegmentSum. doDiff(List<SDVariable> gradients)Method parameters in org.nd4j.linalg.api.ops.impl.transforms.segment with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>UnsortedSegmentMax. doDiff(List<SDVariable> gradients)List<SDVariable>UnsortedSegmentMean. doDiff(List<SDVariable> gradients)List<SDVariable>UnsortedSegmentMin. doDiff(List<SDVariable> gradients)List<SDVariable>UnsortedSegmentProd. doDiff(List<SDVariable> gradients)List<SDVariable>UnsortedSegmentSqrtN. doDiff(List<SDVariable> gradients)List<SDVariable>UnsortedSegmentSum. doDiff(List<SDVariable> gradients) -
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.segment.bp
-
Uses of SDVariable in org.nd4j.linalg.api.ops.impl.transforms.strict
Constructors in org.nd4j.linalg.api.ops.impl.transforms.strict with parameters of type SDVariable Constructor Description ACos(SameDiff sameDiff, SDVariable i_v)ACos(SameDiff sameDiff, SDVariable i_v, boolean inPlace)ACosh(SameDiff sameDiff, SDVariable i_v)ACosh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)ASin(SameDiff sameDiff, SDVariable i_v)ASin(SameDiff sameDiff, SDVariable i_v, boolean inPlace)ASinh(SameDiff sameDiff, SDVariable i_v)ASinh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)ATan(SameDiff sameDiff, SDVariable i_v)ATan(SameDiff sameDiff, SDVariable i_v, boolean inPlace)ATanh(SameDiff sameDiff, SDVariable i_v)ATanh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Cos(SameDiff sameDiff, SDVariable i_v)Cos(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Cosh(SameDiff sameDiff, SDVariable i_v)Cosh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)ELU(SameDiff sameDiff, SDVariable i_v)Erf(SameDiff sameDiff, SDVariable i_v)Erf(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Erfc(SameDiff sameDiff, SDVariable i_v)Erfc(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Exp(SameDiff sameDiff, SDVariable i_v)Exp(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Expm1(SameDiff sameDiff, SDVariable i_v)Expm1(SameDiff sameDiff, SDVariable i_v, boolean inPlace)GELU(SameDiff sameDiff, SDVariable i_v)GELU(SameDiff sameDiff, SDVariable i_v, boolean precise)GELU(SameDiff sameDiff, SDVariable i_v, boolean inPlace, boolean precise)GELUDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)HardSigmoid(SameDiff sameDiff, SDVariable in)HardSigmoid(SameDiff sameDiff, SDVariable in, boolean inPlace)HardTanh(SameDiff sameDiff, SDVariable i_v)HardTanh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Log(SameDiff sameDiff, SDVariable i_v)Log(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Log1p(SameDiff sameDiff, SDVariable i_v)Log1p(SameDiff sameDiff, SDVariable i_v, boolean inPlace)LogSigmoid(SameDiff sameDiff, SDVariable i_v)LogSigmoid(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Mish(SameDiff sameDiff, SDVariable i_v, boolean inPlace)MishDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)MishDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)MishDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)PreciseGELU(SameDiff sameDiff, SDVariable i_v)PreciseGELU(SameDiff sameDiff, SDVariable i_v, boolean inPlace, boolean precise)PreciseGELUDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace, boolean precise)RationalTanh(SameDiff sameDiff, SDVariable i_v)RationalTanh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)RectifiedTanh(SameDiff sameDiff, SDVariable i_v)RectifiedTanh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Rint(SameDiff sameDiff, SDVariable i_v, boolean inPlace)SELU(SameDiff sameDiff, SDVariable i_v)SELU(SameDiff sameDiff, SDVariable i_v, boolean inPlace)SetRange(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double min, double max)Sigmoid(SameDiff sameDiff, SDVariable i_v)Sigmoid(SameDiff sameDiff, SDVariable i_v, boolean inPlace)SigmoidDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Deprecated.SigmoidDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)Deprecated.SigmoidDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)Deprecated.Sin(SameDiff sameDiff, SDVariable i_v)Sin(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Sinh(SameDiff sameDiff, SDVariable i_v)Sinh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)SoftPlus(SameDiff sameDiff, SDVariable i_v)SoftPlus(SameDiff sameDiff, SDVariable i_v, boolean inPlace)SoftSign(SameDiff sameDiff, SDVariable i_v)SoftSign(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Stabilize(SameDiff sameDiff, SDVariable i_v, boolean inPlace, double realMin, double cutOff, double k)Swish(SameDiff sameDiff, SDVariable i_v)Swish(SameDiff sameDiff, SDVariable i_v, boolean inPlace)SwishDerivative(SameDiff sameDiff, SDVariable i_v)SwishDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2)SwishDerivative(SameDiff sameDiff, SDVariable i_v1, SDVariable i_v2, boolean inPlace)Tan(SameDiff sameDiff, SDVariable i_v)Tan(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Tanh(SameDiff sameDiff, SDVariable i_v)Tanh(SameDiff sameDiff, SDVariable i_v, boolean inPlace)TanhDerivative(SameDiff sameDiff, SDVariable i_v, boolean inPlace)Deprecated. -
Uses of SDVariable in org.nd4j.linalg.api.ops.random
Constructors in org.nd4j.linalg.api.ops.random with parameters of type SDVariable Constructor Description BaseRandomOp(SameDiff sameDiff, SDVariable i_v) -
Uses of SDVariable in org.nd4j.linalg.api.ops.random.compat
Constructors in org.nd4j.linalg.api.ops.random.compat with parameters of type SDVariable Constructor Description RandomStandardNormal(SameDiff sameDiff, SDVariable[] args) -
Uses of SDVariable in org.nd4j.linalg.api.ops.random.custom
Methods in org.nd4j.linalg.api.ops.random.custom that return types with arguments of type SDVariable Modifier and Type Method Description List<SDVariable>DistributionUniform. doDiff(List<SDVariable> gradients)List<SDVariable>RandomBernoulli. doDiff(List<SDVariable> gradients)List<SDVariable>RandomExponential. doDiff(List<SDVariable> gradients)List<SDVariable>RandomNormal. doDiff(List<SDVariable> grad)Method parameters in org.nd4j.linalg.api.ops.random.custom with type arguments of type SDVariable Modifier and Type Method Description List<SDVariable>DistributionUniform. doDiff(List<SDVariable> gradients)List<SDVariable>RandomBernoulli. doDiff(List<SDVariable> gradients)List<SDVariable>RandomExponential. doDiff(List<SDVariable> gradients)List<SDVariable>RandomNormal. doDiff(List<SDVariable> grad)Constructors in org.nd4j.linalg.api.ops.random.custom with parameters of type SDVariable Constructor Description DistributionUniform(SameDiff sd, SDVariable shape, double min, double max)DistributionUniform(SameDiff sd, SDVariable shape, double min, double max, DataType dataType)RandomBernoulli(SameDiff sd, SDVariable shape, double p)RandomExponential(SameDiff sd, SDVariable shape, double lambda)RandomGamma(@NonNull SameDiff sameDiff, @NonNull SDVariable shape, @NonNull SDVariable alpha, SDVariable beta, int... seeds)RandomNormal(SameDiff sameDiff, SDVariable shape, double mean, double stdev)RandomPoisson(@NonNull SameDiff sameDiff, @NonNull SDVariable shape, @NonNull SDVariable rate, int... seeds)RandomShuffle(@NonNull SameDiff sameDiff, @NonNull SDVariable value, int... seeds) -
Uses of SDVariable in org.nd4j.linalg.api.ops.random.impl
Constructors in org.nd4j.linalg.api.ops.random.impl with parameters of type SDVariable Constructor Description DropOut(SameDiff sameDiff, SDVariable input, double p)DropOutInverted(SameDiff sameDiff, SDVariable input, double p)Range(SameDiff sd, SDVariable from, SDVariable to, SDVariable step, DataType dataType) -
Uses of SDVariable in org.nd4j.linalg.indexing.masking
Methods in org.nd4j.linalg.indexing.masking that return SDVariable Modifier and Type Method Description static SDVariableMasking. applyMask(SameDiff ret, SDVariable input, SDVariable mask, int axis)Methods in org.nd4j.linalg.indexing.masking with parameters of type SDVariable Modifier and Type Method Description static SDVariableMasking. applyMask(SameDiff ret, SDVariable input, SDVariable mask, int axis) -
Uses of SDVariable in org.nd4j.linalg.lossfunctions
Fields in org.nd4j.linalg.lossfunctions declared as SDVariable Modifier and Type Field Description protected SDVariableSameDiffLoss. scorePerExampleVariableMethods in org.nd4j.linalg.lossfunctions that return SDVariable Modifier and Type Method Description abstract SDVariableSameDiffLoss. defineLoss(SameDiff sd, SDVariable layerInput, SDVariable labels)Define the loss function.
NOTE: The score on a *per example* basis - should return a SDVariable with shape [minibatch], where out[i] is the score for the ith minibatchMethods in org.nd4j.linalg.lossfunctions with parameters of type SDVariable Modifier and Type Method Description abstract SDVariableSameDiffLoss. defineLoss(SameDiff sd, SDVariable layerInput, SDVariable labels)Define the loss function.
NOTE: The score on a *per example* basis - should return a SDVariable with shape [minibatch], where out[i] is the score for the ith minibatch
-