org.nd4j.autodiff.samediff.internal

Class AbstractSession<T,O>

java.lang.Object

org.nd4j.autodiff.samediff.internal.AbstractSession<T,O>

Type Parameters:

T - Node output type - for example, INDArray, shape, etc depending on what we're calculating

O - Op type

Direct Known Subclasses:

DataTypesSession, InferenceSession

public abstract class AbstractSession<T,O>
extends Object

Additional functionality to add: - Workspaces support - Proper cache support

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	AbstractSession.FrameIter
static class	AbstractSession.VarId

Field Summary

Fields

Modifier and Type	Field and Description
protected Queue<AbstractSession.VarId>	availableForExec
protected Set<AbstractSession.VarId>	availableForExecSet
protected Map<String,Set<String>>	execConstInputs Contains the set set of constant and placeholders inputs Essentially the same as the execInputs map, but the constants and placeholders are used for calculating all instances of a variable - i.e., the input (constant/placeholder) applies to all frames and iterations.
protected Map<AbstractSession.VarId,Set<AbstractSession.VarId>>	execInputs Stores what variables are required to calculate the specific variable.
protected Map<AbstractSession.VarId,Set<AbstractSession.VarId>>	execInputsAllIter As per execInputs map - with the different that the iteration number should be ignored (i.e., always 0) Reason: Enter nodes - these are executed once Example: EnterOp(x) -> LoopCondition(less(x,y)): less op requires "X" on all iterations which is the output of the enter op, which is only executed for iteration 0 in a frame.
protected Map<String,AbstractSession.FrameIter>	frameParents Map for exit ops.
protected Map<AbstractSession.VarId,T>	nodeOutputs
static String	OUTER_FRAME
protected SameDiff	sameDiff
protected Set<String>	subgraph Contains variables we *might* need to execute in process of getting outputs we want.
protected Map<AbstractSession.VarId,List<T>>	tensorArrays

Constructor Summary

Constructors

Constructor and Description
AbstractSession(SameDiff sameDiff)

Method Summary

Modifier and Type	Method and Description
protected void	addToExecInputs(boolean isConstOrPh, AbstractSession.VarId inputVar, AbstractSession.VarId forVariable) This method is used to record that the specified input is required for calculating the specified output.
protected boolean	allInputsAvailable(int execStep, String[] inputsThisOp, AbstractSession.VarId executedVar)
boolean	contains(String variable, String frame, int iteration, AbstractSession.FrameIter parentFrameIter)
T	get(String variable, String frame, int iteration, AbstractSession.FrameIter parentFrameIter) Get a previously calculated output; throws an exception if the output does not exist
T	get(String variable, String frame, int iteration, AbstractSession.FrameIter parentFrameIter, boolean enforceExistence) Get a previously calculated output
abstract O	getAndParameterizeOp(String opName, AbstractSession.FrameIter frameIter, Set<AbstractSession.VarId> inputs, Set<AbstractSession.VarId> allIterInputs, Set<String> constAndPhInputs, Map<String,T> placeholderValues) Get the parameterized op to execute - for example, the op/DifferentialFunction with all inputs set
abstract T	getConstantOrVariable(String variableName) Get the constant or variable output - for example, constant array or constant shape.
abstract T[]	getOutputs(O op, AbstractSession.FrameIter outputFrameIter, Set<AbstractSession.VarId> inputs, Set<AbstractSession.VarId> allIterInputs, Set<String> constAndPhInputs, List<Listener> listeners, At at, MultiDataSet batch) Execute the op - calculate INDArrays, or shape info, etc
protected void	initSubgraph(List<String> variables)
protected static AbstractSession.VarId	lookup(String name, Collection<AbstractSession.VarId> varIds, boolean exceptionOnNotFound)
AbstractSession.VarId	newVarId(String variable, AbstractSession.FrameIter frameIter)
AbstractSession.VarId	newVarId(String variable, String frame, int iteration, AbstractSession.FrameIter parentFrameIter)
Map<String,T>	output(List<String> variables, Map<String,T> placeholderValues, MultiDataSet batch, Collection<String> requiredActivations, boolean training, At at) Deprecated. Use output(List, Map, MultiDataSet, Collection, List, At).
Map<String,T>	output(List<String> variables, Map<String,T> placeholderValues, MultiDataSet batch, Collection<String> requiredActivations, List<Listener> listeners, At at) Get the output of the session - i.e., perform inference/forward pass
protected Map<String,T>	preprocessPlaceholders(Map<String,T> placeholders) Preprocess the placeholder values, if required.
protected void	updateDescendentsForExec(int execStep, AbstractSession.VarId executedVar) This method should be called for a variable once it's array is ready for use.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

