LSTM

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def accGradParameters(input: Table, gradOutput: Table): Unit

Computing the gradient of the module with respect to its own parameters.

def addTimes(other: Cell[T]): Unit

def apply(name: String): Option[AbstractModule[Activity, Activity, T]]

Find a module with given name.

final def asInstanceOf[T0]: T0

var bRegularizer: Regularizer[T]

def backward(input: Table, gradOutput: Table): Table

Performs a back-propagation step through the module, with respect to the given input.

var backwardTime: Long

var backwardTimes: Array[Long]

def buildGates()(input1: ModuleNode[T], input2: ModuleNode[T]): (ModuleNode[T], ModuleNode[T], ModuleNode[T], ModuleNode[T])

def buildLSTM(): Graph[T]

def buildModel(): Sequential[T]

def canEqual(other: Any): Boolean

var cell: AbstractModule[Activity, Activity, T]

Any recurrent kernels should have a cell member variable which represents the module in the kernel.

var cellLayer: Sequential[T]

def checkEngineType(): LSTM.this.type

get execution engine type

def clearState(): LSTM.this.type

Clear cached activities to save storage space or network bandwidth.

def clone(): AnyRef

def cloneModule(): AbstractModule[Table, Table, T]

def copyStatus(src: Module[T]): LSTM.this.type

Copy the useful running status from src to this.

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def evaluate(dataSet: LocalDataSet[MiniBatch[T]], vMethods: Array[ValidationMethod[T]]): Array[(ValidationResult, ValidationMethod[T])]

def evaluate(dataset: RDD[Sample[T]], vMethods: Array[ValidationMethod[T]], batchSize: Option[Int] = None): Array[(ValidationResult, ValidationMethod[T])]

use ValidationMethod to evaluate module

def evaluate(): LSTM.this.type

def finalize(): Unit

final def forward(input: Table): Table

Takes an input object, and computes the corresponding output of the module.

var forwardTime: Long

var forwardTimes: Array[Long]

def freeze(names: String*): LSTM.this.type

freeze the module, i.e.

var gates: Sequential[T]

final def getClass(): Class[_]

def getName(): String

Get the module name, default name is className@namePostfix

def getNamePostfix: String

def getNumericType(): TensorDataType

def getParameters(): (Tensor[T], Tensor[T])

This method compact all parameters and gradients of the model into two tensors.

def getParametersTable(): Table

This function returns a table contains ModuleName, the parameter names and parameter value in this module.

def getPrintName(): String

def getScaleB(): Double

Get the scale of gradientBias

def getScaleW(): Double

Get the scale of gradientWeight

def getTimes(): Array[(AbstractModule[_ <: Activity, _ <: Activity, T], Long, Long)]

def getWeightsBias(): Array[Tensor[T]]

Get weight and bias for the module

var gradInput: Table

The cached gradient of activities.

def hasName: Boolean

def hashCode(): Int

def hidResize(hidden: Activity, batchSize: Int, stepShape: Array[Int]): Activity

resize the hidden parameters wrt the batch size, hiddens shapes.

val hiddenSize: Int

Hidden unit size in the LSTM

def hiddenSizeOfPreTopo: Int

val hiddensShape: Array[Int]

represents the shape of hiddens which would be transferred to the next recurrent time step.

val inputSize: Int

the size of each input vector

def inputs(first: (ModuleNode[T], Int), nodesWithIndex: (ModuleNode[T], Int)*): ModuleNode[T]

Build graph: some other modules point to current module

def inputs(nodes: ModuleNode[T]*): ModuleNode[T]

Build graph: some other modules point to current module

final def isInstanceOf[T0]: Boolean

final def isTraining(): Boolean

var line: String

def loadModelWeights(srcModel: Module[Float], matchAll: Boolean = true): LSTM.this.type

copy weights from another model, mapping by layer name

def loadWeights(weightPath: String, matchAll: Boolean = true): LSTM.this.type

load pretrained weights and bias to current module

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

var output: Table

The cached output.

val p: Double

is used for Dropout probability.

def parameters(): (Array[Tensor[T]], Array[Tensor[T]])

This function returns two arrays.

var preTopology: TensorModule[T]

The preTopology defines operations to pre-process the input when it is not dependent on the time dimension.

def predict(dataset: RDD[Sample[T]], batchSize: Int = 1, shareBuffer: Boolean = false): RDD[Activity]

module predict, return the probability distribution

def predictClass(dataset: RDD[Sample[T]], batchSize: Int = 1): RDD[Int]

module predict, return the predict label

def quantize(): Module[T]

def regluarized(isRegularized: Boolean): Unit

Use this method to set the whether the recurrent cell is regularized

var regularizers: Array[Regularizer[T]]

If the subclass has regularizers, it need to put the regularizers into an array and pass the array into the Cell constructor as an argument.

def reset(): Unit

def resetTimes(): Unit

def saveCaffe(prototxtPath: String, modelPath: String, useV2: Boolean = true, overwrite: Boolean = false): LSTM.this.type

def saveDefinition(path: String, overWrite: Boolean = false): LSTM.this.type

Save this module definition to path.

def saveModule(path: String, overWrite: Boolean = false): LSTM.this.type

Save this module to path with protobuf format

def saveTF(inputs: Seq[(String, Seq[Int])], path: String, byteOrder: ByteOrder = ByteOrder.LITTLE_ENDIAN, dataFormat: TensorflowDataFormat = TensorflowDataFormat.NHWC): LSTM.this.type

def saveTorch(path: String, overWrite: Boolean = false): LSTM.this.type

def saveWeights(path: String, overWrite: Boolean): Unit

save weights and bias to file

var scaleB: Double

var scaleW: Double

The scale of gradient weight and gradient bias before gradParameters being accumulated.

def setLine(line: String): LSTM.this.type

def setName(name: String): LSTM.this.type

Set the module name

def setNamePostfix(namePostfix: String): Unit

def setScaleB(b: Double): LSTM.this.type

Set the scale of gradientBias

def setScaleW(w: Double): LSTM.this.type

Set the scale of gradientWeight

def setWeightsBias(newWeights: Array[Tensor[T]]): LSTM.this.type

Set weight and bias for the module

var subModules: Array[AbstractModule[_ <: Activity, _ <: Activity, T]]

final def synchronized[T0](arg0: ⇒ T0): T0

var times: Array[(AbstractModule[_ <: Activity, _ <: Activity, T], Long, Long)]

def toGraph(startNodes: ModuleNode[T]*): Graph[T]

Generate graph module with start nodes

def toString(): String

var train: Boolean

Module status.

def training(): LSTM.this.type

var uRegularizer: Regularizer[T]

def unFreeze(names: String*): LSTM.this.type

"unfreeze" module, i.e.

def updateGradInput(input: Table, gradOutput: Table): Table

Computing the gradient of the module with respect to its own input.

def updateOutput(input: Table): Table

Computes the output using the current parameter set of the class and input.

def updateParameters(learningRate: T): Unit

var wRegularizer: Regularizer[T]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zeroGradParameters(): Unit

If the module has parameters, this will zero the accumulation of the gradients with respect to these parameters.

def save(path: String, overWrite: Boolean = false): LSTM.this.type

Save this module to path.