RandomForest

Random Forests. Given a datasource of data and labels, compute a random classification or regression Forest.

* Options

depth(20): Bound on the tree depth, also the number of passes over the dataset.
ntrees(20): Number of trees in the Forest.
nsamps(32): Number of random features to try to split each node.
nnodes(200000): Bound on the size of each tree (number of nodes).
nbits(16): Number of bits to use for feature values.
gain(0.01f): Lower bound on impurity gain in order to split a node.
catsPerSample(1f): Number of cats per sample for multilabel classification.
ncats(0): Number of cats or regression values. 0 means guess from datasource.
training(true): Run for training (true) or prediction (false)
impurity(0): Impurity type, 0=entropy, 1=Gini
regression(false): Build a regression Forest (true) or classification Forest (false).
seed(1): Random seed for selecting features. Use this to train distinct Forests in multiple runs.
useIfeats(false): An internal var, when true use explicit feature indices vs compute them.
MAE(true): true=Use Mean Absolute Error when reporting performance vs. false=Mean Squared Error
trace(0): level of debugging information to print (0,1,2).

NOTE: The algorithm uses a packed representation of the dataset statistics with fixed precision fields. Setting nbits selects how many bits to use from each input data. For integer data, the lower nbits are used. For floating point data, the leading nbits are used. So e.g. 16 float bits gives sign, 8 bits of exponent, and 7 bits of mantissa with a leading 1.

For regression, discrete (integer) target values should be used in the training data. The output will be continuous values interpolated from them.

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

batchSize(10000): The number of samples processed in a block
putBack(-1): Whether to put predictions back into the datasource target. Should be 1 for prediction.
useGPU(true): Use GPU acceleration if available

Example:

a is an nfeats x ninstances data matrix, c is a 1 x ninstances vector of labels

val (nn, opts) = RandomForest.learner(a,c)
opts.what             // prints the available options
opts.depth=25         // Set depth - something like log2(ninstances / 10) is good
opts.ntrees=20        // Good starting value. Increasing this usually increases accuracy.
opts.nsamps=30        // Typically sqrt(nfeats) is good. Larger values may work better.
opts.nnodes           // Bounded by 2^depth, but usually smaller than this.
opts.ncats=10         // Its a good idea to set this - learner will try to guess it, but may get it wrong
opts.nbits=10         // Number of bits to use from input data.
nn.train              // train the learner.
nn.modelmats          // get the final model (4 matrices)

Linear Supertypes

Model, AnyRef, Any

Instance Constructors

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

Type Members

trait imptyType extends AnyRef

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
val ICat: Int
val IFeat: Int
val INode: Int
val ITree: Int
val IVFeat: Int
val JFeat: Int
var _modelmats: Array[Mat]

Definition Classes
Model
def addSVecs(a: Array[SVec], totals: Array[SVTree]): Unit
def addV(ind1: LMat, counts1: IMat, ind2: LMat, counts2: IMat): (LMat, IMat)
final def asInstanceOf[T0]: T0

Definition Classes
Any
var batchSize: Int
def bind(ds: DataSource): Unit

Definition Classes
Model
var blockv: SVec
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
def copycounts(cnts: IMat, tmpc: IMat): IMat
def copyinds(inds: LMat, tmp: LMat): LMat
def countV(ind1: LMat, counts1: IMat, ind2: LMat, counts2: IMat): Int
var ctrees: FMat
var datasource: DataSource

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

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

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

Definition Classes
Model
def extractAbove(fieldNum: Int, packedFields: Long, fieldshifts: Array[Int]): Int

Annotations
@inline()
def extractField(fieldNum: Int, packedFields: Long, fieldshifts: Array[Int], fieldmasks: Array[Int]): Int

Annotations
@inline()
val fieldlengths: IMat
var fieldmasks: Array[Int]
var fieldshifts: Array[Int]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def findBoundaries(keys: LMat, jc: IMat): (IMat, IMat)
def findIndex(blockv: SVec, itree: Int): Int
def floatConvert(a: Float): Int

Annotations
@inline()
def floatConvert2(a: Float): Int

Annotations
@inline()
var ftrees: IMat
def gaddV(gix: GLMat, gcx: GIMat, gmidinds: GLMat, gmidcounts: GIMat, gmergedinds: GLMat, gmergedcounts: GIMat): (GLMat, GIMat)
var gains: FMat
var gctrees: GMat
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getFieldMasks(fL: IMat): Array[Int]
def getFieldShifts(fL: IMat): Array[Int]
def getSum(totals: Array[SVTree]): Array[SVec]
var gfieldlengths: GIMat
var gfnodes: GMat
var gftree: GIMat
var gftrees: GIMat
object giniImpurity extends imptyType
var gitree: GIMat
var gitrees: GIMat
def gjfeatsToIfeats(itree: Int, inodes: IMat, ifeats: IMat, seed: Int, gitree: GIMat, gftree: GIMat): Unit
def gmakeV(keys: GLMat, vals: GIMat, tmpkeys: GLMat, tmpcounts: GIMat): SVec
var gmats: Array[Mat]

