GLM

Train a GLM model. The types of model are given by the values of opts.links (IMat). They are:

0 = linear model (squared loss)
1 = logistic model (logistic loss)
2 = hinge 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.

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) = GLM.learner(a, d)    // On an input matrix a including targets (set opts.targets to specify them),
                                      // learns a GLM model of type d.
                                      // returns the model (nn) and the options class (opts).
val (mm, opts) = GLM.learner(a, c, d) // On an input matrix a and target matrix c, learns a GLM model of type d.
                                      // returns the model (nn) and the options class (opts).
val (nn, nopts) = 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) = GLM.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 GLM(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
GLM → 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
var hashFeatures: Boolean
def init(): Unit

Definition Classes
GLM → 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
GLM → RegressionModel
def meval2(in: Mat, targ: Mat): FMat

Definition Classes
GLM → RegressionModel
def meval3(in: Mat, targ: Mat, dweights: Mat): FMat
def modelmats: Array[Mat]

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

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

Definition Classes
GLM → RegressionModel
def mupdate3(in: Mat, targ: Mat, dweights: Mat): Any
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
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
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( ... )

class GLM extends RegressionModel

Instance Constructors

new GLM(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

var hashFeatures: Boolean

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 modelmats: Array[Mat]

def mupdate(in: Mat): Unit

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

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

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

def updatePass(ipass: Int): Unit

var updatemats: Array[Mat]

var useDouble: Boolean

var useGPU: Boolean

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from RegressionModel

Inherited from Model

Inherited from AnyRef

Inherited from Any

Ungrouped