FileBasedMaxEntDecodeSeqGen

Instance Constructors

new FileBasedMaxEntDecodeSeqGen(m: MaxEntModel, opts: Options)

Type Members

type DeserializationT = MaxEntDeserialization

Definition Classes
MaxEntSeqGenCore → SeqGen
type FRepT = MEFRep[List[(FeatureId, Double)]]

Definition Classes
MaxEntSeqGen → SeqGen
type Seqs = IndexedSeq[SourceSequence[List[(FeatureId, Double)]]]

Definition Classes
SeqGen
type Src = ObsSource[List[(FeatureId, Double)]]

Definition Classes
SeqGen

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
var addBeginStates: Boolean

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

Definition Classes
MaxEntSeqGen
final def asInstanceOf[T0]: T0

Definition Classes
Any
val boundaries: Tagset

Definition Classes
DecodingSeqGen → SeqGen
def buildInstance(l: String): Option[MaxEntInstance]

Attributes
protected
Definition Classes
MaxEntSeqGenAttVal
def buildInstanceUsingPosteriors(l: String): Option[MaxEntInstance]

Attributes
protected
Definition Classes
MaxEntSeqGenAttVal
def cleanUp(): Unit

Definition Classes
SeqGen
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def closeFVecStream(): Unit

Definition Classes
MaxEntSeqGen
var cnt: Int
def countFeatureTypes(spSeqs: Seqs): Unit

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

Definition Classes
SeqGen
def countFeatureTypesFromFiles: Unit

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

Definition Classes
SeqGen
def createInstancesDirectly: IndexedSeq[InstanceSequence]

Attributes
protected
Definition Classes
MaxEntSeqGen
def createInstancesFromFiles: IndexedSeq[InstanceSequence]

Definition Classes
SeqGen
def createInstancesOnDisk: Unit
def createSeqsFromFiles: IndexedSeq[InstanceSequence]

Definition Classes
MaxEntSeqGenAttValFromFileProcessor → MaxEntSeqGen → SeqGen
def createSeqsWithInput(dseq: IndexedSeq[DeserializationT]): IndexedSeq[InstanceSequence]

Definition Classes
SeqGen
def createSeqsWithInput(d: DeserializationT): IndexedSeq[InstanceSequence]

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

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

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

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

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

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

Attributes
protected
Definition Classes
SeqGen
def createSourceSequence(ss: Seq[ObsSource[String]], st: Int, en: Int): SourceSequence[String]

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

Creates a source sequence.
Creates a source sequence. Subclasses can over-ride this to add additional infor regarding sequences
returns
SourceSequence[Obs] - observation sequence

Definition Classes
SeqGen
def createSourcesFromFiles: IndexedSeq[Seqs]

Definition Classes
MaxEntSeqGenAttValFromFileProcessor → SeqGen
val decodingOpts: Options

Definition Classes
DecodingSeqGen
def deserializeFromFile(file: String): DeserializationT

Create a deserialization from a file path provided as a String
Create a deserialization from a file path provided as a String
file
File path as a string
returns
A deserialized object

Definition Classes
MaxEntSeqGenCore → SeqGen
def deserializeFromFile(file: File): DeserializationT

Create a deserialization from a File object
Create a deserialization from a File object
file
File object
returns
A deserialized object

Definition Classes
SeqGen
def deserializeFromRawString(string: String): DeserializationT

Definition Classes
MaxEntSeqGenCore
def deserializeFromString(s: String): DeserializationT

Create a deserialized object from a string containing a serialized representation
Create a deserialized object from a string containing a serialized representation
returns
A deserialized object

Definition Classes
MaxEntSeqGenCore → SeqGen
def deserializeFromTokenSeq(seq: Seq[String]): DeserializationT

Create a deserialized object from a list of tokens
Create a deserialized object from a list of tokens
returns
A deserialized object

Definition Classes
MaxEntSeqGenCore → SeqGen
var dumpFVecStream: Option[OutputStreamWriter]

Definition Classes
MaxEntSeqGen
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def evaluateSequences(seqs: Seq[InstanceSequence]): Unit

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