Definition Classes
Model
var gout: GLMat
var gpiones: GIMat
def gpsort(gout: GLMat): Int
var gtmpcounts: GIMat
var gtmpinds: GLMat
var gtnodes: GIMat
def gtreePack(gdata: GMat, gtnodes: GIMat, gcats: GMat, gout: GLMat, seed: Int): GLMat
def gtreePack(gdata: GMat, gtnodes: GIMat, gcats: GIMat, gout: GLMat, seed: Int): GLMat
def gtreePack(fdata: FMat, tnodes: IMat, icats: IMat, gout: GLMat, seed: Int): GLMat
def gtreeStep(gdata: GMat, tnodes: GIMat, fnodes: GMat, itrees: GIMat, ftrees: GIMat, vtrees: GIMat, ctrees: GMat, getcat: Boolean): Unit
def gtreeWalk(fdata: GMat, tnodes: GIMat, fnodes: GMat, itrees: GIMat, ftrees: GIMat, vtrees: GIMat, ctrees: GMat, depth: Int, getcat: Boolean): Unit
var gvtrees: GIMat
def hashCode(): Int

Definition Classes
AnyRef → Any
var igains: FMat
val imptyFunArray: Array[imptyType]
def init(): Unit

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

Definition Classes
Any
var itrees: IMat
var jc: IMat
def jfeatsToIfeats(itree: Int, inodes: IMat, ifeats: IMat, seed: Int, gitree: GIMat, gftree: GIMat): Unit
var lens0: Long
var lens1: Long
def load(fname: String): Unit
var lout: LMat
final val magnitude: Int
def makeV(ind: LMat): SVec
var mats: Array[Mat]

Definition Classes
Model
def minImpurity(keys: LMat, cnts: IMat, outv: IMat, outf: IMat, outn: IMat, outg: FMat, outc: FMat, outleft: FMat, outright: FMat, jc: IMat, jtree: IMat, itree: Int, fnum: Int, regression: Boolean): (FMat, Double)
def minImpurity_thread(keys: LMat, cnts: IMat, outv: IMat, outf: IMat, outn: IMat, outg: FMat, outc: FMat, outleft: FMat, outright: FMat, jc: IMat, jtree: IMat, itree: Int, fnum: Int, regression: Boolean, ithread: Int, nthreads: Int): (FMat, Double)
def minImpurityx(keys: LMat, cnts: IMat, outv: IMat, outf: IMat, outn: IMat, outg: FMat, outc: FMat, outleft: FMat, outright: FMat, jc: IMat, jtree: IMat, itree: Int, fnum: Int, regression: Boolean): (FMat, Double)
def modelmats: Array[Mat]

Definition Classes
Model
var nbits: Int
var ncats: Int
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
var nfeats: Int
var nnodes: Int
var nodecounts: IMat
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
var nsamps: Int
var ntrees: Int
val opts: Opts

Definition Classes
RandomForest → Model
var outc: FMat
var outf: IMat
var outg: FMat
var outleft: FMat
var outn: IMat
var outright: FMat
var outv: IMat
def packFields(itree: Int, inode: Int, jfeat: Int, ifeat: Int, ivfeat: Int, icat: Int, fieldlengths: Array[Int]): Long

Annotations
@inline()
var parent_model: Model

Definition Classes
Model
var putBack: Int

Definition Classes
Model
var refresh: Boolean

Definition Classes
Model
def regressVar(sumsq: Double, tott: Int, acc: Double, tot: Int, acct: Double, tot2: Int): Double
def rhash(v1: Int, v2: Int, v3: Int, v4: Int, nb: Int): Int

Annotations
@inline()
def rhash(v1: Int, v2: Int, v3: Int, nb: Int): Int

Annotations
@inline()
val runtimes: FMat
def save(fname: String): Unit
var seed: Int
def setmodelmats(a: Array[Mat]): Unit

Definition Classes
Model
final val signbit: Int
def splittableNodes(blockv: SVec): Array[SVec]
def splittableNodes_thread(blockv: SVec, itree: Int): SVec
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
var t0: Float
var t1: Float
var t2: Float
var t3: Float
var t4: Float
var t5: Float
var t6: Float
def tally(nodes: FMat): IMat
def tallyv(nodes: FMat): FMat
def toString(): String