OUTER_FRAME

public static final String OUTER_FRAME

See Also:

Constant Field Values

sameDiff

protected final SameDiff sameDiff

nodeOutputs

protected final Map<AbstractSession.VarId,T> nodeOutputs

tensorArrays

protected final Map<AbstractSession.VarId,List<T>> tensorArrays

availableForExec

protected final Queue<AbstractSession.VarId> availableForExec

availableForExecSet

protected final Set<AbstractSession.VarId> availableForExecSet

subgraph

protected final Set<String> subgraph

Contains variables we *might* need to execute in process of getting outputs we want. Variables not in this set are definitely not needed to get the requested output variables, but variables that are in this set may not be executed depending on the graph structure - i.e., switch ops, etc

execInputs

protected final Map<AbstractSession.VarId,Set<AbstractSession.VarId>> execInputs

Stores what variables are required to calculate the specific variable. These inputs could be inputs to an op that calculates the variable's value, or it could be a control dependenci Keys: variable (in specific frame/iteration) to be executed Values: inputs to that node (inc. frame and iteration), unordered - needed for execution of op giving variable

execInputsAllIter

protected final Map<AbstractSession.VarId,Set<AbstractSession.VarId>> execInputsAllIter

As per execInputs map - with the different that the iteration number should be ignored (i.e., always 0) Reason: Enter nodes - these are executed once Example: EnterOp(x) -> LoopCondition(less(x,y)): less op requires "X" on all iterations which is the output of the enter op, which is only executed for iteration 0 in a frame.

execConstInputs

protected final Map<String,Set<String>> execConstInputs

Contains the set set of constant and placeholders inputs Essentially the same as the execInputs map, but the constants and placeholders are used for calculating all instances of a variable - i.e., the input (constant/placeholder) applies to all frames and iterations. Keys: variable (any/all frame/iteration) to be executed Values: constant or placeholder needed for execution of op giving variable

frameParents

protected final Map<String,AbstractSession.FrameIter> frameParents

Map for exit ops. This is used to determine where an exit op should exit to. Values added on enter ops. Note that it's not sufficient to Key: frame name (for enter/exit nodes). Value: parent frame name + iteration

Constructor Detail

AbstractSession

public AbstractSession(@NonNull
                       SameDiff sameDiff)

Method Detail

contains

public boolean contains(String variable,
                        String frame,
                        int iteration,
                        AbstractSession.FrameIter parentFrameIter)

get

public T get(String variable,
             String frame,
             int iteration,
             AbstractSession.FrameIter parentFrameIter)

Get a previously calculated output; throws an exception if the output does not exist

get

public T get(String variable,
             String frame,
             int iteration,
             AbstractSession.FrameIter parentFrameIter,
             boolean enforceExistence)

Get a previously calculated output

Parameters:

enforceExistence - If true: throw an exception if the array does not exist

newVarId

public AbstractSession.VarId newVarId(String variable,
                                      String frame,
                                      int iteration,
                                      AbstractSession.FrameIter parentFrameIter)

newVarId

public AbstractSession.VarId newVarId(String variable,
                                      AbstractSession.FrameIter frameIter)

output

@Deprecated
public Map<String,T> output(@NonNull
                                         List<String> variables,
                                         Map<String,T> placeholderValues,
                                         MultiDataSet batch,
                                         Collection<String> requiredActivations,
                                         boolean training,
                                         At at)

Deprecated. Use output(List, Map, MultiDataSet, Collection, List, At).

Parameters:

training - Uses Operation.TRAINING if true, otherwise Operation.INFERENCE

output

