Modifier and Type | Method and Description |
---|---|
INDArray[] |
BasicGraphExecutioner.executeGraph(int id,
SDVariable... variables)
This method executes
|
INDArray[] |
GraphExecutioner.executeGraph(int id,
SDVariable... variables)
This method executes
|
INDArray[] |
BasicGraphExecutioner.executeGraph(SameDiff sd)
This method executes given graph and returns results
PLEASE NOTE: Default configuration is used
|
INDArray[] |
GraphExecutioner.executeGraph(SameDiff graph) |
INDArray[] |
BasicGraphExecutioner.executeGraph(SameDiff graph,
ExecutorConfiguration configuration)
This method executes given graph and returns results
|
INDArray[] |
GraphExecutioner.executeGraph(SameDiff graph,
ExecutorConfiguration configuration)
This method executes given graph and returns results
|
INDArray[] |
BasicGraphExecutioner.importProto(File file) |
INDArray[] |
GraphExecutioner.importProto(File file)
This method executes TF graph
PLEASE NOTE: This feature is under development yet
|
INDArray[] |
BasicGraphExecutioner.reuseGraph(SameDiff graph,
Map<Integer,INDArray> inputs) |
INDArray[] |
GraphExecutioner.reuseGraph(SameDiff graph,
Map<Integer,INDArray> inputs) |
Modifier and Type | Method and Description |
---|---|
INDArray[] |
BasicGraphExecutioner.reuseGraph(SameDiff graph,
Map<Integer,INDArray> inputs) |
INDArray[] |
GraphExecutioner.reuseGraph(SameDiff graph,
Map<Integer,INDArray> inputs) |
Modifier and Type | Method and Description |
---|---|
static boolean |
GradCheckUtil.checkGradients(SDVariable function,
SDVariable wrt,
double epsilon,
double maxRelError,
boolean print,
Map<String,INDArray> inputParameters) |
Modifier and Type | Method and Description |
---|---|
INDArray |
SameDiffOpExecutioner.bitmapDecode(INDArray encoded,
INDArray target) |
INDArray |
SameDiffOpExecutioner.bitmapEncode(INDArray indArray,
double threshold) |
INDArray |
SDVariable.eval()
Evaluate the result of this variable
|
INDArray[] |
SameDiff.eval(Map<String,INDArray> inputs)
Evaluate the given inputs
based on the current graph
|
INDArray |
SameDiffOpExecutioner.exec(Accumulation accumulation,
int... dimension)
Execute an accumulation along one or more dimensions
|
INDArray |
SameDiffOpExecutioner.exec(BroadcastOp broadcast,
int... dimension)
Execute an broadcast along one or more dimensions
|
INDArray |
SameDiffOpExecutioner.exec(IndexAccumulation indexAccum,
int... dimension)
Execute an index accumulation along one or more dimensions
|
INDArray |
SameDiffOpExecutioner.exec(RandomOp op)
This method executes specified RandomOp using default RNG available via Nd4j.getRandom()
|
INDArray |
SameDiffOpExecutioner.exec(RandomOp op,
Random rng)
This method executes specific RandomOp against specified RNG
|
INDArray |
SameDiffOpExecutioner.exec(Variance accumulation,
boolean biasCorrected,
int... dimension)
Execute an accumulation along one or more dimensions
|
INDArray |
SameDiff.execAndEndResult() |
INDArray |
SameDiff.execAndEndResult(List<DifferentialFunction> ops)
u
|
INDArray |
SameDiff.execAndEndResult(String functionName)
Exec a given function
|
INDArray |
SameDiffOpExecutioner.execAndReturn(BroadcastOp op)
Execute and return the result from a vector op
|
INDArray |
SameDiffOpExecutioner.execAndReturn(Op op)
Execute and return a result
ndarray from the given op
|
INDArray |
SameDiffOpExecutioner.execAndReturn(ScalarOp op)
Execute and return the result from a scalar op
|
INDArray |
SameDiffOpExecutioner.execAndReturn(ShapeOp op)
Execute and return the result from a vector op
|
INDArray |
SameDiffOpExecutioner.execAndReturn(TransformOp op)
Execute a TransformOp and return the result
|
INDArray |
SameDiff.execBackwardAndEndResult()
Exec a backwards operation
and return the end result
|
INDArray |
SameDiff.execWithPlaceHolderAndEndResult(Map<String,INDArray> inputs)
Creates and executes a list of operations
|
INDArray |
SDVariable.getArr()
A getter for the allocated ndarray
with this
SDVariable . |
INDArray |
SameDiff.getArrForVarName(String varName)
Get an
INDArray
for a given vertex id |
INDArray |
SDVariable.storeAndAllocateNewArray()
Allocate and return a new array
based on the vertex id and weight initialization.
|
INDArray |
SameDiffOpExecutioner.thresholdDecode(INDArray encoded,
INDArray target)
This method decodes thresholds array, and puts it into target array
|
INDArray |
SameDiffOpExecutioner.thresholdEncode(INDArray input,
double threshold)
This method encodes array as thresholds, updating input array at the same time
|
INDArray |
SameDiffOpExecutioner.thresholdEncode(INDArray input,
double threshold,
Integer boundary)
This method encodes array as thresholds, updating input array at the same time
|
INDArray |
SameDiff.yetAnotherExecMethod(Map<String,INDArray> inputs) |
Modifier and Type | Method and Description |
---|---|
Map<String,INDArray> |
SameDiffOpExecutioner.executeGraph(long id,
Map<String,INDArray> map) |
Modifier and Type | Method and Description |
---|---|
void |
SameDiff.addPropertyForFunction(DifferentialFunction functionFor,
String propertyName,
INDArray property)
Add a property for the given function
|
void |
SameDiff.associateArrayWithVariable(INDArray arr,
SDVariable variable)
Associate the array with the given variable.
|
INDArray |
SameDiffOpExecutioner.bitmapDecode(INDArray encoded,
INDArray target) |
INDArray |
SameDiffOpExecutioner.bitmapEncode(INDArray indArray,
double threshold) |
long |
SameDiffOpExecutioner.bitmapEncode(INDArray indArray,
INDArray target,
double threshold)
This method returns number of elements affected by encoder
|
SDVariable |
SameDiff.getVariableForArray(INDArray arr)
Get an
SDVariable
for an array reference. |
void |
SameDiff.putArrayForVarName(String varName,
INDArray arr)
Adds an ndarray for a given vertex id.
|
INDArray |
SameDiffOpExecutioner.thresholdDecode(INDArray encoded,
INDArray target)
This method decodes thresholds array, and puts it into target array
|
INDArray |
SameDiffOpExecutioner.thresholdEncode(INDArray input,
double threshold)
This method encodes array as thresholds, updating input array at the same time
|
INDArray |
SameDiffOpExecutioner.thresholdEncode(INDArray input,
double threshold,
Integer boundary)
This method encodes array as thresholds, updating input array at the same time
|
void |
SameDiff.updateArrayForVarName(String varName,
INDArray arr)
Update the ndarray for the given vertex id.
|
void |
SameDiff.updateVariable(String variableName,
INDArray arr)
Update the
INDArray
ndarray for the given variable name |
SDVariable |
SameDiff.var(String name,
INDArray arr) |
Modifier and Type | Method and Description |
---|---|
SDVariable[] |
SameDiff.SameDiffFunctionDefinition.define(SameDiff sameDiff,
Map<String,INDArray> inputs,
SDVariable[] variableInputs) |
void |
SameDiff.defineFunction(String function,
SameDiff.SameDiffFunctionDefinition functionDefinition,
Map<String,INDArray> inputs) |
INDArray[] |
SameDiff.eval(Map<String,INDArray> inputs)
Evaluate the given inputs
based on the current graph
|
Map<String,INDArray> |
SameDiffOpExecutioner.executeGraph(long id,
Map<String,INDArray> map) |
org.nd4j.linalg.primitives.Pair<Map<SDVariable,DifferentialFunction>,List<DifferentialFunction>> |
SameDiff.execWithPlaceHolder(Map<String,INDArray> inputs)
Creates and executes a list of operations
based on the given variables passed in.
|
INDArray |
SameDiff.execWithPlaceHolderAndEndResult(Map<String,INDArray> inputs)
Creates and executes a list of operations
|
void |
SameDiff.resolveVariablesWith(Map<String,INDArray> arrays)
Resolve all ndarrays by updating the variables
for each array specified in the given map.
|
INDArray |
SameDiff.yetAnotherExecMethod(Map<String,INDArray> inputs) |
Modifier and Type | Method and Description |
---|---|
static INDArray[] |
TwoPointApproximation.adjustSchemeToBounds(INDArray x,
INDArray h,
int numSteps,
INDArray lowerBound,
INDArray upperBound)
Adjust final scheme to presence of bounds
Returns (in this order):
adjusted hypothesis, whether to use onesided as an int mask array
|
static INDArray |
TwoPointApproximation.approximateDerivative(org.nd4j.linalg.function.Function<INDArray,INDArray> f,
INDArray x,
INDArray relStep,
INDArray f0,
INDArray bounds) |
static INDArray |
TwoPointApproximation.computeAbsoluteStep(INDArray x) |
static INDArray |
TwoPointApproximation.computeAbsoluteStep(INDArray relStep,
INDArray x) |
static INDArray |
TwoPointApproximation.denseDifference(org.nd4j.linalg.function.Function<INDArray,INDArray> func,
INDArray x0,
INDArray f0,
INDArray h,
INDArray oneSided) |
static INDArray[] |
TwoPointApproximation.prepareBounds(INDArray bounds,
INDArray x)
Prepare the boundaries for processing
|
Modifier and Type | Method and Description |
---|---|
static INDArray[] |
TwoPointApproximation.adjustSchemeToBounds(INDArray x,
INDArray h,
int numSteps,
INDArray lowerBound,
INDArray upperBound)
Adjust final scheme to presence of bounds
Returns (in this order):
adjusted hypothesis, whether to use onesided as an int mask array
|
static INDArray |
TwoPointApproximation.approximateDerivative(org.nd4j.linalg.function.Function<INDArray,INDArray> f,
INDArray x,
INDArray relStep,
INDArray f0,
INDArray bounds) |
static INDArray |
TwoPointApproximation.computeAbsoluteStep(INDArray x) |
static INDArray |
TwoPointApproximation.computeAbsoluteStep(INDArray relStep,
INDArray x) |
static INDArray |
TwoPointApproximation.denseDifference(org.nd4j.linalg.function.Function<INDArray,INDArray> func,
INDArray x0,
INDArray f0,
INDArray h,
INDArray oneSided) |
static double |
TwoPointApproximation.getEpsRelativeTo(INDArray data) |
static INDArray[] |
TwoPointApproximation.prepareBounds(INDArray bounds,
INDArray x)
Prepare the boundaries for processing
|
Modifier and Type | Method and Description |
---|---|
static INDArray |
TwoPointApproximation.approximateDerivative(org.nd4j.linalg.function.Function<INDArray,INDArray> f,
INDArray x,
INDArray relStep,
INDArray f0,
INDArray bounds) |
static INDArray |
TwoPointApproximation.approximateDerivative(org.nd4j.linalg.function.Function<INDArray,INDArray> f,
INDArray x,
INDArray relStep,
INDArray f0,
INDArray bounds) |
static INDArray |
TwoPointApproximation.denseDifference(org.nd4j.linalg.function.Function<INDArray,INDArray> func,
INDArray x0,
INDArray f0,
INDArray h,
INDArray oneSided) |
static INDArray |
TwoPointApproximation.denseDifference(org.nd4j.linalg.function.Function<INDArray,INDArray> func,
INDArray x0,
INDArray f0,
INDArray h,
INDArray oneSided) |
Modifier and Type | Method and Description |
---|---|
INDArray |
GraphMapper.getArrayFrom(NODE_TYPE nodeType,
GRAPH_TYPE graph) |
INDArray |
GraphMapper.getNDArrayFromTensor(String tensorName,
TENSOR_TYPE tensorType,
GRAPH_TYPE graph) |
Modifier and Type | Method and Description |
---|---|
INDArray |
OnnxGraphMapper.getArrayFrom(OnnxProto3.NodeProto nodeProto,
OnnxProto3.GraphProto graph) |
INDArray |
OnnxGraphMapper.getNDArrayFromTensor(String tensorName,
OnnxProto3.TypeProto.Tensor tensorProto,
OnnxProto3.GraphProto graph) |
INDArray |
OnnxGraphMapper.mapTensorProto(OnnxProto3.TensorProto tensor) |
Modifier and Type | Method and Description |
---|---|
INDArray |
TFGraphMapper.getArrayFrom(NodeDef nodeDef,
GraphDef graph) |
INDArray |
TFGraphMapper.getNDArrayFromTensor(String tensorName,
NodeDef node,
GraphDef graph) |
INDArray |
TFGraphMapper.mapTensorProto(TensorProto tfTensor) |
Modifier and Type | Method and Description |
---|---|
INDArray |
IActivation.getActivation(INDArray in,
boolean training)
Carry out activation function on the input array (usually known as 'preOut' or 'z')
Implementations must overwrite "in", transform in place and return "in"
Can support separate behaviour during test
|
INDArray |
IActivation.getGradientViewArray() |
INDArray |
BaseActivationFunction.getGradientViewArray() |
INDArray |
IActivation.getParametersViewArray() |
INDArray |
BaseActivationFunction.getParametersViewArray() |
Modifier and Type | Method and Description |
---|---|
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
IActivation.backprop(INDArray in,
INDArray epsilon)
Backpropagate the errors through the activation function, given input z and epsilon dL/da.
Returns 2 INDArrays: (a) The gradient dL/dz, calculated from dL/da, and (b) The parameter gradients dL/dw, where w is the weights in the activation function. |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
IActivation.backprop(INDArray in,
INDArray epsilon)
Backpropagate the errors through the activation function, given input z and epsilon dL/da.
Returns 2 INDArrays: (a) The gradient dL/dz, calculated from dL/da, and (b) The parameter gradients dL/dw, where w is the weights in the activation function. |
Modifier and Type | Method and Description |
---|---|
TransformOp |
Activation.asTransform(INDArray in,
boolean dup)
Get the Activation function as an ND4J Transform, applied on either the input or a copy of the input
|
Op |
Activation.asTransformDerivative(INDArray in,
boolean dup)
Get the Activation function derivative (i.e., dOut/dIn) as an ND4J Transform, applied on either the input
or a copy of the input
|
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
IActivation.backprop(INDArray in,
INDArray epsilon)
Backpropagate the errors through the activation function, given input z and epsilon dL/da.
Returns 2 INDArrays: (a) The gradient dL/dz, calculated from dL/da, and (b) The parameter gradients dL/dw, where w is the weights in the activation function. |
INDArray |
IActivation.getActivation(INDArray in,
boolean training)
Carry out activation function on the input array (usually known as 'preOut' or 'z')
Implementations must overwrite "in", transform in place and return "in"
Can support separate behaviour during test
|
void |
IActivation.setGradientViewArray(INDArray viewArray) |
void |
BaseActivationFunction.setGradientViewArray(INDArray viewArray) |
void |
IActivation.setParametersViewArray(INDArray viewArray,
boolean initialize) |
void |
BaseActivationFunction.setParametersViewArray(INDArray viewArray,
boolean initialize) |
Modifier and Type | Method and Description |
---|---|
INDArray |
ActivationSwish.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSoftSign.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationELU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSELU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationRationalTanh.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationIdentity.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationHardTanH.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationTanH.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationRectifiedTanh.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSoftPlus.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationRReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSigmoid.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationCube.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationLReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationHardSigmoid.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSoftmax.getActivation(INDArray in,
boolean training) |
Modifier and Type | Method and Description |
---|---|
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSwish.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSwish.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSoftSign.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSoftSign.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationELU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationELU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSELU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSELU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationRationalTanh.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationRationalTanh.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationIdentity.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationIdentity.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationHardTanH.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationHardTanH.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationReLU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationReLU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationTanH.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationTanH.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationRectifiedTanh.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationRectifiedTanh.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSoftPlus.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSoftPlus.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationRReLU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationRReLU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSigmoid.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSigmoid.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationCube.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationCube.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationLReLU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationLReLU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationHardSigmoid.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationHardSigmoid.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSoftmax.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSoftmax.backprop(INDArray in,
INDArray epsilon) |
Modifier and Type | Method and Description |
---|---|
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSwish.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSoftSign.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationELU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSELU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationRationalTanh.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationIdentity.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationHardTanH.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationReLU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationTanH.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationRectifiedTanh.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSoftPlus.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationRReLU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSigmoid.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationCube.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationLReLU.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationHardSigmoid.backprop(INDArray in,
INDArray epsilon) |
org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
ActivationSoftmax.backprop(INDArray in,
INDArray epsilon) |
INDArray |
ActivationSwish.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSoftSign.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationELU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSELU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationRationalTanh.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationIdentity.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationHardTanH.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationTanH.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationRectifiedTanh.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSoftPlus.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationRReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSigmoid.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationCube.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationLReLU.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationHardSigmoid.getActivation(INDArray in,
boolean training) |
INDArray |
ActivationSoftmax.getActivation(INDArray in,
boolean training) |
Modifier and Type | Method and Description |
---|---|
INDArray |
Lapack.getLFactor(INDArray A)
extracts the L (lower triangular) matrix from the LU factor result
L will be the same dimensions as A
|
INDArray |
Lapack.getPFactor(int M,
INDArray ipiv)
This method takes one of the ipiv returns from LAPACK and creates
the permutation matrix.
|
INDArray |
Lapack.getrf(INDArray A)
LU decomposiiton of a matrix
Factorize a matrix A
The matrix A is overridden by the L & U combined.
|
INDArray |
Lapack.getUFactor(INDArray A)
extracts the U (upper triangular) matrix from the LU factor result
U will be n x n matrix where n = num cols in A
|
Modifier and Type | Method and Description |
---|---|
double |
Level1.asum(INDArray arr)
computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum
|
void |
Level1.axpy(int n,
double alpha,
INDArray x,
INDArray y)
computes a vector-scalar product and adds the result to a vector.
|
void |
Level1.copy(INDArray x,
INDArray y)
copy a vector to another vector.
|
double |
Level1.dot(int n,
double alpha,
INDArray X,
INDArray Y)
computes a vector-vector dot product.
|
void |
Level2.gbmv(char order,
char TransA,
int KL,
int KU,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
gbmv computes a matrix-vector product using a general band matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
|
void |
Level3.gemm(char Order,
char TransA,
char TransB,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
gemm performs a matrix-matrix operation
c := alpha*op(a)*op(b) + beta*c,
where c is an m-by-n matrix,
op(a) is an m-by-k matrix,
op(b) is a k-by-n matrix.
|
void |
Level3.gemm(INDArray A,
INDArray B,
INDArray C,
boolean transposeA,
boolean transposeB,
double alpha,
double beta)
A convenience method for matrix-matrix operations with transposes.
|
void |
Level2.gemv(char order,
char transA,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
gemv computes a matrix-vector product using a general matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
|
void |
Lapack.geqrf(INDArray A,
INDArray R)
QR decomposiiton of a matrix
Factorize a matrix A such that A = QR
The matrix A is overwritten by the Q component (i.e.
|
void |
Level2.ger(char order,
double alpha,
INDArray X,
INDArray Y,
INDArray A)
performs a rank-1 update of a general m-by-n matrix a:
a := alpha*x*y' + a.
|
void |
Lapack.gesvd(INDArray A,
INDArray S,
INDArray U,
INDArray VT)
SVD decomposiiton of a matrix
Factorize a matrix into its singular vectors and eigenvalues
The decomposition is such that:
A = U x S x VT
gesvd = singular value decomposition (SVD) of a general matrix (GE)
|
static int |
BlasBufferUtil.getBlasOffset(INDArray arr)
Get blas stride for the
given array
|
static int |
BlasBufferUtil.getBlasStride(INDArray arr)
Get blas stride for the
given array
|
static char |
BlasBufferUtil.getCharForTranspose(INDArray arr)
Returns the proper character for
how to interpret a buffer (fortran being N C being T)
|
static int |
BlasBufferUtil.getDimension(INDArray arr,
boolean defaultRows)
Get the dimension associated with
the given ordering.
|
static double[] |
BlasBufferUtil.getDoubleData(INDArray buf)
Returns the double data
for this ndarray.
|
static float[] |
BlasBufferUtil.getFloatData(INDArray buf)
Returns the float data
for this ndarray.
|
static int |
BlasBufferUtil.getLd(INDArray arr)
Get the leading dimension
for a blas invocation.
|
INDArray |
Lapack.getLFactor(INDArray A)
extracts the L (lower triangular) matrix from the LU factor result
L will be the same dimensions as A
|
INDArray |
Lapack.getPFactor(int M,
INDArray ipiv)
This method takes one of the ipiv returns from LAPACK and creates
the permutation matrix.
|
INDArray |
Lapack.getrf(INDArray A)
LU decomposiiton of a matrix
Factorize a matrix A
The matrix A is overridden by the L & U combined.
|
void |
Lapack.getri(int N,
INDArray A,
int lda,
int[] IPIV,
INDArray WORK,
int lwork,
int INFO)
Generate inverse ggiven LU decomp
|
static int |
BlasBufferUtil.getStrideForOrdering(INDArray arr)
Return the proper stride
through a vector
relative to the ordering of the array
This is for incX/incY parameters in BLAS.
|
INDArray |
Lapack.getUFactor(INDArray A)
extracts the U (upper triangular) matrix from the LU factor result
U will be n x n matrix where n = num cols in A
|
int |
Level1.iamax(INDArray arr)
finds the element of a
vector that has the largest absolute value.
|
int |
Level1.iamax(int n,
INDArray arr,
int stride)
finds the element of a
vector that has the largest absolute value.
|
int |
Level1.iamin(INDArray arr)
finds the element of a vector that has the minimum absolute value.
|
double |
Level1.nrm2(INDArray arr)
computes the Euclidean norm of a vector.
|
void |
Lapack.potrf(INDArray A,
boolean lower)
Triangular decomposiiton of a positive definite matrix ( cholesky )
Factorize a matrix A such that A = LL* (assuming lower==true) or
A = U*U (a * represents conjugate i.e.
|
void |
Level1.rot(int N,
INDArray X,
INDArray Y,
double c,
double s)
performs rotation of points in the plane.
|
void |
Level1.rotg(INDArray a,
INDArray b,
INDArray c,
INDArray s)
computes parameters for a Givens rotation.
|
void |
Level1.rotmg(INDArray d1,
INDArray d2,
INDArray b1,
double b2,
INDArray P)
computes the modified parameters for a Givens rotation.
|
void |
Level2.sbmv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
sbmv computes a matrix-vector product using a symmetric band matrix:
y := alpha*a*x + beta*y.
|
void |
Level1.scal(int N,
double alpha,
INDArray X)
computes a vector by a scalar product.
|
static void |
BlasBufferUtil.setData(double[] data,
INDArray toSet)
Set the data for the underlying array.
|
static void |
BlasBufferUtil.setData(float[] data,
INDArray toSet)
Set the data for the underlying array.
|
void |
Level2.spmv(char order,
char Uplo,
double alpha,
INDArray Ap,
INDArray X,
double beta,
INDArray Y) |
void |
Level2.spr(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Ap)
spr performs a rank-1 update of an n-by-n packed symmetric matrix a:
a := alpha*x*x' + a.
|
void |
Level2.spr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A)
?spr2 performs a rank-2 update of an n-by-n packed symmetric matrix a:
a := alpha*x*y' + alpha*y*x' + a.
|
void |
Level1.swap(INDArray x,
INDArray y)
swaps a vector with another vector.
|
int |
Lapack.syev(char jobz,
char uplo,
INDArray A,
INDArray V)
Caclulate the eigenvalues and vectors of a symmetric matrix.
|
void |
Level3.symm(char Order,
char Side,
char Uplo,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
her2k performs a rank-2k update of an n-by-n Hermitian matrix c, that is, one of the following operations:
c := alpha*a*conjg(b') + conjg(alpha)*b*conjg(a') + beta*c, for trans = 'N'or'n'
c := alpha*conjg(b')*a + conjg(alpha)*conjg(a')*b + beta*c, for trans = 'C'or'c'
where c is an n-by-n Hermitian matrix;
a and b are n-by-k matrices if trans = 'N'or'n',
a and b are k-by-n matrices if trans = 'C'or'c'.
|
void |
Level2.symv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
symv computes a matrix-vector product for a symmetric matrix:
y := alpha*a*x + beta*y.
|
void |
Level2.syr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
INDArray A)
syr performs a rank-1 update of an n-by-n symmetric matrix a:
a := alpha*x*x' + a.
|
void |
Level2.syr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A) |
void |
Level3.syr2k(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
yr2k performs a rank-2k update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*b' + alpha*b*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*b + alpha*b'*a + beta*c for trans = 'T'or't',
where c is an n-by-n symmetric matrix;
a and b are n-by-k matrices, if trans = 'N'or'n',
a and b are k-by-n matrices, if trans = 'T'or't'.
|
void |
Level3.syrk(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
double beta,
INDArray C)
syrk performs a rank-n update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*a + beta*c for trans = 'T'or't','C'or'c',
where c is an n-by-n symmetric matrix;
a is an n-by-k matrix, if trans = 'N'or'n',
a is a k-by-n matrix, if trans = 'T'or't','C'or'c'.
|
void |
Level2.tbmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
syr2 performs a rank-2 update of an n-by-n symmetric matrix a:
a := alpha*x*y' + alpha*y*x' + a.
|
void |
Level2.tbsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
?tbsv solves a system of linear equations whose coefficients are in a triangular band matrix.
|
void |
Level2.tpmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X)
tpmv computes a matrix-vector product using a triangular packed matrix.
|
void |
Level2.tpsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X)
tpsv solves a system of linear equations whose coefficients are in a triangular packed matrix.
|
void |
Level3.trmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B,
INDArray C)
syr2k performs a rank-2k update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*b' + alpha*b*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*b + alpha*b'*a + beta*c for trans = 'T'or't',
where c is an n-by-n symmetric matrix;
a and b are n-by-k matrices, if trans = 'N'or'n',
a and b are k-by-n matrices, if trans = 'T'or't'.
|
void |
Level2.trmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
trmv computes a matrix-vector product using a triangular matrix.
|
void |
Level3.trsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B)
?trsm solves one of the following matrix equations:
op(a)*x = alpha*b or x*op(a) = alpha*b,
where x and b are m-by-n general matrices, and a is triangular;
op(a) must be an m-by-m matrix, if side = 'L'or'l'
op(a) must be an n-by-n matrix, if side = 'R'or'r'.
|
void |
Level2.trsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
trsv solves a system of linear equations whose coefficients are in a triangular matrix.
|
Modifier and Type | Method and Description |
---|---|
INDArray |
SparseBaseLapack.getLFactor(INDArray A) |
INDArray |
BaseLapack.getLFactor(INDArray A) |
INDArray |
SparseBaseLapack.getPFactor(int M,
INDArray ipiv) |
INDArray |
BaseLapack.getPFactor(int M,
INDArray ipiv) |
INDArray |
SparseBaseLapack.getrf(INDArray A) |
INDArray |
BaseLapack.getrf(INDArray A) |
INDArray |
SparseBaseLapack.getUFactor(INDArray A) |
INDArray |
BaseLapack.getUFactor(INDArray A) |
Modifier and Type | Method and Description |
---|---|
double |
SparseBaseLevel1.asum(INDArray arr)
Compute the sum of magnitude of the vector elements
|
double |
BaseLevel1.asum(INDArray arr)
computes the sum of magnitudes of all vector elements or, for a complex vector x, the sum
|
void |
SparseBaseLevel1.axpy(int n,
double alpha,
INDArray x,
INDArray y)
Adds a scalar multiple of compressed sparse vector to a full-storage vector.
|
void |
BaseLevel1.axpy(int n,
double alpha,
INDArray x,
INDArray y)
computes a vector-scalar product and adds the result to a vector.
|
protected abstract void |
BaseLevel2.chpr(char order,
char Uplo,
int N,
INDArray alpha,
IComplexNDArray X,
int incX,
IComplexNDArray A) |
void |
SparseBaseLevel1.copy(INDArray x,
INDArray y) |
void |
BaseLevel1.copy(INDArray x,
INDArray y)
swaps a vector with another vector.
|
protected abstract double |
SparseBaseLevel1.dasum(int N,
INDArray X,
int incx) |
protected abstract double |
BaseLevel1.dasum(int N,
INDArray X,
int incX) |
protected abstract void |
BaseLevel1.daxpy(int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
SparseBaseLevel1.daxpyi(int N,
double alpha,
INDArray X,
DataBuffer pointers,
INDArray Y) |
protected abstract void |
SparseBaseLevel2.dcoomv(char transA,
int M,
DataBuffer values,
DataBuffer rowInd,
DataBuffer colInd,
int nnz,
INDArray x,
INDArray y) |
protected abstract void |
BaseLevel1.dcopy(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract double |
BaseLevel1.ddot(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract double |
SparseBaseLevel1.ddoti(int N,
INDArray X,
DataBuffer indx,
INDArray Y) |
protected abstract void |
BaseLevel2.dgbmv(char order,
char TransA,
int M,
int N,
int KL,
int KU,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel3.dgemm(char Order,
char TransA,
char TransB,
int M,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.dgemv(char order,
char TransA,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
abstract void |
BaseLapack.dgeqrf(int M,
int N,
INDArray A,
INDArray R,
INDArray INFO) |
protected abstract void |
BaseLevel2.dger(char order,
int M,
int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
abstract void |
BaseLapack.dgesvd(byte jobu,
byte jobvt,
int M,
int N,
INDArray A,
INDArray S,
INDArray U,
INDArray VT,
INDArray INFO) |
abstract void |
BaseLapack.dgetrf(int M,
int N,
INDArray A,
INDArray IPIV,
INDArray INFO) |
protected abstract double |
SparseBaseLevel1.dnrm2(int N,
INDArray X,
int incx) |
protected abstract double |
BaseLevel1.dnrm2(int N,
INDArray X,
int incX) |
double |
SparseBaseLevel1.dot(int n,
double alpha,
INDArray X,
INDArray Y)
computes a vector-vector dot product.
|
double |
BaseLevel1.dot(int n,
double alpha,
INDArray X,
INDArray Y)
computes a vector-vector dot product.
|
abstract void |
BaseLapack.dpotrf(byte uplo,
int N,
INDArray A,
INDArray INFO) |
protected abstract void |
BaseLevel1.drot(int N,
INDArray X,
int incX,
INDArray Y,
int incY,
double c,
double s) |
protected abstract void |
SparseBaseLevel1.droti(int N,
INDArray X,
DataBuffer indexes,
INDArray Y,
double c,
double s) |
protected abstract void |
BaseLevel1.drotm(int N,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray P) |
protected abstract void |
BaseLevel1.drotmg(double d1,
double d2,
double b1,
double b2,
INDArray P) |
protected abstract void |
BaseLevel2.dsbmv(char order,
char Uplo,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
SparseBaseLevel1.dscal(int N,
double a,
INDArray X,
int incx) |
protected abstract void |
BaseLevel1.dscal(int N,
double alpha,
INDArray X,
int incX) |
protected abstract double |
BaseLevel1.dsdot(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.dspmv(char order,
char Uplo,
int N,
double alpha,
INDArray Ap,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.dspr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray Ap) |
protected abstract void |
BaseLevel2.dspr2(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A) |
protected abstract void |
BaseLevel1.dswap(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
abstract int |
BaseLapack.dsyev(char jobz,
char uplo,
int N,
INDArray A,
INDArray R) |
protected abstract void |
BaseLevel3.dsymm(char Order,
char Side,
char Uplo,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.dsymv(char order,
char Uplo,
int N,
double alpha,
INDArray A,
int lda,
INDArray X,
int incX,
double beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.dsyr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray A,
int lda) |
protected abstract void |
BaseLevel2.dsyr2(char order,
char Uplo,
int N,
double alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
protected abstract void |
BaseLevel3.dsyr2k(char Order,
char Uplo,
char Trans,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel3.dsyrk(char Order,
char Uplo,
char Trans,
int N,
int K,
double alpha,
INDArray A,
int lda,
double beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.dtbmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.dtbsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.dtpmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.dtpsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected abstract void |
BaseLevel3.dtrmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected abstract void |
BaseLevel2.dtrmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel3.dtrsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected abstract void |
BaseLevel2.dtrsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
void |
SparseBaseLevel2.gbmv(char order,
char TransA,
int KL,
int KU,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y) |
void |
BaseLevel2.gbmv(char order,
char TransA,
int KL,
int KU,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
gbmv computes a matrix-vector product using a general band matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
|
void |
BaseLevel3.gemm(char Order,
char TransA,
char TransB,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
gemm performs a matrix-matrix operation
c := alpha*op(a)*op(b) + beta*c,
where c is an m-by-n matrix,
op(a) is an m-by-k matrix,
op(b) is a k-by-n matrix.
|
void |
SparseBaseLevel3.gemm(char Order,
char TransA,
char TransB,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C) |
void |
BaseLevel3.gemm(INDArray A,
INDArray B,
INDArray C,
boolean transposeA,
boolean transposeB,
double alpha,
double beta)
A convenience method for matrix-matrix operations with transposes.
|
void |
SparseBaseLevel3.gemm(INDArray A,
INDArray B,
INDArray C,
boolean transposeA,
boolean transposeB,
double alpha,
double beta) |
void |
SparseBaseLevel2.gemv(char order,
char transA,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y) |
void |
BaseLevel2.gemv(char order,
char transA,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
gemv computes a matrix-vector product using a general matrix and performs one of the following matrix-vector operations:
y := alpha*a*x + beta*y for trans = 'N'or'n';
y := alpha*a'*x + beta*y for trans = 'T'or't';
y := alpha*conjg(a')*x + beta*y for trans = 'C'or'c'.
|
void |
SparseBaseLapack.geqrf(INDArray A,
INDArray R) |
void |
BaseLapack.geqrf(INDArray A,
INDArray R) |
void |
SparseBaseLevel2.ger(char order,
double alpha,
INDArray X,
INDArray Y,
INDArray A) |
void |
BaseLevel2.ger(char order,
double alpha,
INDArray X,
INDArray Y,
INDArray A)
performs a rank-1 update of a general m-by-n matrix a:
a := alpha*x*y' + a.
|
void |
SparseBaseLapack.gesvd(INDArray A,
INDArray S,
INDArray U,
INDArray VT) |
void |
BaseLapack.gesvd(INDArray A,
INDArray S,
INDArray U,
INDArray VT) |
INDArray |
SparseBaseLapack.getLFactor(INDArray A) |
INDArray |
BaseLapack.getLFactor(INDArray A) |
INDArray |
SparseBaseLapack.getPFactor(int M,
INDArray ipiv) |
INDArray |
BaseLapack.getPFactor(int M,
INDArray ipiv) |
INDArray |
SparseBaseLapack.getrf(INDArray A) |
INDArray |
BaseLapack.getrf(INDArray A) |
void |
SparseBaseLapack.getri(int N,
INDArray A,
int lda,
int[] IPIV,
INDArray WORK,
int lwork,
int INFO) |
INDArray |
SparseBaseLapack.getUFactor(INDArray A) |
INDArray |
BaseLapack.getUFactor(INDArray A) |
protected abstract double |
SparseBaseLevel1.hasum(int N,
INDArray X,
int incx) |
protected abstract float |
BaseLevel1.hasum(int N,
INDArray X,
int incX) |
protected abstract void |
BaseLevel1.haxpy(int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
SparseBaseLevel1.haxpyi(int N,
double alpha,
INDArray X,
DataBuffer pointers,
INDArray Y) |
protected abstract float |
BaseLevel1.hdot(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract double |
SparseBaseLevel1.hdoti(int N,
INDArray X,
DataBuffer indx,
INDArray Y) |
protected abstract void |
BaseLevel3.hgemm(char Order,
char TransA,
char TransB,
int M,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected abstract double |
SparseBaseLevel1.hnrm2(int N,
INDArray X,
int incx) |
protected abstract void |
SparseBaseLevel1.hroti(int N,
INDArray X,
DataBuffer indexes,
INDArray Y,
double c,
double s) |
protected abstract void |
SparseBaseLevel1.hscal(int N,
double a,
INDArray X,
int incx) |
int |
SparseBaseLevel1.iamax(INDArray arr)
Find the index of the element with maximum absolute value
|
int |
BaseLevel1.iamax(INDArray arr)
finds the element of a
vector that has the largest absolute value.
|
int |
SparseBaseLevel1.iamax(int n,
INDArray arr,
int stride) |
int |
BaseLevel1.iamax(int n,
INDArray arr,
int stride) |
int |
SparseBaseLevel1.iamin(INDArray arr)
Find the index of the element with maximum absolute value
|
int |
BaseLevel1.iamin(INDArray arr)
finds the element of a vector that has the minimum absolute value.
|
protected abstract int |
SparseBaseLevel1.idamax(int N,
INDArray X,
int incx) |
protected abstract int |
BaseLevel1.idamax(int N,
INDArray X,
int incX) |
protected abstract int |
SparseBaseLevel1.idamin(int N,
INDArray X,
int incx) |
protected abstract int |
SparseBaseLevel1.ihamax(int N,
INDArray X,
int incx) |
protected abstract int |
SparseBaseLevel1.ihamin(int N,
INDArray X,
int incx) |
protected abstract int |
SparseBaseLevel1.isamax(int N,
INDArray X,
int incx) |
protected abstract int |
BaseLevel1.isamax(int N,
INDArray X,
int incX) |
protected abstract int |
SparseBaseLevel1.isamin(int N,
INDArray X,
int incx) |
double |
SparseBaseLevel1.nrm2(INDArray arr)
Computes the Euclidean norm of a vector.
|
double |
BaseLevel1.nrm2(INDArray arr)
computes the Euclidean norm of a vector.
|
void |
SparseBaseLapack.potrf(INDArray A,
boolean lower) |
void |
BaseLapack.potrf(INDArray A,
boolean lower) |
void |
SparseBaseLevel1.rot(int N,
INDArray X,
INDArray Y,
double c,
double s)
Applies Givens rotation to sparse vectors one of which is in compressed form.
|
void |
BaseLevel1.rot(int N,
INDArray X,
INDArray Y,
double c,
double s)
performs rotation of points in the plane.
|
void |
SparseBaseLevel1.rotg(INDArray a,
INDArray b,
INDArray c,
INDArray s) |
void |
BaseLevel1.rotg(INDArray a,
INDArray b,
INDArray c,
INDArray s)
computes parameters for a Givens rotation.
|
void |
SparseBaseLevel1.rotmg(INDArray d1,
INDArray d2,
INDArray b1,
double b2,
INDArray P) |
void |
BaseLevel1.rotmg(INDArray d1,
INDArray d2,
INDArray b1,
double b2,
INDArray P)
computes the modified parameters for a Givens rotation.
|
protected abstract double |
SparseBaseLevel1.sasum(int N,
INDArray X,
int incx) |
protected abstract float |
BaseLevel1.sasum(int N,
INDArray X,
int incX) |
protected abstract void |
BaseLevel1.saxpy(int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
SparseBaseLevel1.saxpyi(int N,
double alpha,
INDArray X,
DataBuffer pointers,
INDArray Y) |
void |
SparseBaseLevel2.sbmv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y) |
void |
BaseLevel2.sbmv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
sbmv computes a matrix-vector product using a symmetric band matrix:
y := alpha*a*x + beta*y.
|
void |
SparseBaseLevel1.scal(int N,
double alpha,
INDArray X)
Computes the product of a vector by a scalar.
|
void |
BaseLevel1.scal(int N,
double alpha,
INDArray X)
computes a vector by a scalar product.
|
protected abstract void |
SparseBaseLevel2.scoomv(char transA,
int M,
DataBuffer values,
DataBuffer rowInd,
DataBuffer colInd,
int nnz,
INDArray x,
INDArray y) |
protected abstract void |
BaseLevel1.scopy(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract float |
BaseLevel1.sdot(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract double |
SparseBaseLevel1.sdoti(int N,
INDArray X,
DataBuffer indx,
INDArray Y) |
protected abstract float |
BaseLevel1.sdsdot(int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.sgbmv(char order,
char TransA,
int M,
int N,
int KL,
int KU,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel3.sgemm(char Order,
char TransA,
char TransB,
int M,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.sgemv(char order,
char TransA,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
abstract void |
BaseLapack.sgeqrf(int M,
int N,
INDArray A,
INDArray R,
INDArray INFO)
Float/Double versions of QR decomp.
|
protected abstract void |
BaseLevel2.sger(char order,
int M,
int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
abstract void |
BaseLapack.sgesvd(byte jobu,
byte jobvt,
int M,
int N,
INDArray A,
INDArray S,
INDArray U,
INDArray VT,
INDArray INFO) |
abstract void |
BaseLapack.sgetrf(int M,
int N,
INDArray A,
INDArray IPIV,
INDArray INFO)
Float/Double versions of LU decomp.
|
protected abstract double |
SparseBaseLevel1.snrm2(int N,
INDArray X,
int incx) |
protected abstract float |
BaseLevel1.snrm2(int N,
INDArray X,
int incX) |
void |
SparseBaseLevel2.spmv(char order,
char Uplo,
double alpha,
INDArray Ap,
INDArray X,
double beta,
INDArray Y) |
void |
BaseLevel2.spmv(char order,
char Uplo,
double alpha,
INDArray Ap,
INDArray X,
double beta,
INDArray Y) |
abstract void |
BaseLapack.spotrf(byte uplo,
int N,
INDArray A,
INDArray INFO)
Float/Double versions of cholesky decomp for positive definite matrices
A = LL*
|
void |
SparseBaseLevel2.spr(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Ap) |
void |
BaseLevel2.spr(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Ap)
spr performs a rank-1 update of an n-by-n packed symmetric matrix a:
a := alpha*x*x' + a.
|
void |
SparseBaseLevel2.spr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A) |
void |
BaseLevel2.spr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A)
?spr2 performs a rank-2 update of an n-by-n packed symmetric matrix a:
a := alpha*x*y' + alpha*y*x' + a.
|
protected abstract void |
BaseLevel1.srot(int N,
INDArray X,
int incX,
INDArray Y,
int incY,
float c,
float s) |
protected abstract void |
SparseBaseLevel1.sroti(int N,
INDArray X,
DataBuffer indexes,
INDArray Y,
double c,
double s) |
protected abstract void |
BaseLevel1.srotm(int N,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray P) |
protected abstract void |
BaseLevel1.srotmg(float d1,
float d2,
float b1,
float b2,
INDArray P) |
protected abstract void |
BaseLevel2.ssbmv(char order,
char Uplo,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
SparseBaseLevel1.sscal(int N,
double a,
INDArray X,
int incx) |
protected abstract void |
BaseLevel1.sscal(int N,
float alpha,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.sspmv(char order,
char Uplo,
int N,
float alpha,
INDArray Ap,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.sspr(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray Ap) |
protected abstract void |
BaseLevel2.sspr2(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A) |
protected abstract void |
BaseLevel1.sswap(int N,
INDArray X,
int incX,
INDArray Y,
int incY) |
abstract int |
BaseLapack.ssyev(char jobz,
char uplo,
int N,
INDArray A,
INDArray R)
Float/Double versions of eigen value/vector calc.
|
protected abstract void |
BaseLevel3.ssymm(char Order,
char Side,
char Uplo,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.ssymv(char order,
char Uplo,
int N,
float alpha,
INDArray A,
int lda,
INDArray X,
int incX,
float beta,
INDArray Y,
int incY) |
protected abstract void |
BaseLevel2.ssyr(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray A,
int lda) |
protected abstract void |
BaseLevel2.ssyr2(char order,
char Uplo,
int N,
float alpha,
INDArray X,
int incX,
INDArray Y,
int incY,
INDArray A,
int lda) |
protected abstract void |
BaseLevel3.ssyr2k(char Order,
char Uplo,
char Trans,
int N,
int K,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
float beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel3.ssyrk(char Order,
char Uplo,
char Trans,
int N,
int K,
float alpha,
INDArray A,
int lda,
float beta,
INDArray C,
int ldc) |
protected abstract void |
BaseLevel2.stbmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.stbsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
int K,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.stpmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected abstract void |
BaseLevel2.stpsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray Ap,
INDArray X,
int incX) |
protected abstract void |
BaseLevel3.strmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected abstract void |
BaseLevel2.strmv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
protected abstract void |
BaseLevel3.strsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
int M,
int N,
float alpha,
INDArray A,
int lda,
INDArray B,
int ldb) |
protected abstract void |
BaseLevel2.strsv(char order,
char Uplo,
char TransA,
char Diag,
int N,
INDArray A,
int lda,
INDArray X,
int incX) |
void |
SparseBaseLevel1.swap(INDArray x,
INDArray y) |
void |
BaseLevel1.swap(INDArray x,
INDArray y)
swaps a vector with another vector.
|
int |
SparseBaseLapack.syev(char jobz,
char uplo,
INDArray A,
INDArray V) |
int |
BaseLapack.syev(char jobz,
char uplo,
INDArray A,
INDArray V) |
void |
BaseLevel3.symm(char Order,
char Side,
char Uplo,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
her2k performs a rank-2k update of an n-by-n Hermitian matrix c, that is, one of the following operations:
c := alpha*a*conjg(b') + conjg(alpha)*b*conjg(a') + beta*c, for trans = 'N'or'n'
c := alpha*conjg(b')*a + conjg(alpha)*conjg(a')*b + beta*c, for trans = 'C'or'c'
where c is an n-by-n Hermitian matrix;
a and b are n-by-k matrices if trans = 'N'or'n',
a and b are k-by-n matrices if trans = 'C'or'c'.
|
void |
SparseBaseLevel3.symm(char Order,
char Side,
char Uplo,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C) |
void |
SparseBaseLevel2.symv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y) |
void |
BaseLevel2.symv(char order,
char Uplo,
double alpha,
INDArray A,
INDArray X,
double beta,
INDArray Y)
symv computes a matrix-vector product for a symmetric matrix:
y := alpha*a*x + beta*y.
|
void |
SparseBaseLevel2.syr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
INDArray A) |
void |
BaseLevel2.syr(char order,
char Uplo,
int N,
double alpha,
INDArray X,
INDArray A)
syr performs a rank-1 update of an n-by-n symmetric matrix a:
a := alpha*x*x' + a.
|
void |
SparseBaseLevel2.syr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A) |
void |
BaseLevel2.syr2(char order,
char Uplo,
double alpha,
INDArray X,
INDArray Y,
INDArray A) |
void |
BaseLevel3.syr2k(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C)
yr2k performs a rank-2k update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*b' + alpha*b*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*b + alpha*b'*a + beta*c for trans = 'T'or't',
where c is an n-by-n symmetric matrix;
a and b are n-by-k matrices, if trans = 'N'or'n',
a and b are k-by-n matrices, if trans = 'T'or't'.
|
void |
SparseBaseLevel3.syr2k(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
INDArray B,
double beta,
INDArray C) |
void |
BaseLevel3.syrk(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
double beta,
INDArray C)
syrk performs a rank-n update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*a + beta*c for trans = 'T'or't','C'or'c',
where c is an n-by-n symmetric matrix;
a is an n-by-k matrix, if trans = 'N'or'n',
a is a k-by-n matrix, if trans = 'T'or't','C'or'c'.
|
void |
SparseBaseLevel3.syrk(char Order,
char Uplo,
char Trans,
double alpha,
INDArray A,
double beta,
INDArray C) |
void |
SparseBaseLevel2.tbmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X) |
void |
BaseLevel2.tbmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
syr2 performs a rank-2 update of an n-by-n symmetric matrix a:
a := alpha*x*y' + alpha*y*x' + a.
|
void |
SparseBaseLevel2.tbsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X) |
void |
BaseLevel2.tbsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
?tbsv solves a system of linear equations whose coefficients are in a triangular band matrix.
|
void |
SparseBaseLevel2.tpmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X) |
void |
BaseLevel2.tpmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X)
tpmv computes a matrix-vector product using a triangular packed matrix.
|
void |
SparseBaseLevel2.tpsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X) |
void |
BaseLevel2.tpsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray Ap,
INDArray X)
tpsv solves a system of linear equations whose coefficients are in a triangular packed matrix.
|
void |
BaseLevel3.trmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B,
INDArray C)
syr2k performs a rank-2k update of an n-by-n symmetric matrix c, that is, one of the following operations:
c := alpha*a*b' + alpha*b*a' + beta*c for trans = 'N'or'n'
c := alpha*a'*b + alpha*b'*a + beta*c for trans = 'T'or't',
where c is an n-by-n symmetric matrix;
a and b are n-by-k matrices, if trans = 'N'or'n',
a and b are k-by-n matrices, if trans = 'T'or't'.
|
void |
SparseBaseLevel3.trmm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B,
INDArray C) |
void |
SparseBaseLevel2.trmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X) |
void |
BaseLevel2.trmv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
trmv computes a matrix-vector product using a triangular matrix.
|
void |
BaseLevel3.trsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B)
?trsm solves one of the following matrix equations:
op(a)*x = alpha*b or x*op(a) = alpha*b,
where x and b are m-by-n general matrices, and a is triangular;
op(a) must be an m-by-m matrix, if side = 'L'or'l'
op(a) must be an n-by-n matrix, if side = 'R'or'r'.
|
void |
SparseBaseLevel3.trsm(char Order,
char Side,
char Uplo,
char TransA,
char Diag,
double alpha,
INDArray A,
INDArray B) |
void |
SparseBaseLevel2.trsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X) |
void |
BaseLevel2.trsv(char order,
char Uplo,
char TransA,
char Diag,
INDArray A,
INDArray X)
trsv solves a system of linear equations whose coefficients are in a triangular matrix.
|
protected abstract void |
BaseLevel2.zhpr(char order,
char Uplo,
int N,
INDArray alpha,
IComplexNDArray X,
int incX,
IComplexNDArray A) |
Constructor and Description |
---|
GemmParams(INDArray a,
INDArray b,
INDArray c) |
GemmParams(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB) |
GemvParameters(INDArray a,
INDArray x,
INDArray y) |
MMulTranspose(boolean transposeA,
boolean transposeB,
boolean transposeResult,
INDArray a,
INDArray b) |
SparseCOOGemvParameters(INDArray a,
INDArray x,
INDArray y) |
Modifier and Type | Interface and Description |
---|---|
interface |
IComplexNDArray
Complex numbers
|
Modifier and Type | Class and Description |
---|---|
class |
BaseComplexNDArray
ComplexNDArray for complex numbers.
|
Modifier and Type | Method and Description |
---|---|
INDArray |
BaseComplexNDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this nedarray
|
protected INDArray |
BaseComplexNDArray.create(int[] shape,
char ordering) |
protected INDArray |
BaseComplexNDArray.createScalarForIndex(int i,
boolean applyOffset) |
INDArray |
BaseComplexNDArray.getReal() |
INDArray |
IComplexNDArray.getReal()
Gets the real portion of this complex ndarray
|
INDArray |
BaseComplexNDArray.imag()
Get imaginary part of the matrix.
|
INDArray |
IComplexNDArray.imag()
Return all of the imaginary components in this ndarray
|
INDArray |
BaseComplexNDArray.putScalar(int[] i,
double value) |
INDArray |
IComplexNDArray.putScalar(int[] i,
IComplexNumber complexNumber) |
INDArray |
BaseComplexNDArray.real()
Get realComponent part of the matrix.
|
INDArray |
IComplexNDArray.real()
Return all the real components in this ndarray
|
Modifier and Type | Method and Description |
---|---|
IComplexNDArray |
BaseComplexNDArray.add(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.add(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.add(INDArray other)
copy addition of two matrices
|
IComplexNDArray |
IComplexNDArray.add(INDArray other)
copy addition of two matrices
|
IComplexNDArray |
BaseComplexNDArray.add(INDArray other,
INDArray result)
copy addition of two matrices
|
IComplexNDArray |
IComplexNDArray.add(INDArray other,
INDArray result)
copy addition of two matrices
|
IComplexNDArray |
BaseComplexNDArray.add(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.add(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.addColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.addColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.addi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.addi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.addi(INDArray other)
in place addition of two matrices
|
IComplexNDArray |
IComplexNDArray.addi(INDArray other)
in place addition of two matrices
|
IComplexNDArray |
BaseComplexNDArray.addi(INDArray other,
INDArray result)
in place addition of two matrices
|
IComplexNDArray |
IComplexNDArray.addi(INDArray other,
INDArray result)
in place addition of two matrices
|
IComplexNDArray |
BaseComplexNDArray.addi(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.addi(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.addiRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.addiRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.addRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.addRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
BaseComplexNDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this nedarray
|
void |
BaseComplexNDArray.checkDimensions(INDArray other)
Validate dimensions are equal
|
void |
IComplexNDArray.checkDimensions(INDArray other)
Validate dimensions are equal
|
protected void |
BaseComplexNDArray.copyFromReal(INDArray real) |
protected void |
BaseComplexNDArray.copyImagTo(INDArray arr)
Copy imaginary numbers to the given
ndarray
|
protected void |
BaseComplexNDArray.copyRealTo(INDArray arr)
Copy real numbers to arr
|
protected IComplexNDArray |
BaseComplexNDArray.create(INDArray baseNDArray) |
double |
BaseComplexNDArray.distance1(INDArray other)
Returns the (1-norm) distance.
|
double |
BaseComplexNDArray.distance2(INDArray other)
Returns the (euclidean) distance.
|
IComplexNDArray |
BaseComplexNDArray.div(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.div(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.div(INDArray other)
in place (element wise) division of two matrices
|
IComplexNDArray |
IComplexNDArray.div(INDArray other)
in place (element wise) division of two matrices
|
IComplexNDArray |
BaseComplexNDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two matrices
|
IComplexNDArray |
IComplexNDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two matrices
|
IComplexNDArray |
BaseComplexNDArray.div(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.div(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.divColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.divColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.divi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.divi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.divi(INDArray other)
in place (element wise) division of two matrices
|
IComplexNDArray |
IComplexNDArray.divi(INDArray other)
in place (element wise) division of two matrices
|
IComplexNDArray |
BaseComplexNDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two matrices
|
IComplexNDArray |
IComplexNDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two matrices
|
IComplexNDArray |
BaseComplexNDArray.divi(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.divi(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.diviColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.diviColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.diviRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.diviRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.divRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.divRowVector(INDArray rowVector)
In place addition of a column vector
|
protected IComplexNDArray |
BaseComplexNDArray.doColumnWise(INDArray columnVector,
char operation) |
protected IComplexNDArray |
BaseComplexNDArray.doRowWise(INDArray rowVector,
char operation) |
IComplexNDArray |
BaseComplexNDArray.eps(INDArray other)
epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
IComplexNDArray |
IComplexNDArray.eps(INDArray other)
epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
IComplexNDArray |
BaseComplexNDArray.epsi(INDArray other)
In place epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
IComplexNDArray |
IComplexNDArray.epsi(INDArray other)
In place epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
IComplexNDArray |
BaseComplexNDArray.eq(INDArray other) |
IComplexNDArray |
IComplexNDArray.eq(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.eqi(INDArray other) |
IComplexNDArray |
IComplexNDArray.eqi(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.gt(INDArray other) |
IComplexNDArray |
IComplexNDArray.gt(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.gti(INDArray other) |
IComplexNDArray |
IComplexNDArray.gti(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.lt(INDArray other) |
IComplexNDArray |
IComplexNDArray.lt(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.lti(INDArray other) |
IComplexNDArray |
IComplexNDArray.lti(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
IComplexNDArray |
IComplexNDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
IComplexNDArray |
BaseComplexNDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
IComplexNDArray |
IComplexNDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
IComplexNDArray |
BaseComplexNDArray.mmuli(INDArray other)
Perform an copy matrix multiplication
|
IComplexNDArray |
IComplexNDArray.mmuli(INDArray other)
Perform an copy matrix multiplication
|
IComplexNDArray |
BaseComplexNDArray.mmuli(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
IComplexNDArray |
IComplexNDArray.mmuli(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
IComplexNDArray |
BaseComplexNDArray.mul(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.mul(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.mul(INDArray other)
copy (element wise) multiplication of two matrices
|
IComplexNDArray |
IComplexNDArray.mul(INDArray other)
copy (element wise) multiplication of two matrices
|
IComplexNDArray |
BaseComplexNDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two matrices
|
IComplexNDArray |
IComplexNDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two matrices
|
IComplexNDArray |
BaseComplexNDArray.mul(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.mul(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.mulColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.mulColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.muli(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.muli(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.muli(INDArray other)
in place (element wise) multiplication of two matrices
|
IComplexNDArray |
IComplexNDArray.muli(INDArray other)
in place (element wise) multiplication of two matrices
|
IComplexNDArray |
BaseComplexNDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two matrices
|
IComplexNDArray |
IComplexNDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two matrices
|
IComplexNDArray |
BaseComplexNDArray.muli(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.muli(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.muliColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.muliColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.muliRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.muliRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.mulRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.mulRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.neq(INDArray other) |
IComplexNDArray |
IComplexNDArray.neq(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.neqi(INDArray other) |
IComplexNDArray |
IComplexNDArray.neqi(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.put(INDArrayIndex[] indices,
INDArray element) |
IComplexNDArray |
BaseComplexNDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
IComplexNDArray |
IComplexNDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
IComplexNDArray |
BaseComplexNDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
IComplexNDArray |
IComplexNDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
IComplexNDArray |
BaseComplexNDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
IComplexNDArray |
IComplexNDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
IComplexNDArray |
BaseComplexNDArray.putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this
ndarray is not a matrix
|
IComplexNDArray |
IComplexNDArray.putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this
ndarray is not a matrix
|
IComplexNDArray |
BaseComplexNDArray.putRow(int row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this
ndarray is not a matrix
|
IComplexNDArray |
IComplexNDArray.putRow(int row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this
ndarray is not a matrix
|
IComplexNDArray |
BaseComplexNDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
IComplexNDArray |
IComplexNDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
IComplexNDArray |
BaseComplexNDArray.rdiv(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rdiv(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rdiv(INDArray other)
Reverse division
|
IComplexNDArray |
IComplexNDArray.rdiv(INDArray other)
Reverse division
|
IComplexNDArray |
BaseComplexNDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
IComplexNDArray |
IComplexNDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
IComplexNDArray |
BaseComplexNDArray.rdiv(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rdiv(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rdivColumnVector(INDArray columnVector) |
IComplexNDArray |
IComplexNDArray.rdivColumnVector(INDArray columnVector) |
IComplexNDArray |
BaseComplexNDArray.rdivi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rdivi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
IComplexNDArray |
IComplexNDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
IComplexNDArray |
BaseComplexNDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
IComplexNDArray |
IComplexNDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
IComplexNDArray |
BaseComplexNDArray.rdivi(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rdivi(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rdiviColumnVector(INDArray columnVector) |
IComplexNDArray |
IComplexNDArray.rdiviColumnVector(INDArray columnVector) |
IComplexNDArray |
BaseComplexNDArray.rdiviRowVector(INDArray rowVector) |
IComplexNDArray |
IComplexNDArray.rdiviRowVector(INDArray rowVector) |
IComplexNDArray |
BaseComplexNDArray.rdivRowVector(INDArray rowVector) |
IComplexNDArray |
IComplexNDArray.rdivRowVector(INDArray rowVector) |
IComplexNDArray |
BaseComplexNDArray.rsub(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rsub(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rsub(INDArray other) |
IComplexNDArray |
IComplexNDArray.rsub(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
IComplexNDArray |
IComplexNDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
IComplexNDArray |
BaseComplexNDArray.rsub(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rsub(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rsubColumnVector(INDArray columnVector) |
IComplexNDArray |
IComplexNDArray.rsubColumnVector(INDArray columnVector) |
IComplexNDArray |
BaseComplexNDArray.rsubi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rsubi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rsubi(INDArray other) |
IComplexNDArray |
IComplexNDArray.rsubi(INDArray other) |
IComplexNDArray |
BaseComplexNDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
IComplexNDArray |
IComplexNDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
IComplexNDArray |
BaseComplexNDArray.rsubi(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.rsubi(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.rsubiColumnVector(INDArray columnVector) |
IComplexNDArray |
IComplexNDArray.rsubiColumnVector(INDArray columnVector) |
IComplexNDArray |
BaseComplexNDArray.rsubiRowVector(INDArray rowVector) |
IComplexNDArray |
IComplexNDArray.rsubiRowVector(INDArray rowVector) |
IComplexNDArray |
BaseComplexNDArray.rsubRowVector(INDArray rowVector) |
IComplexNDArray |
IComplexNDArray.rsubRowVector(INDArray rowVector) |
double |
BaseComplexNDArray.squaredDistance(INDArray other)
Returns the squared (Euclidean) distance.
|
IComplexNDArray |
BaseComplexNDArray.sub(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.sub(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.sub(INDArray other)
copy subtraction of two matrices
|
IComplexNDArray |
IComplexNDArray.sub(INDArray other)
copy subtraction of two matrices
|
IComplexNDArray |
BaseComplexNDArray.sub(INDArray other,
INDArray result)
copy subtraction of two matrices
|
IComplexNDArray |
IComplexNDArray.sub(INDArray other,
INDArray result)
copy subtraction of two matrices
|
IComplexNDArray |
BaseComplexNDArray.sub(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.sub(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.subColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.subColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.subi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.subi(IComplexNumber n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.subi(INDArray other)
in place subtraction of two matrices
|
IComplexNDArray |
IComplexNDArray.subi(INDArray other)
in place subtraction of two matrices
|
IComplexNDArray |
BaseComplexNDArray.subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
IComplexNDArray |
IComplexNDArray.subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
IComplexNDArray |
BaseComplexNDArray.subi(Number n,
INDArray result) |
IComplexNDArray |
IComplexNDArray.subi(Number n,
INDArray result) |
IComplexNDArray |
BaseComplexNDArray.subiColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.subiColumnVector(INDArray columnVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.subiRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.subiRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
BaseComplexNDArray.subRowVector(INDArray rowVector)
In place addition of a column vector
|
IComplexNDArray |
IComplexNDArray.subRowVector(INDArray rowVector)
In place addition of a column vector
|
Constructor and Description |
---|
BaseComplexNDArray(INDArray m)
Construct a complex matrix from a realComponent matrix.
|
BaseComplexNDArray(INDArray m,
char ordering)
Construct a complex matrix from a realComponent matrix.
|
BaseComplexNDArray(INDArray m,
int[] stride)
Create with the specified ndarray as the real component
and the given stride
|
BaseComplexNDArray(INDArray m,
int[] stride,
char ordering)
Initialize the given ndarray as the real component
|
Modifier and Type | Method and Description |
---|---|
INDArray |
AffinityManager.replicateToDevice(Integer deviceId,
INDArray array)
This method replicates given INDArray, and places it to target device.
|
INDArray |
BasicAffinityManager.replicateToDevice(Integer deviceId,
INDArray array)
This method replicates given INDArray, and places it to target device.
|
Modifier and Type | Method and Description |
---|---|
void |
AffinityManager.ensureLocation(INDArray array,
AffinityManager.Location location)
This method propagates given INDArray to specified location
|
void |
BasicAffinityManager.ensureLocation(INDArray array,
AffinityManager.Location location) |
AffinityManager.Location |
AffinityManager.getActiveLocation(INDArray array)
This method returns last-updated location for the given INDArray
|
AffinityManager.Location |
BasicAffinityManager.getActiveLocation(INDArray array) |
Integer |
AffinityManager.getDeviceForArray(INDArray array)
This method returns id of current device for a given INDArray
|
Integer |
BasicAffinityManager.getDeviceForArray(INDArray array) |
INDArray |
AffinityManager.replicateToDevice(Integer deviceId,
INDArray array)
This method replicates given INDArray, and places it to target device.
|
INDArray |
BasicAffinityManager.replicateToDevice(Integer deviceId,
INDArray array)
This method replicates given INDArray, and places it to target device.
|
void |
AffinityManager.tagLocation(INDArray array,
AffinityManager.Location location)
This method tags specific INDArray as "recent" on specified location
|
void |
BasicAffinityManager.tagLocation(INDArray array,
AffinityManager.Location location) |
void |
AffinityManager.touch(INDArray array)
Utility method, to associate INDArray with specific device (backend-specific)
|
Modifier and Type | Method and Description |
---|---|
void |
Instrumentation.log(INDArray toLog)
Log the given ndarray
|
void |
InMemoryInstrumentation.log(INDArray toLog) |
void |
Instrumentation.log(INDArray toLog,
String status)
Log the given ndarray
|
void |
InMemoryInstrumentation.log(INDArray toLog,
String status) |
Constructor and Description |
---|
LogEntry(INDArray toLog) |
LogEntry(INDArray toLog,
StackTraceElement[] stackTraceElements) |
LogEntry(INDArray toLog,
StackTraceElement[] stackTraceElements,
String status) |
LogEntry(INDArray toLog,
String status) |
Constructor and Description |
---|
FirstAxisIterator(INDArray iterateOver) |
INDArrayIterator(INDArray iterateOver) |
Modifier and Type | Interface and Description |
---|---|
interface |
ISparseNDArray |
Modifier and Type | Class and Description |
---|---|
class |
BaseNDArray
NDArray: (think numpy)
A few things of note.
|
class |
BaseSparseNDArray |
class |
BaseSparseNDArrayCOO |
class |
BaseSparseNDArrayCSR |
Modifier and Type | Method and Description |
---|---|
INDArray |
BaseNDArray.add(INDArray other)
copy addition of two matrices
|
INDArray |
INDArray.add(INDArray other)
Element-wise copy addition of two NDArrays
|
INDArray |
BaseSparseNDArray.add(INDArray other) |
INDArray |
BaseNDArray.add(INDArray other,
INDArray result)
copy addition of two matrices
|
INDArray |
INDArray.add(INDArray other,
INDArray result)
Element-wise copy addition of two NDArrays
|
INDArray |
BaseSparseNDArray.add(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.add(Number n) |
INDArray |
INDArray.add(Number n)
Scalar addition (cloning)
|
INDArray |
BaseSparseNDArray.add(Number n) |
INDArray |
BaseNDArray.add(Number n,
INDArray result) |
INDArray |
INDArray.add(Number n,
INDArray result) |
INDArray |
BaseSparseNDArray.add(Number n,
INDArray result) |
INDArray |
BaseNDArray.addColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.addColumnVector(INDArray columnVector)
Addition of a column vector (copy)
|
INDArray |
BaseSparseNDArray.addColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.addi(INDArray other)
in place addition of two matrices
|
INDArray |
INDArray.addi(INDArray other)
in place (element wise) addition of two NDArrays
|
INDArray |
BaseSparseNDArray.addi(INDArray other) |
INDArray |
BaseNDArray.addi(INDArray other,
INDArray result)
in place addition of two matrices
|
INDArray |
INDArray.addi(INDArray other,
INDArray result)
in place (element wise) addition of two NDArrays
|
INDArray |
BaseSparseNDArray.addi(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.addi(Number n) |
INDArray |
INDArray.addi(Number n)
In place scalar addition
|
INDArray |
BaseSparseNDArray.addi(Number n) |
INDArray |
BaseNDArray.addi(Number n,
INDArray result) |
INDArray |
INDArray.addi(Number n,
INDArray result)
In place addition
|
INDArray |
BaseSparseNDArray.addi(Number n,
INDArray result) |
INDArray |
BaseNDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
BaseSparseNDArray.addiColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.addiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.addiRowVector(INDArray rowVector)
In place addition of a row vector
|
INDArray |
BaseSparseNDArray.addiRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.addRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.addRowVector(INDArray rowVector)
Addition of a row vector (copy)
|
INDArray |
BaseSparseNDArray.addRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.amax(int... dimension) |
INDArray |
INDArray.amax(int... dimension)
Returns the absolute overall max of this ndarray along given dimensions
|
INDArray |
BaseSparseNDArray.amax(int... dimension) |
INDArray |
BaseNDArray.amean(int... dimension) |
INDArray |
INDArray.amean(int... dimension)
Returns the absolute overall mean of this ndarray
|
INDArray |
BaseSparseNDArray.amean(int... dimension) |
INDArray |
BaseNDArray.amin(int... dimension) |
INDArray |
INDArray.amin(int... dimension)
Returns minimum (absolute) value in this INDArray, along the specified dimensions
|
INDArray |
BaseSparseNDArray.amin(int... dimension) |
INDArray |
BaseNDArray.argMax(int... dimension)
This method returns index of highest value along specified dimension(s)
|
INDArray |
INDArray.argMax(int... dimension)
This method returns index of highest value along specified dimension(s)
|
INDArray |
BaseSparseNDArray.argMax(int... dimension) |
INDArray |
BaseNDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
INDArray |
INDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
INDArray |
BaseSparseNDArray.assign(INDArray arr) |
INDArray |
BaseSparseNDArrayCOO.assign(INDArray arr) |
INDArray |
BaseNDArray.assign(Number value)
Set the value of the ndarray to the specified value
|
INDArray |
INDArray.assign(Number value)
Set all entries of the ndarray to the specified value
|
INDArray |
BaseSparseNDArray.assign(Number value) |
INDArray |
BaseNDArray.assignIf(INDArray arr,
Condition condition)
Assign all elements from given ndarray that are matching given condition,
ndarray to this ndarray
|
INDArray |
INDArray.assignIf(INDArray arr,
Condition condition)
Assign all elements from given ndarray that are matching given condition,
ndarray to this ndarray
|
INDArray |
BaseSparseNDArray.assignIf(INDArray arr,
Condition condition) |
INDArray |
BaseNDArray.broadcast(int... shape)
Broadcasts this ndarray to be the specified shape
|
INDArray |
INDArray.broadcast(int... shape)
Broadcasts this ndarray to be the specified shape
|
INDArray |
BaseSparseNDArray.broadcast(int... shape) |
INDArray |
BaseNDArray.cond(Condition condition) |
INDArray |
INDArray.cond(Condition condition)
1 in the ndarray if the element matches
the condition 0 otherwise
|
INDArray |
BaseSparseNDArray.cond(Condition condition) |
INDArray |
BaseNDArray.condi(Condition condition) |
INDArray |
INDArray.condi(Condition condition)
In-place: 1 in the ndarray if the element matches the condition 0 otherwise
|
INDArray |
BaseSparseNDArray.condi(Condition condition) |
INDArray |
BaseNDArray.convertToDoubles() |
INDArray |
INDArray.convertToDoubles() |
INDArray |
BaseSparseNDArrayCOO.convertToDoubles() |
INDArray |
BaseNDArray.convertToFloats() |
INDArray |
INDArray.convertToFloats() |
INDArray |
BaseSparseNDArrayCOO.convertToFloats() |
protected INDArray |
BaseNDArray.create(DataBuffer buffer) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
int[] shape,
int[] strides) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
int[] newShape,
int[] newStrides,
long offset) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
int[] newShape,
int[] newStrides,
long offset,
char ordering) |
protected INDArray |
BaseNDArray.create(DataBuffer data,
int[] shape,
long offset) |
protected INDArray |
BaseNDArray.create(int[] shape) |
protected INDArray |
BaseNDArray.create(int[] shape,
char ordering) |
protected INDArray |
BaseNDArray.create(int[] shape,
int[] strides,
long offset) |
protected INDArray |
BaseNDArray.create(int rows,
int length) |
protected INDArray |
BaseNDArray.createScalar(double d) |
protected INDArray |
BaseNDArray.createScalarForIndex(int i,
boolean applyOffset) |
INDArray |
BaseNDArray.cumsum(int dimension)
Cumulative sum along a dimension (in place)
|
INDArray |
INDArray.cumsum(int dimension)
Returns the cumulative sum along a dimension.
|
INDArray |
BaseSparseNDArray.cumsum(int dimension) |
INDArray |
BaseNDArray.cumsumi(int dimension)
Cumulative sum along a dimension
|
INDArray |
INDArray.cumsumi(int dimension)
Returns the cumulative sum along a dimension.
|
INDArray |
BaseSparseNDArray.cumsumi(int dimension) |
INDArray |
BaseNDArray.detach()
This metod detaches INDArray from Workspace, returning copy.
|
INDArray |
INDArray.detach()
This method detaches INDArray from Workspace, returning copy.
|
INDArray |
BaseSparseNDArray.detach() |
INDArray |
BaseNDArray.dimShuffle(Object[] rearrange,
int[] newOrder,
boolean[] broadCastable)
Dimshuffle: an extension of permute that adds the ability
to broadcast various dimensions.
|
INDArray |
INDArray.dimShuffle(Object[] rearrange,
int[] newOrder,
boolean[] broadCastable)
Dimshuffle: an extension of permute that adds the ability
to broadcast various dimensions.
|
INDArray |
BaseSparseNDArray.dimShuffle(Object[] rearrange,
int[] newOrder,
boolean[] broadCastable) |
INDArray |
BaseNDArray.div(INDArray other)
in place (element wise) division of two matrices
|
INDArray |
INDArray.div(INDArray other)
Copy (element wise) division of two NDArrays
|
INDArray |
BaseSparseNDArray.div(INDArray other) |
INDArray |
BaseNDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two matrices
|
INDArray |
INDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two NDArrays
|
INDArray |
BaseSparseNDArray.div(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.div(Number n) |
INDArray |
INDArray.div(Number n)
Division by a number
|
INDArray |
BaseSparseNDArray.div(Number n) |
INDArray |
BaseNDArray.div(Number n,
INDArray result) |
INDArray |
INDArray.div(Number n,
INDArray result) |
INDArray |
BaseSparseNDArray.div(Number n,
INDArray result) |
INDArray |
BaseNDArray.divColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.divColumnVector(INDArray columnVector)
Division of a column vector (copy)
|
INDArray |
BaseSparseNDArray.divColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.divi(INDArray other)
in place (element wise) division of two matrices
|
INDArray |
INDArray.divi(INDArray other)
in place (element wise) division of two NDArrays
|
INDArray |
BaseSparseNDArray.divi(INDArray other) |
INDArray |
BaseNDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two matrices
|
INDArray |
INDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two NDArrays
|
INDArray |
BaseSparseNDArray.divi(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.divi(Number n) |
INDArray |
INDArray.divi(Number n)
In place scalar division
|
INDArray |
BaseSparseNDArray.divi(Number n) |
INDArray |
BaseNDArray.divi(Number n,
INDArray result) |
INDArray |
INDArray.divi(Number n,
INDArray result)
In place division of this ndarray
|
INDArray |
BaseSparseNDArray.divi(Number n,
INDArray result) |
INDArray |
BaseNDArray.diviColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.diviColumnVector(INDArray columnVector)
In place division of a column vector
|
INDArray |
BaseSparseNDArray.diviColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.diviRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.diviRowVector(INDArray rowVector)
In place division of a row vector
|
INDArray |
BaseSparseNDArray.diviRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.divRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.divRowVector(INDArray rowVector)
Division of a row vector (copy)
|
INDArray |
BaseSparseNDArray.divRowVector(INDArray rowVector) |
protected INDArray |
BaseNDArray.doColumnWise(INDArray columnVector,
char operation)
Do a row wise op (a,s,m,d)
a : add
s : subtract
m : multiply
d : divide
h : reverse subtraction
t : reverse division
|
protected INDArray |
BaseNDArray.doRowWise(INDArray rowVector,
char operation)
Do a row wise op (a,s,m,d)
a : add
s : subtract
m : multiply
d : divide
h : reverse subtraction
t : reverse division
|
INDArray |
BaseNDArray.dup() |
INDArray |
INDArray.dup()
Returns a copy of this ndarray
|
INDArray |
BaseSparseNDArray.dup() |
INDArray |
BaseNDArray.dup(char order) |
INDArray |
INDArray.dup(char order)
Returns a copy of this ndarray, where the returned ndarray has the specified order
|
INDArray |
BaseSparseNDArray.dup(char order) |
INDArray |
BaseNDArray.entropy(int... dimension)
Returns entropy along dimension
|
INDArray |
INDArray.entropy(int... dimension)
Returns entropy value for this INDArray along specified dimension(s)
|
INDArray |
BaseSparseNDArray.entropy(int... dimension)
Returns entropy along dimension
|
INDArray |
BaseNDArray.eps(INDArray other)
epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
INDArray.eps(INDArray other)
Returns the binary ndarray for "Epsilon equals" comparison.
|
INDArray |
BaseSparseNDArray.eps(INDArray other) |
INDArray |
BaseNDArray.eps(Number other)
Returns an ndarray with 1 if the element is epsilon equals
|
INDArray |
INDArray.eps(Number other)
Returns the binary ndarray for "Epsilon equals" comparison.
|
INDArray |
BaseSparseNDArray.eps(Number other) |
INDArray |
BaseNDArray.epsi(INDArray other)
In place epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
INDArray.epsi(INDArray other)
Returns the binary ndarray for "Epsilon equals" comparison.
|
INDArray |
BaseSparseNDArray.epsi(INDArray other) |
INDArray |
BaseNDArray.epsi(Number other)
Returns an ndarray with 1 if the element is epsilon equals
|
INDArray |
INDArray.epsi(Number other)
Returns the binary ndarray for "Epsilon equals" comparison.
|
INDArray |
BaseSparseNDArray.epsi(Number other) |
INDArray |
BaseNDArray.eq(INDArray other) |
INDArray |
INDArray.eq(INDArray other)
Returns the binary ndarray for "Equals" comparison.
|
INDArray |
BaseSparseNDArray.eq(INDArray other) |
INDArray |
BaseNDArray.eq(Number other) |
INDArray |
INDArray.eq(Number other)
Returns the binary ndarray for "Equals" comparison.
|
INDArray |
BaseSparseNDArray.eq(Number other) |
INDArray |
BaseNDArray.eqi(INDArray other) |
INDArray |
INDArray.eqi(INDArray other)
Returns the binary ndarray for "Equals" comparison.
|
INDArray |
BaseSparseNDArray.eqi(INDArray other) |
INDArray |
BaseNDArray.eqi(Number other) |
INDArray |
INDArray.eqi(Number other)
Returns the binary ndarray for "Equals" comparison.
|
INDArray |
BaseSparseNDArray.eqi(Number other) |
INDArray |
BaseNDArray.fmod(INDArray denominator) |
INDArray |
INDArray.fmod(INDArray denominator)
remainder of division
|
INDArray |
BaseSparseNDArray.fmod(INDArray denominator) |
INDArray |
BaseNDArray.fmod(INDArray denominator,
INDArray result) |
INDArray |
INDArray.fmod(INDArray denominator,
INDArray result)
remainder of division
|
INDArray |
BaseSparseNDArray.fmod(INDArray denominator,
INDArray result) |
INDArray |
BaseNDArray.fmod(Number denominator) |
INDArray |
INDArray.fmod(Number denominator) |
INDArray |
BaseSparseNDArray.fmod(Number denominator) |
INDArray |
BaseNDArray.fmod(Number denominator,
INDArray result) |
INDArray |
INDArray.fmod(Number denominator,
INDArray result) |
INDArray |
BaseSparseNDArray.fmod(Number denominator,
INDArray result) |
INDArray |
BaseNDArray.fmodi(INDArray denominator) |
INDArray |
INDArray.fmodi(INDArray denominator)
In place fmod
|
INDArray |
BaseSparseNDArray.fmodi(INDArray denominator) |
INDArray |
BaseNDArray.fmodi(Number denominator) |
INDArray |
INDArray.fmodi(Number denominator)
In place fmod
|
INDArray |
BaseSparseNDArray.fmodi(Number denominator) |
INDArray |
BaseNDArray.get(INDArray indices) |
INDArray |
INDArray.get(INDArray indices)
Get the elements from this ndarray based on the specified indices
|
INDArray |
BaseSparseNDArray.get(INDArray indices) |
INDArray |
BaseNDArray.get(INDArrayIndex... indexes)
Returns a subset of this array based on the specified
indexes
|
INDArray |
INDArray.get(INDArrayIndex... indexes)
Returns a subset of this array based on the specified
indexes
|
INDArray |
BaseSparseNDArray.get(INDArrayIndex... indexes) |
INDArray |
BaseSparseNDArrayCOO.get(INDArrayIndex... indexes)
Returns a subset of this array based on the specified
indexes
|
INDArray |
BaseSparseNDArrayCSR.get(INDArrayIndex... indexes)
Returns a subset of this array based on the specified
indexes
|
INDArray |
BaseNDArray.get(List<List<Integer>> indices) |
INDArray |
INDArray.get(List<List<Integer>> indices)
Get the elements from this ndarray based on the specified indices
|
INDArray |
BaseSparseNDArray.get(List<List<Integer>> indices) |
INDArray |
BaseNDArray.getColumn(int c)
Get the specified column
|
INDArray |
INDArray.getColumn(int i)
Returns the specified column.
|
INDArray |
BaseSparseNDArray.getColumn(int i) |
INDArray |
BaseNDArray.getColumns(int... cindices)
Get whole columns
from the passed indices.
|
INDArray |
INDArray.getColumns(int... columns)
Get an INDArray comprised of the specified columns only.
|
INDArray |
BaseSparseNDArray.getColumns(int... columns) |
INDArray |
BaseNDArray.getRow(int r)
Get a copy of a row.
|
INDArray |
INDArray.getRow(int i)
Returns the specified row.
|
INDArray |
BaseSparseNDArray.getRow(int i) |
INDArray |
INDArray.getRows(int... rows)
Get an INDArray comprised of the specified rows only.
|
INDArray |
BaseSparseNDArray.getRows(int... rows) |
INDArray |
BaseNDArray.getRows(int[] rindices)
Get whole rows from the passed indices.
|
INDArray |
BaseNDArray.getScalar(int... indexes)
Fetch a particular number on a multi dimensional scale.
|
INDArray |
INDArray.getScalar(int... indices)
Returns the elements at the the specified indices
|
INDArray |
BaseSparseNDArray.getScalar(int... indices) |
INDArray |
BaseSparseNDArrayCOO.getScalar(int... indices) |
INDArray |
BaseNDArray.getScalar(int i) |
INDArray |
INDArray.getScalar(int i)
Returns the element at the specified index
|
INDArray |
BaseSparseNDArray.getScalar(int i) |
INDArray |
BaseNDArray.getScalar(int row,
int column)
Returns the element at the specified row/column
This will throw an exception if the
|
INDArray |
INDArray.getScalar(int row,
int column)
Returns the element at the specified row/column
This will throw an exception if the
|
INDArray |
BaseSparseNDArray.getScalar(int row,
int column) |
INDArray |
BaseNDArray.getWhere(INDArray comp,
Condition condition) |
INDArray |
INDArray.getWhere(INDArray comp,
Condition condition)
Boolean indexing:
Return the element if it fulfills the condition in
result array
|
INDArray |
BaseSparseNDArray.getWhere(INDArray comp,
Condition condition) |
INDArray |
BaseNDArray.getWhere(Number comp,
Condition condition) |
INDArray |
INDArray.getWhere(Number comp,
Condition condition)
Boolean indexing:
Return the element if it fulfills the condition in
result array
|
INDArray |
BaseSparseNDArray.getWhere(Number comp,
Condition condition) |
INDArray |
BaseNDArray.gt(INDArray other) |
INDArray |
INDArray.gt(INDArray other)
Returns the binary ndarray for "Greter" comparison.
|
INDArray |
BaseSparseNDArray.gt(INDArray other) |
INDArray |
BaseNDArray.gt(Number other) |
INDArray |
INDArray.gt(Number other)
Returns the binary ndarray for "Greater" comparison.
|
INDArray |
BaseSparseNDArray.gt(Number other) |
INDArray |
BaseNDArray.gte(Number other) |
INDArray |
INDArray.gte(Number other)
Returns binary ndarray for "Greter or equals" comparison.
|
INDArray |
BaseSparseNDArray.gte(Number other) |
INDArray |
BaseNDArray.gtei(Number other) |
INDArray |
INDArray.gtei(Number other)
Returns the binary ndarray for "Greter or equals" comparison.
|
INDArray |
BaseSparseNDArray.gtei(Number other) |
INDArray |
BaseNDArray.gti(INDArray other) |
INDArray |
INDArray.gti(INDArray other)
Returns the binary ndarray for "Greter" comparison.
|
INDArray |
BaseSparseNDArray.gti(INDArray other) |
INDArray |
BaseNDArray.gti(Number other) |
INDArray |
INDArray.gti(Number other)
Returns the binary ndarray for "Greter" comparison.
|
INDArray |
BaseSparseNDArray.gti(Number other) |
INDArray |
BaseNDArray.javaTensorAlongDimension(int index,
int... dimension)
Get the vector along a particular dimension
|
INDArray |
INDArray.javaTensorAlongDimension(int index,
int... dimension)
Get the vector along a particular dimension
|
INDArray |
BaseSparseNDArray.javaTensorAlongDimension(int index,
int... dimension) |
INDArray |
BaseNDArray.leverage()
This method detaches INDArray from current Workspace, and attaches it to Workspace above, if any.
|
INDArray |
INDArray.leverage()
This method detaches INDArray from current Workspace, and attaches it to Workspace above, if any.
|
INDArray |
BaseSparseNDArray.leverage() |
INDArray |
BaseNDArray.leverageOrDetach(String id)
This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id, if a workspace
with the given ID is open and active.
|
INDArray |
INDArray.leverageOrDetach(String id)
This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id, if a workspace
with the given ID is open and active.
|
INDArray |
BaseSparseNDArray.leverageOrDetach(String id) |
INDArray |
BaseNDArray.leverageTo(String id)
This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id
PLEASE NOTE: If this INDArray instance is NOT attached - it will be returned unmodified.
|
INDArray |
INDArray.leverageTo(String id)
This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id - if a workspace
with that ID exists.
|
INDArray |
BaseSparseNDArray.leverageTo(String id) |
INDArray |
BaseNDArray.leverageTo(String id,
boolean enforceExistence)
This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id.
|
INDArray |
INDArray.leverageTo(String id,
boolean enforceExistence)
This method detaches INDArray from current Workspace, and attaches it to Workspace with a given Id.
|
INDArray |
BaseSparseNDArray.leverageTo(String id,
boolean enforceExistence) |
INDArray |
BaseNDArray.linearView()
Returns a linear view reference of shape
1,length(ndarray)
|
INDArray |
INDArray.linearView()
Returns a linear view reference of shape
1,length(ndarray)
|
INDArray |
BaseSparseNDArray.linearView() |
INDArray |
BaseNDArray.linearViewColumnOrder()
Deprecated.
|
INDArray |
INDArray.linearViewColumnOrder()
Returns a linear view reference of shape
1,length(ndarray)
|
INDArray |
BaseSparseNDArray.linearViewColumnOrder() |
INDArray |
BaseNDArray.logEntropy(int... dimension)
Returns log entropy along dimension
|
INDArray |
INDArray.logEntropy(int... dimension)
Returns entropy value for this INDArray along specified dimension(s)
|
INDArray |
BaseSparseNDArray.logEntropy(int... dimension)
Returns log entropy along dimension
|
INDArray |
BaseNDArray.lt(INDArray other) |
INDArray |
INDArray.lt(INDArray other)
Returns the binary ndarray for "Less" comparison.
|
INDArray |
BaseSparseNDArray.lt(INDArray other) |
INDArray |
BaseNDArray.lt(Number other) |
INDArray |
INDArray.lt(Number other)
Returns the binary ndarray for "Less" comparison.
|
INDArray |
BaseSparseNDArray.lt(Number other) |
INDArray |
BaseNDArray.lte(Number other) |
INDArray |
INDArray.lte(Number other)
Returns the binary ndarray for "Less or equals" comparison.
|
INDArray |
BaseSparseNDArray.lte(Number other) |
INDArray |
BaseNDArray.ltei(Number other) |
INDArray |
INDArray.ltei(Number other)
Returns the binary ndarray for "Less or equals" comparison.
|
INDArray |
BaseSparseNDArray.ltei(Number other) |
INDArray |
BaseNDArray.lti(INDArray other) |
INDArray |
INDArray.lti(INDArray other)
Returns the binary ndarray for "Less" comparison.
|
INDArray |
BaseSparseNDArray.lti(INDArray other) |
INDArray |
BaseNDArray.lti(Number other) |
INDArray |
INDArray.lti(Number other)
Returns the binary ndarray for "Less" comparison.
|
INDArray |
BaseSparseNDArray.lti(Number other) |
INDArray |
BaseNDArray.match(INDArray comp,
Condition condition) |
INDArray |
INDArray.match(INDArray comp,
Condition condition)
Return a mask on whether each element
matches the given condition
|
INDArray |
BaseSparseNDArray.match(INDArray comp,
Condition condition) |
INDArray |
BaseNDArray.match(Number comp,
Condition condition) |
INDArray |
INDArray.match(Number comp,
Condition condition)
Returns a mask
|
INDArray |
BaseSparseNDArray.match(Number comp,
Condition condition) |
INDArray |
BaseNDArray.max(int... dimension)
Returns the overall max of this ndarray
|
INDArray |
INDArray.max(int... dimension)
Returns the overall max of this ndarray along given dimensions
|
INDArray |
BaseSparseNDArray.max(int... dimension) |
INDArray |
BaseNDArray.mean(INDArray result,
int... dimension) |
INDArray |
INDArray.mean(INDArray result,
int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
BaseSparseNDArray.mean(INDArray result,
int... dimension) |
INDArray |
BaseNDArray.mean(int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
INDArray.mean(int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
BaseSparseNDArray.mean(int... dimension) |
INDArray |
BaseNDArray.median(int... dimension) |
INDArray |
INDArray.median(int... dimension)
This method returns median along given dimension(s)
|
INDArray |
BaseSparseNDArray.median(int... dimension) |
INDArray |
BaseNDArray.migrate()
This method pulls this INDArray into current Workspace.
|
INDArray |
INDArray.migrate()
This method pulls this INDArray into current Workspace.
|
INDArray |
BaseSparseNDArray.migrate() |
INDArray |
BaseNDArray.migrate(boolean detachOnNoWs)
This method pulls this INDArray into current Workspace, or optionally detaches if no workspace is present.
That is: If current workspace is present/active, INDArray is migrated to it. If no current workspace is present/active, one of two things occur: 1. |
INDArray |
INDArray.migrate(boolean detachOnNoWs)
This method pulls this INDArray into current Workspace, or optionally detaches if no workspace is present.
That is: If current workspace is present/active, INDArray is migrated to it. If no current workspace is present/active, one of two things occur: 1. |
INDArray |
BaseSparseNDArray.migrate(boolean detachIfNoWs) |
INDArray |
BaseNDArray.min(int... dimension)
Returns the overall min of this ndarray
|
INDArray |
INDArray.min(int... dimension)
Returns the overall min of this ndarray
|
INDArray |
BaseSparseNDArray.min(int... dimension) |
INDArray |
BaseNDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
BaseSparseNDArray.mmul(INDArray other) |
INDArray |
BaseNDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
BaseSparseNDArray.mmul(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.mmul(INDArray other,
INDArray result,
MMulTranspose mMulTranspose)
Perform a copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other,
INDArray result,
MMulTranspose mMulTranspose)
Perform an copy matrix multiplication
|
INDArray |
BaseSparseNDArrayCOO.mmul(INDArray other,
INDArray result,
MMulTranspose mMulTranspose)
Perform an copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other,
MMulTranspose mMulTranspose)
Perform a copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other,
MMulTranspose mMulTranspose) |
INDArray |
BaseSparseNDArrayCOO.mmul(INDArray other,
MMulTranspose mMulTranspose) |
INDArray |
BaseNDArray.mmuli(INDArray other)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other)
Perform an inplace matrix multiplication
|
INDArray |
BaseSparseNDArray.mmuli(INDArray other) |
INDArray |
BaseNDArray.mmuli(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other,
INDArray result)
Perform an inplace matrix multiplication
|
INDArray |
BaseSparseNDArray.mmuli(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.mmuli(INDArray other,
INDArray result,
MMulTranspose transpose)
Perform an in place matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other,
INDArray result,
MMulTranspose transpose) |
INDArray |
BaseSparseNDArrayCOO.mmuli(INDArray other,
INDArray result,
MMulTranspose transpose) |
INDArray |
BaseNDArray.mmuli(INDArray other,
MMulTranspose transpose)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other,
MMulTranspose transpose) |
INDArray |
BaseSparseNDArrayCOO.mmuli(INDArray other,
MMulTranspose transpose) |
INDArray |
BaseNDArray.mul(INDArray other)
copy (element wise) multiplication of two matrices
|
INDArray |
INDArray.mul(INDArray other)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseSparseNDArray.mul(INDArray other) |
INDArray |
BaseNDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two matrices
|
INDArray |
INDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseSparseNDArray.mul(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.mul(Number n) |
INDArray |
INDArray.mul(Number n)
Scalar multiplication (copy)
|
INDArray |
BaseSparseNDArray.mul(Number n) |
INDArray |
BaseNDArray.mul(Number n,
INDArray result) |
INDArray |
INDArray.mul(Number n,
INDArray result) |
INDArray |
BaseSparseNDArray.mul(Number n,
INDArray result) |
INDArray |
BaseNDArray.mulColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.mulColumnVector(INDArray columnVector)
Multiplication of a column vector (copy)
|
INDArray |
BaseSparseNDArray.mulColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.muli(INDArray other)
in place (element wise) multiplication of two matrices
|
INDArray |
INDArray.muli(INDArray other)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseSparseNDArray.muli(INDArray other) |
INDArray |
BaseNDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two matrices
|
INDArray |
INDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseSparseNDArray.muli(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.muli(Number n) |
INDArray |
INDArray.muli(Number n)
In place scalar multiplication
|
INDArray |
BaseSparseNDArray.muli(Number n) |
INDArray |
BaseNDArray.muli(Number n,
INDArray result) |
INDArray |
INDArray.muli(Number n,
INDArray result)
In place multiplication of this ndarray
|
INDArray |
BaseSparseNDArray.muli(Number n,
INDArray result) |
INDArray |
BaseNDArray.muliColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.muliColumnVector(INDArray columnVector)
In place multiplication of a column vector
|
INDArray |
BaseSparseNDArray.muliColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.muliRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.muliRowVector(INDArray rowVector)
In place multiplication of a row vector
|
INDArray |
BaseSparseNDArray.muliRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.mulRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.mulRowVector(INDArray rowVector)
Multiplication of a row vector (copy)
|
INDArray |
BaseSparseNDArray.mulRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.neg()
Negate each element.
|
INDArray |
INDArray.neg()
Returns the ndarray negative (cloned)
|
INDArray |
BaseSparseNDArray.neg() |
INDArray |
BaseNDArray.negi()
Negate each element (in-place).
|
INDArray |
INDArray.negi()
In place setting of the negative version of this ndarray
|
INDArray |
BaseSparseNDArray.negi() |
INDArray |
BaseNDArray.neq(INDArray other) |
INDArray |
INDArray.neq(INDArray other)
Returns the binary ndarray for "Not equals" comparison.
|
INDArray |
BaseSparseNDArray.neq(INDArray other) |
INDArray |
BaseNDArray.neq(Number other) |
INDArray |
INDArray.neq(Number other)
Returns the binary ndarray for "Not equals" comparison.
|
INDArray |
BaseSparseNDArray.neq(Number other) |
INDArray |
BaseNDArray.neqi(INDArray other) |
INDArray |
INDArray.neqi(INDArray other)
Returns the binary ndarray for "Not equals" comparison.
|
INDArray |
BaseSparseNDArray.neqi(INDArray other) |
INDArray |
BaseNDArray.neqi(Number other) |
INDArray |
INDArray.neqi(Number other)
Returns the binary ndarray for "Not equals" comparison.
|
INDArray |
BaseSparseNDArray.neqi(Number other) |
protected INDArray |
BaseNDArray.newShape(int[] newShape,
char ordering) |
INDArray |
BaseNDArray.norm1(int... dimension)
Returns the norm1 along the specified dimension
|
INDArray |
INDArray.norm1(int... dimension)
Returns the norm1 (L1 norm, i.e., sum of absolute values; also known as Taxicab or Manhattan norm) along the
specified dimension
|
INDArray |
BaseSparseNDArray.norm1(int... dimension) |
INDArray |
BaseNDArray.norm2(int... dimension)
Returns the norm2 along the specified dimension
|
INDArray |
INDArray.norm2(int... dimension)
Returns the norm2 (L2 norm, sqrt(sum(x_i^2), also known as Euclidean norm) along the specified dimension(s)
|
INDArray |
BaseSparseNDArray.norm2(int... dimension) |
INDArray |
BaseNDArray.normmax(int... dimension)
Returns the normmax along the specified dimension
|
INDArray |
INDArray.normmax(int... dimension)
Returns the max norm (aka infinity norm, equal to the maximum absolute value) along the specified dimension(s)
|
INDArray |
BaseSparseNDArray.normmax(int... dimension) |
INDArray |
BaseNDArray.percentile(Number quantile,
int... dimension) |
INDArray |
INDArray.percentile(Number percentile,
int... dimension)
This method returns median along given dimension(s)
|
INDArray |
BaseSparseNDArray.percentile(Number quantile,
int... dimension) |
INDArray |
BaseNDArray.permute(int... rearrange)
See: http://www.mathworks.com/help/matlab/ref/permute.html
|
INDArray |
INDArray.permute(int... rearrange)
See: http://www.mathworks.com/help/matlab/ref/permute.html
|
INDArray |
BaseSparseNDArray.permute(int... rearrange) |
INDArray |
BaseNDArray.permutei(int... rearrange)
An in-place version of permute.
|
INDArray |
INDArray.permutei(int... rearrange)
An in-place version of permute.
|
INDArray |
BaseSparseNDArray.permutei(int... rearrange) |
INDArray |
BaseNDArray.prod(int... dimension)
Returns the product along a given dimension
|
INDArray |
INDArray.prod(int... dimension)
Returns the product along a given dimension
|
INDArray |
BaseSparseNDArray.prod(int... dimension) |
INDArray |
BaseNDArray.put(INDArray indices,
INDArray element) |
INDArray |
INDArray.put(INDArray indices,
INDArray element)
Put element in to the indices denoted by
the indices ndarray.
|
INDArray |
BaseSparseNDArray.put(INDArray indices,
INDArray element) |
INDArray |
BaseNDArray.put(INDArrayIndex[] indices,
INDArray element) |
INDArray |
INDArray.put(INDArrayIndex[] indices,
INDArray element)
Put the elements of the ndarray
in to the specified indices
|
INDArray |
BaseSparseNDArray.put(INDArrayIndex[] indices,
INDArray element) |
INDArray |
BaseSparseNDArrayCOO.put(INDArrayIndex[] indices,
INDArray element) |
INDArray |
BaseNDArray.put(INDArrayIndex[] indices,
Number element) |
INDArray |
INDArray.put(INDArrayIndex[] indices,
Number element)
Put the elements of the ndarray
in to the specified indices
|
INDArray |
BaseSparseNDArray.put(INDArrayIndex[] indices,
Number element) |
INDArray |
BaseSparseNDArrayCOO.put(INDArrayIndex[] indices,
Number element) |
INDArray |
BaseNDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseSparseNDArray.put(int[] indices,
INDArray element) |
INDArray |
BaseSparseNDArrayCOO.put(int[] indexes,
INDArray element) |
INDArray |
BaseNDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseSparseNDArray.put(int i,
INDArray element) |
INDArray |
BaseSparseNDArrayCOO.put(int i,
INDArray element) |
INDArray |
BaseNDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseSparseNDArray.put(int i,
int j,
INDArray element) |
INDArray |
BaseSparseNDArrayCOO.put(int i,
int j,
INDArray element) |
INDArray |
BaseNDArray.put(int i,
int j,
Number element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int i,
int j,
Number element)
Inserts the element at the specified index
|
INDArray |
BaseSparseNDArray.put(int i,
int j,
Number element) |
INDArray |
BaseSparseNDArrayCOO.put(int i,
int j,
Number element) |
INDArray |
BaseNDArray.put(List<List<Integer>> indices,
INDArray element) |
INDArray |
INDArray.put(List<List<Integer>> indices,
INDArray element)
Put element in to the indices denoted by
the indices ndarray.
|
INDArray |
BaseSparseNDArray.put(List<List<Integer>> indices,
INDArray element) |
INDArray |
BaseNDArray.putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
INDArray.putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
BaseSparseNDArray.putColumn(int column,
INDArray toPut) |
INDArray |
BaseSparseNDArrayCOO.putColumn(int column,
INDArray toPut) |
INDArray |
BaseNDArray.putiColumnVector(INDArray columnVector) |
INDArray |
INDArray.putiColumnVector(INDArray columnVector)
In place assignment of a column vector
|
INDArray |
BaseSparseNDArrayCOO.putiColumnVector(INDArray columnVector) |
INDArray |
BaseSparseNDArrayCSR.putiColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.putiRowVector(INDArray rowVector) |
INDArray |
INDArray.putiRowVector(INDArray rowVector)
in place assignment of row vector, to each row of this array
|
INDArray |
BaseSparseNDArrayCOO.putiRowVector(INDArray rowVector) |
INDArray |
BaseSparseNDArrayCSR.putiRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.putRow(int row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
INDArray.putRow(int row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
BaseSparseNDArray.putRow(int row,
INDArray toPut) |
INDArray |
BaseSparseNDArrayCOO.putRow(int row,
INDArray toPut) |
INDArray |
BaseNDArray.putScalar(int[] indexes,
double value) |
INDArray |
INDArray.putScalar(int[] i,
double value)
Insert the item at the specified indices
|
INDArray |
BaseSparseNDArray.putScalar(int[] i,
double value) |
INDArray |
BaseSparseNDArrayCOO.putScalar(int[] indexes,
double value) |
INDArray |
BaseNDArray.putScalar(int[] indexes,
float value) |
INDArray |
INDArray.putScalar(int[] indexes,
float value)
Put the specified float value at the specified indices in this array
|
INDArray |
BaseSparseNDArray.putScalar(int[] indexes,
float value) |
INDArray |
BaseNDArray.putScalar(int[] indexes,
int value) |
INDArray |
INDArray.putScalar(int[] indexes,
int value)
Put the specified integer value at the specified indices in this array
|
INDArray |
BaseSparseNDArray.putScalar(int[] indexes,
int value) |
INDArray |
BaseNDArray.putScalar(int i,
double value) |
INDArray |
INDArray.putScalar(int i,
double value)
Insert the number linearly in to the ndarray
|
INDArray |
BaseSparseNDArray.putScalar(int i,
double value) |
INDArray |
BaseSparseNDArrayCOO.putScalar(int i,
double value) |
INDArray |
BaseNDArray.putScalar(int i,
float value) |
INDArray |
INDArray.putScalar(int i,
float value)
Insert a scalar float at the specified index
|
INDArray |
BaseSparseNDArray.putScalar(int i,
float value) |
INDArray |
BaseSparseNDArrayCOO.putScalar(int i,
float value) |
INDArray |
BaseNDArray.putScalar(int i,
int value) |
INDArray |
INDArray.putScalar(int i,
int value)
Insert a scalar int at the specified index
|
INDArray |
BaseSparseNDArray.putScalar(int i,
int value) |
INDArray |
BaseSparseNDArrayCOO.putScalar(int i,
int value) |
INDArray |
BaseNDArray.putScalar(int row,
int col,
double value) |
INDArray |
INDArray.putScalar(int row,
int col,
double value)
Insert the value at the specified indices, in a 2d (rank 2) NDArray
Equivalent to putScalar(int[], double) but avoids int[] creation |
INDArray |
BaseSparseNDArray.putScalar(int row,
int col,
double value) |
INDArray |
BaseSparseNDArrayCOO.putScalar(int row,
int col,
double value) |
INDArray |
BaseSparseNDArrayCSR.putScalar(int row,
int col,
double value) |
INDArray |
BaseNDArray.putScalar(int dim0,
int dim1,
int dim2,
double value) |
INDArray |
INDArray.putScalar(int dim0,
int dim1,
int dim2,
double value)
Insert the value at the specified indices, in a 3d (rank 3) NDArray
Equivalent to putScalar(int[], double) but avoids int[] creation |
INDArray |
BaseSparseNDArray.putScalar(int dim0,
int dim1,
int dim2,
double value) |
INDArray |
BaseSparseNDArrayCOO.putScalar(int dim0,
int dim1,
int dim2,
double value) |
INDArray |
BaseNDArray.putScalar(int dim0,
int dim1,
int dim2,
int dim3,
double value) |
INDArray |
INDArray.putScalar(int dim0,
int dim1,
int dim2,
int dim3,
double value)
Insert the value at the specified indices, in a 4d (rank 4) NDArray
Equivalent to putScalar(int[], double) but avoids int[] creation |
INDArray |
BaseSparseNDArray.putScalar(int dim0,
int dim1,
int dim2,
int dim3,
double value) |
INDArray |
BaseSparseNDArrayCOO.putScalar(int dim0,
int dim1,
int dim2,
int dim3,
double value) |
INDArray |
BaseNDArray.putScalarUnsafe(long offset,
double value) |
INDArray |
INDArray.putScalarUnsafe(long offset,
double value)
Insert a scalar
at the given linear offset
|
INDArray |
BaseSparseNDArray.putScalarUnsafe(long offset,
double value) |
INDArray |
BaseNDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
INDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
BaseSparseNDArray.putSlice(int slice,
INDArray put) |
INDArray |
BaseNDArray.putWhere(INDArray comp,
INDArray put,
Condition condition) |
INDArray |
INDArray.putWhere(INDArray comp,
INDArray put,
Condition condition)
Assign the element according
to the comparison array
|
INDArray |
BaseSparseNDArray.putWhere(INDArray comp,
INDArray put,
Condition condition) |
INDArray |
BaseNDArray.putWhere(Number comp,
INDArray put,
Condition condition) |
INDArray |
INDArray.putWhere(Number comp,
INDArray put,
Condition condition)
Assign the element according
to the comparison array
|
INDArray |
BaseSparseNDArray.putWhere(Number comp,
INDArray put,
Condition condition) |
INDArray |
BaseNDArray.putWhere(Number comp,
Number put,
Condition condition) |
INDArray |
INDArray.putWhere(Number comp,
Number put,
Condition condition)
Assign the element according
to the comparison array
|
INDArray |
BaseSparseNDArray.putWhere(Number comp,
Number put,
Condition condition) |
INDArray |
BaseNDArray.putWhereWithMask(INDArray mask,
INDArray put) |
INDArray |
INDArray.putWhereWithMask(INDArray mask,
INDArray put)
Use a pre computed mask
for assigning arrays
|
INDArray |
BaseSparseNDArray.putWhereWithMask(INDArray mask,
INDArray put) |
INDArray |
BaseNDArray.putWhereWithMask(INDArray mask,
Number put) |
INDArray |
INDArray.putWhereWithMask(INDArray mask,
Number put)
Use a pre computed mask
for assigning arrays
|
INDArray |
BaseSparseNDArray.putWhereWithMask(INDArray mask,
Number put) |
INDArray |
BaseNDArray.ravel()
Flattens the array for linear indexing
|
INDArray |
INDArray.ravel()
Returns a flattened version (row vector) of this ndarray
|
INDArray |
BaseSparseNDArray.ravel() |
INDArray |
BaseNDArray.ravel(char ordering)
Flattens the array for linear indexing
|
INDArray |
INDArray.ravel(char order)
Returns a flattened version (row vector) of this ndarray
|
INDArray |
BaseSparseNDArray.ravel(char order) |
INDArray |
BaseNDArray.rdiv(INDArray other)
Reverse division
|
INDArray |
INDArray.rdiv(INDArray other)
Reverse division, elements wise.
|
INDArray |
BaseSparseNDArray.rdiv(INDArray other) |
INDArray |
BaseNDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
INDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
BaseSparseNDArray.rdiv(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.rdiv(Number n) |
INDArray |
INDArray.rdiv(Number n)
Reverse division with a scalar - i.e., (n / thisArrayValues)
|
INDArray |
BaseSparseNDArray.rdiv(Number n) |
INDArray |
BaseNDArray.rdiv(Number n,
INDArray result) |
INDArray |
INDArray.rdiv(Number n,
INDArray result)
Reverse division (number / ndarray)
|
INDArray |
BaseSparseNDArray.rdiv(Number n,
INDArray result) |
INDArray |
BaseNDArray.rdivColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdivColumnVector(INDArray columnVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseSparseNDArray.rdivColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
INDArray |
INDArray.rdivi(INDArray other)
Reverse divsion (in place).
|
INDArray |
BaseSparseNDArray.rdivi(INDArray other) |
INDArray |
BaseNDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
INDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
BaseSparseNDArray.rdivi(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.rdivi(Number n) |
INDArray |
INDArray.rdivi(Number n)
In place reverse division - i.e., (n / thisArrayValues)
|
INDArray |
BaseSparseNDArray.rdivi(Number n) |
INDArray |
BaseNDArray.rdivi(Number n,
INDArray result) |
INDArray |
INDArray.rdivi(Number n,
INDArray result)
Reverse in place division
|
INDArray |
BaseSparseNDArray.rdivi(Number n,
INDArray result) |
INDArray |
BaseNDArray.rdiviColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdiviColumnVector(INDArray columnVector)
In place reverse divison of a column vector
|
INDArray |
BaseSparseNDArray.rdiviColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.rdiviRowVector(INDArray rowVector) |
INDArray |
INDArray.rdiviRowVector(INDArray rowVector)
In place reverse division of a column vector
|
INDArray |
BaseSparseNDArray.rdiviRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.rdivRowVector(INDArray rowVector) |
INDArray |
INDArray.rdivRowVector(INDArray rowVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseSparseNDArray.rdivRowVector(INDArray rowVector) |
INDArray |
NdArrayJSONReader.read(File jsonFile)
Deprecated.
|
INDArray |
BaseNDArray.remainder(INDArray denominator) |
INDArray |
INDArray.remainder(INDArray denominator)
Remainder operator
|
INDArray |
BaseSparseNDArray.remainder(INDArray denominator) |
INDArray |
BaseNDArray.remainder(INDArray denominator,
INDArray result) |
INDArray |
INDArray.remainder(INDArray denominator,
INDArray result)
Remainder operator
|
INDArray |
BaseSparseNDArray.remainder(INDArray denominator,
INDArray result) |
INDArray |
BaseNDArray.remainder(Number denominator) |
INDArray |
INDArray.remainder(Number denominator)
The scalar denominator
|
INDArray |
BaseSparseNDArray.remainder(Number denominator) |
INDArray |
BaseNDArray.remainder(Number denominator,
INDArray result) |
INDArray |
INDArray.remainder(Number denominator,
INDArray result) |
INDArray |
BaseSparseNDArray.remainder(Number denominator,
INDArray result) |
INDArray |
BaseNDArray.remainderi(INDArray denominator) |
INDArray |
INDArray.remainderi(INDArray denominator)
In place remainder
|
INDArray |
BaseSparseNDArray.remainderi(INDArray denominator) |
INDArray |
BaseNDArray.remainderi(Number denominator) |
INDArray |
INDArray.remainderi(Number denominator)
In place remainder
|
INDArray |
BaseSparseNDArray.remainderi(Number denominator) |
INDArray |
BaseSparseNDArrayCOO.removeEntry(int idx)
Remove an element of the ndarray
|
INDArray |
BaseNDArray.repeat(int dimension,
int... repeats) |
INDArray |
INDArray.repeat(int dimension,
int... repeats)
Repeat elements along a specified dimension.
|
INDArray |
BaseSparseNDArray.repeat(int dimension,
int... repeats) |
INDArray |
BaseNDArray.replaceWhere(INDArray arr,
Condition condition)
Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
|
INDArray |
INDArray.replaceWhere(INDArray arr,
Condition condition)
Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
|
INDArray |
BaseSparseNDArray.replaceWhere(INDArray arr,
Condition condition) |
INDArray |
INDArray.repmat(int... shape)
Replicate and tile array to fill out to the given shape
|
INDArray |
BaseSparseNDArray.repmat(int... shape) |
INDArray |
BaseNDArray.repmat(int[] shape)
Replicate and tile array to fill out to the given shape
See:
https://github.com/numpy/numpy/blob/master/numpy/matlib.py#L310-L358
|
INDArray |
BaseNDArray.reshape(char order,
int... newShape) |
INDArray |
INDArray.reshape(char order,
int... newShape)
Reshapes the ndarray (can't change the length of the ndarray).
|
INDArray |
BaseSparseNDArray.reshape(char order,
int... newShape) |
INDArray |
BaseNDArray.reshape(char order,
int rows,
int columns) |
INDArray |
INDArray.reshape(char order,
int rows,
int columns)
Reshapes the ndarray (can't change the length of the ndarray).
|
INDArray |
BaseSparseNDArray.reshape(char order,
int rows,
int columns) |
INDArray |
BaseNDArray.reshape(int... shape)
Reshape the ndarray in to the specified dimensions,
possible errors being thrown for invalid shapes
Note here that one dimension can be -1.
|
INDArray |
INDArray.reshape(int... newShape)
Reshapes the ndarray (can't change the length of the ndarray).
|
INDArray |
BaseSparseNDArray.reshape(int... newShape) |
INDArray |
BaseNDArray.reshape(int newRows,
int newColumns)
Reshape the matrix.
|
INDArray |
INDArray.reshape(int rows,
int columns)
Reshapes the ndarray (can't change the length of the ndarray).
|
INDArray |
BaseSparseNDArray.reshape(int rows,
int columns) |
INDArray |
BaseNDArray.rsub(INDArray other) |
INDArray |
INDArray.rsub(INDArray other)
Element-wise reverse subtraction (copy op).
|
INDArray |
BaseSparseNDArray.rsub(INDArray other) |
INDArray |
BaseNDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
INDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
BaseSparseNDArray.rsub(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.rsub(Number n) |
INDArray |
INDArray.rsub(Number n)
Reverse subtraction with duplicates - i.e., (n - thisArrayValues)
|
INDArray |
BaseSparseNDArray.rsub(Number n) |
INDArray |
BaseNDArray.rsub(Number n,
INDArray result) |
INDArray |
INDArray.rsub(Number n,
INDArray result)
Reverse subtraction
|
INDArray |
BaseSparseNDArray.rsub(Number n,
INDArray result) |
INDArray |
BaseNDArray.rsubColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubColumnVector(INDArray columnVector)
Reverse subtraction of a column vector (copy)
|
INDArray |
BaseSparseNDArray.rsubColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.rsubi(INDArray other) |
INDArray |
INDArray.rsubi(INDArray other)
Element-wise reverse subtraction (in the place op) - i.e., other - this
|
INDArray |
BaseSparseNDArray.rsubi(INDArray other) |
INDArray |
BaseNDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
INDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
BaseSparseNDArray.rsubi(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.rsubi(Number n) |
INDArray |
INDArray.rsubi(Number n)
Reverse subtraction in place - i.e., (n - thisArrayValues)
|
INDArray |
BaseSparseNDArray.rsubi(Number n) |
INDArray |
BaseNDArray.rsubi(Number n,
INDArray result) |
INDArray |
INDArray.rsubi(Number n,
INDArray result)
Reverse in place subtraction
|
INDArray |
BaseSparseNDArray.rsubi(Number n,
INDArray result) |
INDArray |
BaseNDArray.rsubiColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubiColumnVector(INDArray columnVector)
In place reverse subtraction of a column vector
|
INDArray |
BaseSparseNDArray.rsubiColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.rsubiRowVector(INDArray rowVector) |
INDArray |
INDArray.rsubiRowVector(INDArray rowVector)
In place reverse subtraction of a row vector
|
INDArray |
BaseSparseNDArray.rsubiRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.rsubRowVector(INDArray rowVector) |
INDArray |
INDArray.rsubRowVector(INDArray rowVector)
Reverse subtraction of a row vector (copy)
|
INDArray |
BaseSparseNDArray.rsubRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.shannonEntropy(int... dimension)
Returns non-normalized Shannon entropy along dimension
|
INDArray |
INDArray.shannonEntropy(int... dimension)
Returns entropy value for this INDArray along specified dimension(s)
|
INDArray |
BaseSparseNDArray.shannonEntropy(int... dimension)
Returns non-normalized Shannon entropy along dimension
|
INDArray |
BaseNDArray.slice(int slice)
Returns the specified slice of this matrix.
|
INDArray |
INDArray.slice(int i)
Returns the specified slice of this ndarray
|
INDArray |
BaseSparseNDArray.slice(int i) |
INDArray |
BaseNDArray.slice(int slice,
int dimension)
Returns the slice of this from the specified dimension
|
INDArray |
INDArray.slice(int i,
int dimension)
Returns the specified slice of this ndarray
|
INDArray |
BaseSparseNDArray.slice(int i,
int dimension) |
INDArray |
BaseNDArray.std(boolean biasCorrected,
int... dimension) |
INDArray |
INDArray.std(boolean biasCorrected,
int... dimension)
Standard deviation of an ndarray along a dimension
|
INDArray |
BaseSparseNDArray.std(boolean biasCorrected,
int... dimension) |
INDArray |
BaseNDArray.std(int... dimension)
Standard deviation of an ndarray along a dimension
|
INDArray |
INDArray.std(int... dimension)
Standard deviation of an INDArray along one or more dimensions
|
INDArray |
BaseSparseNDArray.std(int... dimension) |
INDArray |
BaseNDArray.sub(INDArray other)
copy subtraction of two matrices
|
INDArray |
INDArray.sub(INDArray other)
copy subtraction of two NDArrays
|
INDArray |
BaseSparseNDArray.sub(INDArray other) |
INDArray |
BaseNDArray.sub(INDArray other,
INDArray result)
copy subtraction of two matrices
|
INDArray |
INDArray.sub(INDArray other,
INDArray result)
copy subtraction of two NDArrays
|
INDArray |
BaseSparseNDArray.sub(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.sub(Number n) |
INDArray |
INDArray.sub(Number n)
Scalar subtraction (copied)
|
INDArray |
BaseSparseNDArray.sub(Number n) |
INDArray |
BaseNDArray.sub(Number n,
INDArray result) |
INDArray |
INDArray.sub(Number n,
INDArray result) |
INDArray |
BaseSparseNDArray.sub(Number n,
INDArray result) |
INDArray |
BaseNDArray.subArray(long[] offsets,
int[] shape,
int[] stride) |
INDArray |
INDArray.subArray(long[] offsets,
int[] shape,
int[] stride) |
INDArray |
BaseSparseNDArray.subArray(long[] offsets,
int[] shape,
int[] stride) |
INDArray |
BaseSparseNDArrayCOO.subArray(long[] offsets,
int[] shape,
int[] stride) |
INDArray |
BaseSparseNDArrayCSR.subArray(long[] offsets,
int[] shape,
int[] stride) |
INDArray |
BaseNDArray.subArray(ShapeOffsetResolution resolution) |
INDArray |
INDArray.subArray(ShapeOffsetResolution resolution)
Sub array based on the
pre calculated shape,strides, offsets
|
INDArray |
BaseSparseNDArray.subArray(ShapeOffsetResolution resolution) |
INDArray |
BaseSparseNDArrayCOO.subArray(ShapeOffsetResolution resolution) |
INDArray |
BaseSparseNDArrayCSR.subArray(ShapeOffsetResolution resolution) |
INDArray |
BaseSparseNDArrayCOO.subArray(ShapeOffsetResolution resolution,
ShapeOffsetResolution resolutionWithoutNewAxis) |
INDArray |
BaseNDArray.subColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.subColumnVector(INDArray columnVector)
Subtraction of a column vector (copy)
|
INDArray |
BaseSparseNDArray.subColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.subi(INDArray other)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(INDArray other)
in place (element wise) subtraction of two NDArrays
|
INDArray |
BaseSparseNDArray.subi(INDArray other) |
INDArray |
BaseNDArray.subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(INDArray other,
INDArray result)
in place (element wise) subtraction of two NDArrays
|
INDArray |
BaseSparseNDArray.subi(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.subi(Number n) |
INDArray |
INDArray.subi(Number n)
In place scalar subtraction
|
INDArray |
BaseSparseNDArray.subi(Number n) |
INDArray |
BaseNDArray.subi(Number n,
INDArray result) |
INDArray |
INDArray.subi(Number n,
INDArray result)
In place subtraction of this ndarray
|
INDArray |
BaseSparseNDArray.subi(Number n,
INDArray result) |
INDArray |
BaseNDArray.subiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.subiColumnVector(INDArray columnVector)
In place subtraction of a column vector
|
INDArray |
BaseSparseNDArray.subiColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.subiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.subiRowVector(INDArray rowVector)
In place subtraction of a row vector
|
INDArray |
BaseSparseNDArray.subiRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.subRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.subRowVector(INDArray rowVector)
Subtraction of a row vector (copy)
|
INDArray |
BaseSparseNDArray.subRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.sum(INDArray result,
int... dimension) |
INDArray |
INDArray.sum(INDArray result,
int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
BaseSparseNDArray.sum(INDArray result,
int... dimension) |
INDArray |
BaseNDArray.sum(int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
INDArray.sum(int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
BaseSparseNDArray.sum(int... dimension) |
INDArray |
BaseNDArray.swapAxes(int dimension,
int with)
Mainly here for people coming from numpy.
|
INDArray |
INDArray.swapAxes(int dimension,
int with)
Mainly here for people coming from numpy.
|
INDArray |
BaseSparseNDArray.swapAxes(int dimension,
int with) |
INDArray |
BaseNDArray.tensorAlongDimension(int index,
int... dimension) |
INDArray |
INDArray.tensorAlongDimension(int index,
int... dimension)
Get the vector along a particular dimension
|
INDArray |
BaseSparseNDArray.tensorAlongDimension(int index,
int... dimension) |
INDArray |
BaseNDArray.toDense() |
INDArray |
INDArray.toDense()
Return a dense representation of the sparse ndarray
|
INDArray |
BaseSparseNDArray.toDense() |
INDArray |
BaseSparseNDArrayCOO.toDense()
Converts the sparse ndarray into a dense one
|
INDArray |
ISparseNDArray.toDense()
Return a dense representation of the sparse ndarray
|
INDArray |
BaseSparseNDArrayCSR.toDense() |
INDArray |
BaseNDArray.transpose()
Return transposed copy of this matrix.
|
INDArray |
INDArray.transpose()
Flip the rows and columns of a matrix
|
INDArray |
BaseSparseNDArray.transpose() |
INDArray |
BaseNDArray.transposei()
Return transposed version of this matrix.
|
INDArray |
INDArray.transposei()
Flip the rows and columns of a matrix, in-place
|
INDArray |
BaseSparseNDArray.transposei() |
INDArray |
INDArray.unsafeDuplication()
Perform efficient (but unsafe) duplication.
|
INDArray |
BaseSparseNDArray.unsafeDuplication() |
INDArray |
INDArray.unsafeDuplication(boolean blocking)
Perform efficient (but unsafe) duplication.
|
INDArray |
BaseSparseNDArray.unsafeDuplication(boolean blocking) |
INDArray |
BaseNDArray.var(boolean biasCorrected,
int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
INDArray.var(boolean biasCorrected,
int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
BaseSparseNDArray.var(boolean biasCorrected,
int... dimension) |
INDArray |
BaseNDArray.var(int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
INDArray.var(int... dimension)
Returns the overall variance of this ndarray
|
INDArray |
BaseSparseNDArray.var(int... dimension) |
INDArray |
BaseNDArray.vectorAlongDimension(int index,
int dimension)
Get the vector along a particular dimension
|
INDArray |
INDArray.vectorAlongDimension(int index,
int dimension)
Get the vector along a particular dimension
|
INDArray |
BaseSparseNDArray.vectorAlongDimension(int index,
int dimension) |
Modifier and Type | Method and Description |
---|---|
INDArray |
BaseNDArray.add(INDArray other)
copy addition of two matrices
|
INDArray |
INDArray.add(INDArray other)
Element-wise copy addition of two NDArrays
|
INDArray |
BaseSparseNDArray.add(INDArray other) |
INDArray |
BaseNDArray.add(INDArray other,
INDArray result)
copy addition of two matrices
|
INDArray |
INDArray.add(INDArray other,
INDArray result)
Element-wise copy addition of two NDArrays
|
INDArray |
BaseSparseNDArray.add(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.add(Number n,
INDArray result) |
INDArray |
INDArray.add(Number n,
INDArray result) |
INDArray |
BaseSparseNDArray.add(Number n,
INDArray result) |
INDArray |
BaseNDArray.addColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.addColumnVector(INDArray columnVector)
Addition of a column vector (copy)
|
INDArray |
BaseSparseNDArray.addColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.addi(INDArray other)
in place addition of two matrices
|
INDArray |
INDArray.addi(INDArray other)
in place (element wise) addition of two NDArrays
|
INDArray |
BaseSparseNDArray.addi(INDArray other) |
INDArray |
BaseNDArray.addi(INDArray other,
INDArray result)
in place addition of two matrices
|
INDArray |
INDArray.addi(INDArray other,
INDArray result)
in place (element wise) addition of two NDArrays
|
INDArray |
BaseSparseNDArray.addi(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.addi(Number n,
INDArray result) |
INDArray |
INDArray.addi(Number n,
INDArray result)
In place addition
|
INDArray |
BaseSparseNDArray.addi(Number n,
INDArray result) |
INDArray |
BaseNDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.addiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
BaseSparseNDArray.addiColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.addiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.addiRowVector(INDArray rowVector)
In place addition of a row vector
|
INDArray |
BaseSparseNDArray.addiRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.addRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.addRowVector(INDArray rowVector)
Addition of a row vector (copy)
|
INDArray |
BaseSparseNDArray.addRowVector(INDArray rowVector) |
protected void |
BaseNDArray.assertSlice(INDArray put,
int slice) |
INDArray |
BaseNDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
INDArray |
INDArray.assign(INDArray arr)
Assign all of the elements in the given
ndarray to this ndarray
|
INDArray |
BaseSparseNDArray.assign(INDArray arr) |
INDArray |
BaseSparseNDArrayCOO.assign(INDArray arr) |
INDArray |
BaseNDArray.assignIf(INDArray arr,
Condition condition)
Assign all elements from given ndarray that are matching given condition,
ndarray to this ndarray
|
INDArray |
INDArray.assignIf(INDArray arr,
Condition condition)
Assign all elements from given ndarray that are matching given condition,
ndarray to this ndarray
|
INDArray |
BaseSparseNDArray.assignIf(INDArray arr,
Condition condition) |
void |
BaseNDArray.checkDimensions(INDArray other) |
void |
INDArray.checkDimensions(INDArray other)
Validate dimensions are equal
|
void |
BaseSparseNDArray.checkDimensions(INDArray other) |
double |
BaseNDArray.distance1(INDArray other)
Returns the (1-norm) distance.
|
double |
INDArray.distance1(INDArray other)
Returns the (1-norm) distance.
|
double |
BaseSparseNDArray.distance1(INDArray other) |
double |
BaseNDArray.distance2(INDArray other)
Returns the (euclidean) distance.
|
double |
INDArray.distance2(INDArray other)
Returns the (euclidean) distance.
|
double |
BaseSparseNDArray.distance2(INDArray other) |
INDArray |
BaseNDArray.div(INDArray other)
in place (element wise) division of two matrices
|
INDArray |
INDArray.div(INDArray other)
Copy (element wise) division of two NDArrays
|
INDArray |
BaseSparseNDArray.div(INDArray other) |
INDArray |
BaseNDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two matrices
|
INDArray |
INDArray.div(INDArray other,
INDArray result)
copy (element wise) division of two NDArrays
|
INDArray |
BaseSparseNDArray.div(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.div(Number n,
INDArray result) |
INDArray |
INDArray.div(Number n,
INDArray result) |
INDArray |
BaseSparseNDArray.div(Number n,
INDArray result) |
INDArray |
BaseNDArray.divColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.divColumnVector(INDArray columnVector)
Division of a column vector (copy)
|
INDArray |
BaseSparseNDArray.divColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.divi(INDArray other)
in place (element wise) division of two matrices
|
INDArray |
INDArray.divi(INDArray other)
in place (element wise) division of two NDArrays
|
INDArray |
BaseSparseNDArray.divi(INDArray other) |
INDArray |
BaseNDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two matrices
|
INDArray |
INDArray.divi(INDArray other,
INDArray result)
in place (element wise) division of two NDArrays
|
INDArray |
BaseSparseNDArray.divi(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.divi(Number n,
INDArray result) |
INDArray |
INDArray.divi(Number n,
INDArray result)
In place division of this ndarray
|
INDArray |
BaseSparseNDArray.divi(Number n,
INDArray result) |
INDArray |
BaseNDArray.diviColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.diviColumnVector(INDArray columnVector)
In place division of a column vector
|
INDArray |
BaseSparseNDArray.diviColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.diviRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.diviRowVector(INDArray rowVector)
In place division of a row vector
|
INDArray |
BaseSparseNDArray.diviRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.divRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.divRowVector(INDArray rowVector)
Division of a row vector (copy)
|
INDArray |
BaseSparseNDArray.divRowVector(INDArray rowVector) |
protected INDArray |
BaseNDArray.doColumnWise(INDArray columnVector,
char operation)
Do a row wise op (a,s,m,d)
a : add
s : subtract
m : multiply
d : divide
h : reverse subtraction
t : reverse division
|
protected INDArray |
BaseNDArray.doRowWise(INDArray rowVector,
char operation)
Do a row wise op (a,s,m,d)
a : add
s : subtract
m : multiply
d : divide
h : reverse subtraction
t : reverse division
|
INDArray |
BaseNDArray.eps(INDArray other)
epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
INDArray.eps(INDArray other)
Returns the binary ndarray for "Epsilon equals" comparison.
|
INDArray |
BaseSparseNDArray.eps(INDArray other) |
INDArray |
BaseNDArray.epsi(INDArray other)
In place epsilon equals than comparison:
If the given number is less than the
comparison number the item is 0 otherwise 1
|
INDArray |
INDArray.epsi(INDArray other)
Returns the binary ndarray for "Epsilon equals" comparison.
|
INDArray |
BaseSparseNDArray.epsi(INDArray other) |
INDArray |
BaseNDArray.eq(INDArray other) |
INDArray |
INDArray.eq(INDArray other)
Returns the binary ndarray for "Equals" comparison.
|
INDArray |
BaseSparseNDArray.eq(INDArray other) |
INDArray |
BaseNDArray.eqi(INDArray other) |
INDArray |
INDArray.eqi(INDArray other)
Returns the binary ndarray for "Equals" comparison.
|
INDArray |
BaseSparseNDArray.eqi(INDArray other) |
INDArray |
BaseNDArray.fmod(INDArray denominator) |
INDArray |
INDArray.fmod(INDArray denominator)
remainder of division
|
INDArray |
BaseSparseNDArray.fmod(INDArray denominator) |
INDArray |
BaseNDArray.fmod(INDArray denominator,
INDArray result) |
INDArray |
INDArray.fmod(INDArray denominator,
INDArray result)
remainder of division
|
INDArray |
BaseSparseNDArray.fmod(INDArray denominator,
INDArray result) |
INDArray |
BaseNDArray.fmod(Number denominator,
INDArray result) |
INDArray |
INDArray.fmod(Number denominator,
INDArray result) |
INDArray |
BaseSparseNDArray.fmod(Number denominator,
INDArray result) |
INDArray |
BaseNDArray.fmodi(INDArray denominator) |
INDArray |
INDArray.fmodi(INDArray denominator)
In place fmod
|
INDArray |
BaseSparseNDArray.fmodi(INDArray denominator) |
INDArray |
BaseNDArray.get(INDArray indices) |
INDArray |
INDArray.get(INDArray indices)
Get the elements from this ndarray based on the specified indices
|
INDArray |
BaseSparseNDArray.get(INDArray indices) |
protected double |
BaseNDArray.getPercentile(Number quantile,
INDArray sorted) |
protected double |
BaseSparseNDArray.getPercentile(Number quantile,
INDArray sorted) |
INDArray |
BaseNDArray.getWhere(INDArray comp,
Condition condition) |
INDArray |
INDArray.getWhere(INDArray comp,
Condition condition)
Boolean indexing:
Return the element if it fulfills the condition in
result array
|
INDArray |
BaseSparseNDArray.getWhere(INDArray comp,
Condition condition) |
INDArray |
BaseNDArray.gt(INDArray other) |
INDArray |
INDArray.gt(INDArray other)
Returns the binary ndarray for "Greter" comparison.
|
INDArray |
BaseSparseNDArray.gt(INDArray other) |
INDArray |
BaseNDArray.gti(INDArray other) |
INDArray |
INDArray.gti(INDArray other)
Returns the binary ndarray for "Greter" comparison.
|
INDArray |
BaseSparseNDArray.gti(INDArray other) |
INDArray |
BaseNDArray.lt(INDArray other) |
INDArray |
INDArray.lt(INDArray other)
Returns the binary ndarray for "Less" comparison.
|
INDArray |
BaseSparseNDArray.lt(INDArray other) |
INDArray |
BaseNDArray.lti(INDArray other) |
INDArray |
INDArray.lti(INDArray other)
Returns the binary ndarray for "Less" comparison.
|
INDArray |
BaseSparseNDArray.lti(INDArray other) |
INDArray |
BaseNDArray.match(INDArray comp,
Condition condition) |
INDArray |
INDArray.match(INDArray comp,
Condition condition)
Return a mask on whether each element
matches the given condition
|
INDArray |
BaseSparseNDArray.match(INDArray comp,
Condition condition) |
INDArray |
BaseNDArray.mean(INDArray result,
int... dimension) |
INDArray |
INDArray.mean(INDArray result,
int... dimension)
Returns the overall mean of this ndarray
|
INDArray |
BaseSparseNDArray.mean(INDArray result,
int... dimension) |
INDArray |
BaseNDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other)
Perform a copy matrix multiplication
|
INDArray |
BaseSparseNDArray.mmul(INDArray other) |
INDArray |
BaseNDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
BaseSparseNDArray.mmul(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.mmul(INDArray other,
INDArray result,
MMulTranspose mMulTranspose)
Perform a copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other,
INDArray result,
MMulTranspose mMulTranspose)
Perform an copy matrix multiplication
|
INDArray |
BaseSparseNDArrayCOO.mmul(INDArray other,
INDArray result,
MMulTranspose mMulTranspose)
Perform an copy matrix multiplication
|
INDArray |
BaseNDArray.mmul(INDArray other,
MMulTranspose mMulTranspose)
Perform a copy matrix multiplication
|
INDArray |
INDArray.mmul(INDArray other,
MMulTranspose mMulTranspose) |
INDArray |
BaseSparseNDArrayCOO.mmul(INDArray other,
MMulTranspose mMulTranspose) |
INDArray |
BaseNDArray.mmuli(INDArray other)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other)
Perform an inplace matrix multiplication
|
INDArray |
BaseSparseNDArray.mmuli(INDArray other) |
INDArray |
BaseNDArray.mmuli(INDArray other,
INDArray result)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other,
INDArray result)
Perform an inplace matrix multiplication
|
INDArray |
BaseSparseNDArray.mmuli(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.mmuli(INDArray other,
INDArray result,
MMulTranspose transpose)
Perform an in place matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other,
INDArray result,
MMulTranspose transpose) |
INDArray |
BaseSparseNDArrayCOO.mmuli(INDArray other,
INDArray result,
MMulTranspose transpose) |
INDArray |
BaseNDArray.mmuli(INDArray other,
MMulTranspose transpose)
Perform an copy matrix multiplication
|
INDArray |
INDArray.mmuli(INDArray other,
MMulTranspose transpose) |
INDArray |
BaseSparseNDArrayCOO.mmuli(INDArray other,
MMulTranspose transpose) |
INDArray |
BaseNDArray.mul(INDArray other)
copy (element wise) multiplication of two matrices
|
INDArray |
INDArray.mul(INDArray other)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseSparseNDArray.mul(INDArray other) |
INDArray |
BaseNDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two matrices
|
INDArray |
INDArray.mul(INDArray other,
INDArray result)
copy (element wise) multiplication of two NDArrays
|
INDArray |
BaseSparseNDArray.mul(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.mul(Number n,
INDArray result) |
INDArray |
INDArray.mul(Number n,
INDArray result) |
INDArray |
BaseSparseNDArray.mul(Number n,
INDArray result) |
INDArray |
BaseNDArray.mulColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.mulColumnVector(INDArray columnVector)
Multiplication of a column vector (copy)
|
INDArray |
BaseSparseNDArray.mulColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.muli(INDArray other)
in place (element wise) multiplication of two matrices
|
INDArray |
INDArray.muli(INDArray other)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseSparseNDArray.muli(INDArray other) |
INDArray |
BaseNDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two matrices
|
INDArray |
INDArray.muli(INDArray other,
INDArray result)
in place (element wise) multiplication of two NDArrays
|
INDArray |
BaseSparseNDArray.muli(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.muli(Number n,
INDArray result) |
INDArray |
INDArray.muli(Number n,
INDArray result)
In place multiplication of this ndarray
|
INDArray |
BaseSparseNDArray.muli(Number n,
INDArray result) |
INDArray |
BaseNDArray.muliColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.muliColumnVector(INDArray columnVector)
In place multiplication of a column vector
|
INDArray |
BaseSparseNDArray.muliColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.muliRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.muliRowVector(INDArray rowVector)
In place multiplication of a row vector
|
INDArray |
BaseSparseNDArray.muliRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.mulRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.mulRowVector(INDArray rowVector)
Multiplication of a row vector (copy)
|
INDArray |
BaseSparseNDArray.mulRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.neq(INDArray other) |
INDArray |
INDArray.neq(INDArray other)
Returns the binary ndarray for "Not equals" comparison.
|
INDArray |
BaseSparseNDArray.neq(INDArray other) |
INDArray |
BaseNDArray.neqi(INDArray other) |
INDArray |
INDArray.neqi(INDArray other)
Returns the binary ndarray for "Not equals" comparison.
|
INDArray |
BaseSparseNDArray.neqi(INDArray other) |
INDArray |
BaseNDArray.put(INDArray indices,
INDArray element) |
INDArray |
INDArray.put(INDArray indices,
INDArray element)
Put element in to the indices denoted by
the indices ndarray.
|
INDArray |
BaseSparseNDArray.put(INDArray indices,
INDArray element) |
INDArray |
BaseNDArray.put(INDArrayIndex[] indices,
INDArray element) |
INDArray |
INDArray.put(INDArrayIndex[] indices,
INDArray element)
Put the elements of the ndarray
in to the specified indices
|
INDArray |
BaseSparseNDArray.put(INDArrayIndex[] indices,
INDArray element) |
INDArray |
BaseSparseNDArrayCOO.put(INDArrayIndex[] indices,
INDArray element) |
INDArray |
BaseNDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int[] indices,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseSparseNDArray.put(int[] indices,
INDArray element) |
INDArray |
BaseSparseNDArrayCOO.put(int[] indexes,
INDArray element) |
INDArray |
BaseNDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int i,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseSparseNDArray.put(int i,
INDArray element) |
INDArray |
BaseSparseNDArrayCOO.put(int i,
INDArray element) |
INDArray |
BaseNDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
INDArray |
INDArray.put(int i,
int j,
INDArray element)
Inserts the element at the specified index
|
INDArray |
BaseSparseNDArray.put(int i,
int j,
INDArray element) |
INDArray |
BaseSparseNDArrayCOO.put(int i,
int j,
INDArray element) |
INDArray |
BaseNDArray.put(List<List<Integer>> indices,
INDArray element) |
INDArray |
INDArray.put(List<List<Integer>> indices,
INDArray element)
Put element in to the indices denoted by
the indices ndarray.
|
INDArray |
BaseSparseNDArray.put(List<List<Integer>> indices,
INDArray element) |
INDArray |
BaseNDArray.putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
INDArray.putColumn(int column,
INDArray toPut)
Insert a column in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
BaseSparseNDArray.putColumn(int column,
INDArray toPut) |
INDArray |
BaseSparseNDArrayCOO.putColumn(int column,
INDArray toPut) |
INDArray |
BaseNDArray.putiColumnVector(INDArray columnVector) |
INDArray |
INDArray.putiColumnVector(INDArray columnVector)
In place assignment of a column vector
|
INDArray |
BaseSparseNDArrayCOO.putiColumnVector(INDArray columnVector) |
INDArray |
BaseSparseNDArrayCSR.putiColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.putiRowVector(INDArray rowVector) |
INDArray |
INDArray.putiRowVector(INDArray rowVector)
in place assignment of row vector, to each row of this array
|
INDArray |
BaseSparseNDArrayCOO.putiRowVector(INDArray rowVector) |
INDArray |
BaseSparseNDArrayCSR.putiRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.putRow(int row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
INDArray.putRow(int row,
INDArray toPut)
Insert a row in to this array
Will throw an exception if this
ndarray is not a matrix
|
INDArray |
BaseSparseNDArray.putRow(int row,
INDArray toPut) |
INDArray |
BaseSparseNDArrayCOO.putRow(int row,
INDArray toPut) |
INDArray |
BaseNDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
INDArray.putSlice(int slice,
INDArray put)
Assigns the given matrix (put) to the specified slice
|
INDArray |
BaseSparseNDArray.putSlice(int slice,
INDArray put) |
INDArray |
BaseNDArray.putWhere(INDArray comp,
INDArray put,
Condition condition) |
INDArray |
INDArray.putWhere(INDArray comp,
INDArray put,
Condition condition)
Assign the element according
to the comparison array
|
INDArray |
BaseSparseNDArray.putWhere(INDArray comp,
INDArray put,
Condition condition) |
INDArray |
BaseNDArray.putWhere(Number comp,
INDArray put,
Condition condition) |
INDArray |
INDArray.putWhere(Number comp,
INDArray put,
Condition condition)
Assign the element according
to the comparison array
|
INDArray |
BaseSparseNDArray.putWhere(Number comp,
INDArray put,
Condition condition) |
INDArray |
BaseNDArray.putWhereWithMask(INDArray mask,
INDArray put) |
INDArray |
INDArray.putWhereWithMask(INDArray mask,
INDArray put)
Use a pre computed mask
for assigning arrays
|
INDArray |
BaseSparseNDArray.putWhereWithMask(INDArray mask,
INDArray put) |
INDArray |
BaseNDArray.putWhereWithMask(INDArray mask,
Number put) |
INDArray |
INDArray.putWhereWithMask(INDArray mask,
Number put)
Use a pre computed mask
for assigning arrays
|
INDArray |
BaseSparseNDArray.putWhereWithMask(INDArray mask,
Number put) |
INDArray |
BaseNDArray.rdiv(INDArray other)
Reverse division
|
INDArray |
INDArray.rdiv(INDArray other)
Reverse division, elements wise.
|
INDArray |
BaseSparseNDArray.rdiv(INDArray other) |
INDArray |
BaseNDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
INDArray.rdiv(INDArray other,
INDArray result)
Reverse division
|
INDArray |
BaseSparseNDArray.rdiv(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.rdiv(Number n,
INDArray result) |
INDArray |
INDArray.rdiv(Number n,
INDArray result)
Reverse division (number / ndarray)
|
INDArray |
BaseSparseNDArray.rdiv(Number n,
INDArray result) |
INDArray |
BaseNDArray.rdivColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdivColumnVector(INDArray columnVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseSparseNDArray.rdivColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.rdivi(INDArray other)
Reverse divsion (in place)
|
INDArray |
INDArray.rdivi(INDArray other)
Reverse divsion (in place).
|
INDArray |
BaseSparseNDArray.rdivi(INDArray other) |
INDArray |
BaseNDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
INDArray.rdivi(INDArray other,
INDArray result)
Reverse division (in-place)
|
INDArray |
BaseSparseNDArray.rdivi(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.rdivi(Number n,
INDArray result) |
INDArray |
INDArray.rdivi(Number n,
INDArray result)
Reverse in place division
|
INDArray |
BaseSparseNDArray.rdivi(Number n,
INDArray result) |
INDArray |
BaseNDArray.rdiviColumnVector(INDArray columnVector) |
INDArray |
INDArray.rdiviColumnVector(INDArray columnVector)
In place reverse divison of a column vector
|
INDArray |
BaseSparseNDArray.rdiviColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.rdiviRowVector(INDArray rowVector) |
INDArray |
INDArray.rdiviRowVector(INDArray rowVector)
In place reverse division of a column vector
|
INDArray |
BaseSparseNDArray.rdiviRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.rdivRowVector(INDArray rowVector) |
INDArray |
INDArray.rdivRowVector(INDArray rowVector)
Reverse division of a column vector (copy)
|
INDArray |
BaseSparseNDArray.rdivRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.remainder(INDArray denominator) |
INDArray |
INDArray.remainder(INDArray denominator)
Remainder operator
|
INDArray |
BaseSparseNDArray.remainder(INDArray denominator) |
INDArray |
BaseNDArray.remainder(INDArray denominator,
INDArray result) |
INDArray |
INDArray.remainder(INDArray denominator,
INDArray result)
Remainder operator
|
INDArray |
BaseSparseNDArray.remainder(INDArray denominator,
INDArray result) |
INDArray |
BaseNDArray.remainder(Number denominator,
INDArray result) |
INDArray |
INDArray.remainder(Number denominator,
INDArray result) |
INDArray |
BaseSparseNDArray.remainder(Number denominator,
INDArray result) |
INDArray |
BaseNDArray.remainderi(INDArray denominator) |
INDArray |
INDArray.remainderi(INDArray denominator)
In place remainder
|
INDArray |
BaseSparseNDArray.remainderi(INDArray denominator) |
INDArray |
BaseNDArray.replaceWhere(INDArray arr,
Condition condition)
Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
|
INDArray |
INDArray.replaceWhere(INDArray arr,
Condition condition)
Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
|
INDArray |
BaseSparseNDArray.replaceWhere(INDArray arr,
Condition condition) |
INDArray |
BaseNDArray.rsub(INDArray other) |
INDArray |
INDArray.rsub(INDArray other)
Element-wise reverse subtraction (copy op).
|
INDArray |
BaseSparseNDArray.rsub(INDArray other) |
INDArray |
BaseNDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
INDArray.rsub(INDArray other,
INDArray result)
Reverse subtraction
|
INDArray |
BaseSparseNDArray.rsub(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.rsub(Number n,
INDArray result) |
INDArray |
INDArray.rsub(Number n,
INDArray result)
Reverse subtraction
|
INDArray |
BaseSparseNDArray.rsub(Number n,
INDArray result) |
INDArray |
BaseNDArray.rsubColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubColumnVector(INDArray columnVector)
Reverse subtraction of a column vector (copy)
|
INDArray |
BaseSparseNDArray.rsubColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.rsubi(INDArray other) |
INDArray |
INDArray.rsubi(INDArray other)
Element-wise reverse subtraction (in the place op) - i.e., other - this
|
INDArray |
BaseSparseNDArray.rsubi(INDArray other) |
INDArray |
BaseNDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
INDArray.rsubi(INDArray other,
INDArray result)
Reverse subtraction (in-place)
|
INDArray |
BaseSparseNDArray.rsubi(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.rsubi(Number n,
INDArray result) |
INDArray |
INDArray.rsubi(Number n,
INDArray result)
Reverse in place subtraction
|
INDArray |
BaseSparseNDArray.rsubi(Number n,
INDArray result) |
INDArray |
BaseNDArray.rsubiColumnVector(INDArray columnVector) |
INDArray |
INDArray.rsubiColumnVector(INDArray columnVector)
In place reverse subtraction of a column vector
|
INDArray |
BaseSparseNDArray.rsubiColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.rsubiRowVector(INDArray rowVector) |
INDArray |
INDArray.rsubiRowVector(INDArray rowVector)
In place reverse subtraction of a row vector
|
INDArray |
BaseSparseNDArray.rsubiRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.rsubRowVector(INDArray rowVector) |
INDArray |
INDArray.rsubRowVector(INDArray rowVector)
Reverse subtraction of a row vector (copy)
|
INDArray |
BaseSparseNDArray.rsubRowVector(INDArray rowVector) |
double |
BaseNDArray.squaredDistance(INDArray other)
Returns the square of the Euclidean distance.
|
double |
INDArray.squaredDistance(INDArray other)
Returns the square of the Euclidean distance.
|
double |
BaseSparseNDArray.squaredDistance(INDArray other) |
INDArray |
BaseNDArray.sub(INDArray other)
copy subtraction of two matrices
|
INDArray |
INDArray.sub(INDArray other)
copy subtraction of two NDArrays
|
INDArray |
BaseSparseNDArray.sub(INDArray other) |
INDArray |
BaseNDArray.sub(INDArray other,
INDArray result)
copy subtraction of two matrices
|
INDArray |
INDArray.sub(INDArray other,
INDArray result)
copy subtraction of two NDArrays
|
INDArray |
BaseSparseNDArray.sub(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.sub(Number n,
INDArray result) |
INDArray |
INDArray.sub(Number n,
INDArray result) |
INDArray |
BaseSparseNDArray.sub(Number n,
INDArray result) |
INDArray |
BaseNDArray.subColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.subColumnVector(INDArray columnVector)
Subtraction of a column vector (copy)
|
INDArray |
BaseSparseNDArray.subColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.subi(INDArray other)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(INDArray other)
in place (element wise) subtraction of two NDArrays
|
INDArray |
BaseSparseNDArray.subi(INDArray other) |
INDArray |
BaseNDArray.subi(INDArray other,
INDArray result)
in place subtraction of two matrices
|
INDArray |
INDArray.subi(INDArray other,
INDArray result)
in place (element wise) subtraction of two NDArrays
|
INDArray |
BaseSparseNDArray.subi(INDArray other,
INDArray result) |
INDArray |
BaseNDArray.subi(Number n,
INDArray result) |
INDArray |
INDArray.subi(Number n,
INDArray result)
In place subtraction of this ndarray
|
INDArray |
BaseSparseNDArray.subi(Number n,
INDArray result) |
INDArray |
BaseNDArray.subiColumnVector(INDArray columnVector)
In place addition of a column vector
|
INDArray |
INDArray.subiColumnVector(INDArray columnVector)
In place subtraction of a column vector
|
INDArray |
BaseSparseNDArray.subiColumnVector(INDArray columnVector) |
INDArray |
BaseNDArray.subiRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.subiRowVector(INDArray rowVector)
In place subtraction of a row vector
|
INDArray |
BaseSparseNDArray.subiRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.subRowVector(INDArray rowVector)
In place addition of a column vector
|
INDArray |
INDArray.subRowVector(INDArray rowVector)
Subtraction of a row vector (copy)
|
INDArray |
BaseSparseNDArray.subRowVector(INDArray rowVector) |
INDArray |
BaseNDArray.sum(INDArray result,
int... dimension) |
INDArray |
INDArray.sum(INDArray result,
int... dimension)
Returns the sum along the last dimension of this ndarray
|
INDArray |
BaseSparseNDArray.sum(INDArray result,
int... dimension) |
static void |
NdArrayJSONWriter.write(INDArray thisnD,
String filePath)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
void |
BaseNDArray.sliceVectors(List<INDArray> list)
Flattens the array for linear indexing
|
void |
INDArray.sliceVectors(List<INDArray> list) |
void |
BaseSparseNDArray.sliceVectors(List<INDArray> list) |
Constructor and Description |
---|
BaseNDArrayProxy(INDArray anInstance) |
Constructor and Description |
---|
BaseNDArray(List<INDArray> slices,
int[] shape)
Create an ndarray from the specified slices.
|
BaseNDArray(List<INDArray> slices,
int[] shape,
char ordering)
Create an ndarray from the specified slices.
|
BaseNDArray(List<INDArray> slices,
int[] shape,
int[] stride)
Create an ndarray from the specified slices.
|
BaseNDArray(List<INDArray> slices,
int[] shape,
int[] stride,
char ordering)
Create an ndarray from the specified slices.
|
Modifier and Type | Field and Description |
---|---|
protected INDArray |
BaseOp.x |
protected INDArray |
BaseOp.y |
protected INDArray |
BaseOp.z |
Modifier and Type | Method and Description |
---|---|
INDArray |
DynamicCustomOp.getInputArgument(int index) |
INDArray |
CustomOp.getInputArgument(int index) |
INDArray |
DynamicCustomOp.getOutputArgument(int index) |
INDArray |
CustomOp.getOutputArgument(int index) |
INDArray |
LossFunction.input()
The true
|
INDArray[] |
DynamicCustomOp.inputArguments() |
INDArray[] |
CustomOp.inputArguments() |
INDArray |
Accumulation.noOp()
Returns the no op version
of the input
Basically when a reduce can't happen (eg: sum(0) on a row vector)
you have a no op state for a given reduction.
|
INDArray |
BaseAccumulation.noOp() |
INDArray |
LossFunction.output()
The guess
|
INDArray[] |
DynamicCustomOp.outputArguments() |
INDArray[] |
CustomOp.outputArguments() |
INDArray |
GradientOp.wrt()
The array
to the gradient with respect to
|
INDArray |
BaseGradientOp.wrt()
The array
to the gradient with respect to
|
INDArray |
Op.x()
The origin ndarray
|
INDArray |
BaseOp.x() |
INDArray |
Op.y()
The pairwise op ndarray
|
INDArray |
BaseOp.y() |
INDArray |
BaseTransformOp.z() |
INDArray |
Op.z()
The resulting ndarray
|
INDArray |
BaseScalarOp.z() |
INDArray |
BaseOp.z() |
Modifier and Type | Method and Description |
---|---|
void |
DynamicCustomOp.addInputArgument(INDArray... arg) |
void |
CustomOp.addInputArgument(INDArray... arg) |
DynamicCustomOp.DynamicCustomOpsBuilder |
DynamicCustomOp.SameDiffBuilder.addInputs(INDArray... inputs) |
DynamicCustomOp.DynamicCustomOpsBuilder |
DynamicCustomOp.DynamicCustomOpsBuilder.addInputs(INDArray... inputs)
This method
takes arbitrary number of input INDArrays in, as Op input
Note that this ACCUMULATES arguments.
|
void |
DynamicCustomOp.addOutputArgument(INDArray... arg) |
void |
CustomOp.addOutputArgument(INDArray... arg) |
DynamicCustomOp.DynamicCustomOpsBuilder |
DynamicCustomOp.SameDiffBuilder.addOutputs(INDArray... outputs) |
DynamicCustomOp.DynamicCustomOpsBuilder |
DynamicCustomOp.DynamicCustomOpsBuilder.addOutputs(INDArray... outputs)
This method takes arbitrary number of
output INDArrays in, to store operation result
Note that this ACCUMULATES arguments.
|
void |
Module.exec(INDArray... inputs) |
void |
BaseIndexAccumulation.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Op.init(INDArray x,
INDArray y,
INDArray z,
long n)
Initialize the operation based on the parameters
|
void |
BaseOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
DynamicCustomOp.removeInputArgument(INDArray arg) |
void |
CustomOp.removeInputArgument(INDArray arg) |
void |
DynamicCustomOp.removeOutputArgument(INDArray arg) |
void |
CustomOp.removeOutputArgument(INDArray arg) |
void |
DynamicCustomOp.setInputArgument(int index,
INDArray input) |
void |
DynamicCustomOp.setOutputArgument(int index,
INDArray output) |
void |
Op.setX(INDArray x)
set x (the input ndarray)
|
void |
BaseOp.setX(INDArray x) |
void |
Op.setY(INDArray y)
set y(the pairwise ndarray)
|
void |
BaseOp.setY(INDArray y) |
void |
Op.setZ(INDArray z)
set z (the solution ndarray)
|
void |
BaseOp.setZ(INDArray z) |
Constructor and Description |
---|
BaseAccumulation(INDArray x) |
BaseAccumulation(INDArray x,
INDArray y) |
BaseAccumulation(INDArray x,
INDArray y,
INDArray z,
long n)
Initialize with the given
input, pairwise transform, result, and number
of elements
|
BaseAccumulation(INDArray x,
INDArray y,
long n) |
BaseBroadcastOp(INDArray x,
INDArray y,
INDArray z,
int... dimension) |
BaseGradientOp(INDArray x) |
BaseGradientOp(INDArray x,
INDArray z) |
BaseGradientOp(INDArray x,
INDArray y,
INDArray z,
long n) |
BaseGradientOp(INDArray x,
INDArray z,
long n) |
BaseIndexAccumulation(INDArray x) |
BaseIndexAccumulation(INDArray x,
INDArray y) |
BaseIndexAccumulation(INDArray x,
INDArray y,
INDArray z,
long n)
Initialize with the given
input, pairwise transform, result, and number
of elements
|
BaseIndexAccumulation(INDArray x,
INDArray y,
long n) |
BaseModule(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments,
List<Module> modules) |
BaseModule(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments,
List<Module> modules) |
BaseOp(INDArray x)
An op for one ndarray
|
BaseOp(INDArray x,
INDArray z)
Specify an alternative result array
|
BaseOp(INDArray x,
INDArray y,
INDArray z,
long n) |
BaseOp(INDArray x,
INDArray z,
long n)
Specify an alternative output array
|
BaseScalarOp(INDArray x,
INDArray y,
INDArray z,
long n,
Number num) |
BaseScalarOp(INDArray x,
Number num) |
BaseTransformOp(INDArray x) |
BaseTransformOp(INDArray x,
INDArray z) |
BaseTransformOp(INDArray x,
INDArray y,
INDArray z,
long n) |
BaseTransformOp(INDArray x,
INDArray z,
long n) |
DynamicCustomOp(String opName,
INDArray[] inputs,
INDArray[] outputs)
Initialize this operation for execution (pre created ndarrays)
|
DynamicCustomOp(String opName,
INDArray[] inputs,
INDArray[] outputs)
Initialize this operation for execution (pre created ndarrays)
|
DynamicCustomOp(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments)
Initialize this custom op with all of the
inputs, outputs, and respective
arguments for execution
|
DynamicCustomOp(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments)
Initialize this custom op with all of the
inputs, outputs, and respective
arguments for execution
|
ShapeOp(INDArray x)
An op for one ndarray
|
ShapeOp(INDArray x,
INDArray z)
Specify an alternative result array
|
ShapeOp(INDArray x,
INDArray y,
INDArray z,
long n) |
ShapeOp(INDArray x,
INDArray z,
long n)
Specify an alternative output array
|
Modifier and Type | Field and Description |
---|---|
protected List<INDArray> |
BaseAggregate.arguments |
Modifier and Type | Method and Description |
---|---|
List<INDArray> |
Aggregate.getArguments() |
List<INDArray> |
BaseAggregate.getArguments() |
Constructor and Description |
---|
AggregateAxpy(INDArray x,
INDArray y,
double alpha) |
AggregateCBOW(INDArray syn0,
INDArray syn1,
INDArray syn1Neg,
INDArray expTable,
INDArray negTable,
int wordIdx,
int[] idxSyn0,
int[] idxSyn1,
int[] codes,
int negativeRounds,
int ngStarter,
int vectorLength,
double alpha,
long nextRandom,
int vocabSize)
Default constructor for CBOW implementation wrapper
|
AggregateCBOW(INDArray syn0,
INDArray syn1,
INDArray syn1Neg,
INDArray expTable,
INDArray negTable,
int wordIdx,
int[] idxSyn0,
int[] idxSyn1,
int[] codes,
int negativeRounds,
int ngStarter,
int vectorLength,
double alpha,
long nextRandom,
int vocabSize,
int numLabels,
boolean trainWords,
INDArray inferenceVector)
Optional constructor for ParagraphVectors PV-DM implementation
|
AggregateDot(INDArray x,
INDArray y) |
AggregateGEMM(int Order,
int TransA,
int TransB,
int M,
int N,
int K,
double alpha,
INDArray A,
int lda,
INDArray B,
int ldb,
double beta,
INDArray C,
int ldc) |
AggregateSkipGram(INDArray syn0,
INDArray syn1,
INDArray syn1Neg,
INDArray expTable,
INDArray negTable,
int idxSyn0,
int[] idxSyn1,
int[] codes,
int negativeRounds,
int ngStarter,
int vectorLength,
double alpha,
long nextRandom,
int vocabSize) |
AggregateSkipGram(INDArray syn0,
INDArray syn1,
INDArray syn1Neg,
INDArray expTable,
INDArray negTable,
int idxSyn0,
int[] idxSyn1,
int[] codes,
int negativeRounds,
int ngStarter,
int vectorLength,
double alpha,
long nextRandom,
int vocabSize,
INDArray inferenceVector) |
HierarchicSoftmax(INDArray syn0,
INDArray syn1,
INDArray expTable,
INDArray neu1e,
int code,
double lr) |
Modifier and Type | Method and Description |
---|---|
INDArray |
ScatterUpdate.getInputArgument(int index) |
INDArray |
ScatterUpdate.getOutputArgument(int index) |
INDArray[] |
ScatterUpdate.inputArguments() |
INDArray[] |
ScatterUpdate.outputArguments() |
Modifier and Type | Method and Description |
---|---|
void |
ScatterUpdate.addInputArgument(INDArray... arg) |
void |
ScatterUpdate.addOutputArgument(INDArray... arg) |
void |
ScatterUpdate.removeInputArgument(INDArray arg) |
void |
ScatterUpdate.removeOutputArgument(INDArray arg) |
Constructor and Description |
---|
ScatterUpdate(INDArray original,
INDArray updates,
INDArray result,
int[] indices,
int[] dimension,
ScatterUpdate.UpdateOp op) |
ScatterUpdate(INDArray original,
INDArray updates,
int[] indices,
int[] dimension,
ScatterUpdate.UpdateOp op) |
Modifier and Type | Method and Description |
---|---|
INDArray |
DefaultOpExecutioner.bitmapDecode(INDArray encoded,
INDArray target) |
INDArray |
OpExecutioner.bitmapDecode(INDArray encoded,
INDArray target) |
INDArray |
DefaultOpExecutioner.bitmapEncode(INDArray indArray,
double threshold) |
INDArray |
OpExecutioner.bitmapEncode(INDArray indArray,
double threshold) |
INDArray |
DefaultOpExecutioner.exec(Accumulation op,
int... dimension) |
INDArray |
OpExecutioner.exec(Accumulation accumulation,
int... dimension)
Execute an accumulation along one or more dimensions
|
INDArray |
DefaultOpExecutioner.exec(BroadcastOp broadcast,
int... dimension) |
INDArray |
OpExecutioner.exec(BroadcastOp broadcast,
int... dimension)
Execute an broadcast along one or more dimensions
|
INDArray |
DefaultOpExecutioner.exec(IndexAccumulation op,
int... dimension) |
INDArray |
OpExecutioner.exec(IndexAccumulation indexAccum,
int... dimension)
Execute an index accumulation along one or more dimensions
|
INDArray |
DefaultOpExecutioner.exec(RandomOp op)
This method executes specified RandomOp using default RNG available via Nd4j.getRandom()
|
INDArray |
OpExecutioner.exec(RandomOp op)
This method executes specified RandomOp using default RNG available via Nd4j.getRandom()
|
INDArray |
DefaultOpExecutioner.exec(RandomOp op,
Random rng)
This method executes specific RandomOp against specified RNG
|
INDArray |
OpExecutioner.exec(RandomOp op,
Random rng)
This method executes specific RandomOp against specified RNG
|
INDArray |
DefaultOpExecutioner.exec(Variance accumulation,
boolean biasCorrected,
int... dimension) |
INDArray |
OpExecutioner.exec(Variance accumulation,
boolean biasCorrected,
int... dimension)
Execute an accumulation along one or more dimensions
|
INDArray |
DefaultOpExecutioner.execAndReturn(BroadcastOp op) |
INDArray |
OpExecutioner.execAndReturn(BroadcastOp op)
Execute and return the result from a vector op
|
INDArray |
DefaultOpExecutioner.execAndReturn(Op op) |
INDArray |
OpExecutioner.execAndReturn(Op op)
Execute and return a result
ndarray from the given op
|
INDArray |
DefaultOpExecutioner.execAndReturn(ScalarOp op) |
INDArray |
OpExecutioner.execAndReturn(ScalarOp op)
Execute and return the result from a scalar op
|
INDArray |
DefaultOpExecutioner.execAndReturn(ShapeOp op)
Execute and return the result from a vector op
|
INDArray |
OpExecutioner.execAndReturn(ShapeOp op)
Execute and return the result from a vector op
|
INDArray |
DefaultOpExecutioner.execAndReturn(TransformOp op) |
INDArray |
OpExecutioner.execAndReturn(TransformOp op)
Execute a TransformOp and return the result
|
INDArray |
DefaultOpExecutioner.thresholdDecode(INDArray encoded,
INDArray target) |
INDArray |
OpExecutioner.thresholdDecode(INDArray encoded,
INDArray target)
This method decodes thresholds array, and puts it into target array
|
INDArray |
DefaultOpExecutioner.thresholdEncode(INDArray input,
double threshold) |
INDArray |
OpExecutioner.thresholdEncode(INDArray input,
double threshold)
This method encodes array as thresholds, updating input array at the same time
|
INDArray |
DefaultOpExecutioner.thresholdEncode(INDArray input,
double threshold,
Integer boundary) |
INDArray |
OpExecutioner.thresholdEncode(INDArray input,
double threshold,
Integer boundary)
This method encodes array as thresholds, updating input array at the same time
|
Modifier and Type | Method and Description |
---|---|
Map<String,INDArray> |
DefaultOpExecutioner.executeGraph(long id,
Map<String,INDArray> map) |
Map<String,INDArray> |
OpExecutioner.executeGraph(long id,
Map<String,INDArray> map) |
Modifier and Type | Method and Description |
---|---|
INDArray |
DefaultOpExecutioner.bitmapDecode(INDArray encoded,
INDArray target) |
INDArray |
OpExecutioner.bitmapDecode(INDArray encoded,
INDArray target) |
INDArray |
DefaultOpExecutioner.bitmapEncode(INDArray indArray,
double threshold) |
INDArray |
OpExecutioner.bitmapEncode(INDArray indArray,
double threshold) |
long |
DefaultOpExecutioner.bitmapEncode(INDArray indArray,
INDArray target,
double threshold) |
long |
OpExecutioner.bitmapEncode(INDArray indArray,
INDArray target,
double threshold)
This method returns number of elements affected by encoder
|
static boolean |
OpExecutionerUtil.canDoOpDirectly(INDArray x)
Can we do the op (X = Op(X)) directly on the arrays without breaking X up into 1d tensors first?
In general, this is possible if the elements of X are contiguous in the buffer, OR if every element
of X is at position offset+i*elementWiseStride in the buffer
|
static boolean |
OpExecutionerUtil.canDoOpDirectly(INDArray x,
INDArray y)
Can we do the transform op (X = Op(X,Y)) directly on the arrays without breaking them up into 1d tensors first?
|
static boolean |
OpExecutionerUtil.canDoOpDirectly(INDArray x,
INDArray y,
INDArray z)
Can we do the transform op (Z = Op(X,Y)) directly on the arrays without breaking them up into 1d tensors first?
|
static void |
OpExecutionerUtil.checkForAny(INDArray z) |
static void |
OpExecutionerUtil.checkForInf(INDArray z) |
static void |
OpExecutionerUtil.checkForNaN(INDArray z) |
static int |
OpExecutionerUtil.chooseElementWiseTensorDimension(INDArray x)
Choose tensor dimension for operations with one argument: x=Op(x) or similar
When doing some operations in parallel, it is necessary to break up operations along a dimension to give a set of 1d tensors. |
static int |
OpExecutionerUtil.chooseElementWiseTensorDimension(INDArray x,
INDArray y)
Choose tensor dimension for operations with 2 arguments: x=Op(x,y) or similar
|
static int |
OpExecutionerUtil.chooseElementWiseTensorDimension(INDArray x,
INDArray y,
INDArray z)
Choose tensor dimension for operations with 3 arguments: z=Op(x,y) or similar
|
static OpExecutionerUtil.Tensor1DStats |
OpExecutionerUtil.get1DTensorStats(INDArray array,
int... dimension)
Tensor1DStats, used to efficiently iterate through tensors on a matrix (2d NDArray) for element-wise ops
For example, the offset of each 1d tensor can be calculated using only a single tensorAlongDimension method call,
hence is potentially faster than approaches requiring multiple tensorAlongDimension calls.
Note that this can only (generally) be used for 2d NDArrays. |
INDArray |
DefaultOpExecutioner.thresholdDecode(INDArray encoded,
INDArray target) |
INDArray |
OpExecutioner.thresholdDecode(INDArray encoded,
INDArray target)
This method decodes thresholds array, and puts it into target array
|
INDArray |
DefaultOpExecutioner.thresholdEncode(INDArray input,
double threshold) |
INDArray |
OpExecutioner.thresholdEncode(INDArray input,
double threshold)
This method encodes array as thresholds, updating input array at the same time
|
INDArray |
DefaultOpExecutioner.thresholdEncode(INDArray input,
double threshold,
Integer boundary) |
INDArray |
OpExecutioner.thresholdEncode(INDArray input,
double threshold,
Integer boundary)
This method encodes array as thresholds, updating input array at the same time
|
static void |
DefaultOpExecutioner.validateDataType(DataBuffer.Type expectedType,
INDArray... operands) |
Modifier and Type | Method and Description |
---|---|
Map<String,INDArray> |
DefaultOpExecutioner.executeGraph(long id,
Map<String,INDArray> map) |
Map<String,INDArray> |
OpExecutioner.executeGraph(long id,
Map<String,INDArray> map) |
Modifier and Type | Method and Description |
---|---|
INDArray |
Variance.noOp() |
INDArray |
Norm2.noOp() |
INDArray |
NormMax.noOp() |
INDArray |
Norm1.noOp() |
Modifier and Type | Method and Description |
---|---|
void |
Variance.init(INDArray x,
INDArray y,
INDArray z,
long n) |
Modifier and Type | Method and Description |
---|---|
INDArray |
If.getInputArgument(int index) |
INDArray |
While.getInputArgument(int index) |
INDArray |
If.getOutputArgument(int index) |
INDArray |
While.getOutputArgument(int index) |
INDArray[] |
If.inputArguments() |
INDArray[] |
While.inputArguments() |
INDArray[] |
If.outputArguments() |
INDArray[] |
While.outputArguments() |
Modifier and Type | Method and Description |
---|---|
void |
If.addInputArgument(INDArray... arg) |
void |
While.addInputArgument(INDArray... arg) |
void |
If.addOutputArgument(INDArray... arg) |
void |
While.addOutputArgument(INDArray... arg) |
void |
If.removeInputArgument(INDArray arg) |
void |
While.removeInputArgument(INDArray arg) |
void |
If.removeOutputArgument(INDArray arg) |
void |
While.removeOutputArgument(INDArray arg) |
Constructor and Description |
---|
Select(INDArray[] inputs,
INDArray[] outputs) |
Select(INDArray[] inputs,
INDArray[] outputs) |
Select(INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
Select(INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
Where(INDArray[] inputs,
INDArray[] outputs) |
Where(INDArray[] inputs,
INDArray[] outputs) |
Where(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
Where(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
WhereNumpy(INDArray[] inputs,
INDArray[] outputs) |
WhereNumpy(INDArray[] inputs,
INDArray[] outputs) |
WhereNumpy(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
WhereNumpy(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
Constructor and Description |
---|
BaseGridOp(INDArray x,
INDArray y) |
FreeGridOp(INDArray x,
INDArray y) |
Constructor and Description |
---|
FirstIndex(INDArray x,
Condition condition) |
FirstIndex(INDArray x,
Condition condition,
double eps) |
IAMax(INDArray x) |
IAMax(INDArray x,
INDArray y) |
IAMax(INDArray x,
INDArray y,
long n) |
IAMin(INDArray x) |
IAMin(INDArray x,
INDArray y) |
IAMin(INDArray x,
INDArray y,
long n) |
IMax(INDArray x) |
IMax(INDArray x,
INDArray y,
long n) |
IMin(INDArray x) |
IMin(INDArray x,
INDArray y) |
IMin(INDArray x,
INDArray y,
long n) |
LastIndex(INDArray x,
Condition condition) |
LastIndex(INDArray x,
Condition condition,
double eps) |
Modifier and Type | Method and Description |
---|---|
void |
Linear.exec(INDArray... inputs) |
Constructor and Description |
---|
AvgPooling2D(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] arrayInputs,
INDArray[] arrayOutputs,
Pooling2DConfig config) |
AvgPooling2D(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] arrayInputs,
INDArray[] arrayOutputs,
Pooling2DConfig config) |
BatchNorm(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputArrays,
boolean inPlace,
boolean applyGamma,
boolean applyBeta,
double epsilon) |
BatchNorm(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputArrays,
boolean inPlace,
boolean applyGamma,
boolean applyBeta,
double epsilon) |
BatchNormDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputArrays,
boolean inPlace,
boolean applyGamma,
boolean applyBeta,
double epsilon) |
BatchNormDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputArrays,
boolean inPlace,
boolean applyGamma,
boolean applyBeta,
double epsilon) |
Col2Im(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig conv2DConfig) |
Col2Im(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig conv2DConfig) |
Conv1D(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv1DConfig config) |
Conv1D(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv1DConfig config) |
Conv2D(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig config) |
Conv2D(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig config) |
Conv2DDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig config) |
Conv2DDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig config) |
Conv3D(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputs,
INDArray[] outputs,
Conv3DConfig conv3DConfig) |
Conv3D(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputs,
INDArray[] outputs,
Conv3DConfig conv3DConfig) |
Conv3DDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputs,
INDArray[] outputs,
Conv3DConfig conv3DConfig) |
Conv3DDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputs,
INDArray[] outputs,
Conv3DConfig conv3DConfig) |
DeConv2D(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
DeConv2DConfig config) |
DeConv2D(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
DeConv2DConfig config) |
DeConv2DDerivative(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
DeConv2DConfig config) |
DeConv2DDerivative(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
DeConv2DConfig config) |
DepthwiseConv2D(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig config) |
DepthwiseConv2D(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig config) |
FullConv3D(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputs,
INDArray[] outputs,
FullConv3DConfig config) |
FullConv3D(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputs,
INDArray[] outputs,
FullConv3DConfig config) |
FullConv3DDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputs,
INDArray[] outputs,
FullConv3DConfig conv3DConfig) |
FullConv3DDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputs,
INDArray[] outputs,
FullConv3DConfig conv3DConfig) |
Im2col(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig conv2DConfig) |
Im2col(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig conv2DConfig) |
LegacyPooling2D(INDArray x,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dh,
int dw,
boolean isSameMode,
LegacyPooling2D.Pooling2DType type,
double extra,
INDArray z)
Deprecated.
|
LocalResponseNormalization(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputs,
INDArray[] outputs,
boolean inPlace,
LocalResponseNormalizationConfig config) |
LocalResponseNormalization(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputs,
INDArray[] outputs,
boolean inPlace,
LocalResponseNormalizationConfig config) |
LocalResponseNormalizationDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputs,
INDArray[] outputs,
boolean inPlace,
LocalResponseNormalizationConfig config) |
LocalResponseNormalizationDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputs,
INDArray[] outputs,
boolean inPlace,
LocalResponseNormalizationConfig config) |
MaxPooling2D(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] arrayInputs,
INDArray[] arrayOutputs,
Pooling2DConfig config) |
MaxPooling2D(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] arrayInputs,
INDArray[] arrayOutputs,
Pooling2DConfig config) |
Pooling2D(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] arrayInputs,
INDArray[] arrayOutputs,
Pooling2DConfig config) |
Pooling2D(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] arrayInputs,
INDArray[] arrayOutputs,
Pooling2DConfig config) |
Pooling2DDerivative(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] arrayInputs,
INDArray[] arrayOutputs,
Pooling2DConfig config) |
Pooling2DDerivative(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] arrayInputs,
INDArray[] arrayOutputs,
Pooling2DConfig config) |
Pooling3D(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
boolean inPlace,
Pooling3DConfig pooling3DConfig,
Pooling3D.Pooling3DType type) |
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) |
Pooling3DDerivative(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
boolean inPlace,
Pooling3DConfig pooling3DConfig,
Pooling3D.Pooling3DType type) |
SConv2D(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig conv2DConfig) |
SConv2D(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig conv2DConfig) |
SConv2DDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig conv2DConfig) |
SConv2DDerivative(SameDiff sameDiff,
SDVariable[] inputFunctions,
INDArray[] inputArrays,
INDArray[] outputs,
Conv2DConfig conv2DConfig) |
Upsampling(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
boolean inPlace,
int scaleFactor) |
Upsampling(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
boolean inPlace,
int scaleFactor) |
UpsamplingDerivative(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
boolean inPlace,
int scaleFactor) |
UpsamplingDerivative(SameDiff sameDiff,
SDVariable[] inputs,
INDArray[] inputArrays,
INDArray[] outputs,
boolean inPlace,
int scaleFactor) |
Constructor and Description |
---|
BaseMetaOp(INDArray x,
INDArray y) |
InvertedPredicateMetaOp(INDArray x,
INDArray y) |
PostulateMetaOp(INDArray x,
INDArray y) |
PredicateMetaOp(INDArray x,
INDArray y) |
ReduceMetaOp(INDArray x,
INDArray y) |
Modifier and Type | Method and Description |
---|---|
void |
ScalarMin.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
ScalarSet.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
ScalarMax.init(INDArray x,
INDArray y,
INDArray z,
long n) |
Constructor and Description |
---|
ScalarEquals(INDArray x) |
ScalarEquals(INDArray x,
INDArray y,
INDArray z,
long n,
Number num) |
ScalarEquals(INDArray x,
Number num) |
ScalarGreaterThan(INDArray x,
INDArray y,
INDArray z,
long n,
Number num) |
ScalarGreaterThan(INDArray x,
Number num) |
ScalarGreaterThanOrEqual(INDArray x,
INDArray y,
INDArray z,
long n,
Number num) |
ScalarGreaterThanOrEqual(INDArray x,
Number num) |
ScalarLessThan(INDArray x,
INDArray y,
INDArray z,
long n,
Number num) |
ScalarLessThan(INDArray x,
Number num) |
ScalarLessThanOrEqual(INDArray x,
INDArray y,
INDArray z,
long n,
Number num) |
ScalarLessThanOrEqual(INDArray x,
Number num) |
ScalarNotEquals(INDArray x,
INDArray y,
INDArray z,
long n,
Number num) |
ScalarNotEquals(INDArray x,
Number num) |
ScalarSetValue(INDArray x,
INDArray y,
INDArray z,
long n,
Number num) |
ScalarSetValue(INDArray x,
Number num) |
Modifier and Type | Method and Description |
---|---|
INDArray |
RollAxis.z() |
Constructor and Description |
---|
Diag(INDArray[] inputs,
INDArray[] outputs) |
Diag(INDArray[] inputs,
INDArray[] outputs) |
ExpandDims(INDArray[] inputs,
INDArray[] outputs) |
ExpandDims(INDArray[] inputs,
INDArray[] outputs) |
Repeat(INDArray[] inputs,
INDArray[] outputs,
int axis) |
Repeat(INDArray[] inputs,
INDArray[] outputs,
int axis) |
Repeat(INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments,
int axis) |
Repeat(INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments,
int axis) |
RollAxis(INDArray x) |
RollAxis(INDArray x,
INDArray z) |
RollAxis(INDArray x,
INDArray y,
INDArray z,
long n) |
RollAxis(INDArray x,
INDArray z,
long n) |
Modifier and Type | Method and Description |
---|---|
void |
LeakyReLU.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
ReplaceNans.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
LegacyDropOut.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
OldAtan2Op.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Relu6.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
PowDerivative.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Reciprocal.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Pow.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
OldSoftMax.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
SetRange.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
RectifedLinear.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
LegacyDropOutInverted.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Step.init(INDArray x,
INDArray y,
INDArray z,
long n) |
Modifier and Type | Method and Description |
---|---|
void |
OldAddOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
TruncateDivOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
OldMulOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
Axpy.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
OldDivOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
OldSubOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
OldRDivOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
RemainderOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
OldFModOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
OldFloorDivOp.init(INDArray x,
INDArray y,
INDArray z,
long n) |
Constructor and Description |
---|
ClipByValue(INDArray[] inputs,
INDArray[] outputs,
double clipValueMin,
double clipValueMax,
boolean inPlace) |
ClipByValue(INDArray[] inputs,
INDArray[] outputs,
double clipValueMin,
double clipValueMax,
boolean inPlace) |
Modifier and Type | Method and Description |
---|---|
void |
CompareAndSet.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
CompareAndReplace.init(INDArray x,
INDArray y,
INDArray z,
long n) |
Constructor and Description |
---|
Choose(INDArray[] inputs,
Condition condition) |
Choose(INDArray[] inputs,
List<Integer> iArgs,
List<Double> tArgs,
Condition condition)
Note that iArgs (integer arguments) and tArgs(double/float arguments)
may end up being used under the following conditions:
scalar operations (if a scalar is specified the you do not need to specify an ndarray)
otherwise, if an ndarray is needed as a second input then put it in the inputs
Usually, you only need 1 input (the equivalent of the array you're trying to do indexing on)
|
Choose(String opName,
INDArray[] inputs,
Condition condition) |
Choose(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
Choose(String opName,
INDArray[] inputs,
INDArray[] outputs,
List<Double> tArguments,
List<Integer> iArguments) |
CompareAndReplace(INDArray x,
INDArray y,
Condition condition)
With this constructor, op will check each X element against given Condition, and if condition met, element Z will be set to Y value, and X otherwise
PLEASE NOTE: X will be modified inplace.
|
CompareAndReplace(INDArray x,
INDArray y,
INDArray z,
Condition condition)
With this constructor, op will check each X element against given Condition, and if condition met, element Z will be set to Y value, and X otherwise
Pseudocode:
z[i] = condition(x[i]) ? y[i] : x[i];
|
CompareAndSet(INDArray x,
double set,
Condition condition)
With this constructor, op will check each X element against given Condition, and if condition met, element will be replaced with Set value
Pseudocode:
z[i] = condition(x[i]) ? set : x[i];
PLEASE NOTE: X will be modified inplace.
|
CompareAndSet(INDArray x,
double compare,
double set,
double eps) |
CompareAndSet(INDArray x,
double compare,
double set,
double eps,
Condition condition) |
CompareAndSet(INDArray x,
INDArray y,
Condition condition)
With this constructor, op will check each Y element against given Condition, and if condition met, element Z will be set to Y value, and X otherwise
PLEASE NOTE: X will be modified inplace.
|
CompareAndSet(INDArray x,
INDArray z,
double set,
Condition condition)
With this constructor, op will check each X element against given Condition, and if condition met, element will be replaced with Set value
Pseudocode:
z[i] = condition(x[i]) ? set : x[i];
|
CompareAndSet(INDArray x,
INDArray z,
double compare,
double set,
double eps)
This constructor is shortcut to epsEquals.
|
CompareAndSet(INDArray x,
INDArray z,
double compare,
double set,
double eps,
long n)
This constructor is shortcut to epsEquals.
|
CompareAndSet(INDArray x,
INDArray y,
INDArray z,
Condition condition)
With this constructor, op will check each Y element against given Condition, and if condition met, element Z will be set to Y value, and X otherwise
Pseudocode:
z[i] = condition(y[i]) ? y[i] : x[i];
|
Eps(INDArray x) |
Eps(INDArray x,
INDArray z) |
Eps(INDArray x,
INDArray y,
INDArray z,
long n) |
Eps(INDArray x,
INDArray z,
long n) |
EqualTo(INDArray[] inputs,
INDArray[] outputs) |
EqualTo(INDArray[] inputs,
INDArray[] outputs) |
GreaterThan(INDArray[] inputs,
INDArray[] outputs) |
GreaterThan(INDArray[] inputs,
INDArray[] outputs) |
GreaterThanOrEqual(INDArray[] inputs,
INDArray[] outputs) |
GreaterThanOrEqual(INDArray[] inputs,
INDArray[] outputs) |
IsNonDecreasing(INDArray[] inputs,
INDArray[] outputs) |
IsNonDecreasing(INDArray[] inputs,
INDArray[] outputs) |
IsNumericTensor(INDArray[] inputs,
INDArray[] outputs) |
IsNumericTensor(INDArray[] inputs,
INDArray[] outputs) |
IsStrictlyIncreasing(INDArray[] inputs,
INDArray[] outputs) |
IsStrictlyIncreasing(INDArray[] inputs,
INDArray[] outputs) |
LessThan(INDArray[] inputs,
INDArray[] outputs) |
LessThan(INDArray[] inputs,
INDArray[] outputs) |
LessThanOrEqual(INDArray[] inputs,
INDArray[] outputs) |
LessThanOrEqual(INDArray[] inputs,
INDArray[] outputs) |
Max(INDArray[] inputs,
INDArray[] outputs) |
Max(INDArray[] inputs,
INDArray[] outputs) |
Min(INDArray[] inputs,
INDArray[] outputs) |
Min(INDArray[] inputs,
INDArray[] outputs) |
NotEqualTo(INDArray[] inputs,
INDArray[] outputs) |
NotEqualTo(INDArray[] inputs,
INDArray[] outputs) |
OldEqualTo(INDArray x) |
OldEqualTo(INDArray x,
INDArray z) |
OldEqualTo(INDArray x,
INDArray y,
INDArray z,
long n) |
OldEqualTo(INDArray x,
INDArray z,
long n) |
OldGreaterThan(INDArray x) |
OldGreaterThan(INDArray x,
INDArray z) |
OldGreaterThan(INDArray x,
INDArray y,
INDArray z,
long n) |
OldGreaterThan(INDArray x,
INDArray z,
long n) |
OldGreaterThanOrEqual(INDArray x) |
OldGreaterThanOrEqual(INDArray x,
INDArray z) |
OldGreaterThanOrEqual(INDArray x,
INDArray y,
INDArray z,
long n) |
OldGreaterThanOrEqual(INDArray x,
INDArray z,
long n) |
OldLessThan(INDArray x) |
OldLessThan(INDArray ndArray,
INDArray dup) |
OldLessThan(INDArray x,
INDArray y,
INDArray z,
long n) |
OldLessThan(INDArray x,
INDArray z,
long n) |
OldLessThanOrEqual(INDArray x) |
OldLessThanOrEqual(INDArray x,
INDArray z) |
OldLessThanOrEqual(INDArray x,
INDArray y,
INDArray z,
long n) |
OldLessThanOrEqual(INDArray x,
INDArray z,
long n) |
OldMax(INDArray x) |
OldMax(INDArray ndArray,
INDArray dup) |
OldMax(INDArray x,
INDArray y,
INDArray z,
long n) |
OldMax(INDArray x,
INDArray z,
long n) |
OldMin(INDArray x) |
OldMin(INDArray x,
INDArray z) |
OldMin(INDArray x,
INDArray y,
INDArray z,
long n) |
OldMin(INDArray x,
INDArray z,
long n) |
OldNotEqualTo(INDArray x) |
OldNotEqualTo(INDArray x,
INDArray z) |
OldNotEqualTo(INDArray x,
INDArray y,
INDArray z,
long n) |
OldNotEqualTo(INDArray x,
INDArray z,
long n) |
Modifier and Type | Method and Description |
---|---|
void |
LeakyReLUDerivative.init(INDArray x,
INDArray y,
INDArray z,
long n) |
Modifier and Type | Method and Description |
---|---|
void |
DropOut.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
AlphaDropOut.init(INDArray x,
INDArray y,
INDArray z,
long n) |
void |
DropOutInverted.init(INDArray x,
INDArray y,
INDArray z,
long n) |
Constructor and Description |
---|
AlphaDropOut(INDArray x,
double p,
double alpha,
double alphaPrime,
double beta) |
AlphaDropOut(INDArray x,
INDArray z,
double p,
double alpha,
double alphaPrime,
double beta) |
AlphaDropOut(INDArray x,
INDArray z,
double p,
double alpha,
double alphaPrime,
double beta,
long n) |
BernoulliDistribution(INDArray z,
double prob)
This op fills Z with bernoulli trial results, so 0, or 1, depending by common probability
|
BernoulliDistribution(INDArray z,
INDArray prob)
This op fills Z with bernoulli trial results, so 0, or 1, each element will have it's own success probability defined in prob array
|
BinomialDistribution(INDArray z,
INDArray probabilities)
This op fills Z with binomial distribution over given trials with probability for each trial given as probabilities INDArray
|
BinomialDistribution(INDArray z,
int trials,
double probability)
This op fills Z with binomial distribution over given trials with single given probability for all trials
|
BinomialDistribution(INDArray z,
int trials,
INDArray probabilities)
This op fills Z with binomial distribution over given trials with probability for each trial given as probabilities INDArray
|
BinomialDistributionEx(INDArray z,
INDArray probabilities)
This op fills Z with binomial distribution over given trials with probability for each trial given as probabilities INDArray
|
BinomialDistributionEx(INDArray z,
int trials,
double probability)
This op fills Z with binomial distribution over given trials with single given probability for all trials
|
BinomialDistributionEx(INDArray z,
int trials,
INDArray probabilities)
This op fills Z with binomial distribution over given trials with probability for each trial given as probabilities INDArray
|
Choice(INDArray source,
INDArray probabilities,
INDArray z) |
DropOut(INDArray x,
double p) |
DropOut(INDArray x,
INDArray z,
double p) |
DropOut(INDArray x,
INDArray z,
double p,
long n) |
DropOutInverted(INDArray x,
double p) |
DropOutInverted(INDArray x,
INDArray z,
double p) |
DropOutInverted(INDArray x,
INDArray z,
double p,
long n) |
GaussianDistribution(INDArray z)
This op fills Z with random values within -1.0..0..1.0
|
GaussianDistribution(INDArray z,
double stddev)
This op fills Z with random values within stddev..0..stddev
|
GaussianDistribution(INDArray z,
double mean,
double stddev)
This op fills Z with random values within stddev..mean..stddev boundaries
|
GaussianDistribution(INDArray z,
INDArray means,
double stddev) |
Linspace(INDArray z,
double from,
double to) |
LogNormalDistribution(INDArray z)
This op fills Z with random values within -1.0..0..1.0
|
LogNormalDistribution(INDArray z,
double stddev)
This op fills Z with random values within stddev..0..stddev
|
LogNormalDistribution(INDArray z,
double mean,
double stddev)
This op fills Z with random values within stddev..mean..stddev boundaries
|
LogNormalDistribution(INDArray z,
INDArray means,
double stddev) |
ProbablisticMerge(INDArray x,
INDArray y,
double probability) |
ProbablisticMerge(INDArray x,
INDArray y,
INDArray z,
double probability) |
TruncatedNormalDistribution(INDArray z)
This op fills Z with random values within -1.0..0..1.0
|
TruncatedNormalDistribution(INDArray z,
double stddev)
This op fills Z with random values within stddev..0..stddev
|
TruncatedNormalDistribution(INDArray z,
double mean,
double stddev)
This op fills Z with random values within stddev..mean..stddev boundaries
|
TruncatedNormalDistribution(INDArray z,
INDArray means,
double stddev) |
UniformDistribution(INDArray z)
This op fills Z with random values within 0...1
|
UniformDistribution(INDArray z,
double to)
This op fills Z with random values within 0...to
|
UniformDistribution(INDArray z,
double from,
double to)
This op fills Z with random values within from...to boundaries
|
Modifier and Type | Method and Description |
---|---|
INDArray |
DefaultRandom.nextDouble(char order,
int[] shape) |
INDArray |
Random.nextDouble(char order,
int[] shape)
Generate a uniform number ndarray
of the specified shape and order
|
INDArray |
DefaultRandom.nextDouble(int[] shape) |
INDArray |
Random.nextDouble(int[] shape)
Generate a uniform number ndarray
of the specified shape
|
INDArray |
DefaultRandom.nextFloat(char order,
int[] shape) |
INDArray |
Random.nextFloat(char order,
int[] shape)
Generate a uniform number ndarray
of the specified shape
|
INDArray |
DefaultRandom.nextFloat(int[] shape) |
INDArray |
Random.nextFloat(int[] shape)
Generate a uniform number ndarray
of the specified shape
|
INDArray |
DefaultRandom.nextGaussian(char order,
int[] shape) |
INDArray |
Random.nextGaussian(char order,
int[] shape)
Generate a gaussian number ndarray
of the specified shape and order
|
INDArray |
DefaultRandom.nextGaussian(int[] shape) |
INDArray |
Random.nextGaussian(int[] shape)
Generate a gaussian number ndarray
of the specified shape
|
INDArray |
DefaultRandom.nextInt(int[] shape) |
INDArray |
Random.nextInt(int[] shape)
Generate a random set of integers
of the specified shape.
|
INDArray |
DefaultRandom.nextInt(int n,
int[] shape) |
INDArray |
Random.nextInt(int n,
int[] shape)
Generate a random set of integers
of the specified shape.
|
Modifier and Type | Method and Description |
---|---|
INDArray |
BaseDistribution.sample(INDArray target) |
INDArray |
Distribution.sample(INDArray target)
Fill the target array by sampling from the distribution
|
INDArray |
BaseDistribution.sample(int[] shape) |
INDArray |
Distribution.sample(int[] shape)
Sample the given shape
|
Modifier and Type | Method and Description |
---|---|
INDArray |
BaseDistribution.sample(INDArray target) |
INDArray |
Distribution.sample(INDArray target)
Fill the target array by sampling from the distribution
|
Modifier and Type | Method and Description |
---|---|
Distribution |
DistributionFactory.createBinomial(int n,
INDArray p)
Create a distribution
|
Distribution |
DefaultDistributionFactory.createBinomial(int n,
INDArray p) |
Distribution |
DistributionFactory.createNormal(INDArray mean,
double std)
Create a normal distribution
with the given mean and std
|
Distribution |
DefaultDistributionFactory.createNormal(INDArray mean,
double std) |
Modifier and Type | Method and Description |
---|---|
INDArray |
UniformDistribution.sample(INDArray ret) |
INDArray |
TruncatedNormalDistribution.sample(INDArray ret) |
INDArray |
ConstantDistribution.sample(INDArray target) |
INDArray |
BinomialDistribution.sample(INDArray ret) |
INDArray |
NormalDistribution.sample(INDArray ret) |
INDArray |
OrthogonalDistribution.sample(INDArray target) |
INDArray |
LogNormalDistribution.sample(INDArray ret) |
INDArray |
UniformDistribution.sample(int[] shape) |
INDArray |
TruncatedNormalDistribution.sample(int[] shape) |
INDArray |
ConstantDistribution.sample(int[] shape) |
INDArray |
BinomialDistribution.sample(int[] shape) |
INDArray |
NormalDistribution.sample(int[] shape) |
INDArray |
OrthogonalDistribution.sample(int[] shape) |
INDArray |
LogNormalDistribution.sample(int[] shape) |
Modifier and Type | Method and Description |
---|---|
INDArray |
UniformDistribution.sample(INDArray ret) |
INDArray |
TruncatedNormalDistribution.sample(INDArray ret) |
INDArray |
ConstantDistribution.sample(INDArray target) |
INDArray |
BinomialDistribution.sample(INDArray ret) |
INDArray |
NormalDistribution.sample(INDArray ret) |
INDArray |
OrthogonalDistribution.sample(INDArray target) |
INDArray |
LogNormalDistribution.sample(INDArray ret) |
Constructor and Description |
---|
BinomialDistribution(int n,
INDArray p) |
LogNormalDistribution(double standardDeviation,
INDArray means) |
LogNormalDistribution(INDArray mean,
double std) |
LogNormalDistribution(Random rng,
double standardDeviation,
INDArray means) |
NormalDistribution(double standardDeviation,
INDArray means) |
NormalDistribution(INDArray mean,
double std) |
NormalDistribution(Random rng,
double standardDeviation,
INDArray means) |
TruncatedNormalDistribution(double standardDeviation,
INDArray means) |
TruncatedNormalDistribution(INDArray mean,
double std) |
TruncatedNormalDistribution(Random rng,
double standardDeviation,
INDArray means) |
Modifier and Type | Method and Description |
---|---|
static INDArray |
Shape.newShapeNoCopy(INDArray arr,
int[] newShape,
boolean isFOrder)
A port of numpy's reshaping algorithm that leverages
no copy where possible and returns
null if the reshape
couldn't happen without copying
|
static INDArray |
Shape.toMmulCompatible(INDArray input)
This method is used in DL4J LSTM implementation
|
static INDArray |
Shape.toOffsetZero(INDArray arr)
Create a copy of the matrix
where the new offset is zero
|
static INDArray |
Shape.toOffsetZeroCopy(INDArray arr)
Create a copy of the ndarray where the new offset is zero
|
static INDArray |
Shape.toOffsetZeroCopy(INDArray arr,
char order)
Create a copy of the ndarray where the new offset is zero, and has specified order
|
static INDArray |
Shape.toOffsetZeroCopyAnyOrder(INDArray arr)
Create a copy of the ndarray where the new offset is zero.
|
Modifier and Type | Method and Description |
---|---|
static void |
Shape.assertBroadcastable(INDArray x,
INDArray y) |
static double |
Shape.getDouble(INDArray arr,
int... indices)
Get a double based on the array and given indices
|
static int[] |
Shape.getMaxShape(INDArray... inputs)
Return the shape of the largest length array
based on the input
|
static char |
Shape.getOrder(INDArray arr)
Infer the order for the ndarray based on the
array's strides
|
static boolean |
Shape.hasDefaultStridesForShape(INDArray input) |
static int[] |
Shape.ind2sub(INDArray arr,
long index)
Convert a linear index to
the equivalent nd index based on the shape of the specified ndarray.
|
static int[] |
Shape.ind2subC(INDArray arr,
long index)
Convert a linear index to
the equivalent nd index based on the shape of the specified ndarray.
|
static boolean |
Shape.isContiguousInBuffer(INDArray in)
Are the elements in the buffer contiguous for this NDArray?
|
static void |
Shape.iterate(INDArray arr,
CoordinateFunction coordinateFunction)
Iterate over 2
coordinate spaces given 2 arrays
|
static void |
Shape.iterate(INDArray arr,
INDArray arr2,
CoordinateFunction coordinateFunction)
Iterate over 2
coordinate spaces given 2 arrays
|
static INDArray |
Shape.newShapeNoCopy(INDArray arr,
int[] newShape,
boolean isFOrder)
A port of numpy's reshaping algorithm that leverages
no copy where possible and returns
null if the reshape
couldn't happen without copying
|
static long |
Shape.offsetFor(INDArray arr,
int[] indexes)
Compute the offset for the given array
given the indices
|
static String |
Shape.shapeToString(INDArray arr)
Prints the shape
for this shape information
|
static boolean |
Shape.strideDescendingCAscendingF(INDArray array)
Check if strides are in order suitable for non-strided mmul etc.
|
static INDArray |
Shape.toMmulCompatible(INDArray input)
This method is used in DL4J LSTM implementation
|
static INDArray |
Shape.toOffsetZero(INDArray arr)
Create a copy of the matrix
where the new offset is zero
|
static INDArray |
Shape.toOffsetZeroCopy(INDArray arr)
Create a copy of the ndarray where the new offset is zero
|
static INDArray |
Shape.toOffsetZeroCopy(INDArray arr,
char order)
Create a copy of the ndarray where the new offset is zero, and has specified order
|
static INDArray |
Shape.toOffsetZeroCopyAnyOrder(INDArray arr)
Create a copy of the ndarray where the new offset is zero.
|
Modifier and Type | Method and Description |
---|---|
org.nd4j.linalg.primitives.Pair<DataBuffer,DataBuffer> |
TADManager.getTADOnlyShapeInfo(INDArray array,
int... dimension)
This method returns TAD shapeInfo and all offsets
for specified tensor and dimensions.
|
Constructor and Description |
---|
TadDescriptor(INDArray array,
int[] dimension)
Pass in an ndarray to get the databuffer
and the appropriate dimensions
|
Modifier and Type | Method and Description |
---|---|
static INDArray |
CheckUtil.convertFromApacheMatrix(org.apache.commons.math3.linear.RealMatrix matrix) |
Modifier and Type | Method and Description |
---|---|
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get3dPermutedWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get3dReshapedWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get3dSubArraysWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get3dTensorAlongDimensionWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get4dPermutedWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get4dReshapedWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get4dSubArraysWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get4dTensorAlongDimensionWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get5dPermutedWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get5dReshapedWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get5dSubArraysWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get5dTensorAlongDimensionWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get6dPermutedWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get6dReshapedWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.get6dSubArraysWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.getAll3dTestArraysWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.getAll4dTestArraysWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.getAll5dTestArraysWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.getAll6dTestArraysWithShape(int seed,
int... shape) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.getAllTestMatricesWithShape(char ordering,
int rows,
int cols,
int seed)
Get an array of INDArrays (2d) all with the specified shape.
|
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.getAllTestMatricesWithShape(int rows,
int cols,
int seed)
Get an array of INDArrays (2d) all with the specified shape.
|
static org.nd4j.linalg.primitives.Pair<INDArray,String> |
NDArrayCreationUtil.getPermutedWithShape(char ordering,
int rows,
int cols,
int seed) |
static org.nd4j.linalg.primitives.Pair<INDArray,String> |
NDArrayCreationUtil.getPermutedWithShape(int rows,
int cols,
int seed) |
static org.nd4j.linalg.primitives.Pair<INDArray,String> |
NDArrayCreationUtil.getReshapedWithShape(char ordering,
int rows,
int cols,
int seed) |
static org.nd4j.linalg.primitives.Pair<INDArray,String> |
NDArrayCreationUtil.getReshapedWithShape(int rows,
int cols,
int seed) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.getSubMatricesWithShape(char ordering,
int rows,
int cols,
int seed) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.getSubMatricesWithShape(int rows,
int cols,
int seed) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.getTensorAlongDimensionMatricesWithShape(char ordering,
int rows,
int cols,
int seed) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.getTensorAlongDimensionMatricesWithShape(int rows,
int cols,
int seed) |
static List<org.nd4j.linalg.primitives.Pair<INDArray,String>> |
NDArrayCreationUtil.getTestMatricesWithVaryingShapes(int rank,
char order)
Test utility to sweep shapes given a rank
Given a rank will generate random test matrices that will cover all cases of a shape with a '1' anywhere in the shape
as well a shape with random ints that are not 0 or 1
eg.
|
static org.nd4j.linalg.primitives.Pair<INDArray,String> |
NDArrayCreationUtil.getTransposedMatrixWithShape(char ordering,
int rows,
int cols,
int seed) |
static org.nd4j.linalg.primitives.Pair<INDArray,String> |
NDArrayCreationUtil.getTransposedMatrixWithShape(int rows,
int cols,
int seed) |
Modifier and Type | Method and Description |
---|---|
static boolean |
CheckUtil.checkAdd(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference)
Same as checkMmul, but for matrix addition
|
static boolean |
CheckUtil.checkDivManually(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkEntries(INDArray expected,
INDArray actual,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkEntries(org.apache.commons.math3.linear.RealMatrix rmResult,
INDArray result,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkGemm(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB,
double alpha,
double beta,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkMmul(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference)
Check first.mmul(second) using Apache commons math mmul.
|
static boolean |
CheckUtil.checkMulManually(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference) |
static boolean |
CheckUtil.checkSubtract(INDArray first,
INDArray second,
double maxRelativeDifference,
double minAbsDifference)
Same as checkMmul, but for matrix subtraction
|
static org.apache.commons.math3.linear.RealMatrix |
CheckUtil.convertToApacheMatrix(INDArray matrix) |
static void |
CheckUtil.printFailureDetails(INDArray first,
INDArray second,
INDArray expected,
INDArray actual,
INDArray onCopies,
String op) |
static void |
CheckUtil.printFailureDetails(INDArray first,
INDArray second,
org.apache.commons.math3.linear.RealMatrix expected,
INDArray actual,
INDArray onCopies,
String op) |
static void |
CheckUtil.printGemmFailureDetails(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB,
double alpha,
double beta,
org.apache.commons.math3.linear.RealMatrix expected,
INDArray actual,
INDArray onCopies) |
static void |
CheckUtil.printMatrixFullPrecision(INDArray matrix) |
static void |
CheckUtil.printNDArrayHeader(INDArray array) |
Modifier and Type | Method and Description |
---|---|
INDArray |
BasicNDArrayCompressor.compress(double[] array)
This method returns compressed INDArray instance which contains JVM array passed in
|
INDArray |
NDArrayCompressor.compress(double[] data)
This method creates compressed INDArray from Java double array, skipping usual INDArray instantiation routines
Please note: This method compresses input data as vector
|
INDArray |
NDArrayCompressor.compress(double[] data,
int[] shape,
char order)
This method creates compressed INDArray from Java double array, skipping usual INDArray instantiation routines
|
INDArray |
BasicNDArrayCompressor.compress(float[] array)
This method returns compressed INDArray instance which contains JVM array passed in
|
INDArray |
NDArrayCompressor.compress(float[] data)
This method creates compressed INDArray from Java float array, skipping usual INDArray instantiation routines
Please note: This method compresses input data as vector
|
INDArray |
NDArrayCompressor.compress(float[] data,
int[] shape,
char order)
This method creates compressed INDArray from Java float array, skipping usual INDArray instantiation routines
|
INDArray |
BasicNDArrayCompressor.compress(INDArray array) |
INDArray |
NDArrayCompressor.compress(INDArray array)
This method returns compressed copy of referenced array
|
INDArray |
BasicNDArrayCompressor.compress(INDArray array,
String algorithm)
Returns a compressed version of the
given ndarray
|
INDArray |
BasicNDArrayCompressor.decompress(INDArray array) |
INDArray |
NDArrayCompressor.decompress(INDArray array)
This method returns
decompressed copy of referenced array
|
INDArray |
AbstractStorage.get(T key)
Get object from the storage, by key
|
Modifier and Type | Method and Description |
---|---|
void |
BasicNDArrayCompressor.autoDecompress(INDArray... arrays)
Decompress several ndarrays
|
void |
BasicNDArrayCompressor.autoDecompress(INDArray array) |
INDArray |
BasicNDArrayCompressor.compress(INDArray array) |
INDArray |
NDArrayCompressor.compress(INDArray array)
This method returns compressed copy of referenced array
|
INDArray |
BasicNDArrayCompressor.compress(INDArray array,
String algorithm)
Returns a compressed version of the
given ndarray
|
void |
BasicNDArrayCompressor.compressi(INDArray array)
In place compression of the passed in ndarray
with the default compression algorithm
|
void |
NDArrayCompressor.compressi(INDArray array)
Inplace compression of INDArray
|
void |
BasicNDArrayCompressor.compressi(INDArray array,
String algorithm)
In place Compress the given ndarray
with the given algorithm
|
INDArray |
BasicNDArrayCompressor.decompress(INDArray array) |
INDArray |
NDArrayCompressor.decompress(INDArray array)
This method returns
decompressed copy of referenced array
|
void |
BasicNDArrayCompressor.decompressi(INDArray array)
in place decompression of the given
ndarray.
|
void |
NDArrayCompressor.decompressi(INDArray array)
Inplace decompression of INDArray
|
void |
AbstractStorage.store(T key,
INDArray object)
Store object into storage
|
boolean |
AbstractStorage.storeIfAbsent(T key,
INDArray object)
Store object into storage, if it doesn't exist
|
Modifier and Type | Method and Description |
---|---|
static INDArray |
Convolution.col2im(INDArray col,
INDArray z,
int sy,
int sx,
int ph,
int pw,
int h,
int w,
int dh,
int dw) |
static INDArray |
Convolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
OldConvolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
Convolution.col2im(INDArray col,
int sy,
int sx,
int ph,
int pw,
int h,
int w)
Rearrange matrix
columns into blocks
|
static INDArray |
OldConvolution.col2im(INDArray col,
int sy,
int sx,
int ph,
int pw,
int h,
int w)
Rearrange matrix
columns into blocks
|
static INDArray |
Convolution.conv2d(IComplexNDArray input,
IComplexNDArray kernel,
Convolution.Type type) |
INDArray |
BaseConvolution.conv2d(IComplexNDArray input,
IComplexNDArray kernel,
Convolution.Type type) |
INDArray |
ConvolutionInstance.conv2d(IComplexNDArray input,
IComplexNDArray kernel,
Convolution.Type type) |
static INDArray |
Convolution.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
INDArray |
BaseConvolution.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
INDArray |
ConvolutionInstance.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
BaseConvolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
INDArray |
DefaultConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
static INDArray |
Convolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
OldConvolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean isSameMode)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean isSameMode,
INDArray out) |
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int pval,
boolean isSameMode)
Implement column formatted images
|
static INDArray |
OldConvolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int pval,
boolean coverAll)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dh,
int dw,
boolean isSameMode) |
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dH,
int dW,
boolean isSameMode,
INDArray out) |
static INDArray |
Convolution.pooling2D(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dh,
int dw,
boolean isSameMode,
Pooling2D.Pooling2DType type,
Pooling2D.Divisor divisor,
double extra,
int virtualHeight,
int virtualWidth,
INDArray out)
Pooling 2d implementation
|
Modifier and Type | Method and Description |
---|---|
static INDArray |
Convolution.col2im(INDArray col,
INDArray z,
int sy,
int sx,
int ph,
int pw,
int h,
int w,
int dh,
int dw) |
static INDArray |
Convolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
OldConvolution.col2im(INDArray col,
int[] stride,
int[] padding,
int height,
int width) |
static INDArray |
Convolution.col2im(INDArray col,
int sy,
int sx,
int ph,
int pw,
int h,
int w)
Rearrange matrix
columns into blocks
|
static INDArray |
OldConvolution.col2im(INDArray col,
int sy,
int sx,
int ph,
int pw,
int h,
int w)
Rearrange matrix
columns into blocks
|
static INDArray |
Convolution.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
INDArray |
BaseConvolution.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
INDArray |
ConvolutionInstance.conv2d(INDArray input,
INDArray kernel,
Convolution.Type type)
2d convolution (aka the last 2 dimensions
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
BaseConvolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type)
ND Convolution
|
static INDArray |
Convolution.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
INDArray |
ConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
INDArray |
DefaultConvolutionInstance.convn(INDArray input,
INDArray kernel,
Convolution.Type type,
int[] axes)
ND Convolution
|
static INDArray |
Convolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
OldConvolution.im2col(INDArray img,
int[] kernel,
int[] stride,
int[] padding) |
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean isSameMode)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
boolean isSameMode,
INDArray out) |
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int pval,
boolean isSameMode)
Implement column formatted images
|
static INDArray |
OldConvolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int pval,
boolean coverAll)
Implement column formatted images
|
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dh,
int dw,
boolean isSameMode) |
static INDArray |
Convolution.im2col(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dH,
int dW,
boolean isSameMode,
INDArray out) |
static INDArray |
Convolution.pooling2D(INDArray img,
int kh,
int kw,
int sy,
int sx,
int ph,
int pw,
int dh,
int dw,
boolean isSameMode,
Pooling2D.Pooling2DType type,
Pooling2D.Divisor divisor,
double extra,
int virtualHeight,
int virtualWidth,
INDArray out)
Pooling 2d implementation
|
Modifier and Type | Method and Description |
---|---|
INDArray |
DataSet.exampleMaxs() |
INDArray |
DataSet.exampleMeans() |
INDArray |
DataSet.exampleSums() |
INDArray |
DataSet.getFeatureMatrix()
Get the feature matrix (inputs for the data)
|
INDArray |
DataSet.getFeatures() |
INDArray[] |
MultiDataSet.getFeatures() |
INDArray |
MultiDataSet.getFeatures(int index) |
INDArray |
DataSet.getFeaturesMaskArray() |
INDArray |
MultiDataSet.getFeaturesMaskArray(int index) |
INDArray[] |
MultiDataSet.getFeaturesMaskArrays() |
INDArray |
DataSet.getLabels()
Returns the labels for the dataset
|
INDArray[] |
MultiDataSet.getLabels() |
INDArray |
MultiDataSet.getLabels(int index) |
INDArray |
DataSet.getLabelsMaskArray() |
INDArray |
MultiDataSet.getLabelsMaskArray(int index) |
INDArray[] |
MultiDataSet.getLabelsMaskArrays() |
Modifier and Type | Method and Description |
---|---|
void |
DataSet.addFeatureVector(INDArray toAdd)
Adds a feature for each example on to the current feature vector
|
void |
DataSet.addFeatureVector(INDArray feature,
int example)
The feature to add, and the example/row number
|
List<String> |
DataSet.getLabelNames(INDArray idxs) |
void |
DataSet.setFeatures(INDArray features) |
void |
MultiDataSet.setFeatures(INDArray[] features) |
void |
MultiDataSet.setFeatures(int idx,
INDArray features) |
void |
DataSet.setFeaturesMaskArray(INDArray featuresMask) |
void |
MultiDataSet.setFeaturesMaskArray(int idx,
INDArray maskArray) |
void |
MultiDataSet.setFeaturesMaskArrays(INDArray[] maskArrays) |
void |
DataSet.setLabels(INDArray labels) |
void |
MultiDataSet.setLabels(INDArray[] labels) |
void |
MultiDataSet.setLabels(int idx,
INDArray labels) |
void |
DataSet.setLabelsMaskArray(INDArray labelsMask) |
void |
MultiDataSet.setLabelsMaskArray(INDArray[] labelsMaskArrays) |
void |
MultiDataSet.setLabelsMaskArray(int idx,
INDArray labelsMaskArray) |
Constructor and Description |
---|
DataSet(INDArray first,
INDArray second)
Creates a dataset with the specified input matrix and labels
|
DataSet(INDArray features,
INDArray labels,
INDArray featuresMask,
INDArray labelsMask)
Create a dataset with the specified input INDArray and labels (output) INDArray, plus (optionally) mask arrays
for the features and labels
|
MultiDataSet(INDArray[] features,
INDArray[] labels)
MultiDataSet constructor with no mask arrays
|
MultiDataSet(INDArray[] features,
INDArray[] labels)
MultiDataSet constructor with no mask arrays
|
MultiDataSet(INDArray[] features,
INDArray[] labels,
INDArray[] featuresMaskArrays,
INDArray[] labelsMaskArrays) |
MultiDataSet(INDArray[] features,
INDArray[] labels,
INDArray[] featuresMaskArrays,
INDArray[] labelsMaskArrays) |
MultiDataSet(INDArray[] features,
INDArray[] labels,
INDArray[] featuresMaskArrays,
INDArray[] labelsMaskArrays) |
MultiDataSet(INDArray[] features,
INDArray[] labels,
INDArray[] featuresMaskArrays,
INDArray[] labelsMaskArrays) |
MultiDataSet(INDArray features,
INDArray labels)
MultiDataSet constructor with single features/labels input, no mask arrays
|
MultiDataSet(INDArray features,
INDArray labels,
INDArray featuresMask,
INDArray labelsMask)
MultiDataSet constructor with single features/labels input, single mask arrays
|
Modifier and Type | Method and Description |
---|---|
INDArray |
DataSet.exampleMaxs() |
INDArray |
DataSet.exampleMeans() |
INDArray |
DataSet.exampleSums() |
INDArray |
DataSet.getFeatureMatrix()
Deprecated.
|
INDArray |
DataSet.getFeatures()
Returns the features array for the DataSet
|
INDArray[] |
MultiDataSet.getFeatures()
Get all of the input features, as an array of INDArrays
|
INDArray |
MultiDataSet.getFeatures(int index)
Get a single feature/input array
|
INDArray |
DataSet.getFeaturesMaskArray()
Input mask array: a mask array for input, where each value is in {0,1} in order to specify whether an input is
actually present or not.
|
INDArray |
MultiDataSet.getFeaturesMaskArray(int index)
Get the specified feature mask array.
|
INDArray[] |
MultiDataSet.getFeaturesMaskArrays()
Get the feature mask arrays.
|
INDArray |
DataSet.getLabels() |
INDArray[] |
MultiDataSet.getLabels()
Get all of the labels, as an array of INDArrays
|
INDArray |
MultiDataSet.getLabels(int index)
Get a single label/output array
|
INDArray |
DataSet.getLabelsMaskArray()
Labels (output) mask array: a mask array for input, where each value is in {0,1} in order to specify whether an
output is actually present or not.
|
INDArray |
MultiDataSet.getLabelsMaskArray(int index)
Get the specified label mask array.
|
INDArray[] |
MultiDataSet.getLabelsMaskArrays()
Get the labels mask arrays.
|
static INDArray |
DataSetUtil.mergePerOutputMasks2d(int[] outShape,
INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx) |
static INDArray |
DataSetUtil.mergePerOutputMasks2d(int[] outShape,
INDArray[] arrays,
INDArray[] masks) |
static INDArray |
DataSetUtil.tailor2d(DataSet dataSet,
boolean areFeatures) |
static INDArray |
DataSetUtil.tailor2d(INDArray data,
INDArray mask) |
static INDArray |
DataSetUtil.tailor3d2d(DataSet dataset,
boolean areFeatures)
Deprecated.
|
static INDArray |
DataSetUtil.tailor3d2d(INDArray data,
INDArray mask) |
static INDArray |
DataSetUtil.tailor4d2d(DataSet dataset,
boolean areFeatures) |
static INDArray |
DataSetUtil.tailor4d2d(INDArray data) |
Modifier and Type | Method and Description |
---|---|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 2d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 2d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 2d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 2d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 4d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 4d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 4d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 4d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[][] featuresToMerge,
INDArray[][] featureMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified features and mask arrays (i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[][] featuresToMerge,
INDArray[][] featureMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified features and mask arrays (i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[] featuresToMerge,
INDArray[] featureMasksToMerge)
Merge the specified features and mask arrays (i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[] featuresToMerge,
INDArray[] featureMasksToMerge)
Merge the specified features and mask arrays (i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[][] labelsToMerge,
INDArray[][] labelMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified label and label mask arrays
(i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[][] labelsToMerge,
INDArray[][] labelMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified label and label mask arrays
(i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[] labelsToMerge,
INDArray[] labelMasksToMerge)
Merge the specified labels and label mask arrays (i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[] labelsToMerge,
INDArray[] labelMasksToMerge)
Merge the specified labels and label mask arrays (i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified time series (3d) arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified time series (3d) arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[] arrays,
INDArray[] masks)
Merge the specified time series (3d) arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[] arrays,
INDArray[] masks)
Merge the specified time series (3d) arrays and masks.
|
Modifier and Type | Method and Description |
---|---|
void |
DataSet.addFeatureVector(INDArray toAdd) |
void |
DataSet.addFeatureVector(INDArray feature,
int example) |
List<String> |
DataSet.getLabelNames(INDArray idxs) |
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 2d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 2d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 2d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge2d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 2d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 4d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified 4d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 4d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.merge4d(INDArray[] arrays,
INDArray[] masks)
Merge the specified 4d arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray[],INDArray[]> |
DataSetUtil.mergeFeatures(INDArray[][] featuresToMerge,
INDArray[][] featureMasksToMerge)
Merge all of the features arrays into one minibatch.
|
static org.nd4j.linalg.primitives.Pair<INDArray[],INDArray[]> |
DataSetUtil.mergeFeatures(INDArray[][] featuresToMerge,
INDArray[][] featureMasksToMerge)
Merge all of the features arrays into one minibatch.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[][] featuresToMerge,
INDArray[][] featureMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified features and mask arrays (i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[][] featuresToMerge,
INDArray[][] featureMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified features and mask arrays (i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[] featuresToMerge,
INDArray[] featureMasksToMerge)
Merge the specified features and mask arrays (i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeFeatures(INDArray[] featuresToMerge,
INDArray[] featureMasksToMerge)
Merge the specified features and mask arrays (i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[][] labelsToMerge,
INDArray[][] labelMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified label and label mask arrays
(i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[][] labelsToMerge,
INDArray[][] labelMasksToMerge,
int inOutIdx)
Extract out the specified column, and merge the specified label and label mask arrays
(i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[] labelsToMerge,
INDArray[] labelMasksToMerge)
Merge the specified labels and label mask arrays (i.e., concatenate the examples)
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeLabels(INDArray[] labelsToMerge,
INDArray[] labelMasksToMerge)
Merge the specified labels and label mask arrays (i.e., concatenate the examples)
|
static INDArray |
DataSetUtil.mergePerOutputMasks2d(int[] outShape,
INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx) |
static INDArray |
DataSetUtil.mergePerOutputMasks2d(int[] outShape,
INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx) |
static INDArray |
DataSetUtil.mergePerOutputMasks2d(int[] outShape,
INDArray[] arrays,
INDArray[] masks) |
static INDArray |
DataSetUtil.mergePerOutputMasks2d(int[] outShape,
INDArray[] arrays,
INDArray[] masks) |
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified time series (3d) arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[][] arrays,
INDArray[][] masks,
int inOutIdx)
Merge the specified time series (3d) arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[] arrays,
INDArray[] masks)
Merge the specified time series (3d) arrays and masks.
|
static org.nd4j.linalg.primitives.Pair<INDArray,INDArray> |
DataSetUtil.mergeTimeSeries(INDArray[] arrays,
INDArray[] masks)
Merge the specified time series (3d) arrays and masks.
|
void |
DataSet.setFeatures(INDArray features)
Set the features array for the DataSet
|
void |
MultiDataSet.setFeatures(INDArray[] features)
Set all of the features arrays for the MultiDataSet
|
void |
MultiDataSet.setFeatures(int idx,
INDArray features)
Set a single features array (by index) for the MultiDataSet
|
void |
DataSet.setFeaturesMaskArray(INDArray inputMask)
Set the features mask array in this DataSet
|
void |
MultiDataSet.setFeaturesMaskArray(int idx,
INDArray maskArray)
Set a single feature mask array by index
|
void |
MultiDataSet.setFeaturesMaskArrays(INDArray[] maskArrays)
Set the feature mask arrays
|
void |
DataSet.setLabels(INDArray labels) |
void |
MultiDataSet.setLabels(INDArray[] labels)
Set all of the labels arrays for the MultiDataSet
|
void |
MultiDataSet.setLabels(int idx,
INDArray labels)
Set a single labels array (by index) for the MultiDataSet
|
void |
DataSet.setLabelsMaskArray(INDArray labelsMask)
Set the labels mask array in this data set
|
void |
MultiDataSet.setLabelsMaskArray(INDArray[] labels)
Set the labels mask arrays
|
void |
MultiDataSet.setLabelsMaskArray(int idx,
INDArray labelsMaskArray)
Set a single labels mask array by index
|
static void |
DataSetUtil.setMaskedValuesToZero(INDArray data,
INDArray mask) |
static INDArray |
DataSetUtil.tailor2d(INDArray data,
INDArray mask) |
static INDArray |
DataSetUtil.tailor3d2d(INDArray data,
INDArray mask) |
static INDArray |
DataSetUtil.tailor4d2d(INDArray data) |
Modifier and Type | Method and Description |
---|---|
INDArray |
StandardScaler.getMean()
Deprecated.
|
INDArray |
StandardScaler.getStd()
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
protected INDArray |
BaseDataFetcher.createInputMatrix(int numRows)
Creates a feature vector
|
protected INDArray |
BaseDataFetcher.createOutputMatrix(int numRows) |
protected INDArray |
BaseDataFetcher.createOutputVector(int outcomeLabel)
Creates an output label matrix
|
Modifier and Type | Field and Description |
---|---|
static INDArray |
VGG16ImagePreProcessor.VGG_MEAN_OFFSET_BGR |
Modifier and Type | Method and Description |
---|---|
INDArray |
MultiNormalizerStandardize.getFeatureMean(int input) |
INDArray |
MultiNormalizerStandardize.getFeatureStd(int input) |
INDArray |
NormalizerMinMaxScaler.getLabelMax() |
INDArray |
MultiNormalizerMinMaxScaler.getLabelMax(int output) |
INDArray |
NormalizerStandardize.getLabelMean() |
INDArray |
MultiNormalizerStandardize.getLabelMean(int output) |
INDArray |
NormalizerMinMaxScaler.getLabelMin() |
INDArray |
MultiNormalizerMinMaxScaler.getLabelMin(int output) |
INDArray |
NormalizerStandardize.getLabelStd() |
INDArray |
MultiNormalizerStandardize.getLabelStd(int output) |
INDArray |
NormalizerMinMaxScaler.getMax() |
INDArray |
MultiNormalizerMinMaxScaler.getMax(int input) |
INDArray |
NormalizerStandardize.getMean() |
INDArray |
NormalizerMinMaxScaler.getMin() |
INDArray |
MultiNormalizerMinMaxScaler.getMin(int input) |
INDArray |
NormalizerStandardize.getStd() |
Modifier and Type | Method and Description |
---|---|
void |
VGG16ImagePreProcessor.preProcess(INDArray features) |
void |
ImagePreProcessingScaler.preProcess(INDArray features) |
void |
StandardizeStrategy.preProcess(INDArray array,
INDArray maskArray,
DistributionStats stats)
Normalize a data array
|
void |
MinMaxStrategy.preProcess(INDArray array,
INDArray maskArray,
MinMaxStats stats)
Normalize a data array
|
void |
NormalizerStrategy.preProcess(INDArray array,
INDArray maskArray,
S stats)
Normalize a data array
|
void |
StandardizeStrategy.revert(INDArray array,
INDArray maskArray,
DistributionStats stats)
Denormalize a data array
|
void |
MinMaxStrategy.revert(INDArray array,
INDArray maskArray,
MinMaxStats stats)
Denormalize a data array
|
void |
NormalizerStrategy.revert(INDArray array,
INDArray maskArray,
S stats)
Denormalize a data array
|
void |
AbstractDataSetNormalizer.revertFeatures(INDArray features) |
void |
VGG16ImagePreProcessor.revertFeatures(INDArray features) |
void |
DataNormalization.revertFeatures(INDArray features)
Undo (revert) the normalization applied by this DataNormalization instance to the specified features array
|
void |
ImagePreProcessingScaler.revertFeatures(INDArray features) |
void |
MultiNormalizerHybrid.revertFeatures(INDArray[] features)
Undo (revert) the normalization applied by this DataNormalization instance to the entire inputs array
|
void |
AbstractMultiDataSetNormalizer.revertFeatures(INDArray[] features)
Undo (revert) the normalization applied by this normalizer to the features arrays
|
void |
ImageMultiPreProcessingScaler.revertFeatures(INDArray[] features) |
void |
MultiDataNormalization.revertFeatures(INDArray[] features)
Undo (revert) the normalization applied by this DataNormalization instance to the specified features array
|
void |
MultiNormalizerHybrid.revertFeatures(INDArray[] features,
INDArray[] maskArrays)
Undo (revert) the normalization applied by this DataNormalization instance to the entire inputs array
|
void |
MultiNormalizerHybrid.revertFeatures(INDArray[] features,
INDArray[] maskArrays)
Undo (revert) the normalization applied by this DataNormalization instance to the entire inputs array
|
void |
AbstractMultiDataSetNormalizer.revertFeatures(INDArray[] features,
INDArray[] maskArrays)
Undo (revert) the normalization applied by this normalizer to the features arrays
|
void |
AbstractMultiDataSetNormalizer.revertFeatures(INDArray[] features,
INDArray[] maskArrays)
Undo (revert) the normalization applied by this normalizer to the features arrays
|
void |
ImageMultiPreProcessingScaler.revertFeatures(INDArray[] features,
INDArray[] featuresMask) |
void |
ImageMultiPreProcessingScaler.revertFeatures(INDArray[] features,
INDArray[] featuresMask) |
void |
MultiDataNormalization.revertFeatures(INDArray[] features,
INDArray[] featuresMask)
Undo (revert) the normalization applied by this DataNormalization instance to the specified features array
|
void |
MultiDataNormalization.revertFeatures(INDArray[] features,
INDArray[] featuresMask)
Undo (revert) the normalization applied by this DataNormalization instance to the specified features array
|
void |
MultiNormalizerHybrid.revertFeatures(INDArray[] features,
INDArray[] maskArrays,
int input)
Undo (revert) the normalization applied by this DataNormalization instance to the features of a particular input
|
void |
MultiNormalizerHybrid.revertFeatures(INDArray[] features,
INDArray[] maskArrays,
int input)
Undo (revert) the normalization applied by this DataNormalization instance to the features of a particular input
|
void |
AbstractDataSetNormalizer.revertFeatures(INDArray features,
INDArray featuresMask) |
void |
VGG16ImagePreProcessor.revertFeatures(INDArray features,
INDArray featuresMask) |
void |
DataNormalization.revertFeatures(INDArray features,
INDArray featuresMask)
Undo (revert) the normalization applied by this DataNormalization instance to the specified features array
|
void |
ImagePreProcessingScaler.revertFeatures(INDArray features,
INDArray featuresMask) |
void |
AbstractMultiDataSetNormalizer.revertFeatures(INDArray features,
INDArray mask,
int input)
Undo (revert) the normalization applied by this normalizer to a specific features array.
|
void |
AbstractDataSetNormalizer.revertLabels(INDArray labels)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
VGG16ImagePreProcessor.revertLabels(INDArray labels) |
void |
DataNormalization.revertLabels(INDArray labels)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
ImagePreProcessingScaler.revertLabels(INDArray labels) |
void |
MultiNormalizerHybrid.revertLabels(INDArray[] labels)
Undo (revert) the normalization applied by this DataNormalization instance to the entire outputs array
|
void |
AbstractMultiDataSetNormalizer.revertLabels(INDArray[] labels)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
ImageMultiPreProcessingScaler.revertLabels(INDArray[] labels) |
void |
MultiDataNormalization.revertLabels(INDArray[] labels)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
MultiNormalizerHybrid.revertLabels(INDArray[] labels,
INDArray[] maskArrays)
Undo (revert) the normalization applied by this DataNormalization instance to the entire outputs array
|
void |
MultiNormalizerHybrid.revertLabels(INDArray[] labels,
INDArray[] maskArrays)
Undo (revert) the normalization applied by this DataNormalization instance to the entire outputs array
|
void |
AbstractMultiDataSetNormalizer.revertLabels(INDArray[] labels,
INDArray[] labelsMask)
Undo (revert) the normalization applied by this normalizer to the labels arrays.
|
void |
AbstractMultiDataSetNormalizer.revertLabels(INDArray[] labels,
INDArray[] labelsMask)
Undo (revert) the normalization applied by this normalizer to the labels arrays.
|
void |
ImageMultiPreProcessingScaler.revertLabels(INDArray[] labels,
INDArray[] labelsMask) |
void |
ImageMultiPreProcessingScaler.revertLabels(INDArray[] labels,
INDArray[] labelsMask) |
void |
MultiDataNormalization.revertLabels(INDArray[] labels,
INDArray[] labelsMask)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
MultiDataNormalization.revertLabels(INDArray[] labels,
INDArray[] labelsMask)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
MultiNormalizerHybrid.revertLabels(INDArray[] labels,
INDArray[] maskArrays,
int output)
Undo (revert) the normalization applied by this DataNormalization instance to the labels of a particular output
|
void |
MultiNormalizerHybrid.revertLabels(INDArray[] labels,
INDArray[] maskArrays,
int output)
Undo (revert) the normalization applied by this DataNormalization instance to the labels of a particular output
|
void |
AbstractDataSetNormalizer.revertLabels(INDArray labels,
INDArray labelsMask) |
void |
VGG16ImagePreProcessor.revertLabels(INDArray labels,
INDArray labelsMask) |
void |
DataNormalization.revertLabels(INDArray labels,
INDArray labelsMask)
Undo (revert) the normalization applied by this DataNormalization instance to the specified labels array.
|
void |
ImagePreProcessingScaler.revertLabels(INDArray labels,
INDArray labelsMask) |
void |
AbstractMultiDataSetNormalizer.revertLabels(INDArray labels,
INDArray mask,
int output)
Undo (revert) the normalization applied by this normalizer to a specific labels array.
|
void |
NormalizerMinMaxScaler.setFeatureStats(INDArray featureMin,
INDArray featureMax) |
void |
NormalizerMinMaxScaler.setLabelStats(INDArray labelMin,
INDArray labelMax) |
void |
NormalizerStandardize.setLabelStats(INDArray labelMean,
INDArray labelStd) |
void |
AbstractDataSetNormalizer.transform(INDArray features)
Transform the given INDArray
|
void |
VGG16ImagePreProcessor.transform(INDArray features) |
void |
DataNormalization.transform(INDArray features)
Transform the dataset
|
void |
ImagePreProcessingScaler.transform(INDArray features) |
void |
AbstractDataSetNormalizer.transform(INDArray features,
INDArray featuresMask) |
void |
VGG16ImagePreProcessor.transform(INDArray features,
INDArray featuresMask) |
void |
DataNormalization.transform(INDArray features,
INDArray featuresMask)
Transform the features, with an optional mask array
|
void |
ImagePreProcessingScaler.transform(INDArray features,
INDArray featuresMask) |
void |
AbstractDataSetNormalizer.transformLabel(INDArray label)
Transform the labels.
|
void |
VGG16ImagePreProcessor.transformLabel(INDArray label) |
void |
DataNormalization.transformLabel(INDArray labels)
Transform the labels.
|
void |
ImagePreProcessingScaler.transformLabel(INDArray label) |
void |
AbstractDataSetNormalizer.transformLabel(INDArray label,
INDArray labelsMask) |
void |
VGG16ImagePreProcessor.transformLabel(INDArray labels,
INDArray labelsMask) |
void |
DataNormalization.transformLabel(INDArray labels,
INDArray labelsMask)
Transform the labels.
|
void |
ImagePreProcessingScaler.transformLabel(INDArray labels,
INDArray labelsMask) |
Constructor and Description |
---|
NormalizerStandardize(INDArray featureMean,
INDArray featureStd) |
NormalizerStandardize(INDArray featureMean,
INDArray featureStd,
INDArray labelMean,
INDArray labelStd) |
Modifier and Type | Method and Description |
---|---|
INDArray |
BaseUnderSamplingPreProcessor.adjustMasks(INDArray label,
INDArray labelMask,
int minorityLabel,
double targetDist) |
Modifier and Type | Method and Description |
---|---|
INDArray |
BaseUnderSamplingPreProcessor.adjustMasks(INDArray label,
INDArray labelMask,
int minorityLabel,
double targetDist) |
Modifier and Type | Method and Description |
---|---|
INDArray |
MinMaxStats.getRange()
Get the feature wise
range for the statistics.
|
Modifier and Type | Method and Description |
---|---|
NormalizerStats.Builder<S> |
NormalizerStats.Builder.add(INDArray data,
INDArray mask)
Add rows of data to the statistics
|
DistributionStats.Builder |
DistributionStats.Builder.add(INDArray data,
INDArray mask)
Add rows of data to the statistics
|
MinMaxStats.Builder |
MinMaxStats.Builder.add(INDArray data,
INDArray mask)
Add rows of data to the statistics
|
Constructor and Description |
---|
DistributionStats(INDArray mean,
INDArray std) |
MinMaxStats(INDArray lower,
INDArray upper) |
Modifier and Type | Method and Description |
---|---|
INDArray |
PCA.convertBackToFeatures(INDArray data)
Take the data that has been transformed to the principal components about the mean and
transform it back into the original feature set.
|
INDArray |
PCA.convertToComponents(INDArray data)
Takes a set of data on each row, with the same number of features as the constructing data
and returns the data in the coordinates of the basis set about the mean.
|
static INDArray[] |
PCA.covarianceMatrix(INDArray in)
Returns the covariance matrix of a data set of many records, each with N features.
|
INDArray |
PCA.generateGaussianSamples(int count)
Generates a set of count random samples with the same variance and mean and eigenvector/values
as the data set used to initialize the PCA object, with same number of features N.
|
INDArray |
PCA.getCovarianceMatrix() |
INDArray |
PCA.getEigenvalues() |
INDArray |
PCA.getEigenvectors() |
INDArray |
PCA.getMean() |
static INDArray |
PCA.pca_factor(INDArray A,
double variance,
boolean normalize)
Calculates pca vectors of a matrix, for a given variance.
|
static INDArray |
PCA.pca_factor(INDArray A,
int nDims,
boolean normalize)
Calculates pca factors of a matrix, for a flags number of reduced features
returns the factors to scale observations
The return is a factor matrix to reduce (normalized) feature sets
|
static INDArray |
PCA.pca(INDArray A,
double variance,
boolean normalize)
Calculates pca reduced value of a matrix, for a given variance.
|
static INDArray |
PCA.pca(INDArray A,
int nDims,
boolean normalize)
Calculates pca vectors of a matrix, for a flags number of reduced features
returns the reduced feature set
The return is a projection of A onto principal nDims components
To use the PCA: assume A is the original feature set
then project A onto a reduced set of features.
|
static INDArray |
PCA.pca2(INDArray in,
double variance)
This method performs a dimensionality reduction, including principal components
that cover a fraction of the total variance of the system.
|
static INDArray[] |
PCA.principalComponents(INDArray cov)
Calculates the principal component vectors and their eigenvalues (lambda) for the covariance matrix.
|
INDArray |
RandomProjection.project(INDArray data)
Create a copy random projection by using matrix product with a random matrix
|
INDArray |
RandomProjection.project(INDArray data,
INDArray result)
Create a copy random projection by using matrix product with a random matrix
|
INDArray |
RandomProjection.projecti(INDArray data)
Create an in-place random projection by using in-place matrix product with a random matrix
|
INDArray |
RandomProjection.projecti(INDArray data,
INDArray result)
Create an in-place random projection by using in-place matrix product with a random matrix
|
INDArray |
PCA.reducedBasis(double variance)
Return a reduced basis set that covers a certain fraction of the variance of the data
|
Modifier and Type | Method and Description |
---|---|
INDArray |
PCA.convertBackToFeatures(INDArray data)
Take the data that has been transformed to the principal components about the mean and
transform it back into the original feature set.
|
INDArray |
PCA.convertToComponents(INDArray data)
Takes a set of data on each row, with the same number of features as the constructing data
and returns the data in the coordinates of the basis set about the mean.
|
static INDArray[] |
PCA.covarianceMatrix(INDArray in)
Returns the covariance matrix of a data set of many records, each with N features.
|
double |
PCA.estimateVariance(INDArray data,
int ndims)
Estimate the variance of a single record with reduced # of dimensions.
|
static INDArray |
PCA.pca_factor(INDArray A,
double variance,
boolean normalize)
Calculates pca vectors of a matrix, for a given variance.
|
static INDArray |
PCA.pca_factor(INDArray A,
int nDims,
boolean normalize)
Calculates pca factors of a matrix, for a flags number of reduced features
returns the factors to scale observations
The return is a factor matrix to reduce (normalized) feature sets
|
static INDArray |
PCA.pca(INDArray A,
double variance,
boolean normalize)
Calculates pca reduced value of a matrix, for a given variance.
|
static INDArray |
PCA.pca(INDArray A,
int nDims,
boolean normalize)
Calculates pca vectors of a matrix, for a flags number of reduced features
returns the reduced feature set
The return is a projection of A onto principal nDims components
To use the PCA: assume A is the original feature set
then project A onto a reduced set of features.
|
static INDArray |
PCA.pca2(INDArray in,
double variance)
This method performs a dimensionality reduction, including principal components
that cover a fraction of the total variance of the system.
|
static INDArray[] |
PCA.principalComponents(INDArray cov)
Calculates the principal component vectors and their eigenvalues (lambda) for the covariance matrix.
|
INDArray |
RandomProjection.project(INDArray data)
Create a copy random projection by using matrix product with a random matrix
|
INDArray |
RandomProjection.project(INDArray data,
INDArray result)
Create a copy random projection by using matrix product with a random matrix
|
INDArray |
RandomProjection.projecti(INDArray data)
Create an in-place random projection by using in-place matrix product with a random matrix
|
INDArray |
RandomProjection.projecti(INDArray data,
INDArray result)
Create an in-place random projection by using in-place matrix product with a random matrix
|
protected static int[] |
RandomProjection.targetShape(INDArray X,
double eps)
Compute the target shape of a suitable projection matrix
|
protected static int[] |
RandomProjection.targetShape(INDArray X,
int targetDimension)
Compute the target shape of a suitable projection matrix
|
Constructor and Description |
---|
PCA(INDArray dataset)
Create a PCA instance with calculated data: covariance, mean, eigenvectors, and eigenvalues.
|
Modifier and Type | Field and Description |
---|---|
static INDArray |
Eigen.dummy |
Modifier and Type | Method and Description |
---|---|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A)
Compute generalized eigenvalues of the problem A x = L x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
boolean calculateVectors)
Compute generalized eigenvalues of the problem A x = L x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
INDArray B)
Compute generalized eigenvalues of the problem A x = L B x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
INDArray B,
boolean calculateVectors)
Compute generalized eigenvalues of the problem A x = L B x.
|
Modifier and Type | Method and Description |
---|---|
static IComplexNDArray |
Eigen.eigenvalues(INDArray A)
Computes the eigenvalues of a general matrix.
|
static IComplexNDArray[] |
Eigen.eigenvectors(INDArray A)
Computes the eigenvalues and eigenvectors of a general matrix.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A)
Compute generalized eigenvalues of the problem A x = L x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
boolean calculateVectors)
Compute generalized eigenvalues of the problem A x = L x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
INDArray B)
Compute generalized eigenvalues of the problem A x = L B x.
|
static INDArray |
Eigen.symmetricGeneralizedEigenvalues(INDArray A,
INDArray B,
boolean calculateVectors)
Compute generalized eigenvalues of the problem A x = L B x.
|
Modifier and Type | Field and Description |
---|---|
protected static ReferenceQueue<INDArray> |
Nd4j.referenceQueue |
Modifier and Type | Method and Description |
---|---|
static INDArray |
Nd4j.accumulate(Collection<INDArray> arrays)
This method sums given arrays and stores them to a new target array
|
static INDArray |
Nd4j.accumulate(INDArray... arrays)
This method sums given arrays and stores them to a new array
|
static INDArray |
Nd4j.accumulate(INDArray target,
Collection<INDArray> arrays)
This method sums given arrays and stores them to a given target array
|
INDArray |
NDArrayFactory.accumulate(INDArray target,
INDArray... arrays)
This method sums given arrays to target
|
static INDArray |
Nd4j.accumulate(INDArray target,
INDArray[] arrays)
This method sums given arrays and stores them to a given target array
|
static INDArray |
Broadcast.add(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast add op.
|
static INDArray |
Broadcast.amax(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast absolute max op.
|
static INDArray |
Broadcast.amin(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast absolute min op.
|
static INDArray |
Nd4j.append(INDArray arr,
int padAmount,
double val,
int axis)
Append the given
array with the specified value size
along a particular axis
|
static INDArray |
Nd4j.appendBias(INDArray... vectors) |
INDArray |
NDArrayFactory.appendBias(INDArray... vectors) |
INDArray |
BaseNDArrayFactory.appendBias(INDArray... vectors)
Merge the vectors and append a bias.
|
static INDArray |
Nd4j.arange(double end)
Array of evenly spaced values.
|
static INDArray |
Nd4j.arange(double begin,
double end)
Array of evenly spaced values.
|
INDArray |
NDArrayFactory.arange(double begin,
double end)
Array of evenly spaced values.
|
INDArray |
BaseNDArrayFactory.arange(double begin,
double end)
Array of evenly spaced values.
|
static INDArray |
Nd4j.argMax(INDArray arr,
int... dimension) |
INDArray |
NDArrayFactory.average(Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
static INDArray |
Nd4j.averageAndPropagate(Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray[] arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array.
|
INDArray |
BlasWrapper.axpy(double da,
INDArray dx,
INDArray dy)
Deprecated.
|
INDArray |
BaseBlasWrapper.axpy(double da,
INDArray dx,
INDArray dy) |
INDArray |
BaseSparseBlasWrapper.axpy(double da,
INDArray dx,
INDArray dy) |
INDArray |
BlasWrapper.axpy(float da,
INDArray dx,
INDArray dy)
Deprecated.
|
INDArray |
BaseBlasWrapper.axpy(float da,
INDArray dx,
INDArray dy) |
INDArray |
BaseSparseBlasWrapper.axpy(float da,
INDArray dx,
INDArray dy) |
INDArray |
BlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy)
Compute y <- y + x * alpha
|
INDArray |
BaseBlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy) |
INDArray |
BaseSparseBlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy) |
static INDArray |
Nd4j.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
INDArray |
NDArrayFactory.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
INDArray |
BaseNDArrayFactory.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
INDArray target)
This method samples value from Source array to Target, with probabilites provided in Probs argument
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
INDArray target,
Random rng)
This method samples value from Source array to Target, with probabilites provided in Probs argument
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
int numSamples)
This method returns new INDArray instance, sampled from Source array with probabilities given in Probs
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
int numSamples,
Random rng)
This method returns new INDArray instance, sampled from Source array with probabilities given in Probs
|
static INDArray |
Nd4j.complexZeros(int rows,
int columns)
Creates a matrix of zeros
|
static INDArray |
Nd4j.concat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
|
INDArray |
NDArrayFactory.concat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
|
INDArray |
BaseNDArrayFactory.concat(int dimension,
INDArray... toConcat)
concatenate ndarrays along a dimension
|
INDArray |
NDArrayFactory.convertDataEx(DataBuffer.TypeEx typeSrc,
INDArray source,
DataBuffer.TypeEx typeDst) |
INDArray |
BlasWrapper.copy(INDArray x,
INDArray y)
Compute y <- x (copy a matrix)
|
INDArray |
BaseBlasWrapper.copy(INDArray x,
INDArray y) |
INDArray |
BaseSparseBlasWrapper.copy(INDArray x,
INDArray y) |
static INDArray |
Broadcast.copy(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast copy op.
|
static INDArray |
Nd4j.create(DataBuffer buffer) |
INDArray |
NDArrayFactory.create(DataBuffer data)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(DataBuffer data,
int[] shape) |
INDArray |
NDArrayFactory.create(DataBuffer data,
int[] shape)
Create an ndrray with the specified shape
|
INDArray |
NDArrayFactory.create(DataBuffer buffer,
int[] shape,
int[] stride,
char order,
long offset) |
INDArray |
BaseNDArrayFactory.create(DataBuffer buffer,
int[] shape,
int[] stride,
char order,
long offset) |
static INDArray |
Nd4j.create(DataBuffer data,
int[] shape,
int[] strides,
long offset) |
INDArray |
NDArrayFactory.create(DataBuffer data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(DataBuffer data,
int[] newShape,
int[] newStride,
long offset,
char ordering) |
INDArray |
NDArrayFactory.create(DataBuffer data,
int[] newShape,
int[] newStride,
long offset,
char ordering) |
static INDArray |
Nd4j.create(DataBuffer data,
int[] shape,
long offset) |
INDArray |
NDArrayFactory.create(DataBuffer buffer,
int[] shape,
long offset) |
INDArray |
NDArrayFactory.create(DataBuffer data,
int rows,
int columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(double[] data)
Creates a row vector with the data
|
INDArray |
NDArrayFactory.create(double[] data)
Creates a row vector with the data
|
INDArray |
BaseNDArrayFactory.create(double[] data)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(double[][] data)
Create an ndarray based on the given data layout
|
INDArray |
NDArrayFactory.create(double[][] data)
Create an ndarray with the given data layout
|
static INDArray |
Nd4j.create(double[][] data,
char ordering) |
INDArray |
NDArrayFactory.create(double[][] data,
char ordering) |
static INDArray |
Nd4j.create(double[] data,
char order)
Creates a row vector with the data
|
INDArray |
NDArrayFactory.create(double[] data,
char order) |
INDArray |
BaseNDArrayFactory.create(double[] data,
char order) |
static INDArray |
Nd4j.create(double[] data,
int[] shape)
Create an ndrray with the specified shape
|
INDArray |
NDArrayFactory.create(double[] data,
int[] shape)
Create an ndrray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(double[] data,
int[] shape)
Create an ndrray with the specified shape
|
static INDArray |
Nd4j.create(double[] data,
int[] shape,
char ordering)
Create an ndrray with the specified shape
|
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
char ordering) |
static INDArray |
Nd4j.create(double[] data,
int[] shape,
char ordering,
long offset) |
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
char order,
long offset) |
INDArray |
BaseNDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
char order,
long offset) |
static INDArray |
Nd4j.create(double[] data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
abstract INDArray |
BaseNDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(double[] data,
int[] shape,
int[] stride,
long offset,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
int[] stride,
long offset,
char ordering) |
static INDArray |
Nd4j.create(double[] data,
int[] shape,
long offset) |
INDArray |
NDArrayFactory.create(double[] data,
int[] shape,
long offset) |
static INDArray |
Nd4j.create(double[] data,
int[] shape,
long offset,
char ordering)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(double[] data,
int rows,
int columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(double[] data,
int rows,
int columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(double[] data,
int rows,
int columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(double[] data,
int rows,
int columns,
int[] stride,
long offset,
char ordering)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(float[] data)
Creates a row vector with the data
|
INDArray |
NDArrayFactory.create(float[] data)
Creates a row vector with the data
|
INDArray |
BaseNDArrayFactory.create(float[] data)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(float[][] data) |
INDArray |
NDArrayFactory.create(float[][] floats) |
static INDArray |
Nd4j.create(float[][] data,
char ordering) |
INDArray |
NDArrayFactory.create(float[][] data,
char ordering) |
static INDArray |
Nd4j.create(float[] data,
char order)
Creates a row vector with the data
|
INDArray |
NDArrayFactory.create(float[] data,
char order) |
INDArray |
BaseNDArrayFactory.create(float[] data,
char order) |
static INDArray |
Nd4j.create(float[] data,
int[] shape)
Create an ndrray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int[] shape)
Create an ndrray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape)
Create an ndrray with the specified shape
|
static INDArray |
Nd4j.create(float[] data,
int[] shape,
char ordering)
Create an ndrray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
char ordering) |
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
char ordering) |
static INDArray |
Nd4j.create(float[] data,
int[] shape,
char ordering,
long offset) |
static INDArray |
Nd4j.create(float[] data,
int[] shape,
int[] stride,
char ordering,
long offset) |
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
char order,
long offset) |
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
char order,
long offset) |
static INDArray |
Nd4j.create(float[] data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
abstract INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(float[] data,
int[] shape,
int[] stride,
long offset,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
int[] stride,
long offset,
char ordering) |
static INDArray |
Nd4j.create(float[] data,
int[] shape,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
long offset) |
INDArray |
BaseNDArrayFactory.create(float[] data,
int[] shape,
long offset) |
INDArray |
NDArrayFactory.create(float[] data,
int[] shape,
long offset,
Character order) |
static INDArray |
Nd4j.create(float[] data,
int rows,
int columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int rows,
int columns,
int[] stride,
long offset) |
INDArray |
BaseNDArrayFactory.create(float[] data,
int rows,
int columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(float[] data,
int rows,
int columns,
int[] stride,
long offset,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(float[] data,
int rows,
int columns,
int[] stride,
long offset,
char ordering) |
static INDArray |
Nd4j.create(int... shape)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.create(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.create(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.create(int[] shape)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int[] shape)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int[] shape,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
char ordering) |
static INDArray |
Nd4j.create(int[] shape,
DataBuffer.Type dataType) |
INDArray |
NDArrayFactory.create(int[] shape,
DataBuffer.Type dataType) |
INDArray |
BaseNDArrayFactory.create(int[] shape,
DataBuffer.Type dataType) |
INDArray |
NDArrayFactory.create(int[] shape,
DataBuffer buffer)
Create an ndarray with the given shape
and data
|
static INDArray |
Nd4j.create(int[] sliceShape,
double[]... arrays)
Create an ndarray based on the given data
|
static INDArray |
Nd4j.create(int[] sliceShape,
float[]... arrays)
Create an ndarray based on the given data
|
static INDArray |
Nd4j.create(int[] shape,
int[] stride)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
int[] stride)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int[] shape,
int[] stride)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int[] shape,
int[] stride,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
int[] ints1,
int[] stride,
char order,
long offset) |
INDArray |
BaseNDArrayFactory.create(int[] data,
int[] shape,
int[] stride,
char order,
long offset) |
INDArray |
NDArrayFactory.create(int[] ints,
int[] ints1,
int[] stride,
long offset) |
INDArray |
BaseNDArrayFactory.create(int[] ints,
int[] ints1,
int[] stride,
long offset) |
static INDArray |
Nd4j.create(int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int[] shape,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int[] shape,
int[] stride,
long offset,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int[] shape,
int[] stride,
long offset,
char ordering) |
INDArray |
BaseNDArrayFactory.create(int[] shape,
int[] stride,
long offset,
char ordering) |
static INDArray |
Nd4j.create(int columns,
char order)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.create(int rows,
int columns)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int rows,
int columns)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int rows,
int columns)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int rows,
int columns,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int rows,
int columns,
char ordering) |
INDArray |
BaseNDArrayFactory.create(int rows,
int columns,
char ordering) |
static INDArray |
Nd4j.create(int rows,
int columns,
int[] stride)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int rows,
int columns,
int[] stride)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int rows,
int columns,
int[] stride)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int rows,
int columns,
int[] stride,
char ordering)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int rows,
int columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(int rows,
int columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
INDArray |
BaseNDArrayFactory.create(int rows,
int columns,
int[] stride,
long offset)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(int rows,
int columns,
int[] stride,
long offset,
char ordering)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(List<? extends Number> list)
Creates a row vector with the data
|
static INDArray |
Nd4j.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
abstract INDArray |
BaseNDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(List<INDArray> list,
int[] shape,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape,
char ordering) |
static INDArray |
Nd4j.createArrayFromShapeBuffer(DataBuffer data,
DataBuffer shapeInfo) |
static INDArray |
Nd4j.createArrayFromShapeBuffer(DataBuffer data,
org.nd4j.linalg.primitives.Pair<DataBuffer,int[]> shapeInfo) |
static INDArray |
Nd4j.createFromFlatArray(FlatArray array)
|
static INDArray |
Nd4j.createFromNpyFile(File file)
Create from a given numpy file.
|
INDArray |
NDArrayFactory.createFromNpyFile(File file)
Create from a given numpy file.
|
static INDArray |
Nd4j.createFromNpyPointer(org.bytedeco.javacpp.Pointer pointer)
Create from an in memory numpy pointer
|
INDArray |
NDArrayFactory.createFromNpyPointer(org.bytedeco.javacpp.Pointer pointer)
Create from an in memory numpy pointer
|
static INDArray |
Nd4j.createNpyFromInputStream(InputStream is)
Create a numpy array based on the passed in
input stream
|
static INDArray |
Nd4j.createSparseCOO(DataBuffer values,
DataBuffer indices,
DataBuffer sparseInformation,
int[] shape) |
INDArray |
NDArrayFactory.createSparseCOO(DataBuffer values,
DataBuffer indices,
DataBuffer sparseInformation,
int[] shape) |
static INDArray |
Nd4j.createSparseCOO(DataBuffer data,
DataBuffer indices,
int[] shape) |
INDArray |
NDArrayFactory.createSparseCOO(DataBuffer values,
DataBuffer indices,
int[] shape) |
static INDArray |
Nd4j.createSparseCOO(DataBuffer values,
DataBuffer indices,
long[] sparseOffsets,
int[] flags,
int[] shape,
int[] hiddenDimensions,
int underlyingRank) |
INDArray |
NDArrayFactory.createSparseCOO(DataBuffer values,
DataBuffer indices,
long[] sparseOffsets,
int[] flags,
int[] hiddenDimensions,
int underlyingRank,
int[] shape) |
static INDArray |
Nd4j.createSparseCOO(double[] data,
int[][] indices,
int[] shape) |
INDArray |
NDArrayFactory.createSparseCOO(double[] values,
int[][] indices,
int[] shape) |
static INDArray |
Nd4j.createSparseCOO(float[] data,
int[][] indices,
int[] shape) |
INDArray |
NDArrayFactory.createSparseCOO(float[] values,
int[][] indices,
int[] shape) |
static INDArray |
Nd4j.createSparseCSR(DataBuffer data,
int[] columns,
int[] pointerB,
int[] pointerE,
int[] shape) |
INDArray |
NDArrayFactory.createSparseCSR(DataBuffer data,
int[] columns,
int[] pointerB,
int[] pointerE,
int[] shape) |
static INDArray |
Nd4j.createSparseCSR(double[] data,
int[] columns,
int[] pointerB,
int[] pointerE,
int[] shape) |
INDArray |
NDArrayFactory.createSparseCSR(double[] data,
int[] columns,
int[] pointerB,
int[] pointerE,
int[] shape) |
static INDArray |
Nd4j.createSparseCSR(float[] data,
int[] columns,
int[] pointerB,
int[] pointerE,
int[] shape) |
INDArray |
NDArrayFactory.createSparseCSR(float[] data,
int[] columns,
int[] pointerB,
int[] pointerE,
int[] shape) |
static INDArray |
Nd4j.createUninitialized(int length)
This method creates an *uninitialized* ndarray of specified length and default ordering.
|
static INDArray |
Nd4j.createUninitialized(int[] shape)
Creates an *uninitialized* ndarray with the specified shape and default ordering.
NOTE: The underlying memory (DataBuffer) will not be initialized. |
static INDArray |
Nd4j.createUninitialized(int[] shape,
char ordering)
Creates an *uninitialized* ndarray with the specified shape and ordering.
NOTE: The underlying memory (DataBuffer) will not be initialized. |
INDArray |
NDArrayFactory.createUninitialized(int[] shape,
char ordering) |
static INDArray |
Nd4j.createUninitialized(int rows,
int columns)
This method returns uninitialized 2D array of rows x columns
PLEASE NOTE: memory of underlying array will be NOT initialized, and won't be set to 0.0
|
static INDArray |
Nd4j.createUninitializedDetached(int length)
Cretes uninitialized INDArray detached from any (if any) workspace
|
static INDArray |
Nd4j.createUninitializedDetached(int[] shape)
Cretes uninitialized INDArray detached from any (if any) workspace
|
static INDArray |
Nd4j.createUninitializedDetached(int[] shape,
char ordering)
Cretes uninitialized INDArray detached from any (if any) workspace
|
INDArray |
NDArrayFactory.createUninitializedDetached(int[] shape,
char ordering)
Cretes uninitialized INDArray detached from any (if any) workspace
|
static INDArray |
Nd4j.cumsum(INDArray compute) |
static INDArray |
Nd4j.cumsum(INDArray compute,
int dimension) |
static INDArray |
Nd4j.diag(INDArray x)
Creates a new matrix where the values of the given vector are the diagonal values of
the matrix if a vector is passed in, if a matrix is returns the kth diagonal
in the matrix
|
static INDArray |
Nd4j.diag(INDArray x,
int k)
Creates a new matrix where the values of the given vector are the diagonal values of
the matrix if a vector is passed in, if a matrix is returns the kth diagonal
in the matrix
|
static INDArray |
Broadcast.div(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast divide op.
|
static INDArray |
Nd4j.emptyLike(INDArray arr)
Empty like
|
static INDArray |
Broadcast.eq(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast equal to op.
|
static INDArray |
Nd4j.expandDims(INDArray input,
int dimension)
Expand the array dimensions.
|
static INDArray |
Nd4j.eye(int n)
Create the identity ndarray
|
INDArray |
NDArrayFactory.eye(int n)
Create the identity ndarray
|
INDArray |
BaseNDArrayFactory.eye(int n)
Create the identity ndarray
|
static INDArray |
Nd4j.fromByteArray(byte[] arr)
Read an ndarray from a byte array
|
INDArray |
BlasWrapper.gemm(double alpha,
INDArray a,
INDArray b,
double beta,
INDArray c)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemm(double alpha,
INDArray a,
INDArray b,
double beta,
INDArray c) |
INDArray |
BaseSparseBlasWrapper.gemm(double alpha,
INDArray a,
INDArray b,
double beta,
INDArray c) |
INDArray |
BlasWrapper.gemm(float alpha,
INDArray a,
INDArray b,
float beta,
INDArray c)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemm(float alpha,
INDArray a,
INDArray b,
float beta,
INDArray c) |
INDArray |
BaseSparseBlasWrapper.gemm(float alpha,
INDArray a,
INDArray b,
float beta,
INDArray c) |
static INDArray |
Nd4j.gemm(INDArray a,
INDArray b,
boolean transposeA,
boolean transposeB)
matrix multiply: implements op(a)*op(b)
where op(x) means transpose x (or not) depending on
setting of arguments transposea and transposeb.
so gemm(a,b,false,false) == a.mmul(b), gemm(a,b,true,false) == a.transpose().mmul(b) etc. |
static INDArray |
Nd4j.gemm(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB,
double alpha,
double beta)
Matrix multiply: Implements c = alpha*op(a)*op(b) + beta*c where op(X) means transpose X (or not)
depending on setting of arguments transposeA and transposeB.
Note that matrix c MUST be fortran order, have zero offset and have c.data().length == c.length(). |
INDArray |
BlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BaseSparseBlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y) |
INDArray |
BaseSparseBlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y) |
INDArray |
BlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y)
************************************************************************
BLAS Level 2
|
INDArray |
BaseBlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BaseSparseBlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a)
Deprecated.
|
INDArray |
BaseBlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BaseSparseBlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a)
Compute A <- alpha * x * y^T + A (general rank-1 update)
|
INDArray |
BaseBlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BaseSparseBlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BaseBlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BaseSparseBlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b)
************************************************************************
LAPACK
|
INDArray |
BaseBlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b) |
INDArray |
BaseSparseBlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b) |
static INDArray |
Broadcast.gt(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast greater than op.
|
static INDArray |
Broadcast.gte(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast greater than or equal to op.
|
static INDArray |
Nd4j.hstack(Collection<INDArray> arrs)
Concatenates two matrices horizontally.
|
static INDArray |
Nd4j.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
NDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
BaseNDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
static INDArray |
Nd4j.linspace(double lower,
double upper,
int num)
Generate a linearly spaced vector
|
static INDArray |
Nd4j.linspace(float lower,
float upper,
int num)
Generate a linearly spaced vector
|
static INDArray |
Nd4j.linspace(int lower,
int upper,
int num)
Generate a linearly spaced vector
|
INDArray |
NDArrayFactory.linspace(int lower,
int upper,
int num)
Generate a linearly spaced vector
|
INDArray |
BaseNDArrayFactory.linspace(int lower,
int upper,
int num)
Generate a linearly spaced vector
|
static INDArray |
Broadcast.lt(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast less than op.
|
static INDArray |
Broadcast.lte(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast less than or equal to op.
|
static INDArray |
Nd4j.max(INDArray compute) |
static INDArray |
Broadcast.max(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast max op.
|
static INDArray |
Nd4j.max(INDArray compute,
int dimension) |
static INDArray |
Nd4j.mean(INDArray compute) |
static INDArray |
Nd4j.mean(INDArray compute,
int dimension) |
static INDArray |
Nd4j.min(INDArray compute) |
static INDArray |
Broadcast.min(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast min op.
|
static INDArray |
Nd4j.min(INDArray compute,
int dimension) |
static INDArray |
Broadcast.mul(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast element-wise multiply op.
|
static INDArray |
Broadcast.neq(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast not equal to op.
|
static INDArray |
Nd4j.norm1(INDArray compute) |
static INDArray |
Nd4j.norm1(INDArray compute,
int dimension) |
static INDArray |
Nd4j.norm2(INDArray compute) |
static INDArray |
Nd4j.norm2(INDArray compute,
int dimension) |
static INDArray |
Nd4j.normmax(INDArray compute) |
static INDArray |
Nd4j.normmax(INDArray compute,
int dimension) |
static INDArray |
Nd4j.ones(int... shape)
Create an ndarray of ones
|
static INDArray |
Nd4j.ones(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.ones(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.ones(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.ones(int[] shape)
Create an ndarray of ones
|
INDArray |
BaseNDArrayFactory.ones(int[] shape)
Create an ndarray of ones
|
static INDArray |
Nd4j.ones(int rows,
int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.ones(int rows,
int columns)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.ones(int rows,
int columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.onesLike(INDArray arr)
Ones like
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[][] padWidth,
List<double[]> constantValues,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[][] padWidth,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[] padWidth,
List<double[]> constantValues,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[] padWidth,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pile(Collection<INDArray> arrays)
This method stacks vertically examples with the same shape, increasing result dimensionality.
|
static INDArray |
Nd4j.pile(INDArray... arrays)
This method stacks vertically examples with the same shape, increasing result dimensionality.
|
static INDArray |
Nd4j.prepend(INDArray arr,
int padAmount,
double val,
int axis)
Append the given
array with the specified value size
along a particular axis
|
static INDArray |
Nd4j.prod(INDArray compute) |
static INDArray |
Nd4j.prod(INDArray compute,
int dimension) |
static INDArray |
Nd4j.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
BaseNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
static INDArray |
Nd4j.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order)
This method produces concatenated array,
that consist from tensors,
fetched from source array,
against some dimension and specified indexes
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
BaseNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
static INDArray |
Nd4j.rand(char order,
int[] shape)
Create a random ndarray with the given shape and array order
|
INDArray |
NDArrayFactory.rand(char order,
int[] shape)
Create a random ndarray with the given shape, and specified output order
|
INDArray |
BaseNDArrayFactory.rand(char order,
int[] shape)
Create a random ndarray with the given shape and order
|
static INDArray |
Nd4j.rand(char order,
int rows,
int columns)
Create a random ndarray with the given shape and output order
|
INDArray |
NDArrayFactory.rand(char order,
int rows,
int columns)
Create a random (uniform 0-1) NDArray with the specified shape and order
|
INDArray |
BaseNDArrayFactory.rand(char order,
int rows,
int columns)
Create a random (uniform 0-1) NDArray with the specified shape and order
|
static INDArray |
Nd4j.rand(INDArray target)
Fill the given ndarray with random numbers drawn from a uniform distribution
|
static INDArray |
Nd4j.rand(INDArray target,
Distribution dist)
Fill the given ndarray with random numbers drawn from the given distribution
|
static INDArray |
Nd4j.rand(INDArray target,
double min,
double max,
Random rng)
Fill the given ndarray with random numbers drawn from a uniform distribution using the given RandomGenerator
|
static INDArray |
Nd4j.rand(INDArray target,
long seed)
Fill the given ndarray with random numbers drawn from a uniform distribution
|
static INDArray |
Nd4j.rand(INDArray target,
Random rng)
Fill the given ndarray with random numbers drawn from a uniform distribution using the given RandomGenerator
|
static INDArray |
Nd4j.rand(int[] shape)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
NDArrayFactory.rand(int[] shape)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
BaseNDArrayFactory.rand(int[] shape)
Create a random ndarray with the given shape using
the current time as the seed
|
static INDArray |
Nd4j.rand(int[] shape,
Distribution dist)
Create a random ndarray with the given shape using the given rng
|
INDArray |
NDArrayFactory.rand(int[] shape,
Distribution r)
Create a random ndarray with the given shape using the given rng
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
Distribution r)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int[] shape,
double min,
double max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
NDArrayFactory.rand(int[] shape,
double min,
double max,
Random rng) |
INDArray |
BaseNDArrayFactory.rand(int[] shape,
double min,
double max,
Random rng) |
INDArray |
NDArrayFactory.rand(int[] shape,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
static INDArray |
Nd4j.rand(int[] shape,
long seed)
Create a random ndarray with the given shape using given seed
|
INDArray |
NDArrayFactory.rand(int[] shape,
long seed)
Create a random ndarray with the given shape using the given rng
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
long seed)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int[] shape,
Random rng)
Create a random ndarray with the given shape using the given RandomGenerator
|
INDArray |
NDArrayFactory.rand(int[] shape,
Random r)
Create a random ndarray with the given shape using the given rng
|
INDArray |
BaseNDArrayFactory.rand(int[] shape,
Random r)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int rows,
int columns)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
NDArrayFactory.rand(int rows,
int columns)
Create a random ndarray with the given shape using
the current time as the seed
|
INDArray |
BaseNDArrayFactory.rand(int rows,
int columns)
Create a random ndarray with the given shape using
the current time as the seed
|
static INDArray |
Nd4j.rand(int rows,
int columns,
double min,
double max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
NDArrayFactory.rand(int rows,
int columns,
double min,
double max,
Random rng) |
INDArray |
BaseNDArrayFactory.rand(int rows,
int columns,
double min,
double max,
Random rng) |
INDArray |
NDArrayFactory.rand(int rows,
int columns,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
INDArray |
BaseNDArrayFactory.rand(int rows,
int columns,
float min,
float max,
Random rng)
Generates a random matrix between min and max
|
static INDArray |
Nd4j.rand(int rows,
int columns,
long seed)
Create a random ndarray with the given shape using the given seed
|
INDArray |
NDArrayFactory.rand(int rows,
int columns,
long seed)
Create a random ndarray with the given shape using the given rng
|
INDArray |
BaseNDArrayFactory.rand(int rows,
int columns,
long seed)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(int rows,
int columns,
Random rng)
Create a random ndarray with the given shape using the given rng
|
INDArray |
NDArrayFactory.rand(int rows,
int columns,
Random r)
Create a random ndarray with the given shape using the given rng
|
INDArray |
BaseNDArrayFactory.rand(int rows,
int columns,
Random r)
Create a random ndarray with the given shape using the given rng
|
static INDArray |
Nd4j.rand(long seed,
int... shape)
Create a random ndarray with the given shape using the given seed
|
static INDArray |
Nd4j.randn(char order,
int[] shape)
Random normal N(0,1) with the specified shape and array order
|
INDArray |
NDArrayFactory.randn(char order,
int[] shape)
Random normal N(0,1) with the specified shape and order
|
INDArray |
BaseNDArrayFactory.randn(char order,
int[] shape)
Random normal using the current time stamp
as the seed
|
static INDArray |
Nd4j.randn(char order,
int rows,
int columns)
Random normal N(0,1) with the specified shape and array order
|
INDArray |
NDArrayFactory.randn(char order,
int rows,
int columns)
Random normal N(0,1), with specified output order
|
INDArray |
BaseNDArrayFactory.randn(char order,
int rows,
int columns)
Generate a random normal N(0,1) with the specified order and shape
|
static INDArray |
Nd4j.randn(INDArray target)
Fill the given ndarray with random numbers drawn from a normal distribution
|
static INDArray |
Nd4j.randn(INDArray target,
long seed)
Fill the given ndarray with random numbers drawn from a normal distribution
|
static INDArray |
Nd4j.randn(INDArray target,
Random rng)
Fill the given ndarray with random numbers drawn from a normal distribution utilizing the given random generator
|
static INDArray |
Nd4j.randn(int[] shape)
Random normal using the current time stamp
as the seed
|
INDArray |
NDArrayFactory.randn(int[] shape)
Random normal N(0,1) using the current time stamp
as the seed
|
INDArray |
BaseNDArrayFactory.randn(int[] shape)
Random normal N(0,1) with the specified shape and
|
static INDArray |
Nd4j.randn(int[] shape,
long seed)
Random normal using the specified seed
|
INDArray |
NDArrayFactory.randn(int[] shape,
long seed)
Random normal using the specified seed
|
INDArray |
BaseNDArrayFactory.randn(int[] shape,
long seed)
Random normal using the specified seed
|
static INDArray |
Nd4j.randn(int[] shape,
Random r)
Random normal using the given rng
|
INDArray |
NDArrayFactory.randn(int[] shape,
Random r)
Random normal using the given rng
|
INDArray |
BaseNDArrayFactory.randn(int[] shape,
Random r)
Random normal using the given rng
|
static INDArray |
Nd4j.randn(int rows,
int columns)
Random normal using the current time stamp
as the seed
|
INDArray |
NDArrayFactory.randn(int rows,
int columns)
Random normal (N(0,1)) using the current time stamp
as the seed
|
INDArray |
BaseNDArrayFactory.randn(int rows,
int columns)
Random normal using the current time stamp
as the seed
|
static INDArray |
Nd4j.randn(int rows,
int columns,
long seed)
Random normal using the specified seed
|
INDArray |
NDArrayFactory.randn(int rows,
int columns,
long seed)
Random normal using the specified seed
|
INDArray |
BaseNDArrayFactory.randn(int rows,
int columns,
long seed)
Random normal using the specified seed
|
static INDArray |
Nd4j.randn(int rows,
int columns,
Random r)
Random normal using the given rng
|
INDArray |
NDArrayFactory.randn(int rows,
int columns,
Random r)
Random normal using the given rng
|
INDArray |
BaseNDArrayFactory.randn(int rows,
int columns,
Random r)
Random normal using the given rng
|
static INDArray |
Broadcast.rdiv(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast reverse division op.
|
static INDArray |
Nd4j.read(DataInputStream dis)
Read in an ndarray from a data input stream
|
static INDArray |
Nd4j.read(InputStream reader)
Raad an ndarray from an input stream
|
static INDArray |
Nd4j.readBinary(File read)
Read a binary ndarray from the given file
|
static INDArray |
Nd4j.readNumpy(InputStream filePath,
String split)
Read line via input streams
|
static INDArray |
Nd4j.readNumpy(String filePath)
Read line via input streams
|
static INDArray |
Nd4j.readNumpy(String filePath,
String split)
Read line via input streams
|
static INDArray |
Nd4j.readTxt(String filePath)
Read line via input streams
|
static INDArray |
Nd4j.readTxt(String filePath,
String sep)
Deprecated.
|
static INDArray |
Nd4j.readTxtString(InputStream ndarray)
Read line via input streams
|
static INDArray |
Nd4j.readTxtString(InputStream ndarray,
String sep)
Deprecated.
|
static INDArray |
Nd4j.repeat(INDArray n,
int num)
Create an n x (shape)
ndarray where the ndarray is repeated num times
|
static INDArray |
Nd4j.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
NDArrayFactory.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
BaseNDArrayFactory.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Nd4j.rollAxis(INDArray a,
int axis)
Roll the specified axis backwards,
until it lies in a given position.
|
static INDArray |
Nd4j.rollAxis(INDArray a,
int axis,
int start)
Roll the specified axis backwards,
until it lies in a given position.
|
static INDArray |
Nd4j.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
NDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
BaseNDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Broadcast.rsub(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast reverse subtraction op.
|
INDArray |
BlasWrapper.scal(double alpha,
INDArray x)
Deprecated.
|
INDArray |
BaseBlasWrapper.scal(double alpha,
INDArray x) |
INDArray |
BaseSparseBlasWrapper.scal(double alpha,
INDArray x) |
INDArray |
BlasWrapper.scal(float alpha,
INDArray x)
Deprecated.
|
INDArray |
BaseBlasWrapper.scal(float alpha,
INDArray x) |
INDArray |
BaseSparseBlasWrapper.scal(float alpha,
INDArray x) |
static INDArray |
Nd4j.scalar(double value)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(double value)
Create a scalar nd array with the specified value and offset
|
INDArray |
BaseNDArrayFactory.scalar(double value)
Create a scalar nd array with the specified value and offset
|
static INDArray |
Nd4j.scalar(double value,
long offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(double value,
long offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
BaseNDArrayFactory.scalar(double value,
long offset)
Create a scalar nd array with the specified value and offset
|
static INDArray |
Nd4j.scalar(float value)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(float value)
Create a scalar nd array with the specified value and offset
|
INDArray |
BaseNDArrayFactory.scalar(float value)
Create a scalar nd array with the specified value and offset
|
static INDArray |
Nd4j.scalar(float value,
long offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(float value,
long offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
BaseNDArrayFactory.scalar(float value,
long offset)
Create a scalar nd array with the specified value and offset
|
INDArray |
NDArrayFactory.scalar(int value,
long offset) |
INDArray |
BaseNDArrayFactory.scalar(int value,
long offset)
Create a scalar nd array with the specified value and offset
|
static INDArray |
Nd4j.scalar(Number value)
Create a scalar ndarray with the specified offset
|
INDArray |
NDArrayFactory.scalar(Number value)
Create a scalar ndarray with the specified offset
|
INDArray |
BaseNDArrayFactory.scalar(Number value)
Create a scalar ndarray with the specified offset
|
static INDArray |
Nd4j.scalar(Number value,
long offset)
Create a scalar ndarray with the specified offset
|
INDArray |
NDArrayFactory.scalar(Number value,
long offset)
Create a scalar ndarray with the specified offset
|
INDArray |
BaseNDArrayFactory.scalar(Number value,
long offset)
Create a scalar ndarray with the specified offset
|
static INDArray |
Nd4j.sort(INDArray ndarray,
boolean ascending) |
INDArray |
NDArrayFactory.sort(INDArray x,
boolean descending) |
INDArray |
NDArrayFactory.sort(INDArray x,
boolean descending,
int... dimensions) |
static INDArray |
Nd4j.sort(INDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension
|
static INDArray |
Nd4j.sortColumns(INDArray in,
int rowIdx,
boolean ascending)
Sort (shuffle) the columns of a 2d array according to the value at a specified row.
|
INDArray |
NDArrayFactory.sortCooIndices(INDArray x) |
static INDArray |
Nd4j.sortRows(INDArray in,
int colIdx,
boolean ascending)
Sort (shuffle) the rows of a 2d array according to the value at a specified column.
|
static INDArray[] |
Nd4j.sortWithIndices(IComplexNDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension
|
static INDArray[] |
Nd4j.sortWithIndices(INDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension
|
static INDArray |
Nd4j.specialConcat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
PLEASE NOTE: This method is special for GPU backend, it works on HOST side only.
|
INDArray |
NDArrayFactory.specialConcat(int dimension,
INDArray... toConcat)
Concatenate ndarrays along a dimension
PLEASE NOTE: This method is special for GPU backend, it works on HOST side only.
|
static INDArray |
Nd4j.std(INDArray compute) |
static INDArray |
Nd4j.std(INDArray compute,
int dimension) |
static INDArray |
Nd4j.stripOnes(INDArray toStrip)
Reshapes an ndarray to remove leading 1s
|
static INDArray |
Broadcast.sub(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast subtraction op.
|
static INDArray |
Nd4j.sum(INDArray compute) |
static INDArray |
Nd4j.sum(INDArray compute,
int dimension) |
INDArray |
BlasWrapper.swap(INDArray x,
INDArray y)
Compute x <-> y (swap two matrices)
|
INDArray |
BaseBlasWrapper.swap(INDArray x,
INDArray y) |
INDArray |
BaseSparseBlasWrapper.swap(INDArray x,
INDArray y) |
INDArray |
BlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
INDArray |
BaseBlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
INDArray |
BaseSparseBlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
static INDArray[] |
Nd4j.tear(INDArray tensor,
int... dimensions)
This method does the opposite to pile/vstack/hstack - it returns independent TAD copies along given dimensions
|
INDArray[] |
NDArrayFactory.tear(INDArray tensor,
int... dimensions) |
static INDArray |
Nd4j.tensorMmul(INDArray a,
INDArray b,
INDArray result,
int[][] axes)
Tensor matrix multiplication.
|
static INDArray |
Nd4j.tensorMmul(INDArray a,
INDArray b,
int[][] axes)
Tensor matrix multiplication.
|
static INDArray |
Nd4j.tile(INDArray tile,
int... repeat)
An alias for repmat
|
static INDArray |
Nd4j.toFlattened(char order,
Collection<INDArray> matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(char order,
Collection<INDArray> matrices)
Returns a flattened ndarray with all elements in each ndarray
regardless of dimension.
|
static INDArray |
Nd4j.toFlattened(char order,
INDArray... matrices)
Create a long row vector of all of the given ndarrays/
|
INDArray |
NDArrayFactory.toFlattened(char order,
INDArray... matrices)
Flatten all of the ndarrays in to one long vector
|
INDArray |
BaseNDArrayFactory.toFlattened(char order,
INDArray... matrices) |
static INDArray |
Nd4j.toFlattened(Collection<INDArray> matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(Collection<INDArray> matrices)
/**
Returns a flattened ndarray with all of the elements in each ndarray
regardless of dimension
|
INDArray |
BaseNDArrayFactory.toFlattened(Collection<INDArray> matrices)
Returns a vector with all of the elements in every nd array
equal to the sum of the lengths of the ndarrays
|
static INDArray |
Nd4j.toFlattened(INDArray... matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(INDArray... matrices)
Flatten all of the ndarrays in to one long vector
|
INDArray |
BaseNDArrayFactory.toFlattened(INDArray... matrices) |
static INDArray |
Nd4j.toFlattened(int length,
Iterator<? extends INDArray>... matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(int length,
Iterator<? extends INDArray>... matrices)
Returns a flattened ndarray with all of the elements in each ndarray
regardless of dimension
|
INDArray |
BaseNDArrayFactory.toFlattened(int length,
Iterator<? extends INDArray>... matrices) |
static INDArray |
Nd4j.tri(int n) |
static INDArray |
Nd4j.tri(int n,
int k) |
static INDArray |
Nd4j.tri(int n,
int m,
int k)
Like the scipy function tri.
|
static INDArray |
Nd4j.triu(INDArray m,
int k) |
static INDArray |
Nd4j.trueScalar(Number scalar)
This method creates new 0D INDArray, aka scalar.
|
INDArray |
NDArrayFactory.trueScalar(Number value) |
INDArray |
BaseNDArrayFactory.trueScalar(Number value) |
static INDArray |
Nd4j.trueVector(double[] data) |
INDArray |
NDArrayFactory.trueVector(double[] data) |
INDArray |
BaseNDArrayFactory.trueVector(double[] data) |
static INDArray |
Nd4j.trueVector(float[] data) |
INDArray |
NDArrayFactory.trueVector(float[] data) |
INDArray |
BaseNDArrayFactory.trueVector(float[] data) |
static INDArray |
Nd4j.typeConversion(INDArray array,
DataBuffer.TypeEx targetType) |
static INDArray |
Nd4j.valueArrayOf(int[] shape,
double value)
Creates an ndarray with the specified value
as the only value in the ndarray.
|
INDArray |
NDArrayFactory.valueArrayOf(int[] shape,
double value)
Creates an ndarray with the specified value
as the only value in the ndarray
|
INDArray |
BaseNDArrayFactory.valueArrayOf(int[] shape,
double value)
Creates an ndarray with the specified value
as the only value in the ndarray
|
static INDArray |
Nd4j.valueArrayOf(int num,
double value)
Creates a row vector ndarray with the specified value
as the only value in the ndarray
Some people may know this as np.full
|
static INDArray |
Nd4j.valueArrayOf(int rows,
int columns,
double value)
Creates a row vector with the specified number of columns
Some people may know this as np.full
|
INDArray |
NDArrayFactory.valueArrayOf(int rows,
int columns,
double value)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.valueArrayOf(int rows,
int columns,
double value)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.var(INDArray compute) |
static INDArray |
Nd4j.var(INDArray compute,
int dimension) |
static INDArray |
Nd4j.vstack(Collection<INDArray> arrs)
Concatenates two matrices vertically.
|
static INDArray |
Nd4j.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
INDArray |
NDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
INDArray |
BaseNDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
static INDArray |
Nd4j.zeros(int... shape)
Create an ndarray of zeros
|
static INDArray |
Nd4j.zeros(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.zeros(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.zeros(int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.zeros(int[] shape)
Create an ndarray of zeros
|
INDArray |
BaseNDArrayFactory.zeros(int[] shape)
Create an ndarray of zeros
|
static INDArray |
Nd4j.zeros(int[] shape,
char order)
Create an ndarray of zeros
|
static INDArray |
Nd4j.zeros(int[] shape,
DataBuffer.Type dataType) |
static INDArray |
Nd4j.zeros(int[] shape,
int[] stride) |
static INDArray |
Nd4j.zeros(int[] shape,
int[] stride,
char ordering) |
static INDArray |
Nd4j.zeros(int[] shape,
int[] stride,
long offset) |
static INDArray |
Nd4j.zeros(int[] shape,
int[] stride,
long offset,
char ordering) |
static INDArray |
Nd4j.zeros(int columns,
char order) |
static INDArray |
Nd4j.zeros(int rows,
int columns)
Creates a row vector with the specified number of columns
|
INDArray |
NDArrayFactory.zeros(int rows,
int columns)
Creates a row vector with the specified number of columns
|
INDArray |
BaseNDArrayFactory.zeros(int rows,
int columns)
Creates a row vector with the specified number of columns
|
static INDArray |
Nd4j.zeros(int rows,
int columns,
char ordering) |
static INDArray |
Nd4j.zeros(int rows,
int columns,
int[] stride) |
static INDArray |
Nd4j.zeros(int rows,
int columns,
int[] stride,
char ordering) |
static INDArray |
Nd4j.zeros(int rows,
int columns,
int[] stride,
long offset) |
static INDArray |
Nd4j.zeros(int rows,
int columns,
int[] stride,
long offset,
char ordering) |
static INDArray |
Nd4j.zerosLike(INDArray arr)
Empty like
|
Modifier and Type | Method and Description |
---|---|
static ReferenceQueue<INDArray> |
Nd4j.refQueue()
The reference queue used for cleaning up
ndarrays
|
Modifier and Type | Method and Description |
---|---|
static INDArray |
Nd4j.accumulate(INDArray... arrays)
This method sums given arrays and stores them to a new array
|
static INDArray |
Nd4j.accumulate(INDArray target,
Collection<INDArray> arrays)
This method sums given arrays and stores them to a given target array
|
INDArray |
NDArrayFactory.accumulate(INDArray target,
INDArray... arrays)
This method sums given arrays to target
|
INDArray |
NDArrayFactory.accumulate(INDArray target,
INDArray... arrays)
This method sums given arrays to target
|
static INDArray |
Nd4j.accumulate(INDArray target,
INDArray[] arrays)
This method sums given arrays and stores them to a given target array
|
static INDArray |
Nd4j.accumulate(INDArray target,
INDArray[] arrays)
This method sums given arrays and stores them to a given target array
|
static INDArray |
Broadcast.add(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast add op.
|
static INDArray |
Broadcast.amax(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast absolute max op.
|
static INDArray |
Broadcast.amin(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast absolute min op.
|
static INDArray |
Nd4j.append(INDArray arr,
int padAmount,
double val,
int axis)
Append the given
array with the specified value size
along a particular axis
|
static INDArray |
Nd4j.appendBias(INDArray... vectors) |
INDArray |
NDArrayFactory.appendBias(INDArray... vectors) |
INDArray |
BaseNDArrayFactory.appendBias(INDArray... vectors)
Merge the vectors and append a bias.
|
static INDArray |
Nd4j.argMax(INDArray arr,
int... dimension) |
static void |
DataTypeValidation.assertDouble(INDArray... d) |
static void |
DataTypeValidation.assertDouble(INDArray d) |
static void |
DataTypeValidation.assertFloat(INDArray... d2) |
static void |
DataTypeValidation.assertFloat(INDArray d2) |
static void |
DataTypeValidation.assertSameDataType(INDArray... indArrays) |
double |
BlasWrapper.asum(INDArray x)
Compute || x ||_1 (1-norm, sum of absolute values)
|
double |
BaseBlasWrapper.asum(INDArray x) |
double |
BaseSparseBlasWrapper.asum(INDArray x) |
INDArray |
NDArrayFactory.average(INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array
|
static INDArray |
Nd4j.averageAndPropagate(INDArray[] arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
INDArray[] arrays)
This method averages input arrays, and returns averaged array.
|
INDArray |
BlasWrapper.axpy(double da,
INDArray dx,
INDArray dy)
Deprecated.
|
INDArray |
BaseBlasWrapper.axpy(double da,
INDArray dx,
INDArray dy) |
INDArray |
BaseSparseBlasWrapper.axpy(double da,
INDArray dx,
INDArray dy) |
INDArray |
BlasWrapper.axpy(float da,
INDArray dx,
INDArray dy)
Deprecated.
|
INDArray |
BaseBlasWrapper.axpy(float da,
INDArray dx,
INDArray dy) |
INDArray |
BaseSparseBlasWrapper.axpy(float da,
INDArray dx,
INDArray dy) |
INDArray |
BlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy)
Compute y <- y + x * alpha
|
INDArray |
BaseBlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy) |
INDArray |
BaseSparseBlasWrapper.axpy(Number da,
INDArray dx,
INDArray dy) |
static INDArray |
Nd4j.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
INDArray |
NDArrayFactory.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
INDArray |
BaseNDArrayFactory.bilinearProducts(INDArray curr,
INDArray in)
Returns a column vector where each entry is the nth bilinear
product of the nth slices of the two tensors.
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
INDArray target)
This method samples value from Source array to Target, with probabilites provided in Probs argument
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
INDArray target,
Random rng)
This method samples value from Source array to Target, with probabilites provided in Probs argument
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
int numSamples)
This method returns new INDArray instance, sampled from Source array with probabilities given in Probs
|
static INDArray |
Nd4j.choice(INDArray source,
INDArray probs,
int numSamples,
Random rng)
This method returns new INDArray instance, sampled from Source array with probabilities given in Probs
|
static void |
Nd4j.clearNans(INDArray arr)
Clear nans from an ndarray
|
static INDArray |
Nd4j.concat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
|
INDArray |
NDArrayFactory.concat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
|
INDArray |
BaseNDArrayFactory.concat(int dimension,
INDArray... toConcat)
concatenate ndarrays along a dimension
|
INDArray |
NDArrayFactory.convertDataEx(DataBuffer.TypeEx typeSrc,
INDArray source,
DataBuffer.TypeEx typeDst) |
static void |
Nd4j.copy(INDArray a,
INDArray b)
Copy a to b
|
INDArray |
BlasWrapper.copy(INDArray x,
INDArray y)
Compute y <- x (copy a matrix)
|
INDArray |
BaseBlasWrapper.copy(INDArray x,
INDArray y) |
void |
NDArrayFactory.copy(INDArray a,
INDArray b)
Copy a to b
|
INDArray |
BaseSparseBlasWrapper.copy(INDArray x,
INDArray y) |
void |
BaseNDArrayFactory.copy(INDArray a,
INDArray b)
Copy a to b
|
static INDArray |
Broadcast.copy(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast copy op.
|
static IComplexNDArray |
Nd4j.createComplex(INDArray arr)
Create a complex ndarray from the passed in indarray
|
IComplexNDArray |
NDArrayFactory.createComplex(INDArray arr)
Create a complex ndarray from the passed in indarray
|
abstract IComplexNDArray |
BaseNDArrayFactory.createComplex(INDArray arr)
Create a complex ndarray from the passed in indarray
|
static IComplexNDArray |
Nd4j.createComplex(INDArray real,
INDArray imag)
Create a complex ndarray based on the
real and imaginary
|
static INDArray |
Nd4j.cumsum(INDArray compute) |
static INDArray |
Nd4j.cumsum(INDArray compute,
int dimension) |
static INDArray |
Nd4j.diag(INDArray x)
Creates a new matrix where the values of the given vector are the diagonal values of
the matrix if a vector is passed in, if a matrix is returns the kth diagonal
in the matrix
|
static INDArray |
Nd4j.diag(INDArray x,
int k)
Creates a new matrix where the values of the given vector are the diagonal values of
the matrix if a vector is passed in, if a matrix is returns the kth diagonal
in the matrix
|
static INDArray |
Broadcast.div(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast divide op.
|
static void |
Nd4j.doAlongDiagonal(INDArray x,
com.google.common.base.Function<Number,Number> func)
Perform an operation along a diagonal
|
double |
BlasWrapper.dot(INDArray x,
INDArray y)
Compute x^T * y (dot product)
|
double |
BaseBlasWrapper.dot(INDArray x,
INDArray y) |
double |
BaseSparseBlasWrapper.dot(INDArray x,
INDArray y) |
static INDArray |
Nd4j.emptyLike(INDArray arr)
Empty like
|
static INDArray |
Broadcast.eq(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast equal to op.
|
static INDArray |
Nd4j.expandDims(INDArray input,
int dimension)
Expand the array dimensions.
|
int |
BlasWrapper.geev(char jobvl,
char jobvr,
INDArray A,
INDArray WR,
INDArray WI,
INDArray VL,
INDArray VR) |
int |
BaseBlasWrapper.geev(char jobvl,
char jobvr,
INDArray A,
INDArray WR,
INDArray WI,
INDArray VL,
INDArray VR) |
int |
BaseSparseBlasWrapper.geev(char jobvl,
char jobvr,
INDArray A,
INDArray WR,
INDArray WI,
INDArray VL,
INDArray VR) |
void |
BlasWrapper.gelsd(INDArray A,
INDArray B)
Generalized Least Squares via *GELSD.
|
void |
BaseBlasWrapper.gelsd(INDArray A,
INDArray B) |
void |
BaseSparseBlasWrapper.gelsd(INDArray A,
INDArray B) |
INDArray |
BlasWrapper.gemm(double alpha,
INDArray a,
INDArray b,
double beta,
INDArray c)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemm(double alpha,
INDArray a,
INDArray b,
double beta,
INDArray c) |
INDArray |
BaseSparseBlasWrapper.gemm(double alpha,
INDArray a,
INDArray b,
double beta,
INDArray c) |
INDArray |
BlasWrapper.gemm(float alpha,
INDArray a,
INDArray b,
float beta,
INDArray c)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemm(float alpha,
INDArray a,
INDArray b,
float beta,
INDArray c) |
INDArray |
BaseSparseBlasWrapper.gemm(float alpha,
INDArray a,
INDArray b,
float beta,
INDArray c) |
static INDArray |
Nd4j.gemm(INDArray a,
INDArray b,
boolean transposeA,
boolean transposeB)
matrix multiply: implements op(a)*op(b)
where op(x) means transpose x (or not) depending on
setting of arguments transposea and transposeb.
so gemm(a,b,false,false) == a.mmul(b), gemm(a,b,true,false) == a.transpose().mmul(b) etc. |
static INDArray |
Nd4j.gemm(INDArray a,
INDArray b,
INDArray c,
boolean transposeA,
boolean transposeB,
double alpha,
double beta)
Matrix multiply: Implements c = alpha*op(a)*op(b) + beta*c where op(X) means transpose X (or not)
depending on setting of arguments transposeA and transposeB.
Note that matrix c MUST be fortran order, have zero offset and have c.data().length == c.length(). |
INDArray |
BlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BaseSparseBlasWrapper.gemv(double alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y)
Deprecated.
|
INDArray |
BaseBlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y) |
INDArray |
BaseSparseBlasWrapper.gemv(float alpha,
INDArray a,
INDArray x,
float beta,
INDArray y) |
INDArray |
BlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y)
************************************************************************
BLAS Level 2
|
INDArray |
BaseBlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
INDArray |
BaseSparseBlasWrapper.gemv(Number alpha,
INDArray a,
INDArray x,
double beta,
INDArray y) |
void |
BlasWrapper.geqrf(INDArray A,
INDArray tau) |
void |
BaseBlasWrapper.geqrf(INDArray A,
INDArray tau) |
void |
BaseSparseBlasWrapper.geqrf(INDArray A,
INDArray tau) |
INDArray |
BlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a)
Deprecated.
|
INDArray |
BaseBlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BaseSparseBlasWrapper.ger(double alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a)
Compute A <- alpha * x * y^T + A (general rank-1 update)
|
INDArray |
BaseBlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BaseSparseBlasWrapper.ger(float alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BaseBlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BaseSparseBlasWrapper.ger(Number alpha,
INDArray x,
INDArray y,
INDArray a) |
INDArray |
BlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b)
************************************************************************
LAPACK
|
INDArray |
BaseBlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b) |
INDArray |
BaseSparseBlasWrapper.gesv(INDArray a,
int[] ipiv,
INDArray b) |
static INDArray |
Broadcast.gt(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast greater than op.
|
static INDArray |
Broadcast.gte(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast greater than or equal to op.
|
static INDArray |
Nd4j.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
NDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
INDArray |
BaseNDArrayFactory.hstack(INDArray... arrs)
Concatenates two matrices horizontally.
|
int |
BlasWrapper.iamax(INDArray x)
Compute index of element with largest absolute value (index of absolute
value maximum)
|
int |
BaseBlasWrapper.iamax(INDArray x) |
int |
BaseSparseBlasWrapper.iamax(INDArray x) |
static INDArray |
Broadcast.lt(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast less than op.
|
static INDArray |
Broadcast.lte(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast less than or equal to op.
|
static INDArray |
Nd4j.max(INDArray compute) |
static INDArray |
Broadcast.max(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast max op.
|
static INDArray |
Nd4j.max(INDArray compute,
int dimension) |
static INDArray |
Nd4j.mean(INDArray compute) |
static INDArray |
Nd4j.mean(INDArray compute,
int dimension) |
static INDArray |
Nd4j.min(INDArray compute) |
static INDArray |
Broadcast.min(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast min op.
|
static INDArray |
Nd4j.min(INDArray compute,
int dimension) |
static INDArray |
Broadcast.mul(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast element-wise multiply op.
|
static INDArray |
Broadcast.neq(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast not equal to op.
|
static INDArray |
Nd4j.norm1(INDArray compute) |
static INDArray |
Nd4j.norm1(INDArray compute,
int dimension) |
static INDArray |
Nd4j.norm2(INDArray compute) |
static INDArray |
Nd4j.norm2(INDArray compute,
int dimension) |
static INDArray |
Nd4j.normmax(INDArray compute) |
static INDArray |
Nd4j.normmax(INDArray compute,
int dimension) |
double |
BlasWrapper.nrm2(INDArray x)
Compute || x ||_2 (2-norm)
|
double |
BaseBlasWrapper.nrm2(INDArray x) |
double |
BaseSparseBlasWrapper.nrm2(INDArray x) |
static INDArray |
Nd4j.onesLike(INDArray arr)
Ones like
|
void |
BlasWrapper.ormqr(char side,
char trans,
INDArray A,
INDArray tau,
INDArray C) |
void |
BaseBlasWrapper.ormqr(char side,
char trans,
INDArray A,
INDArray tau,
INDArray C) |
void |
BaseSparseBlasWrapper.ormqr(char side,
char trans,
INDArray A,
INDArray tau,
INDArray C) |
static INDArray |
Nd4j.pad(INDArray toPad,
int[][] padWidth,
List<double[]> constantValues,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[][] padWidth,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[] padWidth,
List<double[]> constantValues,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pad(INDArray toPad,
int[] padWidth,
Nd4j.PadMode padMode)
Pad the given ndarray to the size along each dimension
|
static INDArray |
Nd4j.pile(INDArray... arrays)
This method stacks vertically examples with the same shape, increasing result dimensionality.
|
void |
BlasWrapper.posv(char uplo,
INDArray A,
INDArray B) |
void |
BaseBlasWrapper.posv(char uplo,
INDArray A,
INDArray B) |
void |
BaseSparseBlasWrapper.posv(char uplo,
INDArray A,
INDArray B) |
static INDArray |
Nd4j.prepend(INDArray arr,
int padAmount,
double val,
int axis)
Append the given
array with the specified value size
along a particular axis
|
static INDArray |
Nd4j.prod(INDArray compute) |
static INDArray |
Nd4j.prod(INDArray compute,
int dimension) |
static INDArray |
Nd4j.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
BaseNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
static INDArray |
Nd4j.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order)
This method produces concatenated array,
that consist from tensors,
fetched from source array,
against some dimension and specified indexes
|
INDArray |
NDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
INDArray |
BaseNDArrayFactory.pullRows(INDArray source,
int sourceDimension,
int[] indexes,
char order)
This method produces concatenated array, that consist from tensors, fetched from source array, against some dimension and specified indexes
|
static INDArray |
Nd4j.rand(INDArray target)
Fill the given ndarray with random numbers drawn from a uniform distribution
|
static INDArray |
Nd4j.rand(INDArray target,
Distribution dist)
Fill the given ndarray with random numbers drawn from the given distribution
|
static INDArray |
Nd4j.rand(INDArray target,
double min,
double max,
Random rng)
Fill the given ndarray with random numbers drawn from a uniform distribution using the given RandomGenerator
|
static INDArray |
Nd4j.rand(INDArray target,
long seed)
Fill the given ndarray with random numbers drawn from a uniform distribution
|
static INDArray |
Nd4j.rand(INDArray target,
Random rng)
Fill the given ndarray with random numbers drawn from a uniform distribution using the given RandomGenerator
|
static INDArray |
Nd4j.randn(INDArray target)
Fill the given ndarray with random numbers drawn from a normal distribution
|
static INDArray |
Nd4j.randn(INDArray target,
long seed)
Fill the given ndarray with random numbers drawn from a normal distribution
|
static INDArray |
Nd4j.randn(INDArray target,
Random rng)
Fill the given ndarray with random numbers drawn from a normal distribution utilizing the given random generator
|
static INDArray |
Broadcast.rdiv(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast reverse division op.
|
static INDArray |
Nd4j.repeat(INDArray n,
int num)
Create an n x (shape)
ndarray where the ndarray is repeated num times
|
static INDArray |
Nd4j.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
NDArrayFactory.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
BaseNDArrayFactory.reverse(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static INDArray |
Nd4j.rollAxis(INDArray a,
int axis)
Roll the specified axis backwards,
until it lies in a given position.
|
static INDArray |
Nd4j.rollAxis(INDArray a,
int axis,
int start)
Roll the specified axis backwards,
until it lies in a given position.
|
static INDArray |
Nd4j.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
NDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
INDArray |
BaseNDArrayFactory.rot(INDArray reverse)
Reverses the passed in matrix such that m[0] becomes m[m.length - 1] etc
|
static void |
Nd4j.rot90(INDArray toRotate)
Rotate a matrix 90 degrees
|
void |
NDArrayFactory.rot90(INDArray toRotate)
Rotate a matrix 90 degrees
|
void |
BaseNDArrayFactory.rot90(INDArray toRotate)
Rotate a matrix 90 degrees
|
static INDArray |
Broadcast.rsub(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast reverse subtraction op.
|
static void |
Nd4j.saveBinary(INDArray arr,
File saveTo)
Save an ndarray to the given file
|
void |
BlasWrapper.saxpy(double alpha,
INDArray x,
INDArray y)
Deprecated.
|
void |
BaseBlasWrapper.saxpy(double alpha,
INDArray x,
INDArray y) |
void |
BaseSparseBlasWrapper.saxpy(double alpha,
INDArray x,
INDArray y) |
void |
BlasWrapper.saxpy(float alpha,
INDArray x,
INDArray y)
Deprecated.
|
void |
BaseBlasWrapper.saxpy(float alpha,
INDArray x,
INDArray y) |
void |
BaseSparseBlasWrapper.saxpy(float alpha,
INDArray x,
INDArray y) |
INDArray |
BlasWrapper.scal(double alpha,
INDArray x)
Deprecated.
|
INDArray |
BaseBlasWrapper.scal(double alpha,
INDArray x) |
INDArray |
BaseSparseBlasWrapper.scal(double alpha,
INDArray x) |
INDArray |
BlasWrapper.scal(float alpha,
INDArray x)
Deprecated.
|
INDArray |
BaseBlasWrapper.scal(float alpha,
INDArray x) |
INDArray |
BaseSparseBlasWrapper.scal(float alpha,
INDArray x) |
static void |
Nd4j.setParams(INDArray theta,
Collection<INDArray>... matrices)
Given a sequence of Iterators over a transform of matrices, fill in all of
the matrices with the entries in the theta vector.
|
static void |
Nd4j.setParams(INDArray theta,
Iterator<? extends INDArray>... matrices)
Given a sequence of Iterators over a transform of matrices, fill in all of
the matrices with the entries in the theta vector.
|
static int[] |
Nd4j.shape(INDArray arr)
Returns the shape of the ndarray
|
static void |
Nd4j.shuffle(INDArray toShuffle,
int... dimension)
In place shuffle of an ndarray
along a specified set of dimensions
|
static void |
Nd4j.shuffle(INDArray toShuffle,
Random random,
int... dimension)
In place shuffle of an ndarray
along a specified set of dimensions
|
void |
NDArrayFactory.shuffle(INDArray array,
Random rnd,
int... dimension)
In place shuffle of an ndarray
along a specified set of dimensions
|
static INDArray |
Nd4j.sort(INDArray ndarray,
boolean ascending) |
INDArray |
NDArrayFactory.sort(INDArray x,
boolean descending) |
INDArray |
NDArrayFactory.sort(INDArray x,
boolean descending,
int... dimensions) |
static INDArray |
Nd4j.sort(INDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension
|
static INDArray |
Nd4j.sortColumns(INDArray in,
int rowIdx,
boolean ascending)
Sort (shuffle) the columns of a 2d array according to the value at a specified row.
|
INDArray |
NDArrayFactory.sortCooIndices(INDArray x) |
static INDArray |
Nd4j.sortRows(INDArray in,
int colIdx,
boolean ascending)
Sort (shuffle) the rows of a 2d array according to the value at a specified column.
|
static INDArray[] |
Nd4j.sortWithIndices(INDArray ndarray,
int dimension,
boolean ascending)
Sort an ndarray along a particular dimension
|
static INDArray |
Nd4j.specialConcat(int dimension,
INDArray... toConcat)
Concatneate ndarrays along a dimension
PLEASE NOTE: This method is special for GPU backend, it works on HOST side only.
|
INDArray |
NDArrayFactory.specialConcat(int dimension,
INDArray... toConcat)
Concatenate ndarrays along a dimension
PLEASE NOTE: This method is special for GPU backend, it works on HOST side only.
|
static INDArray |
Nd4j.std(INDArray compute) |
static INDArray |
Nd4j.std(INDArray compute,
int dimension) |
static INDArray |
Nd4j.stripOnes(INDArray toStrip)
Reshapes an ndarray to remove leading 1s
|
static INDArray |
Broadcast.sub(INDArray x,
INDArray y,
INDArray z,
int... dimensions)
Broadcast subtraction op.
|
static INDArray |
Nd4j.sum(INDArray compute) |
static INDArray |
Nd4j.sum(INDArray compute,
int dimension) |
INDArray |
BlasWrapper.swap(INDArray x,
INDArray y)
Compute x <-> y (swap two matrices)
|
INDArray |
BaseBlasWrapper.swap(INDArray x,
INDArray y) |
INDArray |
BaseSparseBlasWrapper.swap(INDArray x,
INDArray y) |
int |
BlasWrapper.syev(char jobz,
char uplo,
INDArray a,
INDArray w) |
int |
BaseBlasWrapper.syev(char jobz,
char uplo,
INDArray a,
INDArray w) |
int |
BaseSparseBlasWrapper.syev(char jobz,
char uplo,
INDArray a,
INDArray w) |
int |
BlasWrapper.syevd(char jobz,
char uplo,
INDArray A,
INDArray w) |
int |
BaseBlasWrapper.syevd(char jobz,
char uplo,
INDArray A,
INDArray w) |
int |
BaseSparseBlasWrapper.syevd(char jobz,
char uplo,
INDArray A,
INDArray w) |
int |
BlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z,
int[] isuppz)
Deprecated.
|
int |
BaseBlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BaseSparseBlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z,
int[] isuppz)
Deprecated.
|
int |
BaseBlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BaseSparseBlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
Number abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BaseBlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
Number abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BaseSparseBlasWrapper.syevr(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
Number abstol,
INDArray w,
INDArray z,
int[] isuppz) |
int |
BlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z) |
int |
BaseBlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z) |
int |
BaseSparseBlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
double vl,
double vu,
int il,
int iu,
double abstol,
INDArray w,
INDArray z) |
int |
BlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z) |
int |
BaseBlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z) |
int |
BaseSparseBlasWrapper.syevx(char jobz,
char range,
char uplo,
INDArray a,
float vl,
float vu,
int il,
int iu,
float abstol,
INDArray w,
INDArray z) |
int |
BlasWrapper.sygvd(int itype,
char jobz,
char uplo,
INDArray A,
INDArray B,
INDArray W) |
int |
BaseBlasWrapper.sygvd(int itype,
char jobz,
char uplo,
INDArray A,
INDArray B,
INDArray W) |
int |
BaseSparseBlasWrapper.sygvd(int itype,
char jobz,
char uplo,
INDArray A,
INDArray B,
INDArray W) |
INDArray |
BlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
INDArray |
BaseBlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
INDArray |
BaseSparseBlasWrapper.sysv(char uplo,
INDArray a,
int[] ipiv,
INDArray b) |
static INDArray[] |
Nd4j.tear(INDArray tensor,
int... dimensions)
This method does the opposite to pile/vstack/hstack - it returns independent TAD copies along given dimensions
|
INDArray[] |
NDArrayFactory.tear(INDArray tensor,
int... dimensions) |
static INDArray |
Nd4j.tensorMmul(INDArray a,
INDArray b,
INDArray result,
int[][] axes)
Tensor matrix multiplication.
|
static INDArray |
Nd4j.tensorMmul(INDArray a,
INDArray b,
int[][] axes)
Tensor matrix multiplication.
|
static INDArray |
Nd4j.tile(INDArray tile,
int... repeat)
An alias for repmat
|
static byte[] |
Nd4j.toByteArray(INDArray arr)
Convert an ndarray to a byte array
|
static INDArray |
Nd4j.toFlattened(char order,
INDArray... matrices)
Create a long row vector of all of the given ndarrays/
|
INDArray |
NDArrayFactory.toFlattened(char order,
INDArray... matrices)
Flatten all of the ndarrays in to one long vector
|
INDArray |
BaseNDArrayFactory.toFlattened(char order,
INDArray... matrices) |
static INDArray |
Nd4j.toFlattened(INDArray... matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(INDArray... matrices)
Flatten all of the ndarrays in to one long vector
|
INDArray |
BaseNDArrayFactory.toFlattened(INDArray... matrices) |
static INDArray |
Nd4j.triu(INDArray m,
int k) |
static INDArray |
Nd4j.typeConversion(INDArray array,
DataBuffer.TypeEx targetType) |
protected static void |
BaseNDArrayFactory.validateConcat(int dimension,
INDArray... arrs) |
static INDArray |
Nd4j.var(INDArray compute) |
static INDArray |
Nd4j.var(INDArray compute,
int dimension) |
static INDArray |
Nd4j.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
INDArray |
NDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
INDArray |
BaseNDArrayFactory.vstack(INDArray... arrs)
Concatenates two matrices vertically.
|
static void |
Nd4j.write(INDArray arr,
DataOutputStream dataOutputStream)
Write an ndarray to the specified outputstream
|
static void |
Nd4j.write(OutputStream writer,
INDArray write)
Y
Write an ndarray to a writer
|
static void |
Nd4j.writeNumpy(INDArray write,
String filePath,
String split)
Deprecated.
|
static void |
Nd4j.writeTxt(INDArray write,
String filePath)
Write NDArray to a text file
|
static void |
Nd4j.writeTxt(INDArray write,
String filePath,
int precision)
Deprecated.
Precision is no longer used.
Defaults to scientific notation with 18 digits after the decimal
Use
Nd4j.writeTxt(INDArray, String) |
static void |
Nd4j.writeTxt(INDArray write,
String filePath,
String split)
Deprecated.
custom col and higher dimension separators are no longer supported; uses ","
Use
Nd4j.writeTxt(INDArray, String) |
static void |
Nd4j.writeTxt(INDArray write,
String filePath,
String split,
int precision)
Deprecated.
custom col separators are no longer supported; uses ","
|
static void |
Nd4j.writeTxtString(INDArray write,
OutputStream os)
Write ndarray as text to output stream
|
static void |
Nd4j.writeTxtString(INDArray write,
OutputStream os,
int precision)
Deprecated.
precision can no longer be specified. The array is written in scientific notation.
Use
Nd4j.writeTxtString(INDArray, OutputStream) |
static void |
Nd4j.writeTxtString(INDArray write,
OutputStream os,
String split)
Deprecated.
column separator can longer be specified; Uses ","
Use
Nd4j.writeTxtString(INDArray, OutputStream) instead |
static void |
Nd4j.writeTxtString(INDArray write,
OutputStream os,
String split,
int precision)
Deprecated.
custom col separators are no longer supported; uses ","
|
static INDArray |
Nd4j.zerosLike(INDArray arr)
Empty like
|
Modifier and Type | Method and Description |
---|---|
static INDArray |
Nd4j.accumulate(Collection<INDArray> arrays)
This method sums given arrays and stores them to a new target array
|
static INDArray |
Nd4j.accumulate(INDArray target,
Collection<INDArray> arrays)
This method sums given arrays and stores them to a given target array
|
INDArray |
NDArrayFactory.average(Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
INDArray |
NDArrayFactory.average(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array
|
static INDArray |
Nd4j.averageAndPropagate(Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.averageAndPropagate(INDArray target,
Collection<INDArray> arrays)
This method averages input arrays, and returns averaged array.
|
static INDArray |
Nd4j.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
abstract INDArray |
BaseNDArrayFactory.create(List<INDArray> list,
int[] shape)
Creates an ndarray with the specified shape
|
static INDArray |
Nd4j.create(List<INDArray> list,
int[] shape,
char ordering)
Creates an ndarray with the specified shape
|
INDArray |
NDArrayFactory.create(List<INDArray> list,
int[] shape,
char ordering) |
static INDArray |
Nd4j.hstack(Collection<INDArray> arrs)
Concatenates two matrices horizontally.
|
static INDArray |
Nd4j.pile(Collection<INDArray> arrays)
This method stacks vertically examples with the same shape, increasing result dimensionality.
|
static void |
Nd4j.shuffle(Collection<INDArray> toShuffle,
int... dimension)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions
|
static void |
Nd4j.shuffle(Collection<INDArray> toShuffle,
Random rnd,
int... dimension)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions
|
void |
NDArrayFactory.shuffle(Collection<INDArray> array,
Random rnd,
int... dimension)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions.
|
static void |
Nd4j.shuffle(List<INDArray> toShuffle,
Random rnd,
List<int[]> dimensions)
Symmetric in place shuffle of an ndarray
along a variable dimensions
|
void |
NDArrayFactory.shuffle(List<INDArray> array,
Random rnd,
List<int[]> dimensions)
Symmetric in place shuffle of an ndarray
along a specified set of dimensions.
|
static INDArray |
Nd4j.toFlattened(char order,
Collection<INDArray> matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(char order,
Collection<INDArray> matrices)
Returns a flattened ndarray with all elements in each ndarray
regardless of dimension.
|
static INDArray |
Nd4j.toFlattened(Collection<INDArray> matrices)
Create a long row vector of all of the given ndarrays
|
INDArray |
NDArrayFactory.toFlattened(Collection<INDArray> matrices)
/**
Returns a flattened ndarray with all of the elements in each ndarray
regardless of dimension
|
INDArray |
BaseNDArrayFactory.toFlattened(Collection<INDArray> matrices)
Returns a vector with all of the elements in every nd array
equal to the sum of the lengths of the ndarrays
|
static INDArray |
Nd4j.vstack(Collection<INDArray> arrs)
Concatenates two matrices vertically.
|
Modifier and Type | Method and Description |
---|---|
static Task |
TaskUtils.buildTask(INDArray array) |
static Task |
TaskUtils.buildTask(INDArray[] array,
INDArray[] labels) |
static Task |
TaskUtils.buildTask(INDArray[] array,
INDArray[] labels) |
static Task |
TaskUtils.buildTask(INDArray array,
INDArray labels) |
Modifier and Type | Method and Description |
---|---|
static INDArray |
BooleanIndexing.applyMask(INDArray arr,
INDArray mask)
A minor shortcut for applying a bitmask to
a matrix
|
static INDArray |
BooleanIndexing.applyMaskInPlace(INDArray arr,
INDArray mask)
A minor shortcut for applying a bitmask to
a matrix
|
static INDArray |
BooleanIndexing.chooseFrom(INDArray[] input,
Condition condition)
Choose from the inputs based on the given condition.
|
static INDArray |
BooleanIndexing.chooseFrom(INDArray[] input,
List<Double> tArgs,
List<Integer> iArgs,
Condition condition)
Choose from the inputs based on the given condition.
|
static INDArray |
BooleanIndexing.firstIndex(INDArray array,
Condition condition)
This method returns first index matching given condition
PLEASE NOTE: This method will return -1 value if condition wasn't met
|
static INDArray |
BooleanIndexing.firstIndex(INDArray array,
Condition condition,
int... dimension)
This method returns first index matching given condition along given dimensions
PLEASE NOTE: This method will return -1 values for missing conditions
|
static INDArray |
BooleanIndexing.lastIndex(INDArray array,
Condition condition)
This method returns last index matching given condition
PLEASE NOTE: This method will return -1 value if condition wasn't met
|
static INDArray |
BooleanIndexing.lastIndex(INDArray array,
Condition condition,
int... dimension)
This method returns first index matching given condition along given dimensions
PLEASE NOTE: This method will return -1 values for missing conditions
|
Modifier and Type | Method and Description |
---|---|
static INDArrayIndex[] |
NDArrayIndex.allFor(INDArray arr)
Generate an all index
equal to the rank of the given array
|
static boolean |
BooleanIndexing.and(INDArray n,
Condition cond)
And over the whole ndarray given some condition
|
static boolean[] |
BooleanIndexing.and(INDArray n,
Condition condition,
int... dimension)
And over the whole ndarray given some condition, with respect to dimensions
|
static INDArray |
BooleanIndexing.applyMask(INDArray arr,
INDArray mask)
A minor shortcut for applying a bitmask to
a matrix
|
static INDArray |
BooleanIndexing.applyMaskInPlace(INDArray arr,
INDArray mask)
A minor shortcut for applying a bitmask to
a matrix
|
static void |
BooleanIndexing.applyWhere(INDArray to,
Condition condition,
com.google.common.base.Function<Number,Number> function)
Based on the matching elements
op to based on condition to with function function
|
static void |
BooleanIndexing.applyWhere(INDArray to,
Condition condition,
com.google.common.base.Function<Number,Number> function,
com.google.common.base.Function<Number,Number> alternativeFunction)
Based on the matching elements
op to based on condition to with function function
|
static void |
BooleanIndexing.applyWhere(INDArray to,
Condition condition,
Number number)
This method sets provided number to all elements which match specified condition
|
static void |
BooleanIndexing.assignIf(INDArray to,
INDArray from,
Condition condition)
This method does element-wise comparison
for 2 equal-sized matrices, for each element that matches Condition.
|
static INDArray |
BooleanIndexing.chooseFrom(INDArray[] input,
Condition condition)
Choose from the inputs based on the given condition.
|
static INDArray |
BooleanIndexing.chooseFrom(INDArray[] input,
List<Double> tArgs,
List<Integer> iArgs,
Condition condition)
Choose from the inputs based on the given condition.
|
static INDArrayIndex[] |
NDArrayIndex.create(INDArray index)
Create from a matrix.
|
static INDArrayIndex[] |
Indices.createFromStartAndEnd(INDArray start,
INDArray end)
Create an n dimensional index
based on the given interval indices.
|
static INDArrayIndex[] |
Indices.createFromStartAndEnd(INDArray start,
INDArray end,
boolean inclusive)
Create indices representing intervals
along each dimension
|
static INDArray |
BooleanIndexing.firstIndex(INDArray array,
Condition condition)
This method returns first index matching given condition
PLEASE NOTE: This method will return -1 value if condition wasn't met
|
static INDArray |
BooleanIndexing.firstIndex(INDArray array,
Condition condition,
int... dimension)
This method returns first index matching given condition along given dimensions
PLEASE NOTE: This method will return -1 values for missing conditions
|
void |
NDArrayIndexEmpty.init(INDArray arr,
int dimension) |
void |
INDArrayIndex.init(INDArray arr,
int dimension)
Init the index wrt
the dimension and the given nd array
|
void |
SpecifiedIndex.init(INDArray arr,
int dimension) |
void |
PointIndex.init(INDArray arr,
int dimension) |
void |
NewAxis.init(INDArray arr,
int dimension) |
void |
IntervalIndex.init(INDArray arr,
int dimension) |
void |
NDArrayIndex.init(INDArray arr,
int dimension) |
void |
NDArrayIndexEmpty.init(INDArray arr,
long begin,
int dimension) |
void |
INDArrayIndex.init(INDArray arr,
long begin,
int dimension)
Init the index wrt
the dimension and the given nd array
|
void |
SpecifiedIndex.init(INDArray arr,
long begin,
int dimension) |
void |
NDArrayIndexAll.init(INDArray arr,
long begin,
int dimension) |
void |
PointIndex.init(INDArray arr,
long begin,
int dimension) |
void |
NewAxis.init(INDArray arr,
long begin,
int dimension) |
void |
IntervalIndex.init(INDArray arr,
long begin,
int dimension) |
void |
NDArrayIndex.init(INDArray arr,
long begin,
int dimension) |
static boolean |
Indices.isScalar(INDArray indexOver,
INDArrayIndex... indexes)
Check if the given indexes
over the specified array
are searching for a scalar
|
static INDArray |
BooleanIndexing.lastIndex(INDArray array,
Condition condition)
This method returns last index matching given condition
PLEASE NOTE: This method will return -1 value if condition wasn't met
|
static INDArray |
BooleanIndexing.lastIndex(INDArray array,
Condition condition,
int... dimension)
This method returns first index matching given condition along given dimensions
PLEASE NOTE: This method will return -1 values for missing conditions
|
static long |
Indices.linearOffset(int index,
INDArray arr)
Compute the linear offset
for an index in an ndarray.
|
static long |
NDArrayIndex.offset(INDArray arr,
INDArrayIndex... indices)
Compute the offset given an array of offsets.
|
static int |
NDArrayIndex.offset(INDArray arr,
int... offsets)
Compute the offset given an array of offsets.
|
static boolean |
BooleanIndexing.or(INDArray n,
Condition cond)
Or over the whole ndarray given some condition
|
static boolean[] |
BooleanIndexing.or(INDArray n,
Condition condition,
int... dimension)
Or over the whole ndarray given some condition, with respect to dimensions
|
static void |
BooleanIndexing.replaceWhere(INDArray to,
INDArray from,
Condition condition)
This method does element-wise comparison for 2 equal-sized matrices, for each element that matches Condition
|
static void |
BooleanIndexing.replaceWhere(INDArray to,
Number set,
Condition condition)
This method does element-wise assessing for 2 equal-sized matrices, for each element that matches Condition
|
static INDArrayIndex[] |
NDArrayIndex.resolve(INDArray arr,
INDArrayIndex... intendedIndexes)
Given an all index and
the intended indexes, return an
index array containing a combination of all elements
for slicing and overriding particular indexes where necessary
|
static int |
Indices.rowNumber(int index,
INDArray arr)
Compute the linear offset
for an index in an ndarray.
|
static int[] |
Indices.stride(INDArray arr,
INDArrayIndex[] indexes,
int... shape)
Return the stride to be used for indexing
|
static void |
NDArrayIndex.updateForNewAxes(INDArray arr,
INDArrayIndex... indexes)
Set the shape and stride for
new axes based dimensions
|
Constructor and Description |
---|
ShapeOffsetResolution(INDArray arr)
Specify the array to use for resolution
|
Modifier and Type | Method and Description |
---|---|
static INDArray |
InvertMatrix.invert(INDArray arr,
boolean inPlace)
Inverts a matrix
|
Modifier and Type | Method and Description |
---|---|
static INDArray |
InvertMatrix.invert(INDArray arr,
boolean inPlace)
Inverts a matrix
|
Modifier and Type | Field and Description |
---|---|
INDArray |
AdaGradUpdater.historicalGradient |
Modifier and Type | Method and Description |
---|---|
void |
AdaGradUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Gets feature specific learning rates
Adagrad keeps a history of gradients being passed in.
|
void |
NadamUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Calculate the update based on the given gradient
|
void |
AdamUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Calculate the update based on the given gradient
|
void |
GradientUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Modify the gradient to be an update.
|
void |
AdaDeltaUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Get the updated gradient for the given gradient
and also update the state of ada delta.
|
void |
SgdUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch) |
void |
NesterovsUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Get the nesterov update
|
void |
RmsPropUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch) |
void |
AdaMaxUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch)
Calculate the update based on the given gradient
|
void |
NoOpUpdater.applyUpdater(INDArray gradient,
int iteration,
int epoch) |
void |
AdaGradUpdater.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
NadamUpdater.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
AdamUpdater.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
GradientUpdater.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize)
For the internal updater state (if any): set this to use the provided array.
|
void |
AdaDeltaUpdater.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
SgdUpdater.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
NesterovsUpdater.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
RmsPropUpdater.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
AdaMaxUpdater.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
void |
NoOpUpdater.setStateViewArray(INDArray viewArray,
int[] shape,
char order,
boolean initialize) |
Modifier and Type | Method and Description |
---|---|
GradientUpdater |
Sgd.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
Nadam.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
AdaGrad.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
NoOp.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
Adam.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
AdaDelta.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
IUpdater.instantiate(INDArray viewArray,
boolean initializeViewArray)
Create a new gradient updater
|
GradientUpdater |
RmsProp.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
Nesterovs.instantiate(INDArray viewArray,
boolean initializeViewArray) |
GradientUpdater |
AdaMax.instantiate(INDArray viewArray,
boolean initializeViewArray) |
Modifier and Type | Field and Description |
---|---|
INDArray |
AdaGrad.historicalGradient |
Modifier and Type | Method and Description |
---|---|
INDArray |
AdaGrad.getGradient(INDArray gradient,
int iteration)
Gets feature specific learning rates
Adagrad keeps a history of gradients being passed in.
|
INDArray |
AdaGrad.getGradient(INDArray gradient,
int slice,
int[] shape) |
Modifier and Type | Method and Description |
---|---|
INDArray |
AdaGrad.getGradient(INDArray gradient,
int iteration)
Gets feature specific learning rates
Adagrad keeps a history of gradients being passed in.
|
INDArray |
AdaGrad.getGradient(INDArray gradient,
int slice,
int[] shape) |
void |
AdaGrad.setStateViewArray(INDArray viewArray,
int[] gradientShape,
char gradientOrder,
boolean initialize) |
Modifier and Type | Method and Description |
---|---|
INDArray |
ILossFunction.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
Compute the gradient of the loss function with respect to the inputs: dL/dOutput
|
INDArray |
ILossFunction.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
Compute the score (loss function value) for each example individually.
|
Modifier and Type | Method and Description |
---|---|
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
ILossFunction.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average)
Compute both the score (loss function value) and gradient.
|
Modifier and Type | Method and Description |
---|---|
static void |
LossUtil.applyMask(INDArray to,
INDArray mask) |
INDArray |
ILossFunction.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
Compute the gradient of the loss function with respect to the inputs: dL/dOutput
|
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
ILossFunction.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average)
Compute both the score (loss function value) and gradient.
|
double |
ILossFunction.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average)
Compute the score (loss function value) for the given inputs.
|
INDArray |
ILossFunction.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
Compute the score (loss function value) for each example individually.
|
static boolean |
LossUtil.isPerOutputMasking(INDArray to,
INDArray mask) |
Modifier and Type | Field and Description |
---|---|
protected INDArray |
LossL1.weights |
protected INDArray |
LossL2.weights |
Modifier and Type | Method and Description |
---|---|
INDArray |
LossMSE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossHinge.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL1.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSLE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossPoisson.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAPE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossBinaryXENT.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMixtureDensity.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
This method returns the gradient of the cost function with respect to the
output from the previous layer.
|
INDArray |
LossKLD.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMultiLabel.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMCXENT.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossFMeasure.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL2.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossHinge.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL1.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSLE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossPoisson.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAPE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossBinaryXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMixtureDensity.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
This method returns the score for each of the given outputs against the
given set of labels.
|
INDArray |
LossKLD.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMultiLabel.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMCXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossFMeasure.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL2.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossHinge.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL1.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSLE.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossPoisson.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAPE.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMultiLabel.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
protected INDArray |
LossL2.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
Modifier and Type | Method and Description |
---|---|
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossHinge.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossL1.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossMSLE.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossPoisson.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossMAPE.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossBinaryXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossMixtureDensity.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossKLD.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossMultiLabel.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossSquaredHinge.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossMCXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossFMeasure.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossCosineProximity.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossL2.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
Modifier and Type | Method and Description |
---|---|
INDArray |
LossMSE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossHinge.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL1.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSLE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossPoisson.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAPE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossBinaryXENT.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAE.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMixtureDensity.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
This method returns the gradient of the cost function with respect to the
output from the previous layer.
|
INDArray |
LossKLD.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMultiLabel.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMCXENT.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossFMeasure.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL2.computeGradient(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossHinge.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossL1.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossMSLE.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossPoisson.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossMAPE.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossBinaryXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossMixtureDensity.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossKLD.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossMultiLabel.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossSquaredHinge.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossMCXENT.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossFMeasure.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossCosineProximity.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
org.nd4j.linalg.primitives.Pair<Double,INDArray> |
LossL2.computeGradientAndScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMSE.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossHinge.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossL1.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMSLE.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossPoisson.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMAPE.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossBinaryXENT.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMAE.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMixtureDensity.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average)
Computes the aggregate score as a sum of all of the individual scores of
each of the labels against each of the outputs of the network.
|
double |
LossKLD.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMultiLabel.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossSquaredHinge.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossMCXENT.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossFMeasure.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossCosineProximity.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
double |
LossL2.computeScore(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask,
boolean average) |
INDArray |
LossMSE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossHinge.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL1.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSLE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossPoisson.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAPE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossBinaryXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAE.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMixtureDensity.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask)
This method returns the score for each of the given outputs against the
given set of labels.
|
INDArray |
LossKLD.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMultiLabel.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMCXENT.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossFMeasure.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL2.computeScoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
LossMixtureDensity.MixtureDensityComponents |
LossMixtureDensity.extractComponents(INDArray output) |
INDArray |
LossHinge.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossL1.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMSLE.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossPoisson.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMAPE.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossMultiLabel.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossSquaredHinge.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
INDArray |
LossCosineProximity.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
protected INDArray |
LossL2.scoreArray(INDArray labels,
INDArray preOutput,
IActivation activationFn,
INDArray mask) |
Constructor and Description |
---|
LossBinaryXENT(double clipEps,
INDArray weights)
Binary cross entropy where each the output is
(optionally) weighted/scaled by a fixed scalar value.
|
LossBinaryXENT(INDArray weights)
Binary cross entropy where each the output is
(optionally) weighted/scaled by a fixed scalar value.
|
LossL1(INDArray weights)
L1 loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossL2(INDArray weights)
L2 loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossMAE(INDArray weights)
Mean Absolute Error loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossMAPE(INDArray weights)
Mean Absolute Percentage Error loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossMCXENT(double softmaxClipEps,
INDArray weights)
Multi-Class Cross Entropy loss function where each the output is (optionally) weighted/scaled by a fixed scalar value.
|
LossMCXENT(INDArray weights)
Multi-Class Cross Entropy loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossMSE(INDArray weights)
Mean Squared Error loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossMSLE(INDArray weights)
Mean Squared Logarithmic Error loss function where each the output is (optionally) weighted/scaled by a flags scalar value.
|
LossNegativeLogLikelihood(INDArray weights) |
Modifier and Type | Method and Description |
---|---|
INDArray |
RowVectorDeserializer.deserialize(org.nd4j.shade.jackson.core.JsonParser jsonParser,
org.nd4j.shade.jackson.databind.DeserializationContext deserializationContext) |
Modifier and Type | Method and Description |
---|---|
void |
RowVectorSerializer.serialize(INDArray array,
org.nd4j.shade.jackson.core.JsonGenerator jsonGenerator,
org.nd4j.shade.jackson.databind.SerializerProvider serializerProvider) |
Modifier and Type | Method and Description |
---|---|
void |
BasicMemoryManager.collect(INDArray... arrays)
This method detaches off-heap memory from passed INDArray instances, and optionally stores them in cache for future reuse
PLEASE NOTE: Cache options depend on specific implementations
|
void |
MemoryManager.collect(INDArray... arrays)
This method detaches off-heap memory from passed INDArray instances, and optionally stores them in cache for future reuse
PLEASE NOTE: Cache options depend on specific implementations
|
void |
MemoryManager.memset(INDArray array)
This method fills given INDArray with zeroes.
|
Modifier and Type | Field and Description |
---|---|
protected Map<T,INDArray> |
BasicStash.stash |
Modifier and Type | Method and Description |
---|---|
INDArray |
BasicStash.get(T key) |
INDArray |
Stash.get(T key) |
Modifier and Type | Method and Description |
---|---|
void |
BasicStash.put(T key,
INDArray object) |
void |
Stash.put(T key,
INDArray object) |
Modifier and Type | Method and Description |
---|---|
static INDArray |
Transforms.abs(INDArray ndArray)
Abs function
|
static INDArray |
Transforms.abs(INDArray ndArray,
boolean dup)
Abs function
|
static INDArray |
Transforms.acos(INDArray arr) |
static INDArray |
Transforms.acos(INDArray in,
boolean copy) |
static INDArray |
Transforms.allCosineDistances(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.allCosineSimilarities(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.allEuclideanDistances(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.allManhattanDistances(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.and(INDArray x,
INDArray y) |
static INDArray |
Transforms.asin(INDArray arr) |
static INDArray |
Transforms.asin(INDArray in,
boolean copy) |
static INDArray |
Transforms.atan(INDArray arr) |
static INDArray |
Transforms.atan(INDArray in,
boolean copy) |
static INDArray |
Transforms.atan2(INDArray x,
INDArray y)
Atan2 operation, new INDArray instance will be returned
Note the order of x and y parameters is opposite to that of java.lang.Math.atan2
|
static INDArray |
Transforms.atanh(INDArray in)
Sin function
|
static INDArray |
Transforms.atanh(INDArray in,
boolean copy)
Sin function
|
static INDArray |
Transforms.ceil(INDArray arr) |
static INDArray |
Transforms.ceil(INDArray in,
boolean copy) |
static INDArray |
Transforms.ceiling(INDArray ndArray)
Binary matrix of whether the number at a given index is greater than
|
static INDArray |
Transforms.ceiling(INDArray ndArray,
boolean copyOnOps)
Ceiling function
|
static INDArray |
Transforms.cos(INDArray in) |
static INDArray |
Transforms.cos(INDArray in,
boolean copy) |
static INDArray |
Transforms.cosh(INDArray in) |
static INDArray |
Transforms.cosh(INDArray in,
boolean copy) |
static INDArray |
Transforms.elu(INDArray arr) |
static INDArray |
Transforms.elu(INDArray in,
boolean copy) |
static INDArray |
Transforms.eluDerivative(INDArray arr) |
static INDArray |
Transforms.eluDerivative(INDArray in,
boolean copy) |
static INDArray |
Transforms.eps(INDArray ndArray) |
static INDArray |
Transforms.eps(INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.exp(INDArray ndArray)
Run the exp operation
|
static INDArray |
Transforms.exp(INDArray ndArray,
boolean dup)
Exp function
|
static INDArray |
Transforms.expm1(INDArray ndArray,
boolean dup)
Elementwise exponential - 1 function
|
static INDArray |
Transforms.floor(INDArray ndArray)
Binary matrix of whether the number at a given index is greater than
|
static INDArray |
Transforms.floor(INDArray ndArray,
boolean dup)
Floor function
|
static INDArray |
Transforms.greaterThanOrEqual(INDArray first,
INDArray ndArray)
1 if greater than or equal to 0 otherwise (at each element)
|
static INDArray |
Transforms.greaterThanOrEqual(INDArray first,
INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.hardTanh(INDArray ndArray) |
static INDArray |
Transforms.hardTanh(INDArray ndArray,
boolean dup)
Hard tanh
|
static INDArray |
Transforms.hardTanhDerivative(INDArray ndArray) |
static INDArray |
Transforms.hardTanhDerivative(INDArray ndArray,
boolean dup)
Hard tanh
|
static INDArray |
Transforms.identity(INDArray ndArray) |
static INDArray |
Transforms.identity(INDArray ndArray,
boolean dup)
Identity function
|
static INDArray |
Transforms.leakyRelu(INDArray arr) |
static INDArray |
Transforms.leakyRelu(INDArray in,
boolean copy) |
static INDArray |
Transforms.leakyRelu(INDArray arr,
double cutoff) |
static INDArray |
Transforms.leakyRelu(INDArray in,
double cutoff,
boolean copy) |
static INDArray |
Transforms.leakyReluDerivative(INDArray arr,
double cutoff) |
static INDArray |
Transforms.leakyReluDerivative(INDArray in,
double cutoff,
boolean copy) |
static INDArray |
Transforms.lessThanOrEqual(INDArray first,
INDArray ndArray)
1 if less than or equal to 0 otherwise (at each element)
|
static INDArray |
Transforms.lessThanOrEqual(INDArray first,
INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.log(INDArray ndArray) |
static INDArray |
Transforms.log(INDArray ndArray,
boolean dup)
Log function
|
static INDArray |
Transforms.log(INDArray ndArray,
double base)
Log on arbitrary base
|
static INDArray |
Transforms.log(INDArray ndArray,
double base,
boolean duplicate)
Log on arbitrary base
|
static INDArray |
Transforms.log1p(INDArray ndArray,
boolean dup)
Log of x + 1 function
|
static INDArray |
Transforms.max(INDArray ndArray,
double k)
Maximum function with a scalar
|
static INDArray |
Transforms.max(INDArray ndArray,
double k,
boolean dup)
Maximum function with a scalar
|
static INDArray |
Transforms.max(INDArray first,
INDArray second)
Element wise maximum function between 2 INDArrays
|
static INDArray |
Transforms.max(INDArray first,
INDArray second,
boolean dup)
Element wise maximum function between 2 INDArrays
|
static INDArray |
Transforms.min(INDArray ndArray,
double k)
Maximum function with a scalar
|
static INDArray |
Transforms.min(INDArray ndArray,
double k,
boolean dup)
Minimum function with a scalar
|
static INDArray |
Transforms.min(INDArray first,
INDArray second)
Element wise minimum function between 2 INDArrays
|
static INDArray |
Transforms.min(INDArray first,
INDArray second,
boolean dup)
Element wise minimum function between 2 INDArrays
|
static INDArray |
Transforms.mpow(INDArray in,
int n,
boolean dup)
Raises a square matrix to a power n, which can be positive, negative, or zero.
|
static INDArray |
Transforms.neg(INDArray ndArray)
Returns the negative of an ndarray
|
static INDArray |
Transforms.neg(INDArray ndArray,
boolean dup)
Negative
|
static INDArray |
Transforms.normalizeZeroMeanAndUnitVariance(INDArray toNormalize)
Normalize data to zero mean and unit variance
substract by the mean and divide by the standard deviation
|
static INDArray |
Transforms.not(INDArray x) |
static INDArray |
Transforms.or(INDArray x,
INDArray y) |
static INDArray |
Transforms.pow(INDArray ndArray,
INDArray power)
Element-wise power function - x^y, performed element-wise.
|
static INDArray |
Transforms.pow(INDArray ndArray,
INDArray power,
boolean dup)
Element-wise power function - x^y, performed element-wise
|
static INDArray |
Transforms.pow(INDArray ndArray,
Number power)
Pow function
|
static INDArray |
Transforms.pow(INDArray ndArray,
Number power,
boolean dup)
Pow function
|
static INDArray |
Transforms.relu(INDArray arr) |
static INDArray |
Transforms.relu(INDArray in,
boolean copy) |
static INDArray |
Transforms.relu6(INDArray arr) |
static INDArray |
Transforms.relu6(INDArray in,
boolean copy) |
static INDArray |
Transforms.reverse(INDArray x,
boolean dup) |
static INDArray |
Transforms.round(INDArray ndArray)
Rounding function
|
static INDArray |
Transforms.round(INDArray ndArray,
boolean dup)
Rounding function
|
static INDArray |
Transforms.sigmoid(INDArray ndArray)
Sigmoid function
|
static INDArray |
Transforms.sigmoid(INDArray ndArray,
boolean dup)
Sigmoid function
|
static INDArray |
Transforms.sigmoidDerivative(INDArray ndArray)
Sigmoid function
|
static INDArray |
Transforms.sigmoidDerivative(INDArray ndArray,
boolean dup)
Sigmoid function
|
static INDArray |
Transforms.sign(INDArray toSign)
Signum function of this ndarray
|
static INDArray |
Transforms.sign(INDArray toSign,
boolean dup)
Signum function of this ndarray
|
static INDArray |
Transforms.sin(INDArray in)
Sin function
|
static INDArray |
Transforms.sin(INDArray in,
boolean copy)
Sin function
|
static INDArray |
Transforms.sinh(INDArray in)
Sinh function
|
static INDArray |
Transforms.sinh(INDArray in,
boolean copy)
Sinh function
|
static INDArray |
Transforms.softmax(INDArray arr) |
static INDArray |
Transforms.softmax(INDArray in,
boolean copy) |
static INDArray |
Transforms.softPlus(INDArray arr) |
static INDArray |
Transforms.softPlus(INDArray in,
boolean copy) |
static INDArray |
Transforms.softsign(INDArray arr) |
static INDArray |
Transforms.softsign(INDArray in,
boolean copy) |
static INDArray |
Transforms.softsignDerivative(INDArray arr) |
static INDArray |
Transforms.softsignDerivative(INDArray in,
boolean copy) |
static INDArray |
Transforms.sqrt(INDArray ndArray)
Sqrt function
|
static INDArray |
Transforms.sqrt(INDArray ndArray,
boolean dup)
Sqrt function
|
static INDArray |
Transforms.stabilize(INDArray ndArray,
double k) |
static INDArray |
Transforms.stabilize(INDArray ndArray,
double k,
boolean dup)
Stabilize to be within a range of k
|
static INDArray |
Transforms.step(INDArray arr) |
static INDArray |
Transforms.step(INDArray in,
boolean copy) |
static INDArray |
Transforms.tanh(INDArray ndArray)
Tanh function
|
static INDArray |
Transforms.tanh(INDArray ndArray,
boolean dup)
Tanh function
|
static INDArray |
Transforms.unitVec(INDArray toScale)
Scale by 1 / norm2 of the matrix
|
static INDArray |
Transforms.xor(INDArray x,
INDArray y) |
Modifier and Type | Method and Description |
---|---|
static INDArray |
Transforms.abs(INDArray ndArray)
Abs function
|
static INDArray |
Transforms.abs(INDArray ndArray,
boolean dup)
Abs function
|
static INDArray |
Transforms.acos(INDArray arr) |
static INDArray |
Transforms.acos(INDArray in,
boolean copy) |
static INDArray |
Transforms.allCosineDistances(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.allCosineSimilarities(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.allEuclideanDistances(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.allManhattanDistances(INDArray d1,
INDArray d2,
int... dimensions) |
static INDArray |
Transforms.and(INDArray x,
INDArray y) |
static INDArray |
Transforms.asin(INDArray arr) |
static INDArray |
Transforms.asin(INDArray in,
boolean copy) |
static INDArray |
Transforms.atan(INDArray arr) |
static INDArray |
Transforms.atan(INDArray in,
boolean copy) |
static INDArray |
Transforms.atan2(INDArray x,
INDArray y)
Atan2 operation, new INDArray instance will be returned
Note the order of x and y parameters is opposite to that of java.lang.Math.atan2
|
static INDArray |
Transforms.atanh(INDArray in)
Sin function
|
static INDArray |
Transforms.atanh(INDArray in,
boolean copy)
Sin function
|
static INDArray |
Transforms.ceil(INDArray arr) |
static INDArray |
Transforms.ceil(INDArray in,
boolean copy) |
static INDArray |
Transforms.ceiling(INDArray ndArray)
Binary matrix of whether the number at a given index is greater than
|
static INDArray |
Transforms.ceiling(INDArray ndArray,
boolean copyOnOps)
Ceiling function
|
static INDArray |
Transforms.cos(INDArray in) |
static INDArray |
Transforms.cos(INDArray in,
boolean copy) |
static INDArray |
Transforms.cosh(INDArray in) |
static INDArray |
Transforms.cosh(INDArray in,
boolean copy) |
static double |
Transforms.cosineDistance(INDArray d1,
INDArray d2) |
static double |
Transforms.cosineSim(INDArray d1,
INDArray d2)
Cosine similarity
|
static INDArray |
Transforms.elu(INDArray arr) |
static INDArray |
Transforms.elu(INDArray in,
boolean copy) |
static INDArray |
Transforms.eluDerivative(INDArray arr) |
static INDArray |
Transforms.eluDerivative(INDArray in,
boolean copy) |
static INDArray |
Transforms.eps(INDArray ndArray) |
static INDArray |
Transforms.eps(INDArray ndArray,
boolean dup)
Eps function
|
static double |
Transforms.euclideanDistance(INDArray d1,
INDArray d2) |
static INDArray |
Transforms.exp(INDArray ndArray)
Run the exp operation
|
static INDArray |
Transforms.exp(INDArray ndArray,
boolean dup)
Exp function
|
static INDArray |
Transforms.expm1(INDArray ndArray,
boolean dup)
Elementwise exponential - 1 function
|
static INDArray |
Transforms.floor(INDArray ndArray)
Binary matrix of whether the number at a given index is greater than
|
static INDArray |
Transforms.floor(INDArray ndArray,
boolean dup)
Floor function
|
static INDArray |
Transforms.greaterThanOrEqual(INDArray first,
INDArray ndArray)
1 if greater than or equal to 0 otherwise (at each element)
|
static INDArray |
Transforms.greaterThanOrEqual(INDArray first,
INDArray ndArray,
boolean dup)
Eps function
|
static double |
Transforms.hammingDistance(INDArray d1,
INDArray d2) |
static INDArray |
Transforms.hardTanh(INDArray ndArray) |
static INDArray |
Transforms.hardTanh(INDArray ndArray,
boolean dup)
Hard tanh
|
static INDArray |
Transforms.hardTanhDerivative(INDArray ndArray) |
static INDArray |
Transforms.hardTanhDerivative(INDArray ndArray,
boolean dup)
Hard tanh
|
static INDArray |
Transforms.identity(INDArray ndArray) |
static INDArray |
Transforms.identity(INDArray ndArray,
boolean dup)
Identity function
|
static double |
Transforms.jaccardDistance(INDArray d1,
INDArray d2) |
static INDArray |
Transforms.leakyRelu(INDArray arr) |
static INDArray |
Transforms.leakyRelu(INDArray in,
boolean copy) |
static INDArray |
Transforms.leakyRelu(INDArray arr,
double cutoff) |
static INDArray |
Transforms.leakyRelu(INDArray in,
double cutoff,
boolean copy) |
static INDArray |
Transforms.leakyReluDerivative(INDArray arr,
double cutoff) |
static INDArray |
Transforms.leakyReluDerivative(INDArray in,
double cutoff,
boolean copy) |
static INDArray |
Transforms.lessThanOrEqual(INDArray first,
INDArray ndArray)
1 if less than or equal to 0 otherwise (at each element)
|
static INDArray |
Transforms.lessThanOrEqual(INDArray first,
INDArray ndArray,
boolean dup)
Eps function
|
static INDArray |
Transforms.log(INDArray ndArray) |
static INDArray |
Transforms.log(INDArray ndArray,
boolean dup)
Log function
|
static INDArray |
Transforms.log(INDArray ndArray,
double base)
Log on arbitrary base
|
static INDArray |
Transforms.log(INDArray ndArray,
double base,
boolean duplicate)
Log on arbitrary base
|
static INDArray |
Transforms.log1p(INDArray ndArray,
boolean dup)
Log of x + 1 function
|
static double |
Transforms.manhattanDistance(INDArray d1,
INDArray d2) |
static INDArray |
Transforms.max(INDArray ndArray,
double k)
Maximum function with a scalar
|
static INDArray |
Transforms.max(INDArray ndArray,
double k,
boolean dup)
Maximum function with a scalar
|
static INDArray |
Transforms.max(INDArray first,
INDArray second)
Element wise maximum function between 2 INDArrays
|
static INDArray |
Transforms.max(INDArray first,
INDArray second,
boolean dup)
Element wise maximum function between 2 INDArrays
|
static INDArray |
Transforms.min(INDArray ndArray,
double k)
Maximum function with a scalar
|
static INDArray |
Transforms.min(INDArray ndArray,
double k,
boolean dup)
Minimum function with a scalar
|
static INDArray |
Transforms.min(INDArray first,
INDArray second)
Element wise minimum function between 2 INDArrays
|
static INDArray |
Transforms.min(INDArray first,
INDArray second,
boolean dup)
Element wise minimum function between 2 INDArrays
|
static INDArray |
Transforms.mpow(INDArray in,
int n,
boolean dup)
Raises a square matrix to a power n, which can be positive, negative, or zero.
|
static INDArray |
Transforms.neg(INDArray ndArray)
Returns the negative of an ndarray
|
static INDArray |
Transforms.neg(INDArray ndArray,
boolean dup)
Negative
|
static INDArray |
Transforms.normalizeZeroMeanAndUnitVariance(INDArray toNormalize)
Normalize data to zero mean and unit variance
substract by the mean and divide by the standard deviation
|
static INDArray |
Transforms.not(INDArray x) |
static INDArray |
Transforms.or(INDArray x,
INDArray y) |
static INDArray |
Transforms.pow(INDArray ndArray,
INDArray power)
Element-wise power function - x^y, performed element-wise.
|
static INDArray |
Transforms.pow(INDArray ndArray,
INDArray power,
boolean dup)
Element-wise power function - x^y, performed element-wise
|
static INDArray |
Transforms.pow(INDArray ndArray,
Number power)
Pow function
|
static INDArray |
Transforms.pow(INDArray ndArray,
Number power,
boolean dup)
Pow function
|
static INDArray |
Transforms.relu(INDArray arr) |
static INDArray |
Transforms.relu(INDArray in,
boolean copy) |
static INDArray |
Transforms.relu6(INDArray arr) |
static INDArray |
Transforms.relu6(INDArray in,
boolean copy) |
static INDArray |
Transforms.reverse(INDArray x,
boolean dup) |
static INDArray |
Transforms.round(INDArray ndArray)
Rounding function
|
static INDArray |
Transforms.round(INDArray ndArray,
boolean dup)
Rounding function
|
static INDArray |
Transforms.sigmoid(INDArray ndArray)
Sigmoid function
|
static INDArray |
Transforms.sigmoid(INDArray ndArray,
boolean dup)
Sigmoid function
|
static INDArray |
Transforms.sigmoidDerivative(INDArray ndArray)
Sigmoid function
|
static INDArray |
Transforms.sigmoidDerivative(INDArray ndArray,
boolean dup)
Sigmoid function
|
static INDArray |
Transforms.sign(INDArray toSign)
Signum function of this ndarray
|
static INDArray |
Transforms.sign(INDArray toSign,
boolean dup)
Signum function of this ndarray
|
static INDArray |
Transforms.sin(INDArray in)
Sin function
|
static INDArray |
Transforms.sin(INDArray in,
boolean copy)
Sin function
|
static INDArray |
Transforms.sinh(INDArray in)
Sinh function
|
static INDArray |
Transforms.sinh(INDArray in,
boolean copy)
Sinh function
|
static INDArray |
Transforms.softmax(INDArray arr) |
static INDArray |
Transforms.softmax(INDArray in,
boolean copy) |
static INDArray |
Transforms.softPlus(INDArray arr) |
static INDArray |
Transforms.softPlus(INDArray in,
boolean copy) |
static INDArray |
Transforms.softsign(INDArray arr) |
static INDArray |
Transforms.softsign(INDArray in,
boolean copy) |
static INDArray |
Transforms.softsignDerivative(INDArray arr) |
static INDArray |
Transforms.softsignDerivative(INDArray in,
boolean copy) |
static INDArray |
Transforms.sqrt(INDArray ndArray)
Sqrt function
|
static INDArray |
Transforms.sqrt(INDArray ndArray,
boolean dup)
Sqrt function
|
static INDArray |
Transforms.stabilize(INDArray ndArray,
double k) |
static INDArray |
Transforms.stabilize(INDArray ndArray,
double k,
boolean dup)
Stabilize to be within a range of k
|
static INDArray |
Transforms.step(INDArray arr) |
static INDArray |
Transforms.step(INDArray in,
boolean copy) |
static INDArray |
Transforms.tanh(INDArray ndArray)
Tanh function
|
static INDArray |
Transforms.tanh(INDArray ndArray,
boolean dup)
Tanh function
|
static INDArray |
Transforms.unitVec(INDArray toScale)
Scale by 1 / norm2 of the matrix
|
static INDArray |
Transforms.xor(INDArray x,
INDArray y) |
Modifier and Type | Method and Description |
---|---|
void |
OpProfiler.processBlasCall(boolean isGemm,
INDArray... operands) |
OpProfiler.PenaltyCause[] |
OpProfiler.processOperands(INDArray... operands)
This method checks for something somewhere
|
OpProfiler.PenaltyCause[] |
OpProfiler.processOperands(INDArray x,
INDArray y) |
OpProfiler.PenaltyCause[] |
OpProfiler.processOperands(INDArray x,
INDArray y,
INDArray z) |
String |
OpProfiler.processOrders(INDArray... operands) |
Modifier and Type | Method and Description |
---|---|
String |
NDArrayStrings.format(INDArray arr) |
String |
NDArrayStrings.format(INDArray arr,
boolean summarize)
Format the given ndarray as a string
|
Modifier and Type | Method and Description |
---|---|
static INDArray |
NDArrayUtil.toNDArray(int[] nums) |
static INDArray |
NDArrayUtil.toNDArray(int[][] nums) |
static INDArray |
FeatureUtil.toOutcomeMatrix(int[] index,
int numOutcomes)
Creates an out come vector from the specified inputs
|
static INDArray |
FeatureUtil.toOutcomeVector(int index,
int numOutcomes)
Creates an out come vector from the specified inputs
|
Modifier and Type | Method and Description |
---|---|
static void |
LinAlgExceptions.assertColumns(INDArray n,
INDArray n2) |
static void |
LinAlgExceptions.assertMatrix(INDArray... arr) |
static void |
LinAlgExceptions.assertMatrix(INDArray arr) |
static void |
LinAlgExceptions.assertMultiplies(INDArray nd1,
INDArray nd2)
Asserts matrix multiply rules (columns of left == rows of right or rows of left == columns of right)
|
static void |
LinAlgExceptions.assertRows(INDArray n,
INDArray n2) |
static void |
LinAlgExceptions.assertSameLength(INDArray n,
INDArray n2)
Asserts both arrays be the same length
|
static void |
LinAlgExceptions.assertSameShape(INDArray n,
INDArray n2) |
static void |
LinAlgExceptions.assertValidNum(INDArray n) |
static void |
LinAlgExceptions.assertVector(INDArray... arr) |
static void |
LinAlgExceptions.assertVector(INDArray arr) |
void |
DeviceLocalNDArray.broadcast(INDArray array)
This method duplicates array, and stores it to all devices
|
static int |
NDArrayMath.lengthPerSlice(INDArray arr)
Return the length of a slice
|
static int |
NDArrayMath.lengthPerSlice(INDArray arr,
int... dimension)
The number of elements in a slice
along a set of dimensions
|
static int |
NDArrayMath.mapIndexOntoTensor(int index,
INDArray arr,
int... rank)
This maps an index of a vector
on to a vector in the matrix that can be used
for indexing in to a tensor
|
static int |
NDArrayMath.mapIndexOntoVector(int index,
INDArray arr)
This maps an index of a vector
on to a vector in the matrix that can be used
for indexing in to a tensor
|
static int |
NDArrayMath.matricesPerSlice(INDArray arr)
The number of vectors
in each slice of an ndarray.
|
static void |
FeatureUtil.normalizeMatrix(INDArray toNormalize) |
static int |
NDArrayMath.numVectors(INDArray arr)
Return the number of vectors for an array
the number of vectors for an array
|
static int |
NDArrayMath.offsetForSlice(INDArray arr,
int slice)
Compute the offset for a given slice
|
static void |
FeatureUtil.scaleByMax(INDArray toScale)
Divides each row by its max
|
static void |
FeatureUtil.scaleMinMax(double min,
double max,
INDArray toScale)
Scales the ndarray columns
to the given min/max values
|
void |
DataSetUtils.showINDArray(int mtLv,
String itemCode,
INDArray INDA,
int digits,
int r_End_I,
int c_End_I)
showINDArray
public void showINDArray( int mtLv, String itemCode, INDArray INDA, int digits, int r_End_I, int c_End_I ) Shows content of INDArray. Shows first rows and than columns. |
void |
DataSetUtils.showINDArray(int mtLv,
String itemCode,
INDArray INDA,
int digits,
int r_End_I,
int c_End_I,
boolean turned)
showINDArray
public void showINDArray( int mtLv, String itemCode, INDArray INDA, int digits, int r_End_I, int c_End_I, boolean turned ) Shows content of INDArray. If turned is false shows first rows and than columns. If turned is true shows first columns and than rows. |
static int |
NDArrayMath.sliceOffsetForTensor(int index,
INDArray arr,
int[] tensorShape)
calculates the offset for a tensor
|
static int |
NDArrayMath.tensorsPerSlice(INDArray arr,
int[] tensorShape)
Computes the tensors per slice
given a tensor shape and array
|
static int[] |
NDArrayUtil.toInts(INDArray n) |
static int |
NDArrayMath.vectorsPerSlice(INDArray arr)
The number of vectors
in each slice of an ndarray.
|
static int |
NDArrayMath.vectorsPerSlice(INDArray arr,
int... rank)
The number of vectors
in each slice of an ndarray.
|
Constructor and Description |
---|
DeviceLocalNDArray(INDArray array) |
Modifier and Type | Field and Description |
---|---|
protected INDArray |
BaseNDArrayList.container |
Modifier and Type | Method and Description |
---|---|
INDArray |
BaseNDArrayList.array()
Get a view of the underlying array
relative to the size of the actual array.
|
INDArray |
NDArrayList.array()
Get a view of the underlying array
relative to the size of the actual array.
|
Constructor and Description |
---|
BaseNDArrayList(INDArray container)
Specify the underlying ndarray for this list.
|
FloatNDArrayList(INDArray container) |
IntNDArrayList(INDArray container) |
NDArrayList(INDArray container)
Specify the underlying ndarray for this list.
|
Modifier and Type | Method and Description |
---|---|
INDArray |
MatrixBaseNDArrayList.array()
Get a view of the underlying array
relative to the size of the actual array.
|
Modifier and Type | Method and Description |
---|---|
static INDArray |
BinarySerde.readFromDisk(File readFrom)
Read an ndarray from disk
|
static INDArray |
BinarySerde.toArray(ByteBuffer buffer)
Create an ndarray
from the unsafe buffer
|
static INDArray |
BinarySerde.toArray(ByteBuffer buffer,
int offset)
Create an ndarray
from the unsafe buffer
|
Modifier and Type | Method and Description |
---|---|
static org.nd4j.linalg.primitives.Pair<INDArray,ByteBuffer> |
BinarySerde.toArrayAndByteBuffer(ByteBuffer buffer,
int offset)
Create an ndarray and existing bytebuffer
|
Modifier and Type | Method and Description |
---|---|
static int |
BinarySerde.byteBufferSizeFor(INDArray arr)
Returns the byte buffer size for the given
ndarray.
|
static void |
BinarySerde.doByteBufferPutCompressed(INDArray arr,
ByteBuffer allocated,
boolean rewind)
Setup the given byte buffer
for serialization (note that this is for compressed INDArrays)
4 bytes for rank
4 bytes for data opType
shape information
codec information
data opType
|
static void |
BinarySerde.doByteBufferPutUnCompressed(INDArray arr,
ByteBuffer allocated,
boolean rewind)
Setup the given byte buffer
for serialization (note that this is for uncompressed INDArrays)
4 bytes int for rank
4 bytes for data opType
shape buffer
data buffer
|
static ByteBuffer |
BinarySerde.toByteBuffer(INDArray arr)
Convert an ndarray to an unsafe buffer
for use by aeron
|
static void |
BinarySerde.writeArrayToDisk(INDArray arr,
File toWrite)
Write an ndarray to disk in
binary format
|
static void |
BinarySerde.writeArrayToOutputStream(INDArray arr,
OutputStream outputStream)
Write an array to an output stream.
|
Modifier and Type | Method and Description |
---|---|
INDArray |
BaseWeightInitScheme.create(int[] shape) |
INDArray |
WeightInitScheme.create(int[] shape)
Create the array
|
INDArray |
BaseWeightInitScheme.create(int[] shape,
INDArray paramsView) |
INDArray |
WeightInitScheme.create(int[] shape,
INDArray paramsView)
Create the array
|
abstract INDArray |
BaseWeightInitScheme.doCreate(int[] shape,
INDArray paramsView) |
protected INDArray |
BaseWeightInitScheme.handleParamsView(INDArray outputArray,
INDArray paramView) |
Modifier and Type | Method and Description |
---|---|
INDArray |
BaseWeightInitScheme.create(int[] shape,
INDArray paramsView) |
INDArray |
WeightInitScheme.create(int[] shape,
INDArray paramsView)
Create the array
|
abstract INDArray |
BaseWeightInitScheme.doCreate(int[] shape,
INDArray paramsView) |
protected INDArray |
BaseWeightInitScheme.handleParamsView(INDArray outputArray,
INDArray paramView) |
Modifier and Type | Method and Description |
---|---|
INDArray |
NDArraySupplierInitScheme.create(int[] shape) |
INDArray |
NDArraySupplierInitScheme.create(int[] shape,
INDArray paramsView) |
INDArray |
SigmoidUniformInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
ZeroInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
XavierInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
ReluUniformInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
XavierFanInInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalFanInInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
LecunUniformInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
VarScalingUniformFanAvgInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
UniformInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
ConstantInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalUniformFanOutInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalUniformFanInInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
ReluInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
IdentityInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalFanOutInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalFanAvgInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
OneInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
XavierUniformInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
DistributionInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
NDArraySupplierInitScheme.NDArraySupplier.getArr()
An array proxy method.
|
Modifier and Type | Method and Description |
---|---|
INDArray |
NDArraySupplierInitScheme.create(int[] shape,
INDArray paramsView) |
INDArray |
SigmoidUniformInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
ZeroInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
XavierInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
ReluUniformInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
XavierFanInInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalFanInInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
LecunUniformInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
VarScalingUniformFanAvgInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
UniformInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
ConstantInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalUniformFanOutInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalUniformFanInInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
ReluInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
IdentityInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalFanOutInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
VarScalingNormalFanAvgInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
OneInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
XavierUniformInitScheme.doCreate(int[] shape,
INDArray paramsView) |
INDArray |
DistributionInitScheme.doCreate(int[] shape,
INDArray paramsView) |
Copyright © 2018. All rights reserved.