Definition Classes
MaxEntSeqGenAttVal → SeqGen
def extractFeatures(obs: ObsSource[List[(FeatureId, Double)]]): AbstractInstance

Definition Classes
MaxEntSeqGenAttVal
def extractFeatures(sourcePairSeqs: Seqs): IndexedSeq[InstanceSequence]

Definition Classes
MaxEntSeqGenAttVal → SeqGen
def extractFeaturesSeq(sourcePairSeqsSeq: IndexedSeq[Seqs]): IndexedSeq[InstanceSequence]

Definition Classes
SeqGen
def filterAndNormalizeFeatures(insts: Seq[MaxEntInstance]): Unit

Attributes
protected
Definition Classes
MaxEntSeqGenAttVal
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
val frep: MEFRep[List[(FeatureId, Double)]]

Definition Classes
FileBasedMaxEntDecodeSeqGen → SeqGen
def gatherFeatureTables(d: DeserializationT): Unit

Definition Classes
SeqGen
def gatherFeatures(seqs: Seq[InstanceSequence]): Map[String, Double]

Definition Classes
MaxEntSeqGenAttValFromFileProcessor
def getAccuracy: Double

Definition Classes
SeqGen
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getIndex(l: AbstractLabel): Int

Attributes
protected
Definition Classes
SeqGen
def getInducedFeatureMap: Option[InducedFeatureMap]

Return the lexicon used by the feature manager
Return the lexicon used by the feature manager
returns
An optional lexicon

Definition Classes
SeqGen
def getLAlphabet: Alphabet[AbstractLabel]

Return the label Alphabet to use.
Return the label Alphabet to use. Should be overrided with a different alphabet when doing recoding, for example.
returns
A label alphabet to pass to the trainer/decoder

Definition Classes
SeqGen
def getLexicon: Option[BloomLexicon]

Return the lexicon used by the feature manager
Return the lexicon used by the feature manager
returns
An optional lexicon

Definition Classes
SeqGen
def getMaxSegmentSize: Int

Definition Classes
SeqGen
def getModelName: String

