FM - BIDMach.models.FM

Factorization Machine Model. This class computes a factorization machine model a la

Steffen Rendle (2012): Factorization Machines with libFM, in ACM Trans. Intell. Syst. Technol., 3(3), May.

We depart slightly from the original FM formulation by including both positive definite and negative definite factors. While the positive definite factor can approximate any matrix in the limit, using both positive and negative definite factors should give better performance for a fixed number of factors. This is what we observed on several datasets. With both positive definite and negative definite factors, there should also be no need to remove diagonal terms, since the positive and negative factorizations already form a conventional eigendecomposition (a best least-squares fit for a given number of factors) of the matrix of second-order interactions.

The types of model are given by the values of opts.links (IMat) and are the same as for GLM models. They are:

0 = linear model (squared loss)
1 = logistic model (logistic loss)
2 = absolute logistic (hinge loss on logistic prediction)
3 = SVM model (hinge loss)

Options are:

links: an IMat whose nrows should equal the number of targets. Values as above. Can be different for different targets.
iweight: an FMat typically used to select a weight row from the input. i.e. iweight = 0,1,0,0,0 uses the second row of input data as weights to be applied to input samples. The iweight field should be 0 in mask.
dim1: Dimension of the positive definite factor
dim2: Dimension of the negative definite factor
strictFM: the exact FM model zeros the diagonal terms of the factorization. As mentioned above, this probably isn't needed in our version of the model, but its available.

Inherited from Regression Model:

rmask: FMat, optional, 0-1-valued. Used to ignore certain input rows (which are targets or weights). Zero value in an element will ignore the corresponding row.
targets: FMat, optional, 0-1-valued. ntargs x nfeats. Used to specify which input features corresponding to targets.
targmap: FMat, optional, 0-1-valued. nntargs x ntargs. Used to replicate actual targets, e.g. to train multiple models (usually with different parameters) for the same target.

Some convenience functions for training:

val (mm, opts) = FM.learner(a, d)     // On an input matrix a including targets (set opts.targets to specify them),
                                      // learns an FM model of type d.
                                      // returns the model (nn) and the options class (opts).
val (mm, opts) = FM.learner(a, c, d)  // On an input matrix a and target matrix c, learns an FM model of type d.
                                      // returns the model (nn) and the options class (opts).
val (nn, nopts) = FM.predictor(model, ta, pc, d) // constructs a prediction learner from an existing model. returns the learner and options.
                                      // pc should be the same dims as the test label matrix, and will contain results after nn.predict
val (mm, mopts, nn, nopts) = FM.learner(a, c, ta, pc, d) // a = training data, c = training labels, ta = test data, pc = prediction matrix, d = type.
                                      // returns a training learner mm, with options mopts. Also returns a prediction model nn with its own options.
                                      // typically set options, then do mm.train; nn.predict with results in pc.
val (mm, opts) = learner(ds)          // Build a learner for a general datasource ds (e.g. a files data source).

Linear Supertypes

RegressionModel, Model, AnyRef, Any

Instance Constructors

new FM(opts: Opts)

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
var _modelmats: Array[Mat]

Definition Classes
Model
final def asInstanceOf[T0]: T0

Definition Classes
Any
def bind(ds: DataSource): Unit

Definition Classes
Model
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def copyMats(from: Array[Mat], to: Array[Mat]): Unit

Definition Classes
Model
def copyTo(mod: Model): Unit

Definition Classes
FM → RegressionModel → Model
var datasource: DataSource

Definition Classes
Model
def doblock(gmats: Array[Mat], ipass: Int, i: Long): Unit

Definition Classes
RegressionModel → Model
def doblockg(amats: Array[Mat], ipass: Int, here: Long): Unit

Definition Classes
Model
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def evalblock(mats: Array[Mat], ipass: Int, here: Long): FMat

Definition Classes
RegressionModel → Model
def evalblockg(amats: Array[Mat], ipass: Int, here: Long): FMat

Definition Classes
Model
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
var gmats: Array[Mat]

Definition Classes
Model
def hashCode(): Int

Definition Classes
AnyRef → Any
def init(): Unit

