StochasticGeneralizedEMCrf

abstract def train(seqAccessor: AccessSeq[AbstractInstance], maxIters: Int, mi: Option[(CoreModel, Int) ⇒ Unit]): CoreModel

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val C: Double

var adjustible: Boolean

When set to true, the Crf will allow the state-space to be dynamically sized - i.e.

var alpha: Matrix

Alpha values.

final def asInstanceOf[T0]: T0

def assign(v1: Array[Double], f: (Double) ⇒ Double): Unit

def assign1(v1: Array[Double], v2: Array[Double], f: (Double, Double) ⇒ Double): Unit

def backwardPass(iseq: Seq[AbstractInstance]): Unit

def backwardPassConstrained(iseq: Seq[AbstractInstance]): Unit

val batchSize: Int

var beta: Matrix

Beta values.

def clone(): AnyRef

def computeScores(inst_features: Array[Array[Feature]], takeExp: Boolean): Unit

final def computeScores(ri: Matrix, mi: Tensor, inst_features: Array[Array[Feature]], takeExp: Boolean, nls: Int, lambdas: Array[Double]): Unit

def computeScoresConstrained(absInstSeq: Seq[AbstractInstance], pos: Int, takeExp: Boolean): Unit

var conBeta: Matrix

Constrained Beta values.

var conCurA: Array[Double]

Current constrained alpha values used for Forward-Backward computation

val conMarginalState: Array[Double]

val conMarginals: Matrix

var conMi: Tensor

For each segment size, the mi matrix holds transition scores for adjacent labels

var conNewA: Array[Double]

Alpha values at the next position used for Forward-Backward computation

var conRi: Matrix

For each segment size (general case) the ri matrix holds state scores for each label

var conScale: Array[Double]

var conTmp: Array[Double]

val curA: Array[Double]

Current alpha values used for Forward-Backward computation

var curNls: Int

var curPos: Int

val empiricalDist: Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val eta: Double

lazy val etas: Array[Double]

def finalize(): Unit

def forwardPass(iseq: IndexedSeq[AbstractInstance]): Double

val gPrior: Double

The Gaussian prior variance used as a regularizer

final def getClass(): Class[_]

def getCoreModel(): CoreModel

def getGradient(seqAccessor: AccessSeq[AbstractInstance]): Option[Double]

def getLambdas: Array[Double]

def gradNorm: Double

val gradient: HashMap[Int, DoubleCell]

def hashCode(): Int

val initialLearningRate: Double

def initialize(): Unit

val invSigSqr: Double

The value of the inverse square of the Gaussian prior

final def isInstanceOf[T0]: Boolean

val lambdas: Array[Double]

Parameter (lambda) vector

final def matrixMult(mat: Matrix, vec: Array[Double], rvec: Array[Double], alpha: Double, beta: Double, trans: Boolean): Unit

val maxEpochs: Int

val mi: Tensor

For each segment size, the mi matrix holds transition scores for adjacent labels

val momentum: Double

val nGates: Int

Number of neural gates per label (for NeuralCrf)

val nNfs: Int

Number of neural gate input features (for NeuralCrf)

final def ne(arg0: AnyRef): Boolean

val newA: Array[Double]

Alpha values at the next position used for Forward-Backward computation

val nfs: Int

Number of features

val nls: Int

Number of labels/states

final def notify(): Unit

final def notifyAll(): Unit

var numGradIssues: Int

val numParams: Int

val opts: Options

General program parameters/options passed in to trainer

val pAlpha: Double

val periodSize: Int

def printGradient: Unit

def printMi(m: Array[Array[Array[Double]]]): Unit

val quiet: Boolean

def reset(all: Boolean, slen: Int): Unit

def reset(l: Int): Unit

def resetParameters(): Unit

val ri: Matrix

For each segment size (general case) the ri matrix holds state scores for each label

var scale: Array[Double]

An array of scaling coefficients to avoid underflow without having to do computations in log space.

val segSize: Int

The size of segments.

def setConstrainedMarginals(ri: Array[Double], mi: Matrix, pos: Int): Unit

final def setMatrix(m: Matrix, v: Double = 0.0): Unit

def setNewEtas(es: Array[Double]): Unit

def setNewParams(ls: Array[Double]): Unit

final def setTensor(t: Tensor, v: Double = 0.0): Unit

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

val tmp: Array[Double]

def toString(): String

def train(seqAccessor: AccessSeq[AbstractInstance]): CoreModel

def updateScoreMatrices(iseq: Seq[AbstractInstance], pos: Int): Unit

def vecSum(vec: Array[Double]): Double

final def wait(): Unit

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

final def wait(arg0: Long): Unit