FixedLedger

abstract def apply(in: Array[Int]): OutInfo

Apply this layer (forward computation)

abstract val outVecOf: (OutInfo) ⇒ DataVec

Output converter from OutInfo to Vector *

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

var NIn: Int

Size of input *

var NOut: Int

Size of output *

def apply(in: RDD[(Long, Array[Int])]): RDD[(Long, DataVec)]

Apply RDD of vector.

final def asInstanceOf[T0]: T0

def backprop(seq: ParSeq[((Array[Int], OutInfo), DataVec)]): (ParSeq[DataVec], ParSeq[() ⇒ Unit])

Backward computation

def backward(error: ParSeq[DataVec]): (ParSeq[DataVec], ParSeq[() ⇒ Unit])

Backward computation using propagated error.

var bcModel: Broadcast[LedgerModel]

def broadcast(sc: SparkContext): Unit

Broadcast resources of this layer.

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit val evidenceI: ClassTag[Array[Int]]

ClassTag for input *

def finalize(): Unit

def forward(in: ParSeq[Array[Int]]): ParSeq[DataVec]

Apply Parallel Sequence of vector.

final def forward(in: RDD[(Long, Array[Int])]): RDD[(Long, DataVec)]

Apply RDD of vector.

final def forward(in: Array[Int]): DataVec

Apply this layer (forward computation)

final def getClass(): Class[_]

def hashCode(): Int

def initiateBy(builder: WeightBuilder): FixedLedger.this.type

Set weight builder for this layer.

var inoutSEQ: ParSeq[(Array[Int], OutInfo)]

Sequence for backpropagation.

final def isInstanceOf[T0]: Boolean

var isUpdatable: Boolean

True if this layer affected by backward propagation *

def loss: Double

Weight Loss of this layer

var model: LedgerModel

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pad: DataVec

var padID: Int

def read(kryo: Kryo, input: Input): Unit

def setUpdatable(bool: Boolean): Unit

Assign whether this layer updatable or not.

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

def toString(): String

def unbroadcast(): Unit

Unpersist broadcast of this layer.

def vectorOf(str: Int): DataVec

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withModel(model: LedgerModel): FixedLedger.this.type

def write(kryo: Kryo, output: Output): Unit

def withInput(in: Int): FixedLedger.this.type

Set input size

def withOutput(out: Int): FixedLedger.this.type

Set output size