NeuralNetLike

Implementation trait for all subclasses of neural net. Implements everything that is necessary to perform parameter optimization (feed forward, backpropagation, minimization with non-linear conjugate gradient or similar algorithm).

For those not familiar with the "-Like"-implementation trait pattern: it's main purpose is to ensure that the results of optimization have the right type for all subclasses of neural net (so that one gets an optimized Autoencoder after running the minimization, not just some abstract neural net). For this, it keeps the information about the concrete representation type Repr.

Subclasses that inherit the backpropagation functionality from this implementation trait have to provide a build method, which takes a list of Layers and returns the right flavor of neural net built from those layers.

Self Type: Repr

Linear Supertypes

Visualizable, (Mat) ⇒ Mat, AnyRef, Any

Known Subclasses

Autoencoder, NeuralNet, Rbm

Abstract Value Members

abstract def build(layers: List[Layer]): Repr

Builds a neural net of the right type and of the right shape out of specified layers.
Builds a neural net of the right type and of the right shape out of specified layers.
Note that this method depends on instance, not just a class: fore example the Autoencoder has to know what it's 'central' Layer is.
abstract def layers: List[Layer]

Enumerates layers of this (linear) neural net.
Enumerates layers of this (linear) neural net.
TODO: generalize it to arbitrary directed acyclic graphs, what's so special about lists?...

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

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

Definition Classes
Any
final def ##(): Int

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

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

Definition Classes
Any
def activities(input: Mat): List[Mat]
def andThen[A](g: (Mat) ⇒ A): (Mat) ⇒ A

Definition Classes
Function1
Annotations
@unspecialized()
def apply(input: Mat): Mat

Propagates the input from the visible layer up to the top layer
Propagates the input from the visible layer up to the top layer

Definition Classes
NeuralNetLike → Function1
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def compose[A](g: (A) ⇒ Mat): (A) ⇒ Mat

Definition Classes
Function1
Annotations
@unspecialized()
var dataSample: Option[Mat]
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

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

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def optimize(input: Mat, output: Mat, errorFunctionFactory: DifferentiableErrorFunctionFactory[Mat] = SquareErrorFunctionFactory, relativeValidationSetSize: Double, maxEvals: Int, trainingObservers: List[TrainingObserver]): Repr

Performs optimization of all parameters of the neural network using the specified input and output, the specified method to define an error function (defaults to SquareErrorFunctionFactory).
Performs optimization of all parameters of the neural network using the specified input and output, the specified method to define an error function (defaults to SquareErrorFunctionFactory).
Standard feed-forward algorithm is used for evaluation of the function, backpropagation is used for calculation of the gradient.
def prependAffineLinearTransformation(factor: Mat, offset: Mat): Repr

Assumes that this is a "usual" neural net with alternating unit and connection layers and prepends an affine linear transformation to it.
Assumes that this is a "usual" neural net with alternating unit and connection layers and prepends an affine linear transformation to it.
Why the heck did I implement biased layers at all, why didn't I stuff all this cruft into something like "AffineLinearTransform" or so... Damn
def reverse(output: Mat): Mat

Propagates the output from top layer down to the visible layer
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toImage: BufferedImage

Definition Classes
NeuralNetLike → Visualizable
def toImage(w: Int, h: Int): BufferedImage

Definition Classes
Visualizable
def toImage(colormap: (Double) ⇒ Int): BufferedImage

Definition Classes
Visualizable
def toString(): String

Definition Classes
Function1 → AnyRef → Any
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( ... )

trait NeuralNetLike[+Repr <: NeuralNetLike[Repr]] extends (Mat) ⇒ Mat with Visualizable

Abstract Value Members

abstract def build(layers: List[Layer]): Repr

abstract def layers: List[Layer]

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def activities(input: Mat): List[Mat]

def andThen[A](g: (Mat) ⇒ A): (Mat) ⇒ A

def apply(input: Mat): Mat

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compose[A](g: (A) ⇒ Mat): (A) ⇒ Mat

var dataSample: Option[Mat]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def optimize(input: Mat, output: Mat, errorFunctionFactory: DifferentiableErrorFunctionFactory[Mat] = SquareErrorFunctionFactory, relativeValidationSetSize: Double, maxEvals: Int, trainingObservers: List[TrainingObserver]): Repr

def prependAffineLinearTransformation(factor: Mat, offset: Mat): Repr

def reverse(output: Mat): Mat

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

def toImage: BufferedImage

def toImage(w: Int, h: Int): BufferedImage

def toImage(colormap: (Double) ⇒ Int): BufferedImage

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from Visualizable

Inherited from (Mat) ⇒ Mat

Inherited from AnyRef

Inherited from Any

Ungrouped