TextSeqGen

abstract val boundaries: Tagset

abstract def extractFeatures(src: SourceSequence[String]): InstanceSequence

abstract def extractFeatures(spSeqs: Seqs): IndexedSeq[InstanceSequence]

abstract val frep: FRepT

abstract def getNumberOfFeatures: Int

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

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val MAX_SEQ_LEN: Int

object StateCache

var addBeginStates: Boolean

final def asInstanceOf[T0]: T0

def cleanUp(): Unit

def clone(): AnyRef

def countFeatureTypes(spSeqs: Seqs): Unit

def countFeatureTypes(src: SourceSequence[String]): Unit

def countFeatureTypesFromFiles: Unit

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

def createInstancesFromFiles: IndexedSeq[InstanceSequence]

def createSeqsFromFiles: IndexedSeq[InstanceSequence]

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

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

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

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

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

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

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

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

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(s: 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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

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

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 getLabelAndAttrsFromTag(t: String): (String, Map[String, String])

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

var ignoreFlag: Boolean

lazy val invLa: Map[Int, AbstractLabel]

final def isInstanceOf[T0]: Boolean

val lAlphabet: Alphabet[AbstractLabel]

lazy val lexAttributedTagSet: Boolean

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

val other: AbstractLabel

def otherIndex: Option[Int]

def printElemAsSingleTag(empty: Boolean, x: Node): String

val printExistingTags: Boolean

val recode: Boolean

val recodeAlphabet: Alphabet[AbstractLabel]

def reset(): Unit

def seqToWriter(d: DeserializationT, iSeq: InstanceSequence, os: OutputStreamWriter): Unit

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 seqsToSlicedWriter(d: DeserializationT, dseq: SourceSequence[String], iseqs: InstanceSequence, os: OutputStreamWriter): Unit

def seqsToStream(d: DeserializationT, seqs: Seq[InstanceSequence], ostr: OutputStream, close: Boolean = true): Unit

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

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

implicit def seqsToXmlAtts(x: Map[String, String]): MetaData

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

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

val unrecodeAlphabet: Alphabet[AbstractLabel]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def writeTok(write: Boolean, t: String, os: OutputStreamWriter, lexInfo: Option[Map[String, String]] = None): Unit

implicit def xmlAttsToSeq(x: MetaData): Map[String, String]