Return the name of the feature manager instance (i.e.
Return the name of the feature manager instance (i.e. feature set name)
returns
A feature set name String

Definition Classes
SeqGen
def getNumberOfFeatures: Int

Definition Classes
FileBasedMaxEntDecodeSeqGen → SeqGen
def getNumberOfNeuralFeatures: Int

Definition Classes
SeqGen
def getNumberOfStates: Int

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

Definition Classes
SeqGen
def getState(l: AbstractLabel, b: Boolean): AbstractLabel

Definition Classes
SeqGen
def getWordProps: Option[WordProperties]

Return the lexicon used by the feature manager
Return the lexicon used by the feature manager
returns
An optional lexicon

Definition Classes
SeqGen
def getWordScores: Option[WordScores]

Return the lexicon used by the feature manager
Return the lexicon used by the feature manager
returns
An optional lexicon

Definition Classes
SeqGen
def hashCode(): Int

Definition Classes
AnyRef → Any
def initialize(): Unit

Definition Classes
MaxEntSeqGenCore
lazy val invLa: Map[Int, AbstractLabel]

Definition Classes
SeqGen
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val lAlphabet: Alphabet[AbstractLabel]

Definition Classes
DecodingSeqGen → SeqGen
def mapToMaxEntInstance(lab: String, fs: Seq[InstanceSequence], fileName: String): MaxEntInstance

Definition Classes
MaxEntSeqGenAttValFromFileProcessor
def mapToMaxEntSource(lab: String, fs: Seq[InstanceSequence]): ObsSource[List[(FeatureId, Double)]]

Definition Classes
MaxEntSeqGenAttValFromFileProcessor
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val numReg: Regex

Definition Classes
MaxEntSeqGenAttVal
val opts: Options

A set of command-line options passed in by user
A set of command-line options passed in by user

Definition Classes
SeqGen
def otherIndex: Option[Int]

Definition Classes
SeqGen
val printExistingTags: Boolean

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

Definition Classes
MaxEntSeqGenAttVal → SeqGen
val recode: Boolean

Definition Classes
SeqGen
val recodeAlphabet: Alphabet[AbstractLabel]

Definition Classes
DecodingSeqGen → SeqGen
def reset(): Unit

Definition Classes
SeqGen
val selfCode: Long

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

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

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

Definition Classes
MaxEntSeqGenCore
def seqsToFile(d: DeserializationT, seqs: Seq[InstanceSequence], f: String): Unit

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

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

Definition Classes
MaxEntSeqGenCore
def setBegin(): Unit

Definition Classes
DecodingSeqGen
def setFVecStream(f: File): Unit

Definition Classes
MaxEntSeqGen
val subSeqGen: TrainingSeqGen[String] with TextSeqGen

Definition Classes
FileBasedMaxEntDecodeSeqGen → MaxEntSeqGenAttValFromFileProcessor
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toAbstractInstance(s: String): AbstractInstance

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

Definition Classes
MaxEntSeqGenAttVal
def toInstances(inReader: DeserializationT): InstanceSequence

Definition Classes
MaxEntSeqGenAttVal → MaxEntSeqGen
def toSources(d: DeserializationT): Seqs

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

Definition Classes
MaxEntSeqGenAttVal → SeqGen
def toSources(file: File): Seqs

Definition Classes
SeqGen
def toSources(file: String): Seqs

Takes a file path (as string) and converts it to a sequence of sequences of ObsSource objects
Takes a file path (as string) and converts it to a sequence of sequences of ObsSource objects
file
A file path as a string
returns
A sequence of sequences of ObsSource objects that represent observations and auxiliary information.

Definition Classes
SeqGen
def toString(): String

Definition Classes
AnyRef → Any
var totalIncorrectTok: Int

Definition Classes
SeqGen
var totalTokCnt: Int

Definition Classes
SeqGen
var ufset: Set[Long]

Definition Classes
MaxEntSeqGen
val unkCode: Long

Definition Classes
MaxEntSeqGen
val unrecodeAlphabet: Alphabet[AbstractLabel]

Definition Classes
SeqGen
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package maxent

class FileBasedMaxEntDecodeSeqGen extends DecodingSeqGen[List[(FeatureId, Double)]] with MaxEntSeqGenAttVal with MaxEntSeqGenAttValFromFileProcessor

Instance Constructors

new FileBasedMaxEntDecodeSeqGen(m: MaxEntModel, opts: Options)

Type Members

type DeserializationT = MaxEntDeserialization

type FRepT = MEFRep[List[(FeatureId, Double)]]

type Seqs = IndexedSeq[SourceSequence[List[(FeatureId, Double)]]]

type Src = ObsSource[List[(FeatureId, Double)]]

Value Members

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

val boundaries: Tagset

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

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

def cleanUp(): Unit

def clone(): AnyRef

def closeFVecStream(): Unit

var cnt: Int

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 createInstancesOnDisk: Unit

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]

def createSourcesFromFiles: IndexedSeq[Seqs]

val decodingOpts: Options

def deserializeFromFile(file: String): DeserializationT

def deserializeFromFile(file: File): DeserializationT

def deserializeFromRawString(string: String): DeserializationT

def deserializeFromString(s: String): DeserializationT

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

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

val frep: MEFRep[List[(FeatureId, Double)]]

def gatherFeatureTables(d: DeserializationT): Unit

def gatherFeatures(seqs: Seq[InstanceSequence]): Map[String, Double]

def getAccuracy: Double

final def getClass(): Class[_]

def getIndex(l: AbstractLabel): Int

def getInducedFeatureMap: Option[InducedFeatureMap]

def getLAlphabet: Alphabet[AbstractLabel]

def getLexicon: Option[BloomLexicon]

def getMaxSegmentSize: Int

def getModelName: String

def getNumberOfFeatures: Int

def getNumberOfNeuralFeatures: Int

def getNumberOfStates: Int

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

def getWordProps: Option[WordProperties]

def getWordScores: Option[WordScores]

def hashCode(): Int

def initialize(): Unit

lazy val invLa: Map[Int, AbstractLabel]

final def isInstanceOf[T0]: Boolean