DirectTrainingSeqGen

abstract def deserializeFromFile(file: String): DeserializationT

Create a deserialization from a file path provided as a String

abstract def deserializeFromString(string: String): DeserializationT

Create a deserialized object from a string containing a serialized representation

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

Create a deserialized object from a list of tokens

abstract def processSupportingFeatures(src: SourceSequence[Obs]): InstanceSequence

abstract def toSources(d: DeserializationT): Seqs

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

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

var addBeginStates: Boolean

final def asInstanceOf[T0]: T0

val boundaries: Tagset

def cleanUp(): Unit

def clone(): AnyRef

def countFeatureTypes(dseq: SourceSequence[Obs]): Unit

def countFeatureTypes(spSeqs: Seqs): Unit

def countFeatureTypesFromFiles: Unit

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

def createInstancesFromFiles: IndexedSeq[InstanceSequence]

def createSeqsFromFiles: IndexedSeq[InstanceSequence]

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

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

def createSource(o: Obs, i: Map[String, String]): ObsSource[Obs]

def createSource(l: AbstractLabel, o: Obs, i: Map[String, String]): ObsSource[Obs]

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

def createSource(l: AbstractLabel, o: Obs): ObsSource[Obs]

def createSource(l: AbstractLabel, o: Obs, beg: Boolean): ObsSource[Obs]

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

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: File): DeserializationT

Create a deserialization from a File object

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

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

def extractFeatures(dseq: SourceSequence[Obs]): InstanceSequence

def extractFeaturesDirect(dseq: SourceSequence[Obs]): IndexedSeq[AbstractInstance]

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

def finalize(): Unit

val frep: FRepT

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 getNumberOfFeatures: Int

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

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 opts: Options

A set of command-line options passed in by user

def otherIndex: Option[Int]

val printExistingTags: Boolean

val recode: Boolean

val recodeAlphabet: Alphabet[AbstractLabel]

def reset(): Unit

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

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

val unrecodeAlphabet: Alphabet[AbstractLabel]

final def wait(): Unit

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

final def wait(arg0: Long): Unit