FeatureManagerBuilder

A FeatureManager defines includes a set of common feature function definitions. It also holds a list of actual feature function objects that are applied to a sequence of observations. Sequence labeling applications will need to create a concrete subclass of FeatureManager that specifies exactly which feature functions will be applied. This class defines a simple DSL (Domain-Specific Language) that allows the set of feature functions for a particular application to be clearly specified.

There are also higher-order feature functions that take other feature functions as arguments to easily and compactly specify more complicated feature extraction functionality. The FeatureManager is type-parameterized by Obs which represents the observation type and Info which denotes the type of the auxilliary information (if any) associated with each observation.

An application-specific FeatureManager should subclass this class and specify, within the body of the class definition a set of feature functions, where each function is described as a single expression that returns an instance of FeatureReturn. Below is an example:

object MyFeatureManager extends FeatureManager[String,Map[String,String] {
  "wdFn"      as wdFn
  "capRegFn"  as regexpFn("Capitalized", "[A-Z].*".r)
  "wdNgrm1"    as wdFn ngram (-2 to 0)
  "wdNgrm2"    as wdFn ngram (-1,0,1)
  "cross1"    as wdFn ngram (-1,0) cross (regexpFn("EndIn-ed",".*ed$".r) over (-2 to 2))
}

Each top-level function consists as a String followed by the keyword method name "as" which is then followed by a feature function. That feature function may be either 1) a simple feature function such as wdFn or 2) a complex feature function created by composing other feature functions. For example, the feature function named "wdNgrm1" creates an n-gram consisting of the concatenation of the features that result from applying the wdFn feature function at the positions -2,-1 and 0 relative to the current position. The "cross1" feature function is a more complicated instance that takes the ngram computed from the words at -1 and 0 and conjoins that feature with all the features that result from applying the regular expression function that returns the feature name "EndIn-ed" (when its pattern is matched) over the relative positions -2,-1,0,1,2.

Linear Supertypes

Serializable, Serializable, AnyRef, Any

Known Subclasses

DynamicFeatureManagerBuilder, DynamicRecodeFeatureManager, StaticFeatureManagerBuilder

Instance Constructors

new FeatureManagerBuilder(lex: Option[BloomLexicon], wdProps: Option[WordProperties], wdScores: Option[WordScores], inducedFeatureMap: Option[InducedFeatureMap], iString: String, inducingNewMap: Boolean)

Type Members

type Fn = (Int, SourceSequence[Obs], Int) ⇒ FeatureReturn
type FnList = List[Fn]

Abstract Value Members

abstract def buildFeatureFns(s: String = "default"): List[FeatureFn[Obs]]

Concrete 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
def _caselessWdFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

Computes a feature as the current observation ignoring case
Computes a feature as the current observation ignoring case
s
Segment length
sarr
SourceSequence of ObsSource[Obs] objects
pos
Current position within the sequence
returns
A FeatureReturn with the observation feature
def _edgeFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

