Optimizer

abstract def optimize(): Module[T]

Trigger the optimization process

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

var checkSingleton: Boolean

var checkpointPath: Option[String]

var checkpointTrigger: Option[Trigger]

def clone(): AnyRef

var computeThresholdbatchSize: Int

val criterion: Criterion[T]

the criterion used to evaluate the loss of the model given an input

val dataset: DataSet[D]

the data set used to train a model

var dropPercentage: Double

var endWhen: Trigger

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def getCheckpointPath(): Option[String]

Get the directory of saving checkpoint

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

var isOverWrite: Boolean

var maxDropPercentage: Double

var model: Module[T]

the model to be trained

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

var optimMethod: OptimMethod[T]

def overWriteCheckpoint(): Optimizer.this.type

Enable overwrite saving checkpoint

def prepareInput(): Unit

def setCheckpoint(path: String, trigger: Trigger): Optimizer.this.type

Set a check point saved at path triggered by trigger

def setDropMoudleProperty(dropPercentage: Double, maxDropPercentage: Double, batchsize: Int = 100, warmupIteration: Int = 200): Optimizer.this.type

Set dropping a certain percentage (dropPercentage) of models during distributed training to accelerate, because some cached model may take too long.

def setEndWhen(endWhen: Trigger): Optimizer.this.type

When to stop, passed in a Trigger

def setModel(newModel: Module[T]): Optimizer.this.type

Set a model to the optimizer

def setOptimMethod(method: OptimMethod[T]): Optimizer.this.type

Set an optimization method

def setState(state: Table): Optimizer.this.type

Set a state(learning rate, epochs...) to the optimizer

def setTrainSummary(trainSummary: TrainSummary): Optimizer.this.type

Enable train summary.

def setValidation(trigger: Trigger, sampleRDD: RDD[Sample[T]], vMethods: Array[ValidationMethod[T]], batchSize: Int): Optimizer.this.type

Set a validate evaluation

def setValidation(trigger: Trigger, dataset: DataSet[MiniBatch[T]], vMethods: Array[ValidationMethod[T]]): Optimizer.this.type

Set a validate evaluation

def setValidationSummary(validationSummary: ValidationSummary): Optimizer.this.type

Enable validation summary.

var state: Table

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

def toString(): String

var trainSummary: Option[TrainSummary]

var validationDataSet: Option[DataSet[MiniBatch[T]]]

var validationMethods: Option[Array[ValidationMethod[T]]]

var validationSummary: Option[ValidationSummary]

var validationTrigger: Option[Trigger]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

var warmupIterationNum: Int

def disableCheckSingleton(): Optimizer.this.type

make optimizer not check the singleton model on a node