NeuralCF

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: Tensor[T], gradOutput: Tensor[T]): Unit

def addModel(model: AbstractModule[Tensor[T], Tensor[T], T]): NeuralCF.this.type

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

final def asInstanceOf[T0]: T0

def backward(input: Tensor[T], gradOutput: Tensor[T]): Tensor[T]

var backwardTime: Long

def build(): NeuralCF.this.type

def buildModel(): AbstractModule[Tensor[T], Tensor[T], T]

Override this method to define a model.

def canEqual(other: Any): Boolean

final def checkEngineType(): NeuralCF.this.type

def clearState(): NeuralCF.this.type

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

def clone(): AnyRef

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

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

final def evaluate(): NeuralCF.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]]

final def forward(input: Tensor[T]): Tensor[T]

var forwardTime: Long

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

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

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

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

var gradInput: Tensor[T]

final def hasName: Boolean

def hashCode(): Int

val hiddenLayers: Array[Int]

Units hiddenLayers for MLP.

val includeMF: Boolean

Whether to include Matrix Factorization.

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]

final def isInstanceOf[T0]: Boolean

final def isTraining(): Boolean

val itemCount: Int

The number of items.

val itemEmbed: Int

Units of item embedding.

var line: String

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

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

val mfEmbed: Int

Units of matrix factorization embedding.

def model: AbstractModule[Tensor[T], Tensor[T], T]

The defined model, either from buildModel() or loaded from file.

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val numClasses: Int

The number of classes.

var output: Tensor[T]

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

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 = 1, zeroBasedLabel: Boolean = true): RDD[Int]

Predict for classes.

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

def predictUserItemPair(featureRdd: RDD[UserItemFeature[T]]): RDD[UserItemPrediction]

Predict for user-item pairs.

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 recommendForItem(featureRdd: RDD[UserItemFeature[T]], maxUsers: Int): RDD[UserItemPrediction]

Recommend a number of users for each item given a rdd of user item pair features.

def recommendForUser(featureRdd: RDD[UserItemFeature[T]], maxItems: Int): RDD[UserItemPrediction]

Recommend a number of items for each user given a rdd of user item pair features.

def release(): Unit

def reset(): Unit

def resetTimes(): Unit

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

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

def saveModel(path: String, weightPath: String = null, overWrite: Boolean = false): NeuralCF.this.type

Save the model to the specified path.

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

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

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

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

var scaleB: Double

var scaleW: Double

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

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

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

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

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

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

def summary(): Unit

Print out the summary of the model.

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

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

def toString(): String

var train: Boolean

final def training(): NeuralCF.this.type

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

def updateGradInput(input: Tensor[T], gradOutput: Tensor[T]): Tensor[T]

def updateOutput(input: Tensor[T]): Tensor[T]

val userCount: Int

The number of users.

val userEmbed: Int

Units of user embedding.

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): NeuralCF.this.type