Definition Classes
FM → RegressionModel → Model
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
var iweight: Mat
val linkArray: Array[GLMlink]
var llim: Mat
var mask: Mat

Definition Classes
RegressionModel
var mats: Array[Mat]

Definition Classes
Model
def meval(in: Mat): FMat

Definition Classes
FM → RegressionModel
def meval2(in: Mat, targ: Mat): FMat

Definition Classes
FM → RegressionModel
def meval3(in: Mat, targ: Mat, dweights: Mat): FMat
def meval4(in: Mat, targ: Mat, dweights: Mat): FMat
var mm1: Mat
var mm2: Mat
def modelmats: Array[Mat]

Definition Classes
Model
def mupdate(in: Mat): Unit

Definition Classes
FM → RegressionModel
def mupdate2(in: Mat, targ: Mat): Unit

Definition Classes
FM → RegressionModel
def mupdate3(in: Mat, targ: Mat, dweights: Mat): Any
def mupdate4(in: Mat, targ: Mat, dweights: Mat): Any
var mv: Mat
var mylinks: Mat
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val opts: Opts

Definition Classes
RegressionModel → Model
var parent_model: Model

Definition Classes
Model
var putBack: Int

Definition Classes
Model
var refresh: Boolean

Definition Classes
Model
def setmodelmats(a: Array[Mat]): Unit

Definition Classes
Model
var sp: Mat

Definition Classes
RegressionModel
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
var targets: Mat

Definition Classes
RegressionModel
var targmap: Mat

Definition Classes
RegressionModel
def toString(): String

Definition Classes
AnyRef → Any
var totflops: Long
var ulim: Mat
var um1: Mat
var um2: Mat
def updatePass(ipass: Int): Unit

Definition Classes
Model
var updatemats: Array[Mat]

Definition Classes
Model
var useDouble: Boolean

Definition Classes
Model
var useGPU: Boolean

Definition Classes
Model
var uv: Mat
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
var xs: Mat

FM

class FM extends RegressionModel

Instance Constructors

new FM(opts: Opts)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

var _modelmats: Array[Mat]

final def asInstanceOf[T0]: T0

def bind(ds: DataSource): Unit

def clone(): AnyRef

def copyMats(from: Array[Mat], to: Array[Mat]): Unit

def copyTo(mod: Model): Unit

var datasource: DataSource

def doblock(gmats: Array[Mat], ipass: Int, i: Long): Unit

def doblockg(amats: Array[Mat], ipass: Int, here: Long): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evalblock(mats: Array[Mat], ipass: Int, here: Long): FMat

def evalblockg(amats: Array[Mat], ipass: Int, here: Long): FMat

def finalize(): Unit

final def getClass(): Class[_]

var gmats: Array[Mat]

def hashCode(): Int

def init(): Unit

final def isInstanceOf[T0]: Boolean

var iweight: Mat

val linkArray: Array[GLMlink]

var llim: Mat

var mask: Mat

var mats: Array[Mat]

def meval(in: Mat): FMat

def meval2(in: Mat, targ: Mat): FMat

def meval3(in: Mat, targ: Mat, dweights: Mat): FMat

def meval4(in: Mat, targ: Mat, dweights: Mat): FMat

var mm1: Mat

var mm2: Mat

def modelmats: Array[Mat]

def mupdate(in: Mat): Unit

def mupdate2(in: Mat, targ: Mat): Unit

def mupdate3(in: Mat, targ: Mat, dweights: Mat): Any

def mupdate4(in: Mat, targ: Mat, dweights: Mat): Any

var mv: Mat

var mylinks: Mat

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val opts: Opts

var parent_model: Model

var putBack: Int

var refresh: Boolean

def setmodelmats(a: Array[Mat]): Unit

var sp: Mat

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

var targets: Mat

var targmap: Mat

def toString(): String

var totflops: Long

var ulim: Mat

var um1: Mat

var um2: Mat

def updatePass(ipass: Int): Unit

var updatemats: Array[Mat]

var useDouble: Boolean

var useGPU: Boolean

var uv: Mat

final def wait(): Unit

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

final def wait(arg0: Long): Unit

var xs: Mat

Inherited from RegressionModel

Inherited from Model

Inherited from AnyRef

Inherited from Any

Ungrouped