TorchNet

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

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

final def asInstanceOf[T0]: T0

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

var backwardTime: Long

def clearState(): TorchNet.this.type

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

def clone(): AnyRef

final def cloneModule(): TorchNet.this.type

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

implicit val ev: NumericFloat.type

def evaluate(): TorchNet.this.type

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

final def evaluate(dataset: RDD[MiniBatch[Float]], vMethods: Array[_ <: ValidationMethod[Float]]): Array[(ValidationResult, ValidationMethod[Float])]

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

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

def finalize(): Unit

final def forward(input: Activity): Activity

var forwardTime: Long

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

final def getClass(): Class[_]

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

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 getTimes(): Array[(AbstractModule[_ <: Activity, _ <: Activity, Float], Long, Long)]

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

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

var gradInput: Activity

var gradients: Tensor[Float]

final def hasName: Boolean

def hashCode(): Int

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

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

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

final def isInstanceOf[T0]: Boolean

final def isTraining(): Boolean

var line: String

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

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

val logger: Logger

val module: Module[Float]

lazy val nativeRef: Long

sequential id in cpp: std::vector<std::shared_ptr<torch::jit::script::Module>> handles; mark the model as transient and reload TorchNet from byteArray on executors

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

var output: Activity

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

def predict(x: TextSet): TextSet

The default batchPerThread is 4.

def predict(x: TextSet, batchPerThread: Int): TextSet

Use a model to do prediction on TextSet.

def predict(x: ImageSet): ImageSet

The default batchPerThread is 4.

def predict(x: ImageSet, batchPerThread: Int): ImageSet

Use a model to do prediction on ImageSet.

def predict(x: Array[Sample[Float]])(implicit ev: TensorNumeric[Float]): Array[Activity]

Use a model to do prediction in local mode.

def predict(x: Array[Sample[Float]], batchPerThread: Int)(implicit ev: TensorNumeric[Float]): Array[Activity]

Use a model to do prediction in local mode.

def predict(x: LocalDataSet[MiniBatch[Float]])(implicit ev: TensorNumeric[Float]): Array[Activity]

Use a model to do prediction in local mode.

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

Use a model to do prediction in local mode.

def predict(x: RDD[Sample[Float]])(implicit ev: TensorNumeric[Float]): RDD[Activity]

Use a model to do prediction for RDD.

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

Use a model to do prediction for RDD.

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

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

def predictClasses(x: RDD[Sample[Float]], batchPerThread: Int = 4, 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[Float]]): ImageFrame

def predictMiniBatch(x: RDD[MiniBatch[Float]])(implicit ev: TensorNumeric[Float]): RDD[Activity]

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

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

final def quantize(): Module[Float]

def release(): Unit

def reset(): Unit

def resetTimes(): Unit

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

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

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

def savePytorch(path: String, overWrite: Boolean = false): Unit

export the model to path as a torch script module.

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

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

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

var scaleB: Double

var scaleW: Double

final def setExtraParameter(extraParam: Array[Tensor[Float]]): TorchNet.this.type

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

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

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

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

final def setWeightsBias(newWeights: Array[Tensor[Float]]): TorchNet.this.type

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

implicit val tag: ClassTag[Float]

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

def toString(): String

var train: Boolean

def training(): TorchNet.this.type

def unFreeze(names: String*): TorchNet.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

var weights: Tensor[Float]

def zeroGradParameters(): Unit

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