LDA

LDA model using online Variational Bayes (Hoffman, Blei and Bach, 2010)

Parameters

dim(256): Model dimension
uiter(5): Number of iterations on one block of data
alpha(0.001f): Dirichlet document-topic prior
beta(0.0001f): Dirichlet word-topic prior
exppsi(true): Apply exp(psi(X)) if true, otherwise just use X
LDAeps(1e-9): A safety floor constant

Other key parameters inherited from the learner, datasource and updater:

blockSize: the number of samples processed in a block
power(0.3f): the exponent of the moving average model' = a dmodel + (1-a)*model, a = 1/nblocks^power
npasses(10): number of complete passes over the dataset

Example:

a is a sparse word x document matrix

val (nn, opts) = LDA.learner(a)
opts.what             // prints the available options
opts.uiter=2          // customize options
nn.train              // train the model
nn.modelmat           // get the final model
nn.datamat            // get the other factor (requires opts.putBack=1)

val (nn, opts) = LDA.learnPar(a) // Build a parallel learner
opts.nthreads=2       // number of threads (defaults to number of GPUs)
nn.train              // train the model
nn.modelmat           // get the final model
nn.datamat            // get the other factor

Linear Supertypes

FactorModel, Model, AnyRef, Any

Instance Constructors

new LDA(opts: Opts = new LDA.Options)

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
var alpha: Mat
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
Model
var datasource: DataSource

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

Definition Classes
FactorModel → 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
FactorModel → Model
def evalblockg(amats: Array[Mat], ipass: Int, here: Long): FMat

Definition Classes
Model
def evalfun(sdata: Mat, user: Mat, ipass: Int): FMat

Evaluates model log-likelihood on a held-out batch of the input data.
Evaluates model log-likelihood on a held-out batch of the input data.
sdata
The word x document input data. Has dimension (# words x opts.batchSize), where batchSize is typically much smaller than the total number of documents, so sdata is usually a portion of the full input.
user
An (opts.dim x opts.batchSize) matrix that stores some intermediate/temporary data and gets left- multiplied by modelmats(0) to form sdata.
ipass
Index of the pass over the data (0 = first pass, 1 = second pass, etc.).

Definition Classes
LDA → FactorModel
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

Sets up the modelmats and updatemats arrays and initializes modelmats(0) randomly unless stated otherwise.
Sets up the modelmats and updatemats arrays and initializes modelmats(0) randomly unless stated otherwise.

Definition Classes
LDA → FactorModel → Model
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
var mats: Array[Mat]

Definition Classes
Model
var mm: Mat
def modelmats: Array[Mat]

Definition Classes
Model
def mupdate(sdata: Mat, user: Mat, ipass: Int): Unit

Updates modelmats(0), the topic x word matrix that is ultimately returned as output for the model.
Updates modelmats(0), the topic x word matrix that is ultimately returned as output for the model.
sdata
The word x document input data. Has dimension (# words x opts.batchSize), where batchSize is typically much smaller than the total number of documents, so sdata is usually a portion of the full input.
user
An (opts.dim x opts.batchSize) matrix that stores some intermediate/temporary data and gets left- multiplied by modelmats(0) to form sdata.
ipass
Index of the pass over the data (0 = first pass, 1 = second pass, etc.).

Definition Classes
LDA → FactorModel
def mupdate2(data: Mat, user: Mat, ipass: Int): Unit

Definition Classes
FactorModel
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
LDA → FactorModel → 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
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
var traceMem: Boolean
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
def uupdate(sdata: Mat, user: Mat, ipass: Int): Unit

Updates user according to the variational EM update process in the original (2003) LDA Paper.
Updates user according to the variational EM update process in the original (2003) LDA Paper.
This can be a bit tricky to understand. See Equation 2.2 in Huasha Zhao's PhD from UC Berkeley for details on the math and cross-reference it with the 2003 LDA journal paper.
sdata
The word x document input data. Has dimension (# words x opts.batchSize), where batchSize is typically much smaller than the total number of documents, so sdata is usually a portion of the full input.
user
An (opts.dim x opts.batchSize) matrix that stores some intermediate/temporary data and gets left- multiplied by modelmats(0) to form sdata.
ipass
Index of the pass over the data (0 = first pass, 1 = second pass, etc.).

Definition Classes
LDA → FactorModel
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 LDA extends FactorModel

Instance Constructors

new LDA(opts: Opts = new LDA.Options)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

var _modelmats: Array[Mat]

var alpha: 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 evalfun(sdata: Mat, user: Mat, ipass: Int): FMat

def finalize(): Unit

final def getClass(): Class[_]

var gmats: Array[Mat]

def hashCode(): Int

def init(): Unit

final def isInstanceOf[T0]: Boolean

var mats: Array[Mat]

var mm: Mat

def modelmats: Array[Mat]

def mupdate(sdata: Mat, user: Mat, ipass: Int): Unit

def mupdate2(data: Mat, user: Mat, ipass: Int): Unit

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

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

def toString(): String

var traceMem: Boolean

def updatePass(ipass: Int): Unit

var updatemats: Array[Mat]

var useDouble: Boolean

var useGPU: Boolean

def uupdate(sdata: Mat, user: Mat, ipass: Int): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from FactorModel

Inherited from Model

Inherited from AnyRef

Inherited from Any

Ungrouped