Definition Classes
AnyRef → Any
def tochildren(itree: Int, inodes: IMat, left: FMat, right: FMat): Unit
var totals: Array[SVTree]
def treePack(fdata: FMat, treenodes: IMat, fcats: FMat, out: LMat, seed: Int): LMat
def treePack(fdata: FMat, treenodes: IMat, cats: IMat, out: LMat, seed: Int): LMat
def treeStep(fdata: FMat, tnodes: IMat, fnodes: FMat, itrees: IMat, ftrees: IMat, vtrees: IMat, ctrees: FMat, getcat: Boolean): Unit
def treeWalk(fdata: FMat, tnodes: IMat, fnodes: FMat, itrees: IMat, ftrees: IMat, vtrees: IMat, ctrees: FMat, depth: Int, getcat: Boolean): FMat
def unpackFields(im: Long, fieldlengths: Array[Int]): (Int, Int, Int, Int, Int, Int)

Annotations
@inline()
def updatePass(ipass: Int): Unit

Definition Classes
RandomForest → Model
var updatemats: Array[Mat]

Definition Classes
Model
var useDouble: Boolean

Definition Classes
Model
var useGPU: Boolean

Definition Classes
Model
var useIfeats: Boolean
var vtrees: IMat
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 x: Mat
var xnodes: IMat
var y: Mat
var ynodes: FMat

class RandomForest extends Model

Instance Constructors

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

Type Members

trait imptyType extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val ICat: Int

val IFeat: Int

val INode: Int

val ITree: Int

val IVFeat: Int

val JFeat: Int

var _modelmats: Array[Mat]

def addSVecs(a: Array[SVec], totals: Array[SVTree]): Unit

def addV(ind1: LMat, counts1: IMat, ind2: LMat, counts2: IMat): (LMat, IMat)

final def asInstanceOf[T0]: T0

var batchSize: Int

def bind(ds: DataSource): Unit

var blockv: SVec

def clone(): AnyRef

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

def copyTo(mod: Model): Unit

def copycounts(cnts: IMat, tmpc: IMat): IMat

def copyinds(inds: LMat, tmp: LMat): LMat

def countV(ind1: LMat, counts1: IMat, ind2: LMat, counts2: IMat): Int

var ctrees: FMat

var datasource: DataSource

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

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

object entImpurity extends imptyType

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 extractAbove(fieldNum: Int, packedFields: Long, fieldshifts: Array[Int]): Int

def extractField(fieldNum: Int, packedFields: Long, fieldshifts: Array[Int], fieldmasks: Array[Int]): Int

val fieldlengths: IMat

var fieldmasks: Array[Int]

var fieldshifts: Array[Int]

def finalize(): Unit

def findBoundaries(keys: LMat, jc: IMat): (IMat, IMat)

def findIndex(blockv: SVec, itree: Int): Int

def floatConvert(a: Float): Int

def floatConvert2(a: Float): Int

var ftrees: IMat

def gaddV(gix: GLMat, gcx: GIMat, gmidinds: GLMat, gmidcounts: GIMat, gmergedinds: GLMat, gmergedcounts: GIMat): (GLMat, GIMat)

var gains: FMat

var gctrees: GMat

final def getClass(): Class[_]

def getFieldMasks(fL: IMat): Array[Int]

def getFieldShifts(fL: IMat): Array[Int]

def getSum(totals: Array[SVTree]): Array[SVec]

var gfieldlengths: GIMat

var gfnodes: GMat

var gftree: GIMat

var gftrees: GIMat

object giniImpurity extends imptyType

var gitree: GIMat

var gitrees: GIMat

def gjfeatsToIfeats(itree: Int, inodes: IMat, ifeats: IMat, seed: Int, gitree: GIMat, gftree: GIMat): Unit

def gmakeV(keys: GLMat, vals: GIMat, tmpkeys: GLMat, tmpcounts: GIMat): SVec

var gmats: Array[Mat]

var gout: GLMat

var gpiones: GIMat

def gpsort(gout: GLMat): Int

var gtmpcounts: GIMat

var gtmpinds: GLMat

var gtnodes: GIMat

def gtreePack(gdata: GMat, gtnodes: GIMat, gcats: GMat, gout: GLMat, seed: Int): GLMat

def gtreePack(gdata: GMat, gtnodes: GIMat, gcats: GIMat, gout: GLMat, seed: Int): GLMat

def gtreePack(fdata: FMat, tnodes: IMat, icats: IMat, gout: GLMat, seed: Int): GLMat

def gtreeStep(gdata: GMat, tnodes: GIMat, fnodes: GMat, itrees: GIMat, ftrees: GIMat, vtrees: GIMat, ctrees: GMat, getcat: Boolean): Unit

def gtreeWalk(fdata: GMat, tnodes: GIMat, fnodes: GMat, itrees: GIMat, ftrees: GIMat, vtrees: GIMat, ctrees: GMat, depth: Int, getcat: Boolean): Unit

var gvtrees: GIMat

def hashCode(): Int

var igains: FMat