AbstractModule

Instance Constructors

new AbstractModule()(implicit arg0: ClassTag[A], arg1: ClassTag[B], arg2: ClassTag[T], ev: TensorNumeric[T])

Abstract Value Members

abstract def updateGradInput(input: A, gradOutput: B): A

Computing the gradient of the module with respect to its own input.
Computing the gradient of the module with respect to its own input. This is returned in gradInput. Also, the gradInput state variable is updated accordingly.
abstract def updateOutput(input: A): B

Computes the output using the current parameter set of the class and input.
Computes the output using the current parameter set of the class and input. This function returns the result which is stored in the output field.

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def accGradParameters(input: A, gradOutput: B, scale: Double = 1.0): Unit

Computing the gradient of the module with respect to its own parameters.
Computing the gradient of the module with respect to its own parameters. Many modules do not perform this step as they do not have any parameters. The state variable name for the parameters is module dependent. The module is expected to accumulate the gradients with respect to the parameters in some variable.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def backward(input: A, gradOutput: B): A

Performs a back-propagation step through the module, with respect to the given input.
Performs a back-propagation step through the module, with respect to the given input. In general this method makes the assumption forward(input) has been called before, with the same input. This is necessary for optimization reasons. If you do not respect this rule, backward() will compute incorrect gradients.
input
input data
gradOutput
gradient of next layer
returns
gradient corresponding to input data
var backwardTime: Long

Attributes
protected
def canEqual(other: Any): Boolean
def checkEngineType(): AbstractModule.this.type

get execution engine type
def clearState(): AbstractModule.this.type

Clear cached activities to save storage space or network bandwidth.
Clear cached activities to save storage space or network bandwidth. Note that we use Tensor.set to keep some information like tensor share
The subclass should override this method if it allocate some extra resource, and call the super.clearState in the override method
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def cloneModule(): AbstractModule[A, B, T]
def copyStatus(src: Module[T]): AbstractModule.this.type

Copy the useful running status from src to this.
Copy the useful running status from src to this.
The subclass should override this method if it has some parameters besides weight and bias. Such as runningMean and runningVar of BatchNormalization.
src
source Module
returns
this
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(other: Any): Boolean

Definition Classes
AbstractModule → AnyRef → Any
def evaluate(): AbstractModule.this.type
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def forward(input: A): B

Takes an input object, and computes the corresponding output of the module.
Takes an input object, and computes the corresponding output of the module. After a forward, the output state variable should have been updated to the new value.
input
input data
returns
output data
var forwardTime: Long

Attributes
protected
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getName(): String

Get the module name, default name is className@namePostfix
def getNumericType(): TensorDataType

returns
Float or Double
def getParameters(): (Tensor[T], Tensor[T])

This method compact all parameters and gradients of the model into two tensors.
This method compact all parameters and gradients of the model into two tensors. So it's easier to use optim method
def getParametersTable(): Table

This function returns a table contains ModuleName, the parameter names and parameter value in this module.
This function returns a table contains ModuleName, the parameter names and parameter value in this module. The result table is a structure of Table(ModuleName -> Table(ParameterName -> ParameterValue)), and the type is Table[String, Table[String, Tensor[T]]].
For example, get the weight of a module named conv1: table[Table]("conv1")[Tensor[T]]("weight").
Custom modules should override this function if they have parameters.
returns
Table
def getTimes(): Array[(AbstractModule[_ <: Activity, _ <: Activity, T], Long, Long)]
var gradInput: A

The cached gradient of activities.
The cached gradient of activities. So we don't compute it again when need it
def hashCode(): Int

Definition Classes
AbstractModule → AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isTraining(): Boolean
var line: String

Attributes
protected
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
var output: B

The cached output.
The cached output. So we don't compute it again when need it
def parameters(): (Array[Tensor[T]], Array[Tensor[T]])

This function returns two arrays.
This function returns two arrays. One for the weights and the other the gradients Custom modules should override this function if they have parameters
returns
(Array of weights, Array of grad)
def predict(dataset: RDD[Sample[T]]): RDD[Activity]

module predict, return the probability distribution
module predict, return the probability distribution
dataset
dataset for prediction
def predictClass(dataset: RDD[Sample[T]]): RDD[Int]

module predict, return the predict label
module predict, return the predict label
dataset
dataset for prediction
def reset(): Unit
def resetTimes(): Unit
def save(path: String, overWrite: Boolean = false): AbstractModule.this.type
def saveTorch(path: String, overWrite: Boolean = false): AbstractModule.this.type
def setLine(line: String): AbstractModule.this.type
def setName(name: String): AbstractModule.this.type

Set the module name
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
var train: Boolean

Module status.
Module status. It is useful for modules like dropout/batch normalization

Attributes
protected
def training(): AbstractModule.this.type
def updateParameters(learningRate: T): Unit
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def zeroGradParameters(): Unit

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

Related Doc: package abstractnn

abstract class AbstractModule[A <: Activity, B <: Activity, T] extends Serializable

Instance Constructors

new AbstractModule()(implicit arg0: ClassTag[A], arg1: ClassTag[B], arg2: ClassTag[T], ev: TensorNumeric[T])

Abstract Value Members

abstract def updateGradInput(input: A, gradOutput: B): A

abstract def updateOutput(input: A): B

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def accGradParameters(input: A, gradOutput: B, scale: Double = 1.0): Unit

final def asInstanceOf[T0]: T0

def backward(input: A, gradOutput: B): A

var backwardTime: Long

def canEqual(other: Any): Boolean

def checkEngineType(): AbstractModule.this.type

def clearState(): AbstractModule.this.type

def clone(): AnyRef

def cloneModule(): AbstractModule[A, B, T]

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

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def evaluate(): AbstractModule.this.type

def finalize(): Unit

final def forward(input: A): B

var forwardTime: Long

final def getClass(): Class[_]

def getName(): String

def getNumericType(): TensorDataType

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

def getParametersTable(): Table

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

var gradInput: A

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def isTraining(): Boolean

var line: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

var output: B

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

def predict(dataset: RDD[Sample[T]]): RDD[Activity]

def predictClass(dataset: RDD[Sample[T]]): RDD[Int]

def reset(): Unit

def resetTimes(): Unit

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

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

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

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

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

def toString(): String

var train: Boolean

def training(): AbstractModule.this.type

def updateParameters(learningRate: T): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zeroGradParameters(): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped