Model

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

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

final def asInstanceOf[T0]: T0

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

var backwardTime: Long

def build(calcInputShape: Shape): Shape

def canEqual(other: Any): Boolean

final def checkEngineType(): Model.this.type

def clearGradientClipping(): Unit

Clear gradient clipping parameters.

def clearState(): Model.this.type

final def clone(deepCopy: Boolean): AbstractModule[Activity, Activity, T]

def clone(): AnyRef

final def cloneModule(): AbstractModule[Activity, Activity, T]

def compile(optimizer: OptimMethod[T], loss: (Variable[T], Variable[T]) ⇒ Variable[T])(implicit ev: TensorNumeric[T]): Unit

def compile(optimizer: OptimMethod[T], loss: (Variable[T], Variable[T]) ⇒ Variable[T], metrics: List[ValidationMethod[T]])(implicit ev: TensorNumeric[T]): Unit

def compile(optimizer: String, loss: String)(implicit ev: TensorNumeric[T]): Unit

def compile(optimizer: String, loss: String, metrics: List[String])(implicit ev: TensorNumeric[T]): Unit

Alternatively, one can pass in the corresponding Keras-Style string representations when calling compile.

def compile(optimizer: OptimMethod[T], loss: Criterion[T], metrics: List[ValidationMethod[T]] = null)(implicit ev: TensorNumeric[T]): Unit

Configure the learning process.

def computeOutputShape(inputShape: Shape): Shape

def doBuild(inputShape: Shape): StaticGraph[T]

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def evaluate(x: LocalDataSet[MiniBatch[T]])(implicit ev: TensorNumeric[T]): Array[(ValidationResult, ValidationMethod[T])]

Evaluate a model in local mode.

def evaluate(x: RDD[Sample[T]], batchSize: Int)(implicit ev: TensorNumeric[T]): Array[(ValidationResult, ValidationMethod[T])]

Evaluate a model on a given dataset.

final def evaluate(): Model.this.type

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

final def evaluate(dataset: RDD[Sample[T]], vMethods: Array[_ <: ValidationMethod[T]], batchSize: Option[Int]): Array[(ValidationResult, ValidationMethod[T])]

final def evaluateImage(imageFrame: ImageFrame, vMethods: Array[_ <: ValidationMethod[T]], batchSize: Option[Int]): Array[(ValidationResult, ValidationMethod[T])]

def finalize(): Unit

def findModules(moduleType: String): ArrayBuffer[AbstractModule[_, _, T]]

def fit(x: ImageSet, batchSize: Int, nbEpoch: Int)(implicit ev: TensorNumeric[T]): Unit

def fit(x: ImageSet, batchSize: Int, nbEpoch: Int, validationData: ImageSet)(implicit ev: TensorNumeric[T]): Unit

def fit(x: RDD[Sample[T]], batchSize: Int = 32, nbEpoch: Int = 10, validationData: RDD[Sample[T]] = null)(implicit ev: TensorNumeric[T]): Unit

Train a model for a fixed number of epochs on a dataset.

def fit[D](x: DataSet[D], nbEpoch: Int)(implicit arg0: ClassTag[D], ev: TensorNumeric[T]): Unit

def fit[D](x: DataSet[D], nbEpoch: Int, validationData: DataSet[MiniBatch[T]])(implicit arg0: ClassTag[D], ev: TensorNumeric[T]): Unit

Train a model for a fixed number of epochs on a dataset.

final def forward(input: Activity): Activity

var forwardTime: Long

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

def freezeUpTo(names: String*): Model.this.type

Freeze the model from the bottom up to the layers specified by names (inclusive).

def from[T](vars: Variable[T]*)(implicit arg0: ClassTag[T], ev: TensorNumeric[T]): Variable[T]

Build graph: some other modules point to current module

final def getClass(): Class[_]

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

final def getInputShape(): Shape

final def getName(): String

final def getNumericType(): TensorDataType

final def getOutputShape(): Shape

def getParametersTable(): Table

final def getPrintName(): String

final def getScaleB(): Double

final def getScaleW(): Double

def getSubModules(): List[AbstractModule[Activity, Activity, T]]

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

final def getTimesGroupByModuleType(): Array[(String, Long, Long)]

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

var gradInput: Activity

final def hasName: Boolean

def hashCode(): Int

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

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

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

def isBuilt(): Boolean

def isFrozen[T]()(implicit arg0: ClassTag[T]): Boolean

final def isInstanceOf[T0]: Boolean

def isKerasStyle(): Boolean

final def isTraining(): Boolean

def labor: AbstractModule[Activity, Activity, T]

def labor_=(value: AbstractModule[Activity, Activity, T]): Unit

var line: String

final def loadModelWeights(srcModel: Module[Float], matchAll: Boolean): Model.this.type

final def loadWeights(weightPath: String, matchAll: Boolean): Model.this.type

val modules: ArrayBuffer[AbstractModule[Activity, Activity, T]]

final def ne(arg0: AnyRef): Boolean

def newGraph(outputs: Seq[String]): Model[T]

Specify a seq of nodes as output and return a new graph using the existing nodes

def newGraph(output: String): Model[T]

Specify a node as output and return a new graph using the existing nodes

def node(name: String): ModuleNode[T]

Return the node in the graph as specified by the name

def nodes(names: Seq[String]): Seq[ModuleNode[T]]

Return the nodes in the graph as specified by the names

final def notify(): Unit

final def notifyAll(): Unit

var output: Activity

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

def predict(x: LocalDataSet[MiniBatch[T]], batchSize: Int)(implicit ev: TensorNumeric[T]): Array[Activity]

Use a model to do prediction in local mode.

def predict(x: RDD[Sample[T]], batchSize: Int)(implicit ev: TensorNumeric[T]): RDD[Activity]

Use a model to do prediction.

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

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

def predictClasses(x: RDD[Sample[T]], batchSize: Int = 32, zeroBasedLabel: Boolean = true): RDD[Int]

Use a model to predict for classes.

final def predictImage(imageFrame: ImageFrame, outputLayer: String, shareBuffer: Boolean, batchPerPartition: Int, predictKey: String, featurePaddingParam: Option[PaddingParam[T]]): ImageFrame

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

def processInputs(nodes: Seq[ModuleNode[T]]): ModuleNode[T]

final def quantize(): Module[T]

def release(): Unit

def reset(): Unit

def resetTimes(): Unit

final def saveCaffe(prototxtPath: String, modelPath: String, useV2: Boolean, overwrite: Boolean): Model.this.type

final def saveDefinition(path: String, overWrite: Boolean): Model.this.type

def saveGraphTopology(logPath: String, backward: Boolean = false): Model.this.type

Save the current model graph to a folder, which can be displayed in TensorBoard by running the command: tensorboard --logdir logPath

final def saveModule(path: String, weightPath: String, overWrite: Boolean): Model.this.type

final def saveTF(inputs: Seq[(String, Seq[Int])], path: String, byteOrder: ByteOrder, dataFormat: TensorflowDataFormat): Model.this.type

final def saveTorch(path: String, overWrite: Boolean): Model.this.type

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

var scaleB: Double

var scaleW: Double

def setCheckpoint(path: String, overWrite: Boolean = true): Unit

Configure checkpoint settings to write snapshots every epoch during the training process.

def setConstantGradientClipping(min: Float, max: Float): Unit

Set constant gradient clipping during the training process.

final def setExtraParameter(extraParam: Array[Tensor[T]]): Model.this.type

def setGradientClippingByL2Norm(clipNorm: Float): Unit

Clip gradient to a maximum L2-Norm during the training process.

final def setLine(line: String): Model.this.type

final def setName(name: String): Model.this.type

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

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

def setTensorBoard(logDir: String, appName: String): Unit

Set summary information during the training process for visualization purposes.

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

def summary(lineLength: Int = 120, positions: Array[Double] = Array(.33, .55, .67, 1)): Unit

Print out the summary information of an Analytics Zoo Keras Model.

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

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

def toKeras(): Model[T]

def toModel(): Model[T]

def toString(): String

var train: Boolean

final def training(): Model.this.type

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

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

def updateOutput(input: Activity): Activity

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zeroGradParameters(): Unit

final def save(path: String, overWrite: Boolean): Model.this.type