public Map<String,T> output(@NonNull
                            List<String> variables,
                            Map<String,T> placeholderValues,
                            MultiDataSet batch,
                            Collection<String> requiredActivations,
                            List<Listener> listeners,
                            At at)

Get the output of the session - i.e., perform inference/forward pass

Parameters:

variables - Name of the variables we want the arrays/activations for

placeholderValues - The placeholder values (if any).

batch - The batch data, used to call Listener.opExecution

requiredActivations - Additional activations that are required. Won't be outputed, but opExecution will be called. May be null.

Returns:

The specified variable values, optionally in the specified workspace

initSubgraph

protected void initSubgraph(List<String> variables)

updateDescendentsForExec

protected void updateDescendentsForExec(int execStep,
                                        AbstractSession.VarId executedVar)

This method should be called for a variable once it's array is ready for use. For example, post op execution, etc

Parameters:

execStep - Current execution step (mainly for debugging)

executedVar - Variable that was just executed

allInputsAvailable

protected boolean allInputsAvailable(int execStep,
                                     String[] inputsThisOp,
                                     AbstractSession.VarId executedVar)

preprocessPlaceholders

protected Map<String,T> preprocessPlaceholders(Map<String,T> placeholders)

Preprocess the placeholder values, if required. Mainly reserved for casting in the case of InferenceSession

Parameters:

placeholders - Placeholders to preprocess.

Returns:

Preprocessed placeholders

getConstantOrVariable

public abstract T getConstantOrVariable(String variableName)

Get the constant or variable output - for example, constant array or constant shape. Note that both constants and variables (i.e., VariableType.CONSTANT and VariableType.VARIABLE) are the same for all frames and iterations.

Parameters:

variableName - The name of the variable to get the constant for

Returns:

The constant

getAndParameterizeOp

public abstract O getAndParameterizeOp(String opName,
                                       AbstractSession.FrameIter frameIter,
                                       Set<AbstractSession.VarId> inputs,
                                       Set<AbstractSession.VarId> allIterInputs,
                                       Set<String> constAndPhInputs,
                                       Map<String,T> placeholderValues)

Get the parameterized op to execute - for example, the op/DifferentialFunction with all inputs set

Parameters:

opName - Name of the op

frameIter - The frame and iteration of the op outputs

inputs - The inputs to the op (excluding constants/placeholders) - for the specific frame + iteration

allIterInputs - The inputs - those that are not iteration-specific (mainly Enter op vars, which might be used in all iterations but are only executed once on iter 0)

constAndPhInputs - The constant and placeholder inputs - used for all frames/iterations

Returns:

The parameterized op

getOutputs

public abstract T[] getOutputs(O op,
                               AbstractSession.FrameIter outputFrameIter,
                               Set<AbstractSession.VarId> inputs,
                               Set<AbstractSession.VarId> allIterInputs,
                               Set<String> constAndPhInputs,
                               List<Listener> listeners,
                               At at,
                               MultiDataSet batch)

Execute the op - calculate INDArrays, or shape info, etc

Parameters:

op - Operation to exit. This should be parameterized (i.e., all inputs set)

outputFrameIter - The frame and iteration of the outputs

inputs - The specific input arrays for the op

Returns:

The outputs of the op

addToExecInputs

protected void addToExecInputs(boolean isConstOrPh,
                               AbstractSession.VarId inputVar,
                               AbstractSession.VarId forVariable)

This method is used to record that the specified input is required for calculating the specified output. While the graph structure itself provides us with the (input vars) -> op -> (output vars) type structure, it doesn't tell us exactly which array copy (i.e., variable + frame + iteration) to use as which copy of the output variable (variable + frame + iteration).

This method is basically used to store information we need to parameterize ops for execution later

Parameters:

isConstOrPh - If true: inputVar is either a constant or a placeholder

inputVar - Input variable (i.e., the X in (X, ...) -> op -> (forVariable,...))

forVariable - Output variable (i.e., the Y in (inputVar, ...) -> op -> (Y,...))

lookup

protected static AbstractSession.VarId lookup(String name,
                                              Collection<AbstractSession.VarId> varIds,
                                              boolean exceptionOnNotFound)