Computes a feature with value ":E:"
Computes a feature with value ":E:"
s
Segment length
sarr
SourceSequence of ObsSource[Obs] objects
pos
Current position within the sequence
returns
A FeatureReturn with the unknown word feature :E: as an edge feature
def _edgeFnSemi(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

Computes a feature with value ":E::x" where x is the size of the current segment
Computes a feature with value ":E::x" where x is the size of the current segment
s
Segment length
sarr
SourceSequence of ObsSource[Obs] objects
pos
Current position within the sequence
returns
A FeatureReturn with the unknown word feature :E: as an edge feature
def _filteredLexFn(down: Boolean, filter: Set[String])(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

Add lexicon features, but only if it matches an allowed set of named lexicons Useful for displacing features or other more advanced uses of lexicons
def _lexiconFn(down: Boolean)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def _nodeFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

Computes a feature with value ":U:"
Computes a feature with value ":U:"
s
Segment length
sarr
SourceSequence of ObsSource[Obs] objects
pos
Current position within the sequence
returns
A FeatureReturn with the unknown word feature :U:
def _nodeFnSemi(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

Computes a feature with value ":U::x" where x is the size of the current segment
Computes a feature with value ":U::x" where x is the size of the current segment
s
Segment length
sarr
SourceSequence of ObsSource[Obs] objects
pos
Current position within the sequence
returns
A FeatureReturn with the unknown word feature :U:
def _phraseAttributeFn(att: String)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def _phraseLexFn(aph: Boolean)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def _preLabFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

Computes a feature as the hashed conjunction of ALL labels produced from pre-models
Computes a feature as the hashed conjunction of ALL labels produced from pre-models
s
Segment length
sarr
SourceSequence of ObsSource[Obs] objects
pos
Current position within the sequence
returns
A FeatureReturn with the pre-model labels hash-conjoined
def _regexpFn(fname: String, regexp: Regex)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

Computes a FeatureReturn with a single feature value fname if the observation at the current position matches the specified regular expression.
Computes a FeatureReturn with a single feature value fname if the observation at the current position matches the specified regular expression.
fname
The name of the feature
regexp
A regular expression applied to the observation
s
Segment length
sarr
SourceSequence of ObsSource[Obs] objects
pos
Current position within the sequence
returns
Single feature if regexp matches current observation
def _wdFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

Computes a feature as the current observation
Computes a feature as the current observation
s
Segment length
sarr
SourceSequence of ObsSource[Obs] objects
pos
Current position within the sequence
returns
A FeatureReturn with the observation feature as a hashcode
def allTagFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def antiPrefixFn(size: Int)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def antiSuffixFn(size: Int)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
final def asInstanceOf[T0]: T0

Definition Classes
Any
def attributeFn(att: String)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
val caselessWdFn: Fn
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val denseFeatureWt: Double
def distanceToLeft(att: String, vl: String)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def distanceToRight(att: String, vl: String)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
val downLexFn: Fn
val edgeFn: (Int, SourceSequence[Obs], Int) ⇒ FeatureReturn
val edgeFr: FeatureReturn
val edgePrFr: FeatureReturn
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getFeatureManager: FeatureManager[Obs]
def hashCode(): Int

Definition Classes
AnyRef → Any
val iString: String
val inducedFeatureMap: Option[InducedFeatureMap]
val inducingNewMap: Boolean
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val lex: Option[BloomLexicon]
val lexFn: Fn
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nearCorpAbbrev(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
val nearCorpCode: Long
def nearestLeft(att: String, vl: String, cp: Int, sarr: SourceSequence[Obs]): Int
def nearestRight(att: String, vl: String, cp: Int, sarr: SourceSequence[Obs]): Int
val nodeFn: (Int, SourceSequence[Obs], Int) ⇒ FeatureReturn
val nodeFr: FeatureReturn
val nodePrFr: FeatureReturn
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val numCode: Long
val numRegex: Regex
def phraseFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def phraseWds(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def predicateFn(name: String, fns: List[FeatureFn[Obs]])(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def prefNgrams(size: Int, range: Int)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def prefixFn(size: Int)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
val regexpFn: (String, Regex) ⇒ Fn
def reset: Unit
val selfWdCode: Long
def sentPosition(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def sufNgrams(size: Int, range: Int)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def suffixFn(size: Int)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
implicit def toBuiltFeature(s: String): BuiltFeature
def toString(): String

Definition Classes
AnyRef → Any
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( ... )
val wdFn: (Int, SourceSequence[Obs], Int) ⇒ FeatureReturn

Value for _wdFn _
Value for _wdFn _

See also
#_wdFn(Int,SourceSequence[Obs],Int)
def wdFnNorm(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def wdLen(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
val wdProps: Option[WordProperties]
val wdScoreCode: Long
val wdScores: Option[WordScores]
def wdShape(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
val wdShapeCode: Long
def weightedAttributes(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def wordPropertiesFn(down: Boolean)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def wordPropertiesPrefixesFn(interval: Int, down: Boolean)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn
def wordScoresFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

Related Docs: object FeatureManagerBuilder | package crf

abstract class FeatureManagerBuilder[Obs] extends Serializable

Instance Constructors

new FeatureManagerBuilder(lex: Option[BloomLexicon], wdProps: Option[WordProperties], wdScores: Option[WordScores], inducedFeatureMap: Option[InducedFeatureMap], iString: String, inducingNewMap: Boolean)

Type Members

type Fn = (Int, SourceSequence[Obs], Int) ⇒ FeatureReturn

type FnList = List[Fn]

Abstract Value Members

abstract def buildFeatureFns(s: String = "default"): List[FeatureFn[Obs]]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def _caselessWdFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def _edgeFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def _edgeFnSemi(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def _filteredLexFn(down: Boolean, filter: Set[String])(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def _lexiconFn(down: Boolean)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def _nodeFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def _nodeFnSemi(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def _phraseAttributeFn(att: String)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def _phraseLexFn(aph: Boolean)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def _preLabFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def _regexpFn(fname: String, regexp: Regex)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def _wdFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def allTagFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def antiPrefixFn(size: Int)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def antiSuffixFn(size: Int)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

final def asInstanceOf[T0]: T0

def attributeFn(att: String)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

val caselessWdFn: Fn

def clone(): AnyRef

val denseFeatureWt: Double

def distanceToLeft(att: String, vl: String)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def distanceToRight(att: String, vl: String)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

val downLexFn: Fn

val edgeFn: (Int, SourceSequence[Obs], Int) ⇒ FeatureReturn

val edgeFr: FeatureReturn

val edgePrFr: FeatureReturn

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def getFeatureManager: FeatureManager[Obs]

def hashCode(): Int

val iString: String

val inducedFeatureMap: Option[InducedFeatureMap]

val inducingNewMap: Boolean

final def isInstanceOf[T0]: Boolean

val lex: Option[BloomLexicon]

val lexFn: Fn

final def ne(arg0: AnyRef): Boolean

def nearCorpAbbrev(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

val nearCorpCode: Long

def nearestLeft(att: String, vl: String, cp: Int, sarr: SourceSequence[Obs]): Int

def nearestRight(att: String, vl: String, cp: Int, sarr: SourceSequence[Obs]): Int

val nodeFn: (Int, SourceSequence[Obs], Int) ⇒ FeatureReturn

val nodeFr: FeatureReturn

val nodePrFr: FeatureReturn

final def notify(): Unit

final def notifyAll(): Unit

val numCode: Long

val numRegex: Regex

def phraseFn(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def phraseWds(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def predicateFn(name: String, fns: List[FeatureFn[Obs]])(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def prefNgrams(size: Int, range: Int)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def prefixFn(size: Int)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

val regexpFn: (String, Regex) ⇒ Fn

def reset: Unit

val selfWdCode: Long

def sentPosition(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def sufNgrams(size: Int, range: Int)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

def suffixFn(size: Int)(s: Int, sarr: SourceSequence[Obs], pos: Int): FeatureReturn

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

implicit def toBuiltFeature(s: String): BuiltFeature

def toString(): String

final def wait(): Unit

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