MaxEntSeqGenAttVal

abstract val boundaries: Tagset

abstract val frep: FRepT

abstract def getNumberOfFeatures: Int

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

var addBeginStates: Boolean

def addInFeatures(inst: MaxEntInstance, src: ObsSource[List[(FeatureId, Double)]]): Unit

final def asInstanceOf[T0]: T0

def buildInstance(l: String): Option[MaxEntInstance]

def buildInstanceUsingPosteriors(l: String): Option[MaxEntInstance]

def cleanUp(): Unit

def clone(): AnyRef

def closeFVecStream(): Unit

def countFeatureTypes(spSeqs: Seqs): Unit

def countFeatureTypes(src: SourceSequence[List[(FeatureId, Double)]]): Unit

def countFeatureTypesFromFiles: Unit

def createDistributionalSource(dist: List[(AbstractLabel, Double)], obs: List[(FeatureId, Double)], beg: Boolean, i: Map[String, String]): ObsSource[List[(FeatureId, Double)]]

def createInstancesDirectly: IndexedSeq[InstanceSequence]

def createInstancesFromFiles: IndexedSeq[InstanceSequence]

def createSeqsFromFiles: IndexedSeq[InstanceSequence]

def createSeqsWithInput(dseq: IndexedSeq[DeserializationT]): IndexedSeq[InstanceSequence]

def createSeqsWithInput(d: DeserializationT): IndexedSeq[InstanceSequence]

def createSource(o: List[(FeatureId, Double)], i: Map[String, String]): ObsSource[List[(FeatureId, Double)]]

def createSource(l: AbstractLabel, o: List[(FeatureId, Double)], i: Map[String, String]): ObsSource[List[(FeatureId, Double)]]

def createSource(l: AbstractLabel, o: List[(FeatureId, Double)], beg: Boolean, i: Map[String, String]): ObsSource[List[(FeatureId, Double)]]

def createSource(l: AbstractLabel, o: List[(FeatureId, Double)]): ObsSource[List[(FeatureId, Double)]]

def createSource(l: AbstractLabel, o: List[(FeatureId, Double)], beg: Boolean): ObsSource[List[(FeatureId, Double)]]

def createSourceI(i: Int, o: List[(FeatureId, Double)], b: Boolean, m: Option[Map[String, String]]): ObsSource[List[(FeatureId, Double)]]

def createSourceSequence(ss: Seq[ObsSource[String]], st: Int, en: Int): SourceSequence[String]

def createSourceSequence(ss: Seq[ObsSource[String]]): SourceSequence[String]

Creates a source sequence.

def createSourcesFromFiles: IndexedSeq[Seqs]

def deserializeFromFile(file: String): DeserializationT

Create a deserialization from a file path provided as a String

def deserializeFromFile(file: File): DeserializationT

Create a deserialization from a File object

def deserializeFromRawString(string: String): DeserializationT

def deserializeFromString(s: String): DeserializationT

Create a deserialized object from a string containing a serialized representation

def deserializeFromTokenSeq(seq: Seq[String]): DeserializationT

Create a deserialized object from a list of tokens

var dumpFVecStream: Option[OutputStreamWriter]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def evaluateSequences(seqs: Seq[InstanceSequence]): Unit

def extractFeatures(dseq: SourceSequence[List[(FeatureId, Double)]]): InstanceSequence

def extractFeatures(obs: ObsSource[List[(FeatureId, Double)]]): AbstractInstance

def extractFeatures(sourcePairSeqs: Seqs): IndexedSeq[InstanceSequence]

def extractFeaturesSeq(sourcePairSeqsSeq: IndexedSeq[Seqs]): IndexedSeq[InstanceSequence]

def filterAndNormalizeFeatures(insts: Seq[MaxEntInstance]): Unit

def finalize(): Unit

def gatherFeatureTables(d: DeserializationT): Unit

def getAccuracy: Double

final def getClass(): Class[_]

def getIndex(l: AbstractLabel): Int

def getInducedFeatureMap: Option[InducedFeatureMap]

Return the lexicon used by the feature manager

def getLAlphabet: Alphabet[AbstractLabel]

Return the label Alphabet to use.

def getLexicon: Option[BloomLexicon]

Return the lexicon used by the feature manager

def getMaxSegmentSize: Int

def getModelName: String

Return the name of the feature manager instance (i.e.

def getNumberOfNeuralFeatures: Int

def getNumberOfStates: Int

Return the number of states in the model (when the size is fixed across the dataset)

def getState(l: AbstractLabel, b: Boolean): AbstractLabel

def getWordProps: Option[WordProperties]

Return the lexicon used by the feature manager

def getWordScores: Option[WordScores]

Return the lexicon used by the feature manager

def hashCode(): Int

def initialize(): Unit

lazy val invLa: Map[Int, AbstractLabel]

final def isInstanceOf[T0]: Boolean

val lAlphabet: Alphabet[AbstractLabel]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val numReg: Regex

val opts: Options

A set of command-line options passed in by user

def otherIndex: Option[Int]

val printExistingTags: Boolean

def processSupportingFeatures(dseq: SourceSequence[List[(FeatureId, Double)]]): InstanceSequence

val recode: Boolean

val recodeAlphabet: Alphabet[AbstractLabel]

def reset(): Unit

val selfCode: Long

def seqsToAnnotations(d: DeserializationT, seqs: Seq[InstanceSequence]): Map[AbstractLabel, ListBuffer[Annotation]]

def seqsToDeserialized(d: DeserializationT, seqs: Seq[InstanceSequence]): DeserializationT

def seqsToFile(d: DeserializationT, seqs: Seq[InstanceSequence], f: File): Unit

def seqsToString(d: DeserializationT, seqs: Seq[InstanceSequence]): String

def seqsToWriter(d: DeserializationT, seqs: Seq[InstanceSequence], os: OutputStreamWriter, close: Boolean = true): Unit

def setFVecStream(f: File): Unit

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

def toAbstractInstance(s: String): AbstractInstance

def toAbstractInstanceSeq(inReader: DeserializationT, quiet: Boolean = false): IndexedSeq[AbstractInstance]

def toInstances(inReader: DeserializationT): InstanceSequence

def toSources(d: DeserializationT): Seqs

Computes a sequence of sequences of ObsSource objects from a given deserialized object

def toSources(file: File): Seqs

def toSources(file: String): Seqs

Takes a file path (as string) and converts it to a sequence of sequences of ObsSource objects

def toString(): String

var totalIncorrectTok: Int

var totalTokCnt: Int

var ufset: Set[Long]

val unkCode: Long

val unrecodeAlphabet: Alphabet[AbstractLabel]

final def wait(): Unit

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

final def wait(arg0: Long): Unit