PositionalNeuralModel

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def accumulateCounts(inf: Inference, s: Scorer, d: TreeInstance[L, W], m: Marginal, accum: ExpectedCounts, scale: Double): Unit

final def accumulateCounts(inf: Inference, d: TreeInstance[L, W], accum: ExpectedCounts, scale: Double): Unit

final def asInstanceOf[T0]: T0

def cacheFeatureWeights(weights: DenseVector[Double], suffix: String = ""): Unit

Caches the weights using the cache broker.

def clone(): AnyRef

def cloneModelForEnsembling: PositionalNeuralModel[L, L2, W]

val constrainer: Factory[L, W]

val decoupledTransforms: Seq[OutputTransform[Array[Int], DenseVector[Double]]]

val depTransforms: Seq[OutputTransform[Array[Int], DenseVector[Double]]]

def emptyCounts: StandardExpectedCounts[Feature]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def expectedCounts(inf: Inference, d: TreeInstance[L, W], scale: Double = 1.0): ExpectedCounts

def expectedCountsToObjective(ecounts: ExpectedCounts): (Double, DenseVector[Double])

def extractParser(weights: DenseVector[Double], trainExs: Seq[TreeInstance[L, W]])(implicit deb: Debinarizer[L]): Parser[L, W]

When doing batch normalization, we need to normalize the test network

def extractParser(weights: DenseVector[Double])(implicit deb: Debinarizer[L]): Parser[L, W]

def featureIndex: Index[Feature]

Models have features, and this defines the mapping from indices in the weight vector to features.

final def getClass(): Class[_]

def hashCode(): Int

val index: SegmentedIndex[Feature, Index[Feature]]

Models have features, and this defines the mapping from indices in the weight vector to features.

def inferenceFromWeights(weights: DenseVector[Double], forTrain: Boolean): Inference

def inferenceFromWeights(weights: DenseVector[Double]): Inference

def initialValueForFeature(f: Feature): Double

def initialWeightVector(initWeightsScale: Double, initializerSpec: String, trulyRandom: Boolean = false): DenseVector[Double]

final def isInstanceOf[T0]: Boolean

val lexicon: Lexicon[L, W]

def logger: LazyLogger

val maybeSparseSurfaceFeaturizer: Option[IndexedSpanFeaturizer[L, L2, W]]

def mergeWeightsForEnsembling(x1: DenseVector[Double], x2: DenseVector[Double]): DenseVector[Double]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def numFeatures: Int

def readCachedFeatureWeights(suffix: String = ""): Option[DenseVector[Double]]

just saves feature weights to disk as a serialized counter.

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

def toString(): String

val topology: RuleTopology[L]

val transforms: IndexedSeq[OutputTransform[Array[Int], DenseVector[Double]]]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def weightsCacheName: String

def finalize(): Unit