Overview

Package

Class

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Serialized Form

Package edu.stanford.nlp.classify

Class edu.stanford.nlp.classify.AbstractLinearClassifierFactory extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

labelIndex

Index<E> labelIndex

featureIndex

Index<E> featureIndex

Class edu.stanford.nlp.classify.Dataset extends GeneralDataset<L,F> implements Serializable

serialVersionUID: -3883164942879961091L

Class edu.stanford.nlp.classify.GeneralDataset extends java.lang.Object implements Serializable

serialVersionUID: 19157757130054829L

Serialized Fields

labelIndex

Index<E> labelIndex

featureIndex

Index<E> featureIndex

labels

int[] labels

data

int[][] data

size

int size

Class edu.stanford.nlp.classify.KNNClassifier extends java.lang.Object implements Serializable

serialVersionUID: 7115357548209007944L

Serialized Fields

weightedVotes

boolean weightedVotes

instances

CollectionValuedMap<K,V> instances

classLookup

java.util.Map<K,V> classLookup

l2Normalize

boolean l2Normalize

k

int k

Class edu.stanford.nlp.classify.LinearClassifier extends java.lang.Object implements Serializable

serialVersionUID: 8499574525453275255L

Serialized Fields

weights

double[][] weights

Classifier weights. First index is the featureIndex value and second index is the labelIndex value.

labelIndex

Index<E> labelIndex

featureIndex

Index<E> featureIndex

intern

boolean intern

thresholds

double[] thresholds

Class edu.stanford.nlp.classify.LinearClassifierFactory extends AbstractLinearClassifierFactory<L,F> implements Serializable

serialVersionUID: 7893768984379107397L

Serialized Fields

TOL

double TOL

mem

int mem

verbose

boolean verbose

logPrior

LogPrior logPrior

tuneSigmaHeldOut

boolean tuneSigmaHeldOut

tuneSigmaCV

boolean tuneSigmaCV

folds

int folds

min

double min

max

double max

retrainFromScratchAfterSigmaTuning

boolean retrainFromScratchAfterSigmaTuning

minimizerCreator

Factory<T> minimizerCreator

evalIters

int evalIters

evaluators

Evaluator[] evaluators

heldOutSearcher

LineSearcher heldOutSearcher

Class edu.stanford.nlp.classify.LogisticClassifier extends java.lang.Object implements Serializable

serialVersionUID: 6672245467246897192L

Serialized Fields

weights

double[] weights

featureIndex

Index<E> featureIndex

classes

java.lang.Object[] classes

prior

LogPrior prior

Deprecated.

biased

boolean biased

Deprecated.

Class edu.stanford.nlp.classify.LogisticClassifierFactory extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

weights

double[] weights

featureIndex

Index<E> featureIndex

classes

java.lang.Object[] classes

Class edu.stanford.nlp.classify.LogPrior extends java.lang.Object implements Serializable

serialVersionUID: 7826853908892790965L

Serialized Fields

means

double[] means

otherPrior

LogPrior otherPrior

type

LogPrior.LogPriorType type

sigmaSqM

double[] sigmaSqM

sigmaQuM

double[] sigmaQuM

sigmaSq

double sigmaSq

sigmaQu

double sigmaQu

epsilon

double epsilon

Class edu.stanford.nlp.classify.NaiveBayesClassifier extends java.lang.Object implements Serializable

serialVersionUID: 1544820342684024068L

Serialized Fields

weights

Counter<E> weights

priors

Counter<E> priors

features

java.util.Set<E> features

addZeroValued

boolean addZeroValued

priorZero

Counter<E> priorZero

labels

java.util.Set<E> labels

zero

java.lang.Integer zero

Class edu.stanford.nlp.classify.NaiveBayesClassifierFactory extends java.lang.Object implements Serializable

serialVersionUID: -8164165428834534041L

Serialized Fields

kind

int kind

alphaClass

double alphaClass

alphaFeature

double alphaFeature

sigma

double sigma

prior

int prior

labelIndex

Index<E> labelIndex

featureIndex

Index<E> featureIndex

Class edu.stanford.nlp.classify.NBLinearClassifierFactory extends AbstractLinearClassifierFactory<L,F> implements Serializable

serialVersionUID: 1L

Serialized Fields

sigma

double sigma

interpretAlwaysOnFeatureAsPrior

boolean interpretAlwaysOnFeatureAsPrior

tuneSigma

boolean tuneSigma

folds

int folds

Class edu.stanford.nlp.classify.OneVsAllClassifier extends java.lang.Object implements Serializable

serialVersionUID: -743792054415242776L

Serialized Fields

featureIndex

Index<E> featureIndex

labelIndex

Index<E> labelIndex

binaryClassifiers

java.util.Map<K,V> binaryClassifiers

defaultLabel

java.lang.Object defaultLabel

Class edu.stanford.nlp.classify.RVFDataset extends GeneralDataset<L,F> implements Serializable

serialVersionUID: -3841757837680266182L

Serialized Fields

values

double[][] values

minValues

double[] minValues

maxValues

double[] maxValues

means

double[] means

stdevs

double[] stdevs

sourcesAndIds

java.util.ArrayList<E> sourcesAndIds

Class edu.stanford.nlp.classify.SVMLightClassifier extends LinearClassifier<L,F> implements Serializable

serialVersionUID: 1L

Serialized Fields

platt

LinearClassifier<L,F> platt

Class edu.stanford.nlp.classify.SVMLightClassifierFactory extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

C

double C

C can be tuned using held-out set or cross-validation For binary SVM, if C=0, svmlight uses default of 1/(avg x*x)

useSigmoid

boolean useSigmoid

verbose

boolean verbose

svmLightLearn

java.lang.String svmLightLearn

svmStructLearn

java.lang.String svmStructLearn

svmLightClassify

java.lang.String svmLightClassify

svmStructClassify

java.lang.String svmStructClassify

useAlphaFile

boolean useAlphaFile

alphaFile

java.io.File alphaFile

deleteTempFilesOnExit

boolean deleteTempFilesOnExit

svmLightVerbosity

int svmLightVerbosity

doEval

boolean doEval

tuneHeldOut

boolean tuneHeldOut

tuneCV

boolean tuneCV

scorer

Scorer<L> scorer

tuneMinimizer

LineSearcher tuneMinimizer

folds

int folds

heldOutPercent

double heldOutPercent

whitespacePattern

java.util.regex.Pattern whitespacePattern

Class edu.stanford.nlp.classify.WeightedDataset extends Dataset<L,F> implements Serializable

serialVersionUID: -5435125789127705430L

Serialized Fields

weights

float[] weights

Package edu.stanford.nlp.dcoref

Class edu.stanford.nlp.dcoref.CorefChain extends java.lang.Object implements Serializable

serialVersionUID: 3657691243506528L

Serialized Fields

chainID

int chainID

mentions

java.util.List<E> mentions

mentionMap

java.util.Map<K,V> mentionMap

representative

CorefChain.CorefMention representative

The most representative mention in this cluster

Class edu.stanford.nlp.dcoref.CorefChain.CorefMention extends java.lang.Object implements Serializable

serialVersionUID: 3657691243504173L

Serialized Fields

mentionType

Dictionaries.MentionType mentionType

number

Dictionaries.Number number

gender

Dictionaries.Gender gender

animacy

Dictionaries.Animacy animacy

startIndex

int startIndex

Starting word number, indexed from 1

endIndex

int endIndex

One past the end word number, indexed from 1

headIndex

int headIndex

Head word of the mention

corefClusterID

int corefClusterID

mentionID

int mentionID

sentNum

int sentNum

Sentence number in the document containing this mention, indexed from 1.

position

IntTuple position

Position is a binary tuple of (sentence number, mention number in that sentence). This is used for indexing by mention.

mentionSpan

java.lang.String mentionSpan

Class edu.stanford.nlp.dcoref.CorefCluster extends java.lang.Object implements Serializable

serialVersionUID: 8655265337578515592L

Serialized Fields

corefMentions

java.util.Set<E> corefMentions

clusterID

int clusterID

numbers

java.util.Set<E> numbers

genders

java.util.Set<E> genders

animacies

java.util.Set<E> animacies

nerStrings

java.util.Set<E> nerStrings

heads

java.util.Set<E> heads

words

java.util.Set<E> words

All words in this cluster - for word inclusion feature

firstMention

Mention firstMention

The first mention in this cluster

representative

Mention representative

Return the most representative mention in the chain. A proper noun mention or a mention with more pre-modifiers is preferred.

Class edu.stanford.nlp.dcoref.Document extends java.lang.Object implements Serializable

serialVersionUID: -4139866807494603953L

Serialized Fields

docType

Document.DocType docType

The type of document: conversational or article

annotation

Annotation annotation

Document annotation

conllDoc

CoNLL2011DocumentReader.Document conllDoc

for conll shared task 2011

goldOrderedMentionsBySentence

java.util.List<E> goldOrderedMentionsBySentence

The list of gold mentions

predictedOrderedMentionsBySentence

java.util.List<E> predictedOrderedMentionsBySentence

The list of predicted mentions

corefClusters

java.util.Map<K,V> corefClusters

Clusters for coreferent mentions

goldCorefClusters

java.util.Map<K,V> goldCorefClusters

Gold Clusters for coreferent mentions

allPredictedMentions

java.util.Map<K,V> allPredictedMentions

All mentions in a document mentionID -> mention

allGoldMentions

java.util.Map<K,V> allGoldMentions

roleSet

java.util.Set<E> roleSet

Set of roles (in role apposition) in a document

positions

java.util.Map<K,V> positions

Position of each mention in the input matrix Each mention occurrence with sentence # and position within sentence (Nth mention, not Nth token)

mentionheadPositions

java.util.Map<K,V> mentionheadPositions

goldLinks

java.util.List<E> goldLinks

List of gold links in a document by positions

speakers

java.util.Map<K,V> speakers

UtteranceAnnotation -> String (speaker): mention ID or speaker string

speakerPairs

java.util.Set<E> speakerPairs

mention ID pair

maxUtter

int maxUtter

numParagraph

int numParagraph

numSentences

int numSentences

incompatibles

java.util.Set<E> incompatibles

Set of incompatible mention pairs

Class edu.stanford.nlp.dcoref.Mention extends java.lang.Object implements Serializable

serialVersionUID: -7524485803945717057L

Serialized Fields

mentionType

Dictionaries.MentionType mentionType

number

Dictionaries.Number number

gender

Dictionaries.Gender gender

animacy

Dictionaries.Animacy animacy

person

Dictionaries.Person person

headString

java.lang.String headString

nerString

java.lang.String nerString

startIndex

int startIndex

endIndex

int endIndex

headIndex

int headIndex

mentionID

int mentionID

originalRef

int originalRef

headIndexedWord

IndexedWord headIndexedWord

goldCorefClusterID

int goldCorefClusterID

corefClusterID

int corefClusterID

sentNum

int sentNum

utter

int utter

paragraph

int paragraph

isSubject

boolean isSubject

isDirectObject

boolean isDirectObject

isIndirectObject

boolean isIndirectObject

isPrepositionObject

boolean isPrepositionObject

dependingVerb

IndexedWord dependingVerb

twinless

boolean twinless

generic

boolean generic

isSingleton

boolean isSingleton

sentenceWords

java.util.List<E> sentenceWords

originalSpan

java.util.List<E> originalSpan

mentionSubTree

Tree mentionSubTree

contextParseTree

Tree contextParseTree

headWord

CoreLabel headWord

dependency

SemanticGraph dependency

dependents

java.util.Set<E> dependents

preprocessedTerms

java.util.List<E> preprocessedTerms

synsets

java.lang.Object synsets

appositions

java.util.Set<E> appositions

Set of other mentions in the same sentence that are syntactic appositions to this

predicateNominatives

java.util.Set<E> predicateNominatives

relativePronouns

java.util.Set<E> relativePronouns

Package edu.stanford.nlp.graph

Class edu.stanford.nlp.graph.DirectedMultiGraph extends java.lang.Object implements Serializable

serialVersionUID: 609823567298345145L

Serialized Fields

outgoingEdges

java.util.Map<K,V> outgoingEdges

incomingEdges

java.util.Map<K,V> incomingEdges

Package edu.stanford.nlp.ie

Class edu.stanford.nlp.ie.ChineseMorphFeatureSets extends java.lang.Object implements Serializable

serialVersionUID: -1055526945031459198L

Serialized Fields

featIndex

Index<E> featIndex

singletonFeatures

java.util.Map<K,V> singletonFeatures

affixFeatures

java.util.Map<K,V> affixFeatures

Class edu.stanford.nlp.ie.NERFeatureFactory extends FeatureFactory<IN extends CoreLabel> implements Serializable

serialVersionUID: -2329726064739185544L

Serialized Fields

lexicon

java.util.Map<K,V> lexicon

wordToSubstrings

java.util.Map<K,V> wordToSubstrings

wordToGazetteEntries

java.util.Map<K,V> wordToGazetteEntries

wordToGazetteInfos

java.util.Map<K,V> wordToGazetteInfos

genericAnnotationKeys

java.util.Set<E> genericAnnotationKeys

lastNames

java.util.Set<E> lastNames

maleNames

java.util.Set<E> maleNames

femaleNames

java.util.Set<E> femaleNames

titlePattern

java.util.regex.Pattern titlePattern

Package edu.stanford.nlp.ie.crf

Class edu.stanford.nlp.ie.crf.CRFDatum extends java.lang.Object implements Serializable

serialVersionUID: -8345554365027671190L

Serialized Fields

features

java.util.List<E> features

Features for this Datum.

label

java.lang.Object label

featureVals

java.util.List<E> featureVals

Class edu.stanford.nlp.ie.crf.CRFLabel extends java.lang.Object implements Serializable

serialVersionUID: 7403010868396790276L

Serialized Fields

label

int[] label

hashCode

int hashCode

Package edu.stanford.nlp.ie.machinereading.common

Class edu.stanford.nlp.ie.machinereading.common.NoPunctuationHeadFinder extends ModCollinsHeadFinder implements Serializable

serialVersionUID: 1201891305937180385L

Package edu.stanford.nlp.ie.machinereading.domains.ace.reader

Class edu.stanford.nlp.ie.machinereading.domains.ace.reader.MatchException extends java.lang.RuntimeException implements Serializable

serialVersionUID: 24362462L

Package edu.stanford.nlp.ie.machinereading.structure

Class edu.stanford.nlp.ie.machinereading.structure.EntityMention extends ExtractionObject implements Serializable

serialVersionUID: -2745903102654191527L

Serialized Fields

mentionType

java.lang.String mentionType

Mention type, if available, e.g., nominal

corefID

java.lang.String corefID

headTokenSpan

Span headTokenSpan

Offsets the head span, e.g., "George Bush" in the extent "the president George Bush" The offsets are relative to the sentence containing this mention

syntacticHeadTokenPosition

int syntacticHeadTokenPosition

Position of the syntactic head word of this mention, e.g., "Bush" for the head span "George Bush" The offset is relative the sentence containing this mention Note: use headTokenSpan when sequence tagging entity mentions not this. This is meant to be used only for event/relation feature extraction!

normalizedName

java.lang.String normalizedName

Class edu.stanford.nlp.ie.machinereading.structure.EventMention extends RelationMention implements Serializable

serialVersionUID: 1L

Serialized Fields

eventModification

java.lang.String eventModification

Modifier argument: used for BioNLP

anchor

ExtractionObject anchor

parents

java.util.Set<E> parents

Class edu.stanford.nlp.ie.machinereading.structure.ExtractionObject extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

objectId

java.lang.String objectId

Unique identifier of the object in its document

sentence

CoreMap sentence

Sentence that contains this object This assumes that each extraction object is intra-sentential (true in ACE, Roth, BioNLP, MR)

type

java.lang.String type

Type of this mention, e.g., GPE

subType

java.lang.String subType

Subtype, if available, e.g., GPE.CITY

extentTokenSpan

Span extentTokenSpan

Maximal token span relevant for this object, e.g., the largest NP for an entity mention The offsets are relative to the sentence that contains this object

attributeMap

CoreMap attributeMap

This stores any optional attributes of ExtractionObjects

typeProbabilities

Counter<E> typeProbabilities

Probabilities associated with this object We report probability values for each possible type for this object

Class edu.stanford.nlp.ie.machinereading.structure.RelationMention extends ExtractionObject implements Serializable

serialVersionUID: 8962289597607972827L

Serialized Fields

argNames

java.util.List<E> argNames

List of argument names in this relation

args

java.util.List<E> args

List of arguments in this relation If unnamed, arguments MUST be stored in semantic order, e.g., ARG0 must be a person in a employed-by relation

signature

java.lang.String signature

A signature for a given relation mention, e.g., a concatenation of type and argument strings This is used in KBP, where we merge all RelationMentions corresponding to the same abstract relation

Class edu.stanford.nlp.ie.machinereading.structure.RelationMentionFactory extends java.lang.Object implements Serializable

serialVersionUID: -662846276208839290L

Class edu.stanford.nlp.ie.machinereading.structure.Span extends java.lang.Object implements Serializable

serialVersionUID: -3861451490217976693L

Serialized Fields

start

int start

end

int end

Package edu.stanford.nlp.international.arabic

Class edu.stanford.nlp.international.arabic.ArabicMorphoFeatureSpecification extends MorphoFeatureSpecification implements Serializable

serialVersionUID: 4448045447200922076L

Class edu.stanford.nlp.international.arabic.ArabicMorphoFeatureSpecification.ArabicMorphoFeatures extends MorphoFeatures implements Serializable

serialVersionUID: -4611776415583633186L

Class edu.stanford.nlp.international.arabic.ArabicWordLists extends java.lang.Object implements Serializable

serialVersionUID: 2752179429568209320L

Class edu.stanford.nlp.international.arabic.Buckwalter extends java.lang.Object implements Serializable

serialVersionUID: 4351710914246859336L

Serialized Fields

outputUnicodeValues

boolean outputUnicodeValues

If true (include flag "-o"), outputs space separated unicode values (e.g., "ء" rather than the character version of those values. Only applicable for Buckwalter to Arabic conversion.

arabicChars

char[] arabicChars

buckChars

char[] buckChars

unicode2Buckwalter

boolean unicode2Buckwalter

u2bMap

java.util.Map<K,V> u2bMap

b2uMap

java.util.Map<K,V> b2uMap

unmappable

ClassicCounter<E> unmappable

Package edu.stanford.nlp.international.arabic.pipeline

Class edu.stanford.nlp.international.arabic.pipeline.DefaultLexicalMapper extends java.lang.Object implements Serializable

serialVersionUID: -3798804368296999785L

Serialized Fields

utf8ArabicChart

java.util.regex.Pattern utf8ArabicChart

bwAlefChar

java.lang.String bwAlefChar

bwDiacritics

java.util.regex.Pattern bwDiacritics

bwTatweel

java.util.regex.Pattern bwTatweel

bwAlef

java.util.regex.Pattern bwAlef

bwQuran

java.util.regex.Pattern bwQuran

bwNullAnaphoraMarker

java.util.regex.Pattern bwNullAnaphoraMarker

latinPunc

java.util.regex.Pattern latinPunc

arabicPunc

java.util.regex.Pattern arabicPunc

arabicDigit

java.util.regex.Pattern arabicDigit

utf8Diacritics

java.util.regex.Pattern utf8Diacritics

utf8Tatweel

java.util.regex.Pattern utf8Tatweel

utf8Alef

java.util.regex.Pattern utf8Alef

utf8Quran

java.util.regex.Pattern utf8Quran

utf8ProDrop

java.util.regex.Pattern utf8ProDrop

segmentationMarker

java.util.regex.Pattern segmentationMarker

morphemeBoundary

java.util.regex.Pattern morphemeBoundary

hasDigit

java.util.regex.Pattern hasDigit

useATBVocalizedSectionMapping

boolean useATBVocalizedSectionMapping

stripMorphemeMarkersInUTF8

boolean stripMorphemeMarkersInUTF8

stripSegmentationMarkersInUTF8

boolean stripSegmentationMarkersInUTF8

parentTagString

java.lang.String parentTagString

parentTagsToEscape

java.util.Set<E> parentTagsToEscape

utf8CliticString

java.lang.String utf8CliticString

bwClitics

java.util.Set<E> bwClitics

Class edu.stanford.nlp.international.arabic.pipeline.UnvocLexicalMapper extends DefaultLexicalMapper implements Serializable

serialVersionUID: -8702531532523913125L

Package edu.stanford.nlp.international.arabic.process

Class edu.stanford.nlp.international.arabic.process.ArabicDocumentReaderAndWriter extends java.lang.Object implements Serializable

serialVersionUID: 6730676681967976015L

Serialized Fields

factory

IteratorFromReaderFactory<T> factory

tf

TokenizerFactory<T> tf

segMarker

java.lang.Character segMarker

tagDelimiter

java.lang.String tagDelimiter

inputHasTags

boolean inputHasTags

Class edu.stanford.nlp.international.arabic.process.ArabicSegmenter extends java.lang.Object implements Serializable

serialVersionUID: -4791848633597417788L

Serialized Fields

optTokenized

java.lang.String optTokenized

optTokenizer

java.lang.String optTokenizer

optPrefix

java.lang.String optPrefix

optSuffix

java.lang.String optSuffix

optThreads

java.lang.String optThreads

flags

SeqClassifierFlags flags

tf

TokenizerFactory<T> tf

prefixMarker

java.lang.String prefixMarker

suffixMarker

java.lang.String suffixMarker

isTokenized

boolean isTokenized

tokenizerOptions

java.lang.String tokenizerOptions

Class edu.stanford.nlp.international.arabic.process.ArabicSegmenterFeatureFactory extends FeatureFactory<IN extends CoreLabel> implements Serializable

serialVersionUID: -4560226365250020067L

Class edu.stanford.nlp.international.arabic.process.ArabicTokenizer.ArabicTokenizerFactory extends java.lang.Object implements Serializable

serialVersionUID: 946818805507187330L

Serialized Fields

factory

LexedTokenFactory<T> factory

lexerProperties

java.util.Properties lexerProperties

Package edu.stanford.nlp.international.french

Class edu.stanford.nlp.international.french.FrenchMorphoFeatureSpecification extends MorphoFeatureSpecification implements Serializable

serialVersionUID: -58379347760106784L

Package edu.stanford.nlp.international.morph

Class edu.stanford.nlp.international.morph.MorphoFeatures extends java.lang.Object implements Serializable

serialVersionUID: -3893316324305154940L

Serialized Fields

fSpec

java.util.Map<K,V> fSpec

altTag

java.lang.String altTag

Class edu.stanford.nlp.international.morph.MorphoFeatureSpecification extends java.lang.Object implements Serializable

serialVersionUID: -5720683653931585664L

Serialized Fields

activeFeatures

java.util.Set<E> activeFeatures

Package edu.stanford.nlp.io

Class edu.stanford.nlp.io.RuntimeIOException extends java.lang.RuntimeException implements Serializable

serialVersionUID: -8572218999165094626L

Package edu.stanford.nlp.ling

Class edu.stanford.nlp.ling.BasicDatum extends java.lang.Object implements Serializable

serialVersionUID: -4857004070061779966L

Serialized Fields

features

java.util.Collection<E> features

features for this Datum

labels

java.util.List<E> labels

labels for this Datum. Invariant: always non-null

Class edu.stanford.nlp.ling.BasicDocument extends java.util.ArrayList<Word> implements Serializable

serialVersionUID: -24171720584352262L

Serialized Fields

title

java.lang.String title

title of this document (never null).

originalText

java.lang.String originalText

original text of this document (may be null).

labels

java.util.List<E> labels

Label(s) for this document.

tokenizerFactory

TokenizerFactory<T> tokenizerFactory

TokenizerFactory used to convert the text into words inside BasicDocument.parse(String).

Class edu.stanford.nlp.ling.CategoryWordTag extends StringLabel implements Serializable

serialVersionUID: -745085381666943254L

Serialized Fields

word

java.lang.String word

tag

java.lang.String tag

Class edu.stanford.nlp.ling.CoreLabel extends ArrayCoreMap implements Serializable

serialVersionUID: 2L

Class edu.stanford.nlp.ling.IndexedWord extends CoreLabel implements Serializable

serialVersionUID: 3739633991145239829L

Class edu.stanford.nlp.ling.LabeledWord extends Word implements Serializable

serialVersionUID: -7252006452127051085L

Serialized Fields

tag

Label tag

Class edu.stanford.nlp.ling.RVFDatum extends java.lang.Object implements Serializable

serialVersionUID: -255312811814660438L

Serialized Fields

features

Counter<E> features

features for this Datum

label

java.lang.Object label

labels for this Datum. Invariant: always non-null

Class edu.stanford.nlp.ling.StringLabel extends ValueLabel implements Serializable

serialVersionUID: -4153619273767524247L

Serialized Fields

str

java.lang.String str

beginPosition

int beginPosition

Start position of the word in the original input string

endPosition

int endPosition

End position of the word in the original input string

Class edu.stanford.nlp.ling.Tag extends StringLabel implements Serializable

serialVersionUID: 1143434026005416755L

Class edu.stanford.nlp.ling.TaggedWord extends Word implements Serializable

serialVersionUID: -7252006452127051085L

Serialized Fields

tag

java.lang.String tag

Class edu.stanford.nlp.ling.ValueLabel extends java.lang.Object implements Serializable

serialVersionUID: -1413303679077285530L

Class edu.stanford.nlp.ling.Word extends StringLabel implements Serializable

serialVersionUID: -4817252915997034058L

Class edu.stanford.nlp.ling.WordLemmaTag extends java.lang.Object implements Serializable

serialVersionUID: -5993410244163988138L

Serialized Fields

word

java.lang.String word

lemma

java.lang.String lemma

tag

java.lang.String tag

Class edu.stanford.nlp.ling.WordTag extends java.lang.Object implements Serializable

serialVersionUID: -1859527239216813742L

Serialized Fields

word

java.lang.String word

tag

java.lang.String tag

Package edu.stanford.nlp.ling.tokensregex

Class edu.stanford.nlp.ling.tokensregex.PhraseTable extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

rootTree

java.util.Map<K,V> rootTree

normalize

boolean normalize

caseInsensitive

boolean caseInsensitive

ignorePunctuation

boolean ignorePunctuation

ignorePunctuationTokens

boolean ignorePunctuationTokens

tokenizer

Annotator tokenizer

nPhrases

int nPhrases

nStrings

int nStrings

MAX_LIST_SIZE

int MAX_LIST_SIZE

Class edu.stanford.nlp.ling.tokensregex.SequenceMatchRules.AnnotationExtractRule extends java.lang.Object implements Serializable

Serialized Fields

name

java.lang.String name

Name of the rule

stage

int stage

Stage in which this rule should be applied with respect to others

priority

double priority

Priority in which this rule should be applied with respect to others

weight

double weight

Weight given to the rule (how likely is this rule to fire)

annotationField

java.lang.Class<T> annotationField

Annotation field to apply rule over: text or tokens or numerizedtokens

tokensAnnotationField

java.lang.Class<T> tokensAnnotationField

tokensResultAnnotationField

java.util.List<E> tokensResultAnnotationField

Annotation field(s) on individual tokens to put new annotation

resultAnnotationField

java.util.List<E> resultAnnotationField

Annotation field(s) to put new annotation

resultNestedAnnotationField

java.lang.Class<T> resultNestedAnnotationField

Annotation field for child/nested annotations

matchFindType

SequenceMatcher.FindType matchFindType

matchedExpressionGroup

int matchedExpressionGroup

matchWithResults

boolean matchWithResults

ruleType

java.lang.String ruleType

Type of rule to apply: token string match, pattern string match

isComposite

boolean isComposite

includeNested

boolean includeNested

active

boolean active

extractRule

SequenceMatchRules.ExtractRule<I,O> extractRule

Actual rule performing the extraction (converting annotation to MatchedExpression)

filterRule

Filter<T> filterRule

Class edu.stanford.nlp.ling.tokensregex.SequenceMatchRules.AnnotationMatchedFilter extends java.lang.Object implements Serializable

Serialized Fields

extractor

MatchedExpression.SingleAnnotationExtractor extractor

Class edu.stanford.nlp.ling.tokensregex.SequencePattern.SequenceEndPatternExpr extends SequencePattern.SpecialNodePatternExpr implements Serializable

Class edu.stanford.nlp.ling.tokensregex.SequencePattern.SequenceStartPatternExpr extends SequencePattern.SpecialNodePatternExpr implements Serializable

Package edu.stanford.nlp.ling.tokensregex.parser

Class edu.stanford.nlp.ling.tokensregex.parser.ParseException extends java.lang.Exception implements Serializable

serialVersionUID: 1L

Serialized Fields

currentToken

edu.stanford.nlp.ling.tokensregex.parser.Token currentToken

This is the last token that has been consumed successfully. If this object has been created due to a parse error, the token followng this token will (therefore) be the first error token.

expectedTokenSequences

int[][] expectedTokenSequences

Each entry in this array is an array of integers. Each array of integers represents a sequence of tokens (by their ordinal values) that is expected at this point of the parse.

tokenImage

java.lang.String[] tokenImage

This is a reference to the "tokenImage" array of the generated parser within which the parse error occurred. This array is defined in the generated ...Constants interface.

eol

java.lang.String eol

The end of line string for this machine.

Package edu.stanford.nlp.ling.tokensregex.types

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.AndExpression extends Expressions.FunctionCallExpression implements Serializable

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.AssignableFunctionCallExpression extends Expressions.FunctionCallExpression implements Serializable

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.CompositeValue extends Expressions.SimpleCachedExpression<java.util.Map<java.lang.String,Expression>> implements Serializable

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.FieldExpression extends Expressions.AssignableFunctionCallExpression implements Serializable

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.FunctionCallExpression extends Expressions.TypedExpression implements Serializable

Serialized Fields

function

java.lang.String function

params

java.util.List<E> params

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.IfExpression extends Expressions.TypedExpression implements Serializable

Serialized Fields

condExpr

Expression condExpr

trueExpr

Expression trueExpr

falseExpr

Expression falseExpr

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.IndexedExpression extends Expressions.AssignableFunctionCallExpression implements Serializable

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.ListExpression extends Expressions.TypedExpression implements Serializable

Serialized Fields

exprs

java.util.List<E> exprs

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.MethodCallExpression extends Expressions.TypedExpression implements Serializable

Serialized Fields

function

java.lang.String function

object

Expression object

params

java.util.List<E> params

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.NotExpression extends Expressions.FunctionCallExpression implements Serializable

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.OrExpression extends Expressions.FunctionCallExpression implements Serializable

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.PrimitiveValue extends Expressions.SimpleValue<T> implements Serializable

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.RegexMatchResultVarExpression extends Expressions.SimpleExpression implements Serializable

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.RegexMatchVarExpression extends Expressions.SimpleExpression implements Serializable

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.RegexValue extends Expressions.SimpleValue<java.lang.String> implements Serializable

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.SimpleCachedExpression extends Expressions.SimpleExpression<T> implements Serializable

Serialized Fields

evaluated

Value<T> evaluated

disableCaching

boolean disableCaching

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.SimpleExpression extends Expressions.TypedExpression implements Serializable

Serialized Fields

value

java.lang.Object value

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.SimpleValue extends Expressions.TypedExpression implements Serializable

Serialized Fields

value

java.lang.Object value

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.TypedExpression extends java.lang.Object implements Serializable

serialVersionUID: 2L

Serialized Fields

typename

java.lang.String typename

varName

java.lang.String varName

valueExpr

Expression valueExpr

bindAsValue

boolean bindAsValue

Class edu.stanford.nlp.ling.tokensregex.types.Expressions.VarExpression extends Expressions.SimpleExpression<java.lang.String> implements Serializable

Class edu.stanford.nlp.ling.tokensregex.types.Tags extends java.lang.Object implements Serializable

serialVersionUID: 2L

Serialized Fields

val

double val

dot

double dot

Package edu.stanford.nlp.objectbank

Class edu.stanford.nlp.objectbank.DelimitRegExIterator.DelimitRegExIteratorFactory extends java.lang.Object implements Serializable

serialVersionUID: 6846060575832573082L

Serialized Fields

delim

java.lang.String delim

op

Function<T1,T2> op

Class edu.stanford.nlp.objectbank.LineIterator.LineIteratorFactory extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

oper

Function<T1,T2> oper

Class edu.stanford.nlp.objectbank.ObjectBank extends java.lang.Object implements Serializable

serialVersionUID: -4030295596701541770L

Serialized Fields

rif

ReaderIteratorFactory rif

ifrf

IteratorFromReaderFactory<T> ifrf

java.util.List<E> contents

keepInMemory

boolean keepInMemory

Package edu.stanford.nlp.optimization

Class edu.stanford.nlp.optimization.QNMinimizer.SurpriseConvergence extends java.lang.Throwable implements Serializable

serialVersionUID: 4290178321643529559L

Class edu.stanford.nlp.optimization.ScaledSGDMinimizer.Weights extends java.lang.Object implements Serializable

serialVersionUID: 814182172645533781L

Serialized Fields

w

double[] w

d

double[] d

Class edu.stanford.nlp.optimization.SGDToQNMinimizer extends java.lang.Object implements Serializable

serialVersionUID: -7551807670291500396L

Serialized Fields

bSize

int bSize

quiet

boolean quiet

outputIterationsToFile

boolean outputIterationsToFile

gain

double gain

SGDPasses

int SGDPasses

QNPasses

int QNPasses

hessSampleSize

int hessSampleSize

QNMem

int QNMem

Package edu.stanford.nlp.parser.dvparser

Class edu.stanford.nlp.parser.dvparser.CombinedDVModelReranker extends java.lang.Object implements Serializable

Serialized Fields

op

Options op

models

java.util.List<E> models

Class edu.stanford.nlp.parser.dvparser.DVModel extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Throws:: java.io.IOException; java.lang.ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException

Throws:: java.io.IOException

Serialized Fields

numBinaryMatrices

int numBinaryMatrices

numUnaryMatrices

int numUnaryMatrices

binaryTransformSize

int binaryTransformSize

unaryTransformSize

int unaryTransformSize

binaryScoreSize

int binaryScoreSize

unaryScoreSize

int unaryScoreSize

op

Options op

numCols

int numCols

numRows

int numRows

rand

java.util.Random rand

Class edu.stanford.nlp.parser.dvparser.DVModelReranker extends java.lang.Object implements Serializable

serialVersionUID: 7897546308624261207L

Serialized Fields

op

Options op

model

DVModel model

Class edu.stanford.nlp.parser.dvparser.FilterConfusingRules extends java.lang.Object implements Serializable

Serialized Fields

unaryRules

java.util.Set<E> unaryRules

binaryRules

TwoDimensionalSet<K1,K2> binaryRules

Package edu.stanford.nlp.parser.lexparser

Class edu.stanford.nlp.parser.lexparser.AbstractDependencyGrammar extends java.lang.Object implements Serializable

serialVersionUID: 3L

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream ois)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Throws:: java.io.IOException; java.lang.ClassNotFoundException

Serialized Fields

tagProjection

TagProjection tagProjection

tagIndex

Index<E> tagIndex

wordIndex

Index<E> wordIndex

numTagBins

int numTagBins

tagBin

int[] tagBin

tlp

TreebankLanguagePack tlp

directional

boolean directional

useDistance

boolean useDistance

useCoarseDistance

boolean useCoarseDistance

lex

Lexicon lex

stopTW

IntTaggedWord stopTW

wildTW

IntTaggedWord wildTW

coarseDistanceBins

int[] coarseDistanceBins

regDistanceBins

int[] regDistanceBins

op

Options op

Class edu.stanford.nlp.parser.lexparser.AbstractTreebankParserParams extends java.lang.Object implements Serializable

serialVersionUID: 4299501909017975915L

Serialized Fields

evalGF

boolean evalGF

If true, then evaluation is over grammatical functions as well as the labels If false, then grammatical functions are stripped for evaluation. This really only makes sense if you've trained with grammatical functions but want to evaluate without them.

inputEncoding

java.lang.String inputEncoding

outputEncoding

java.lang.String outputEncoding

tlp

TreebankLanguagePack tlp

Class edu.stanford.nlp.parser.lexparser.AbstractTreebankParserParams.AnnotatePunctuationFunction extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

key

java.lang.String key

annotationMark

java.lang.String annotationMark

Class edu.stanford.nlp.parser.lexparser.ArabicTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: 8853426784197984653L

Serialized Fields

optionsString

java.lang.StringBuilder optionsString

retainNPTmp

boolean retainNPTmp

retainNPSbj

boolean retainNPSbj

retainPRD

boolean retainPRD

retainPPClr

boolean retainPPClr

changeNoLabels

boolean changeNoLabels

collinizerRetainsPunctuation

boolean collinizerRetainsPunctuation

discardX

boolean discardX

headFinder

HeadFinder headFinder

annotationPatterns

java.util.Map<K,V> annotationPatterns

activeAnnotations

java.util.List<E> activeAnnotations

morphoSpec

MorphoFeatureSpecification morphoSpec

baselineFeatures

java.util.List<E> baselineFeatures

These are the annotations included when the user selects the -arabicFactored option.

additionalFeatures

java.util.List<E> additionalFeatures

Class edu.stanford.nlp.parser.lexparser.ArabicUnknownWordModel extends BaseUnknownWordModel implements Serializable

serialVersionUID: 4825624957364628771L

Serialized Fields

smartMutation

boolean smartMutation

unknownSuffixSize

int unknownSuffixSize

unknownPrefixSize

int unknownPrefixSize

Class edu.stanford.nlp.parser.lexparser.BaseLexicon extends java.lang.Object implements Serializable

serialVersionUID: 40L

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream ois)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Throws:: java.io.IOException; java.lang.ClassNotFoundException

Serialized Fields

uwModel

UnknownWordModel uwModel

uwModelTrainerClass

java.lang.String uwModelTrainerClass

trainOptions

TrainOptions trainOptions

testOptions

TestOptions testOptions

op

Options op

smoothInUnknownsThreshold

int smoothInUnknownsThreshold

If a word has been seen more than this many times, then relative frequencies of tags are used for POS assignment; if not, they are smoothed with tag priors.

smartMutation

boolean smartMutation

Have tags changeable based on statistics on word types having various taggings.

wordIndex

Index<E> wordIndex

tagIndex

Index<E> tagIndex

seenCounter

ClassicCounter<E> seenCounter

Records the number of times word/tag pair was seen in training data. Includes word/tag pairs where one is a wildcard not a real word/tag.

smooth

double[] smooth

flexiTag

boolean flexiTag

useSignatureForKnownSmoothing

boolean useSignatureForKnownSmoothing

baseTagCounts

java.util.Map<K,V> baseTagCounts

Only used when training, specifically when training on sentenes that weren't part of annotated (eg markovized, etc) data

tagsToBaseTags

int[] tagsToBaseTags

Class edu.stanford.nlp.parser.lexparser.BaseUnknownWordModel extends java.lang.Object implements Serializable

serialVersionUID: 6355171148751673822L

Serialized Fields

useFirst

boolean useFirst

useEnd

boolean useEnd

useGT

boolean useGT

useFirstCap

boolean useFirstCap

endLength

int endLength

unknownLevel

int unknownLevel

What type of equivalence classing is done in getSignature

trainOptions

TrainOptions trainOptions

wordIndex

Index<E> wordIndex

tagIndex

Index<E> tagIndex

unSeenCounter

ClassicCounter<E> unSeenCounter

Has counts for taggings in terms of unseen signatures. The IntTagWords are for (tag,sig), (tag,null), (null,sig), (null,null). (None for basic UNK if there are signatures.)

tagHash

java.util.Map<K,V> tagHash

This maps from a tag (as a label) to a Counter from word signatures to their P(sig|tag), as estimated in the model. For Chinese, the word signature is just the first character or its unicode type for things that aren't Chinese characters.

seenEnd

java.util.Set<E> seenEnd

This is the set of all signatures that we have seen.

unknownGT

java.util.Map<K,V> unknownGT

lex

Lexicon lex

All classes that implement UnknownWordModel must call the constructor that initializes this variable.

Class edu.stanford.nlp.parser.lexparser.BinaryGrammar extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Throws:: java.io.IOException; java.lang.ClassNotFoundException

Serialized Fields

index

Index<E> index

allRules

java.util.List<E> allRules

Class edu.stanford.nlp.parser.lexparser.BinaryRule extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

parent

int parent

score

float score

Score should be a log probability

leftChild

int leftChild

rightChild

int rightChild

hashCode

int hashCode

Class edu.stanford.nlp.parser.lexparser.ChineseCharacterBasedLexicon extends java.lang.Object implements Serializable

serialVersionUID: -5357655683145854069L

Serialized Fields

lengthPenalty

double lengthPenalty

penaltyType

int penaltyType

charDistributions

java.util.Map<K,V> charDistributions

knownChars

java.util.Set<E> knownChars

POSDistribution

Distribution<E> POSDistribution

useUnknownCharacterModel

boolean useUnknownCharacterModel

wordIndex

Index<E> wordIndex

tagIndex

Index<E> tagIndex

Class edu.stanford.nlp.parser.lexparser.ChineseLexicon extends BaseLexicon implements Serializable

serialVersionUID: -7836464391021114960L

Serialized Fields

useCharBasedUnknownWordModel

boolean useCharBasedUnknownWordModel

useGoodTuringUnknownWordModel

boolean useGoodTuringUnknownWordModel

probRandomWalk

edu.stanford.nlp.parser.lexparser.RandomWalk probRandomWalk

Class edu.stanford.nlp.parser.lexparser.ChineseLexiconAndWordSegmenter extends java.lang.Object implements Serializable

serialVersionUID: -6554995189795187918L

Serialized Fields

chineseLexicon

ChineseLexicon chineseLexicon

wordSegmenter

WordSegmenter wordSegmenter

op

Options op

Class edu.stanford.nlp.parser.lexparser.ChineseMarkovWordSegmenter extends java.lang.Object implements Serializable

serialVersionUID: 1559606198270645508L

Serialized Fields

initialPOSDist

Distribution<E> initialPOSDist

markovPOSDists

java.util.Map<K,V> markovPOSDists

lex

ChineseCharacterBasedLexicon lex

POSes

java.util.Set<E> POSes

wordIndex

Index<E> wordIndex

tagIndex

Index<E> tagIndex

Class edu.stanford.nlp.parser.lexparser.ChineseMaxentLexicon extends java.lang.Object implements Serializable

serialVersionUID: 238834703409896852L

Serialized Fields

featExtractor

edu.stanford.nlp.parser.lexparser.ChineseWordFeatureExtractor featExtractor

wordThreshold

Pair<T1,T2> wordThreshold

charThreshold

Pair<T1,T2> charThreshold

bigramThreshold

Pair<T1,T2> bigramThreshold

conjThreshold

Pair<T1,T2> conjThreshold

featureThresholds

java.util.List<E> featureThresholds

universalThreshold

int universalThreshold

scorer

LinearClassifier<L,F> scorer

functionWordTags

java.util.Map<K,V> functionWordTags

tagDist

Distribution<E> tagDist

wordIndex

Index<E> wordIndex

tagIndex

Index<E> tagIndex

iteratorCutoffFactor

double iteratorCutoffFactor

initialWeightFile

java.lang.String initialWeightFile

trainFloat

boolean trainFloat

tol

double tol

sigma

double sigma

featureLevel

int featureLevel

trainOnLowCount

boolean trainOnLowCount

trainByType

boolean trainByType

tlpParams

TreebankLangParserParams tlpParams

ctlp

TreebankLanguagePack ctlp

op

Options op

tagsForWord

CollectionValuedMap<K,V> tagsForWord

Class edu.stanford.nlp.parser.lexparser.ChineseSimWordAvgDepGrammar extends MLEDependencyGrammar implements Serializable

serialVersionUID: -1845503582705055342L

Serialized Fields

simSmooth

double simSmooth

simArgMap

java.util.Map<K,V> simArgMap

simHeadMap

java.util.Map<K,V> simHeadMap

debug

boolean debug

verbose

boolean verbose

statsCounter

ClassicCounter<E> statsCounter

Class edu.stanford.nlp.parser.lexparser.ChineseTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: 2L

Serialized Fields

ctlp

ChineseTreebankLanguagePack ctlp

The variable ctlp stores the same thing as the tlp variable in AbstractTreebankParserParams, but pre-cast to be a ChineseTreebankLanguagePack.

charTags

boolean charTags

useCharacterBasedLexicon

boolean useCharacterBasedLexicon

useMaxentLexicon

boolean useMaxentLexicon

useMaxentDepGrammar

boolean useMaxentDepGrammar

segment

boolean segment

segmentMarkov

boolean segmentMarkov

sunJurafskyHeadFinder

boolean sunJurafskyHeadFinder

bikelHeadFinder

boolean bikelHeadFinder

discardFrags

boolean discardFrags

useSimilarWordMap

boolean useSimilarWordMap

segmenterClass

java.lang.String segmenterClass

lex

Lexicon lex

segmenter

WordSegmenter segmenter

headFinder

HeadFinder headFinder

chineseSplitDouHao

boolean chineseSplitDouHao

Chinese: Split the dou hao (a punctuation mark separating members of a list) from other punctuation. Good but included below.

chineseSplitPunct

boolean chineseSplitPunct

Chinese: split Chinese punctuation several ways, along the lines of English punctuation plus another category for the dou hao. Good.

chineseSplitPunctLR

boolean chineseSplitPunctLR

Chinese: split left right/paren quote (if chineseSplitPunct is also true. Only very marginal gains, but seems positive.

markVVsisterIP

boolean markVVsisterIP

Chinese: mark VVs that are sister of IP (communication & small-clause-taking verbs). Good: give 0.5%

markPsisterIP

boolean markPsisterIP

Chinese: mark P's that are sister of IP. Negative effect

markIPsisterVVorP

boolean markIPsisterVVorP

Chinese: mark IP's that are sister of VV or P. These rarely have punctuation. Small positive effect.

markADgrandchildOfIP

boolean markADgrandchildOfIP

Chinese: mark ADs that are grandchild of IP.

gpaAD

boolean gpaAD

Grandparent annotate all AD. Seems slightly negative.

chineseVerySelectiveTagPA

boolean chineseVerySelectiveTagPA

chineseSelectiveTagPA

boolean chineseSelectiveTagPA

markIPsisterBA

boolean markIPsisterBA

Chinese: mark IPs that are sister of BA. These always have overt NP. Very slightly positive.

markVPadjunct

boolean markVPadjunct

Chinese: mark phrases that are adjuncts of VP (these tend to be locatives/temporals, and have a specific distribution). Necessary even with chineseSplitVP==3 and parent annotation because parent annotation happens with unsplit parent categories. Slightly positive.

markNPmodNP

boolean markNPmodNP

Chinese: mark NP modifiers of NPs. Quite positive (0.5%)

markModifiedNP

boolean markModifiedNP

Chinese: mark left-modified NPs (rightmost NPs with a left-side mod). Slightly positive.

markNPconj

boolean markNPconj

Chinese: mark NPs that are conjuncts. Negative on small set.

markMultiNtag

boolean markMultiNtag

Chinese: mark nominal tags that are part of multi-nominal rewrites. Doesn't seem any good.

markIPsisDEC

boolean markIPsisDEC

Chinese: mark IPs that are part of prenominal modifiers. Negative.

markIPconj

boolean markIPconj

Chinese: mark IPs that are conjuncts. Or those that have (adjuncts or subjects)

markIPadjsubj

boolean markIPadjsubj

chineseSplitVP

int chineseSplitVP

Chinese VP splitting. 0 = none; 1 = mark with -BA a VP that directly dominates a BA; 2 = mark with -BA a VP that directly dominates a BA or a VP that directly dominates a BA 3 = split VPs into VP-COMP, VP-CRD, VP-ADJ. (Negative value.)

mergeNNVV

boolean mergeNNVV

Chinese: merge NN and VV. A lark.

unaryIP

boolean unaryIP

Chinese: unary category marking

unaryCP

boolean unaryCP

paRootDtr

boolean paRootDtr

Chinese: parent annotate daughter of root. Meant only for selectivesplit=false.

markPostverbalP

boolean markPostverbalP

Chinese: mark P with a left aunt VV, and PP with a left sister VV. Note that it's necessary to mark both to thread the context-marking. Used to identify post-verbal P's, which are rare.

markPostverbalPP

boolean markPostverbalPP

splitBaseNP

boolean splitBaseNP

Mark base NPs. Good.

tagWordSize

boolean tagWordSize

Annotate tags for number of characters contained.

markCC

boolean markCC

Mark phrases which are conjunctions. Appears negative, even with 200K words training data.

splitNPTMP

boolean splitNPTMP

Whether to retain the -TMP functional tag on various phrasal categories. On 80K words training, minutely helpful; on 200K words, best option gives 0.6%. Doing splitNPTMP and splitPPTMP (but not splitXPTMP) is best.

splitPPTMP

boolean splitPPTMP

splitXPTMP

boolean splitXPTMP

dominatesV

boolean dominatesV

Verbal distance -- mark whether symbol dominates a verb (V*). Seems bad for Chinese.

useGoodTuringUnknownWordModel

boolean useGoodTuringUnknownWordModel

useCharBasedUnknownWordModel

boolean useCharBasedUnknownWordModel

lengthPenalty

double lengthPenalty

Parameters for a ChineseCharacterBasedLexicon

useUnknownCharacterModel

boolean useUnknownCharacterModel

penaltyType

int penaltyType

penaltyType should be set as follows: 0: no length penalty 1: quadratic length penalty 2: penalty for continuation chars only TODO: make this an enum

depGramFeatureLevel

int depGramFeatureLevel

Class edu.stanford.nlp.parser.lexparser.ChineseUnknownWordModel extends BaseUnknownWordModel implements Serializable

serialVersionUID: 221L

Serialized Fields

useUnicodeType

boolean useUnicodeType

seenFirst

java.util.Set<E> seenFirst

Class edu.stanford.nlp.parser.lexparser.ChineseWordFeatureExtractor extends java.lang.Object implements Serializable

serialVersionUID: -4327267414095852504L

Serialized Fields

morpho

boolean morpho

chars

boolean chars

rads

boolean rads

useLength

boolean useLength

useFreq

boolean useFreq

bigrams

boolean bigrams

conjunctions

boolean conjunctions

mildConjunctions

boolean mildConjunctions

turnOffWordFeatures

boolean turnOffWordFeatures

wordCounter

IntCounter<E> wordCounter

cmfs

edu.stanford.nlp.ie.ChineseMorphFeatureSets cmfs

threshedFeatures

java.util.Collection<E> threshedFeatures

Class edu.stanford.nlp.parser.lexparser.EnglishTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: 4153878351331522581L

Serialized Fields

headFinder

HeadFinder headFinder

englishTrain

EnglishTreebankParserParams.EnglishTrain englishTrain

englishTest

EnglishTreebankParserParams.EnglishTest englishTest

Class edu.stanford.nlp.parser.lexparser.EnglishTreebankParserParams.EnglishTest extends java.lang.Object implements Serializable

serialVersionUID: 183157656745674521L

Serialized Fields

retainNPTMPSubcategories

boolean retainNPTMPSubcategories

retainTMPSubcategories

boolean retainTMPSubcategories

retainADVSubcategories

boolean retainADVSubcategories

makeCopulaHead

boolean makeCopulaHead

Class edu.stanford.nlp.parser.lexparser.EnglishTreebankParserParams.EnglishTrain extends java.lang.Object implements Serializable

serialVersionUID: 1831576434872643L

Serialized Fields

leaveItAll

int leaveItAll

if true, leave all PTB (functional tag) annotations (bad)

splitIN

int splitIN

Annotate prepositions into subcategories. Values: 0 = no annotation 1 = IN with a ^S.* parent (putative subordinating conjunctions) marked differently from others (real prepositions). OK. 2 = Annotate IN prepositions 3 ways: ^S.* parent, ^N.* parent or rest (generally predicative ADJP, VP). Better than sIN=1. Good. 3 = Annotate prepositions 6 ways: real feature engineering. Great. 4 = Refinement of 3: allows -SC under SINV, WHADVP for -T and no -SCC if the parent is an NP. 5 = Like 4 but maps TO to IN in a "nominal" (N*, P*, A*) context. 6 = 4, but mark V/A complement and leave noun ones unmarked instead.

splitQuotes

boolean splitQuotes

Mark quote marks for single vs. double so don't get mismatched ones.

splitSFP

boolean splitSFP

Separate out sentence final punct. (. ! ?). Doesn't help.

splitPercent

boolean splitPercent

Mark the nouns that are percent signs. Slightly good.

splitNPpercent

int splitNPpercent

Mark phrases that are headed by %. A value of 0 = do nothing, 1 = only NP, 2 = NP and ADJP, 3 = NP, ADJP and QP, 4 = any phrase.

tagRBGPA

boolean tagRBGPA

Grand parent annotate RB to try to distinguish sentential ones and ones in places like NP post modifier (things like 'very' are already distinguished as their parent is ADJP).

splitNNP

int splitNNP

Mark NNP words as to position in phrase (single, left, right, inside) or subcategorizes NNP(S) as initials or initial/final in NP.

joinPound

boolean joinPound

Join pound with dollar.

joinJJ

boolean joinJJ

Joint comparative and superlative adjective with positive.

joinNounTags

boolean joinNounTags

Join proper nouns with common nouns. This isn't to improve performance, but because Genia doesn't use proper noun tags in general.

splitPPJJ

boolean splitPPJJ

A special test for "such" mainly ("such as Fred"). A wash, so omit

splitTRJJ

boolean splitTRJJ

Put a special tag on 'transitive adjectives' with NP complement, like 'due May 15' -- it also catches 'such' in 'such as NP', which may be a good. Matches 658 times in 2-21 training corpus. Wash.

splitJJCOMP

boolean splitJJCOMP

Put a special tag on 'adjectives with complements'. This acts as a general subcat feature for adjectives.

splitMoreLess

boolean splitMoreLess

Specially mark the comparative/superlative words: less, least, more, most

unaryDT

boolean unaryDT

Mark "Intransitive" DT. Good.

unaryRB

boolean unaryRB

Mark "Intransitive" RB. Good.

unaryPRP

boolean unaryPRP

"Intransitive" PRP. Wash -- basically a no-op really.

markReflexivePRP

boolean markReflexivePRP

Mark reflexive PRP words.

unaryIN

boolean unaryIN

Mark "Intransitive" IN. Minutely negative.

splitCC

int splitCC

Provide annotation of conjunctions. Gives modest gains (numbers shown F1 increase with respect to goodPCFG in June 2005). A value of 1 annotates both "and" and "or" as "CC-C" (+0.29%), 2 annotates "but" and "&" separately (+0.17%), 3 annotates just "and" (equalsIgnoreCase) (+0.11%), 0 annotates nothing (+0.00%).

splitNOT

boolean splitNOT

Annotates forms of "not" specially as tag "NOT". BAD

splitRB

boolean splitRB

Split modifier (NP, AdjP) adverbs from others. This does nothing if you're already doing tagPA.

splitAux

int splitAux

Make special tags for forms of BE and HAVE (and maybe DO/HELP, etc.). A value of 0 is do nothing. A value of 1 is the basic form. Positive PCFG effect, but neutral to negative in Factored, and impossible if you use gPA. A value of 2 adds in "s" = "'s" and delves further to disambiguate "'s" as BE or HAVE. Theoretically good, but no practical gains. A value of 3 adds DO. A value of 4 adds HELP (which also takes VB form complement) as DO. A value of 5 adds LET (which also takes VB form complement) as DO. A value of 6 adds MAKE (which also takes VB form complement) as DO. A value of 7 adds WATCH, SEE (which also take VB form complement) as DO. A value of 8 adds come, go, but not inflections (which colloquially can take a VB form complement) as DO. A value of 9 adds GET as BE. Differences are small. You get about 0.3 F1 by doing something; the best appear to be 2 or 3 for sentence exact and 7 or 8 for LP/LR F1.

vpSubCat

boolean vpSubCat

Pitiful attempt at marking V* preterms with their surface subcat frames. Bad so far.

markDitransV

int markDitransV

Attempt to record ditransitive verbs. The value 0 means do nothing; 1 records two or more NP or S* arguments, and 2 means to only record two or more NP arguments (that aren't NP-TMP). 1 gave neutral to bad results.

splitVP

int splitVP

Add (head) tags to VPs. An argument of 0 = no head-subcategorization of VPs, 1 = add head tags (anything, as given by HeadFinder), 2 = add head tags, but collapse finite verb tags (VBP, VBD, VBZ, MD) together, 3 = only annotate verbal tags, and collapse finite verb tags (annotation is VBF, TO, VBG, VBN, VB, or zero), 4 = only split on categories of VBF, TO, VBG, VBN, VB, and map cases that are not headed by a verbal category to an appropriate category based on word suffix (ing, d, t, s, to) or to VB otherwise. We usually use a value of 3; 2 or 3 is much better than 0. See also splitVPNPAgr. If it is true, its effects override any value set for this parameter.

splitVPNPAgr

boolean splitVPNPAgr

Put enough marking on VP and NP to permit "agreement".

splitSTag

int splitSTag

Mark S/SINV/SQ nodes according to verbal tag. Meanings are: 0 = no subcategorization. 1 = mark with head tag 2 = mark only -VBF if VBZ/VBD/VBP/MD tag 3 = as 2 and mark -VBNF if TO/VBG/VBN/VB 4 = as 2 but only mark S not SINV/SQ 5 = as 3 but only mark S not SINV/SQ Previously seen as bad. Option 4 might be promising now.

markContainedVP

boolean markContainedVP

splitNPPRP

boolean splitNPPRP

dominatesV

int dominatesV

Verbal distance -- mark whether symbol dominates a verb (V*, MD). Very good.

dominatesI

boolean dominatesI

Verbal distance -- mark whether symbol dominates a preposition (IN)

dominatesC

boolean dominatesC

Verbal distance -- mark whether symbol dominates a conjunction (CC)

markCC

int markCC

Mark phrases which are conjunctions. 0 = No marking 1 = Any phrase with a CC daughter that isn't first or last. Possibly marginally positive. 2 = As 0 but also a non-marginal CONJP daughter. In principle good, but no gains. 3 = More like Charniak. Not yet implemented. Need to annotate _before_ annotate children! np or vp with two or more np/vp children, a comma, cc or conjp, and nothing else.

splitSGapped

int splitSGapped

Mark specially S nodes with "gapped" subject (control, raising). 1 is basic version. 2 is better mark S nodes with "gapped" subject. 3 seems best on small training set, but all of these are too similar; 4 can't be differentiated. 5 is done on tree before empty splitting. (Bad!?)

splitNumNP

boolean splitNumNP

Mark "numeric NPs". Probably bad?

splitPoss

int splitPoss

Give a special tag to NPs which are possessive NPs (end in 's). A value of 0 means do nothing, 1 means tagging possessive NPs with "-P", 2 means restructure possessive NPs so that they introduce a POSSP node that takes as children the POS and a regularly structured NP. I.e., recover standard good linguistic practice circa 1985. This seems a good idea, but is almost a no-op (modulo fine points of markovization), since the previous NP-P phrase already uniquely captured what is now a POSSP.

splitBaseNP

int splitBaseNP

Mark base NPs. A value of 0 = no marking, 1 = marking baseNP (ones which rewrite just as preterminals), and 2 = doing Collins-style marking, where an extra NP node is inserted above a baseNP, if it isn't already in an NP over NP construction, as in Collins 1999. This option shouldn't really be in EnglishTrain since it's needed at parsing time. But we don't currently use it.... A value of 1 is good.

splitTMP

int splitTMP

Retain NP-TMP (or maybe PP-TMP) annotation. Good. The values for this parameter are defined in NPTmpRetainingTreeNormalizer.

splitSbar

int splitSbar

Split SBAR nodes. 1 = mark 'in order to' purpose clauses; this is actually a small and inconsistent part of what is marked SBAR-PRP in the treebank, which is mainly 'because' reason clauses. 2 = mark all infinitive SBAR. 3 = do 1 and 2. A value of 1 seems minutely positive; 2 and 3 seem negative. Also get 'in case Sfin', 'In order to', and on one occasion 'in order that'

splitNPADV

int splitNPADV

Retain NP-ADV annotation. 0 means strip "-ADV" annotation. 1 means to retain it, and to percolate it down to a head tag providing it can do it through a path of only NP nodes.

splitNPNNP

int splitNPNNP

Mark NP-NNP. 0 is nothing; 1 is only NNP head, 2 is NNP and NNPS head; 3 is NNP or NNPS anywhere in local NP. All bad!

correctTags

boolean correctTags

'Correct' tags to produce verbs in VPs, etc. where possible

rightPhrasal

boolean rightPhrasal

Right edge has a phrasal node. Bad?

sisterSplitLevel

int sisterSplitLevel

Set the support * KL cutoff level (1-4) for sister splitting -- don't use it, as far as we can tell so far

gpaRootVP

boolean gpaRootVP

Grand-parent annotate (root mark) VP below ROOT. Seems negative.

makePPTOintoIN

int makePPTOintoIN

Change TO inside PP to IN.

collapseWhCategories

int collapseWhCategories

Collapse WHPP with PP, etc., in training and perhaps in evaluation. 1 = collapse phrasal categories. 2 = collapse POS categories. 4 = restore them in output (not yet implemented)

Class edu.stanford.nlp.parser.lexparser.EnglishUnknownWordModel extends BaseUnknownWordModel implements Serializable

serialVersionUID: 4825624957364628770L

Serialized Fields

smartMutation

boolean smartMutation

unknownSuffixSize

int unknownSuffixSize

unknownPrefixSize

int unknownPrefixSize

wordClassesFile

java.lang.String wordClassesFile

Class edu.stanford.nlp.parser.lexparser.FactoredLexicon extends BaseLexicon implements Serializable

serialVersionUID: -744693222804176489L

Serialized Fields

morphoSpec

MorphoFeatureSpecification morphoSpec

morphIndex

Index<E> morphIndex

wordTag

TwoDimensionalIntCounter<K1,K2> wordTag

wordTagUnseen

Counter<E> wordTagUnseen

lemmaTag

TwoDimensionalIntCounter<K1,K2> lemmaTag

lemmaTagUnseen

Counter<E> lemmaTagUnseen

morphTag

TwoDimensionalIntCounter<K1,K2> morphTag

morphTagUnseen

Counter<E> morphTagUnseen

tagCounter

Counter<E> tagCounter

Class edu.stanford.nlp.parser.lexparser.FrenchTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: -6976724734594763986L

Serialized Fields

optionsString

java.lang.StringBuilder optionsString

headFinder

HeadFinder headFinder

annotationPatterns

java.util.Map<K,V> annotationPatterns

activeAnnotations

java.util.List<E> activeAnnotations

readPennFormat

boolean readPennFormat

collinizerRetainsPunctuation

boolean collinizerRetainsPunctuation

mwCounter

TwoDimensionalCounter<K1,K2> mwCounter

morphoSpec

MorphoFeatureSpecification morphoSpec

tagSpec

MorphoFeatureSpecification tagSpec

baselineFeatures

java.util.List<E> baselineFeatures

additionalFeatures

java.util.List<E> additionalFeatures

Class edu.stanford.nlp.parser.lexparser.FrenchUnknownWordModel extends BaseUnknownWordModel implements Serializable

serialVersionUID: -776564693549194424L

Serialized Fields

smartMutation

boolean smartMutation

unknownSuffixSize

int unknownSuffixSize

unknownPrefixSize

int unknownPrefixSize

Class edu.stanford.nlp.parser.lexparser.GenericTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: -617650500538652513L

Class edu.stanford.nlp.parser.lexparser.GermanUnknownWordModel extends BaseUnknownWordModel implements Serializable

serialVersionUID: 221L

Class edu.stanford.nlp.parser.lexparser.HebrewTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: -3466519995341208619L

Serialized Fields

optionsString

java.lang.StringBuilder optionsString

Class edu.stanford.nlp.parser.lexparser.IntDependency extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

head

IntTaggedWord head

arg

IntTaggedWord arg

leftHeaded

boolean leftHeaded

distance

short distance

Class edu.stanford.nlp.parser.lexparser.IntTaggedWord extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

word

int word

tag

short tag

Class edu.stanford.nlp.parser.lexparser.Lattice extends java.lang.Object implements Serializable

serialVersionUID: 5135076134500512556L

Serialized Fields

constraints

java.util.List<E> constraints

edges

java.util.List<E> edges

nodes

java.util.Set<E> nodes

edgeStartsAt

java.util.Map<K,V> edgeStartsAt

maxNode

int maxNode

Class edu.stanford.nlp.parser.lexparser.LatticeEdge extends java.lang.Object implements Serializable

serialVersionUID: 4416189959485854286L

Serialized Fields

word

java.lang.String word

label

java.lang.String label

weight

double weight

start

int start

end

int end

attrs

java.util.Map<K,V> attrs

Class edu.stanford.nlp.parser.lexparser.LexicalizedParser extends java.lang.Object implements Serializable

serialVersionUID: 2L

Serialized Fields

lex

Lexicon lex

bg

BinaryGrammar bg

ug

UnaryGrammar ug

dg

DependencyGrammar dg

stateIndex

Index<E> stateIndex

wordIndex

Index<E> wordIndex

tagIndex

Index<E> tagIndex

op

Options op

reranker

Reranker reranker

Class edu.stanford.nlp.parser.lexparser.MaxMatchSegmenter extends java.lang.Object implements Serializable

serialVersionUID: 8260792244886911724L

Serialized Fields

words

java.util.Set<E> words

Class edu.stanford.nlp.parser.lexparser.MLEDependencyGrammar extends AbstractDependencyGrammar implements Serializable

serialVersionUID: 1L

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Throws:: java.io.IOException; java.lang.ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream stream)
                  throws java.io.IOException

Throws:: java.io.IOException

Serialized Fields

useSmoothTagProjection

boolean useSmoothTagProjection

useUnigramWordSmoothing

boolean useUnigramWordSmoothing

numWordTokens

int numWordTokens

argCounter

ClassicCounter<E> argCounter

Stores all the counts for dependencies (with and without the word being a wildcard) in the reduced tag space.

stopCounter

ClassicCounter<E> stopCounter

smooth_aT_hTWd

double smooth_aT_hTWd

Bayesian m-estimate prior for aT given hTWd against base distribution of aT given hTd. TODO: Note that these values are overwritten in the constructor. Find what is best and then maybe remove these defaults!

smooth_aTW_hTWd

double smooth_aTW_hTWd

Bayesian m-estimate prior for aTW given hTWd against base distribution of aTW given hTd.

smooth_stop

double smooth_stop

interp

double interp

Interpolation between model that directly predicts aTW and model that predicts aT and then aW given aT. This percent of the mass is on the model directly predicting aTW.

smooth_aTW_aT

double smooth_aTW_aT

smooth_aTW_hTd

double smooth_aTW_hTd

smooth_aT_hTd

double smooth_aT_hTd

smooth_aPTW_aPT

double smooth_aPTW_aPT

smoothTP

TagProjection smoothTP

smoothTPIndex

Index<E> smoothTPIndex

Class edu.stanford.nlp.parser.lexparser.NegraPennTreebankParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: 757812264219400466L

Serialized Fields

markRC

boolean markRC

markZuVP

boolean markZuVP

markLP

boolean markLP

markColon

boolean markColon

markKonjParent

boolean markKonjParent

markHDParent

boolean markHDParent

markContainsV

boolean markContainsV

nodeCleanup

int nodeCleanup

Node cleanup is how node names are normalized. The known values are: 0 = do nothing; 1 = keep category and function; 2 = keep only category

headFinder

HeadFinder headFinder

treeNormalizerInsertNPinPP

boolean treeNormalizerInsertNPinPP

treeNormalizerLeaveGF

boolean treeNormalizerLeaveGF

treeReaderFactory

NegraPennTreeReaderFactory treeReaderFactory

Class edu.stanford.nlp.parser.lexparser.NoSuchParseException extends java.util.NoSuchElementException implements Serializable

serialVersionUID: 2L

Class edu.stanford.nlp.parser.lexparser.Options extends java.lang.Object implements Serializable

serialVersionUID: 4L

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Making the TestOptions transient means it won't even be constructed when you deserialize an Options, so we need to construct it on our own when deserializing

Throws:: java.io.IOException; java.lang.ClassNotFoundException

Serialized Fields

lexOptions

Options.LexOptions lexOptions

tlpParams

TreebankLangParserParams tlpParams

The treebank-specific parser parameters to use.

forceCNF

boolean forceCNF

Forces parsing with strictly CNF grammar -- unary chains are converted to XP&YP symbols and back

doPCFG

boolean doPCFG

Do a PCFG parse of the sentence. If both variables are on, also do a combined parse of the sentence.

doDep

boolean doDep

Do a dependency parse of the sentence.

freeDependencies

boolean freeDependencies

if true, any child can be the head (seems rather bad!)

directional

boolean directional

Whether dependency grammar considers left/right direction. Good.

genStop

boolean genStop

useSmoothTagProjection

boolean useSmoothTagProjection

useUnigramWordSmoothing

boolean useUnigramWordSmoothing

distance

boolean distance

Use distance bins in the dependency calculations

coarseDistance

boolean coarseDistance

Use coarser distance (4 bins) in dependency calculations

dcTags

boolean dcTags

"double count" tags rewrites as word in PCFG and Dep parser. Good for combined parsing only (it used to not kick in for PCFG parsing). This option is only used at Test time, but it is now in Options, so the correct choice for a grammar is recorded by a serialized parser. You should turn this off for a vanilla PCFG parser.

nodePrune

boolean nodePrune

If true, inside the factored parser, remove any node from the final chosen tree which improves the PCFG score. This was added as the dependency factor tends to encourage 'deep' trees.

trainOptions

TrainOptions trainOptions

wordFunction

Function<T1,T2> wordFunction

A function that maps words used in training and testing to new words. For example, it could be a function to lowercase text, such as edu.stanford.nlp.util.LowercaseFunction (which makes the parser case insensitive). This function is applied in LexicalizedParserQuery.parse and in the training methods which build a new parser.

rerankerKBest

int rerankerKBest

If the parser has a reranker, it looks at this many trees when building the reranked list.

baseParserWeight

double baseParserWeight

If reranking sentences, we can use the score from the original parser as well. This tells us how much weight to give that score.

Class edu.stanford.nlp.parser.lexparser.Options.LexOptions extends java.lang.Object implements Serializable

serialVersionUID: 2805351374506855632L

Serialized Fields

useUnknownWordSignatures

int useUnknownWordSignatures

Whether to use suffix and capitalization information for unknowns. Within the BaseLexicon model options have the following meaning: 0 means a single unknown token. 1 uses suffix, and capitalization. 2 uses a variant (richer) form of signature. Good. Use this one. Using the richer signatures in versions 3 or 4 seems to have very marginal or no positive value. 3 uses a richer form of signature that mimics the NER word type patterns. 4 is a variant of 2. 5 is another with more English specific morphology (good for English unknowns!). 6-9 are options for Arabic. 9 codes some patterns for numbers and derivational morphology, but also supports unknownPrefixSize and unknownSuffixSize. For German, 0 means a single unknown token, and non-zero means to use capitalization of first letter and a suffix of length unknownSuffixSize.

wordVectorFile

java.lang.String wordVectorFile

numHid

int numHid

Number of hidden units in the word vectors. As setting of 0 will make it try to extract the size from the data file.

smoothInUnknownsThreshold

int smoothInUnknownsThreshold

Words more common than this are tagged with MLE P(t|w). Default 100. The smoothing is sufficiently slight that changing this has little effect. But set this to 0 to be able to use the parser as a vanilla PCFG with no smoothing (not as a practical parser but for exposition or debugging).

smartMutation

boolean smartMutation

Smarter smoothing for rare words.

useUnicodeType

boolean useUnicodeType

Make use of unicode code point types in smoothing.

unknownSuffixSize

int unknownSuffixSize

For certain Lexicons, a certain number of word-final letters are used to subclassify the unknown token. This gives the number of letters.

unknownPrefixSize

int unknownPrefixSize

For certain Lexicons, a certain number of word-initial letters are used to subclassify the unknown token. This gives the number of letters.

uwModelTrainer

java.lang.String uwModelTrainer

Model for unknown words that the lexicon should use. This is the name of a class.

flexiTag

boolean flexiTag

useSignatureForKnownSmoothing

boolean useSignatureForKnownSmoothing

Whether to use signature rather than just being unknown as prior in known word smoothing. Currently only works if turned on for English.

wordClassesFile

java.lang.String wordClassesFile

A file of word class data which may be used for smoothing, normally instead of hand-specified signatures.

Class edu.stanford.nlp.parser.lexparser.ParserConstraint extends java.lang.Object implements Serializable

serialVersionUID: 4955237758572202093L

Serialized Fields

start

int start

end

int end

state

java.util.regex.Pattern state

Class edu.stanford.nlp.parser.lexparser.TaggerReranker extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

tagger

MaxentTagger tagger

op

Options op

weight

double weight

Class edu.stanford.nlp.parser.lexparser.TestOptions extends java.lang.Object implements Serializable

serialVersionUID: 7256526346598L

Serialized Fields

noRecoveryTagging

boolean noRecoveryTagging

If false, then failure of the PCFG parser to parse a sentence will trigger allowing all tags for words in parse recovery mode, with a log probability of -1000. If true, these extra taggings are not added. It is false by default. Use option -noRecoveryTagging to set to true.

doRecovery

boolean doRecovery

If true, then failure of the PCFG factor to parse a sentence will trigger parse recovery mode.

useN5

boolean useN5

If true, the n^4 "speed-up" is not used with the Factored Parser.

useFastFactored

boolean useFastFactored

If true, use approximate factored algorithm, which just rescores PCFG k best, rather than exact factored algorithm. This algorithm requires the dependency grammar to exist for rescoring, but not for the dependency grammar to be run. Hence the correct usage for guarding code only required for exact A* factored parsing is now if (op.doPCFG && op.doDep && ! Test.useFastFactored).

iterativeCKY

boolean iterativeCKY

If true, use faster iterative deepening CKY algorithm.

maxLength

int maxLength

The maximum sentence length (including punctuation, etc.) to parse.

MAX_ITEMS

int MAX_ITEMS

The maximum number of edges and hooks combined that the factored parser will build before giving up. This number should probably be relative to the sentence length parsed. In general, though, if the parser cannot parse a sentence after this much work then there is no good parse consistent between the PCFG and Dependency parsers. (Normally, depending on other flags), the parser will then just return the best PCFG parse.)

unseenSmooth

double unseenSmooth

The amount of smoothing put in (as an m-estimate) for unknown words. If negative, set by the code in the lexicon class.

increasingLength

boolean increasingLength

Parse trees in test treebank in order of increasing length.

preTag

boolean preTag

Tag the sentences first, then parse given those (coarse) tags.

forceTags

boolean forceTags

Parse using only tags given from correct answer or the POS tagger

forceTagBeginnings

boolean forceTagBeginnings

taggerSerializedFile

java.lang.String taggerSerializedFile

POS tagger model used when preTag is enabled.

noFunctionalForcing

boolean noFunctionalForcing

Only valid with force tags - strips away functionals when forcing the tags, meaning tags have to start appropriately but the parser will assign the functional part.

evalb

boolean evalb

Write EvalB-readable output files.

verbose

boolean verbose

Print a lot of extra output as you parse.

exhaustiveTest

boolean exhaustiveTest

pcfgThreshold

boolean pcfgThreshold

If this variable is true, and the sum of the inside and outside score for a constituent is worse than the best known score for a sentence by more than pcfgThresholdValue, then -Inf is returned as the outside Score by oScore() (while otherwise the true outside score is returned).

pcfgThresholdValue

double pcfgThresholdValue

printAllBestParses

boolean printAllBestParses

Print out all best PCFG parses.

depWeight

double depWeight

Weighting on dependency log probs. The dependency grammar negative log probability scores are simply multiplied by this number.

prunePunc

boolean prunePunc

addMissingFinalPunctuation

boolean addMissingFinalPunctuation

If a token list does not have sentence final punctuation near the end, then automatically add the default one. This might help parsing if the treebank is all punctuated. Not done if reading a treebank.

outputFormat

java.lang.String outputFormat

Determines format of output trees: choose among penn, oneline

outputFormatOptions

java.lang.String outputFormatOptions

writeOutputFiles

boolean writeOutputFiles

If true, write files parsed to a new file with the same name except for an added ".stp" extension.

outputFilesDirectory

java.lang.String outputFilesDirectory

If the writeOutputFiles option is true, then output files appear in this directory. An unset value (null) means to use the directory of the source files. Use "" or . for the current directory.

outputFilesExtension

java.lang.String outputFilesExtension

If the writeOutputFiles option is true, then output files appear with this extension. Use "" for no extension.

outputFilesPrefix

java.lang.String outputFilesPrefix

If the writeOutputFiles option is true, then output files appear with this prefix.

outputkBestEquivocation

java.lang.String outputkBestEquivocation

If this option is not null, output the k-best equivocation. Must be specified with printPCFGkBest.

maxSpanForTags

int maxSpanForTags

The largest span to consider for word-hood. Used for parsing unsegmented Chinese text and parsing lattices. Keep it at 1 unless you know what you're doing.

lengthNormalization

boolean lengthNormalization

Turns on normalizing scores for sentence length. Makes no difference (except decreased efficiency) unless maxSpanForTags is greater than one. Works only for PCFG (so far).

sample

boolean sample

Used when you want to generate sample parses instead of finding the best parse. (NOT YET USED.)

printPCFGkBest

int printPCFGkBest

Printing k-best parses from PCFG, when k > 0.

evalPCFGkBest

int evalPCFGkBest

If using a kBest eval, use this many trees.

printFactoredKGood

int printFactoredKGood

Printing k-best parses from PCFG, when k > 0.

evals

java.util.Properties evals

What evaluations to report and how to report them (using LexicalizedParser). Known evaluations are: pcfgLB, pcfgCB, pcfgDA, pcfgTA, pcfgLL, pcfgRUO, pcfgCUO, pcfgCatE, pcfgChildSpecific, depDA, depTA, depLL, factLB, factCB, factDA, factTA, factLL, factChildSpecific. The default is pcfgLB,depDA,factLB,factTA. You need to negate those ones out (e.g., -evals "depDA=false") if you don't want them. LB = ParseEval labeled bracketing,
CB = crossing brackets and zero crossing bracket rate,
DA = dependency accuracy, TA = tagging accuracy,
LL = log likelihood score,
RUO/CUO = rules/categories under and over proposed,
CatE = evaluation by phrasal category.
ChildSpecific: supply an argument with =. F1 will be returned for only the nodes which have at least one child that matches this regular expression.
Known styles are: runningAverages, summary, tsv.
The default style is summary. You need to negate it out if you don't want it. Invalid names in the argument to this option are not reported!

fastFactoredCandidateMultiplier

int fastFactoredCandidateMultiplier

This variable says to find k good fast factored parses, how many times k of the best PCFG parses should be examined.

fastFactoredCandidateAddend

int fastFactoredCandidateAddend

This variable says to find k good factored parses, how many added on best PCFG parses should be examined.

useLexiconToScoreDependencyPwGt

boolean useLexiconToScoreDependencyPwGt

If this is true, the Lexicon is used to score P(w|t) in the backoff inside the dependency grammar. (Otherwise, a MLE is used is w is seen, and a constant if w is unseen.

useNonProjectiveDependencyParser

boolean useNonProjectiveDependencyParser

If this is true, perform non-projective dependency parsing.

testingThreads

int testingThreads

Number of threads to use at test time. For example, -testTreebank can use this to go X times faster, with the negative consequence that output is not quite as nicely ordered.

Class edu.stanford.nlp.parser.lexparser.TrainOptions extends java.lang.Object implements Serializable

serialVersionUID: 72571349843538L

Serialized Fields

trainTreeFile

java.lang.String trainTreeFile

trainLengthLimit

int trainLengthLimit

cheatPCFG

boolean cheatPCFG

Add all test set trees to training data for PCFG. (Currently only supported in FactoredParser main.)

markovFactor

boolean markovFactor

Whether to do "horizontal Markovization" (as in ACL 2003 paper). False means regular PCFG expansions.

markovOrder

int markovOrder

hSelSplit

boolean hSelSplit

HSEL_CUT

int HSEL_CUT

markFinalStates

boolean markFinalStates

Whether or not to mark final states in binarized grammar. This must be off to get most value out of grammar compaction.

openClassTypesThreshold

int openClassTypesThreshold

A POS tag has to have been attributed to more than this number of word types before it is regarded as an open-class tag. Unknown words will only possibly be tagged as open-class tags (unless flexiTag is on). If flexiTag is on, unknown words will be able to be tagged any POS for which the unseenMap has nonzero count (that is, the tag was seen for a new word after unseen signature counting was started).

fractionBeforeUnseenCounting

double fractionBeforeUnseenCounting

Start to aggregate signature-tag pairs only for words unseen in the first this fraction of the data.

PA

boolean PA

This variable controls doing parent annotation of phrasal nodes. Good.

gPA

boolean gPA

This variable controls doing 2 levels of parent annotation. Bad.

postPA

boolean postPA

postGPA

boolean postGPA

selectiveSplit

boolean selectiveSplit

Only split the "common high KL divergence" parent categories.... Good.

selectiveSplitCutOff

double selectiveSplitCutOff

selectivePostSplit

boolean selectivePostSplit

selectivePostSplitCutOff

double selectivePostSplitCutOff

postSplitWithBaseCategory

boolean postSplitWithBaseCategory

Whether, in post-splitting of categories, nodes are annotated with the (grand)parent's base category or with its complete subcategorized category.

sisterAnnotate

boolean sisterAnnotate

Selective Sister annotation.

sisterSplitters

java.util.Set<E> sisterSplitters

markUnary

int markUnary

Mark all unary nodes specially. Good for just PCFG. Bad for factored. markUnary affects phrasal nodes. A value of 0 means to do nothing; a value of 1 means to mark the parent (higher) node of a unary rewrite. A value of 2 means to mark the child (lower) node of a unary rewrie. Values of 1 and 2 only apply if the child (lower) node is phrasal. (A value of 1 is better than 2 in combos.) A value of 1 corresponds to the old boolean -unary flag.

markUnaryTags

boolean markUnaryTags

Mark POS tags which are the sole member of their phrasal constituent. This is like markUnary=2, applied to POS tags.

splitPrePreT

boolean splitPrePreT

Mark all pre-preterminals (also does splitBaseNP: don't need both)

tagPA

boolean tagPA

Parent annotation on tags. Good (for PCFG?)

tagSelectiveSplit

boolean tagSelectiveSplit

Do parent annotation on tags selectively. Neutral, but less splits.

tagSelectiveSplitCutOff

double tagSelectiveSplitCutOff

tagSelectivePostSplit

boolean tagSelectivePostSplit

tagSelectivePostSplitCutOff

double tagSelectivePostSplitCutOff

rightRec

boolean rightRec

Right edge is right-recursive (X << X) Bad. (NP only is good)

leftRec

boolean leftRec

Left edge is right-recursive (X << X) Bad.

collinsPunc

boolean collinsPunc

Promote/delete punctuation like Collins. Bad (!)

splitters

java.util.Set<E> splitters

Set the splitter strings. These are a set of parent and/or grandparent annotated categories which should be split off.

postSplitters

java.util.Set<E> postSplitters

deleteSplitters

java.util.Set<E> deleteSplitters

printTreeTransformations

int printTreeTransformations

Just for debugging: check that your tree transforms work correctly. This will print the transformations of the first printTreeTransformations trees.

printAnnotatedPW

java.io.PrintWriter printAnnotatedPW

printBinarizedPW

java.io.PrintWriter printBinarizedPW

printStates

boolean printStates

compactGrammar

int compactGrammar

How to compact grammars as FSMs. 0 = no compaction [uses makeSyntheticLabel1], 1 = no compaction but use label names that wrap from right to left in binarization [uses makeSyntheticLabel2], 2 = wrapping labels and materialize unary at top rewriting passive to active, 3 = ExactGrammarCompactor, 4 = LossyGrammarCompactor, 5 = CategoryMergingGrammarCompactor. (May 2007 CDM note: options 4 and 5 don't seem to be functioning sensibly. 0, 1, and 3 seem to be the 'good' options. 2 is only useful as input to 3. There seems to be no reason not to use 0, despite the default.)

leftToRight

boolean leftToRight

noTagSplit

boolean noTagSplit

ruleSmoothing

boolean ruleSmoothing

Enables linear rule smoothing during grammar extraction but before grammar compaction. The alpha term is the same as that described in Petrov et al. (2006), and has range [0,1].

ruleSmoothingAlpha

double ruleSmoothingAlpha

smoothing

boolean smoothing

TODO wsg2011: This is the old grammar smoothing parameter that no longer does anything in the parser. It should be removed.

ruleDiscount

double ruleDiscount

Discounts the count of BinaryRule's (only, apparently) in training data.

printAnnotatedRuleCounts

boolean printAnnotatedRuleCounts

printAnnotatedStateCounts

boolean printAnnotatedStateCounts

basicCategoryTagsInDependencyGrammar

boolean basicCategoryTagsInDependencyGrammar

Where to use the basic or split tags in the dependency grammar

preTransformer

TreeTransformer preTransformer

A transformer to use on the training data before any other processing step. This is specified by using the -preTransformer flag when training the parser. A comma separated list of classes will be turned into a CompositeTransformer. This can be used to strip subcategories, to run a tsurgeon pattern, or any number of other useful operations.

taggedFiles

java.lang.String taggedFiles

A set of files to use as extra information in the lexicon. This can provide tagged words which are not part of trees

predictSplits

boolean predictSplits

Use the method reported by Berkeley for splitting and recombining states. This is an experimental and still in development reimplementation of that work.

splitCount

int splitCount

If we are predicting splits, we loop this many times

splitRecombineRate

double splitRecombineRate

If we are predicting splits, we recombine states at this rate every loop

simpleBinarizedLabels

boolean simpleBinarizedLabels

When binarizing trees, don't annotate the labels with anything

noRebinarization

boolean noRebinarization

When binarizing trees, don't binarize trees with two children. Only applies when using inside markov binarization for now.

trainingThreads

int trainingThreads

If the training algorithm allows for parallelization, how many threads to use

dvKBest

int dvKBest

dvIterations

int dvIterations

dvBatchSize

int dvBatchSize

regCost

double regCost

qnIterationsPerBatch

int qnIterationsPerBatch

qnEstimates

int qnEstimates

When training the DV parsing method, how many estimates to keep for the qn approximation.

qnTolerance

double qnTolerance

When training the DV parsing method, the tolerance to use if we want to stop qn early

debugOutputSeconds

int debugOutputSeconds

If larger than 0, the parser may choose to output debug information every X seconds

dvSeed

long dvSeed

learningRate

double learningRate

How fast to learn (can mean different things for different algorithms)

deltaMargin

double deltaMargin

How much to penalize the wrong trees for how different they are from the gold tree when training

unknownNumberVector

boolean unknownNumberVector

Whether or not to build an unknown word vector specifically for numbers

unknownDashedWordVectors

boolean unknownDashedWordVectors

Whether or not to handle unknown dashed words by taking the last part

unknownCapsVector

boolean unknownCapsVector

Whether or not to build an unknown word vector for words with caps in them

dvSimplifiedModel

boolean dvSimplifiedModel

Make the dv model as simple as possible

unknownChineseYearVector

boolean unknownChineseYearVector

Whether or not to build an unknown word vector to match Chinese years

unknownChineseNumberVector

boolean unknownChineseNumberVector

Whether or not to build an unknown word vector to match Chinese numbers

unknownChinesePercentVector

boolean unknownChinesePercentVector

Whether or not to build an unknown word vector to match Chinese percentages

scalingForInit

double scalingForInit

How much to scale certain parameters when initializing models. For example, the DVParser uses this to rescale its initial matrices.

maxTrainTimeSeconds

int maxTrainTimeSeconds

unkWord

java.lang.String unkWord

Some models will use external data sources which contain information about unknown words. This variable is a way to provide the name of the unknown word in the external data source.

lowercaseWordVectors

boolean lowercaseWordVectors

Whether or not to lowercase word vectors

transformMatrixType

TrainOptions.TransformMatrixType transformMatrixType

useContextWords

boolean useContextWords

Class edu.stanford.nlp.parser.lexparser.TueBaDZParserParams extends AbstractTreebankParserParams implements Serializable

serialVersionUID: 7303189408025355170L

Serialized Fields

hf

HeadFinder hf

nodeCleanup

int nodeCleanup

markKonjParent

boolean markKonjParent

markContainsV

boolean markContainsV

markZu

boolean markZu

markColons

boolean markColons

leftPhrasal

boolean leftPhrasal

markHDParent

boolean markHDParent

leaveGF

boolean leaveGF

Class edu.stanford.nlp.parser.lexparser.UnaryGrammar extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Throws:: java.io.IOException; java.lang.ClassNotFoundException

Serialized Fields

index

Index<E> index

coreRules

java.util.Map<K,V> coreRules

The basic list of UnaryRules. Really this is treated as a set

Class edu.stanford.nlp.parser.lexparser.UnaryRule extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

parent

int parent

score

float score

Score should be a log probability

child

int child

Package edu.stanford.nlp.pipeline

Class edu.stanford.nlp.pipeline.Annotation extends ArrayCoreMap implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.pipeline.AnnotatorFactory extends java.lang.Object implements Serializable

serialVersionUID: -1554647325549869340L

Serialized Fields

properties

java.util.Properties properties

Package edu.stanford.nlp.process

Class edu.stanford.nlp.process.ChineseDocumentToSentenceProcessor extends java.lang.Object implements Serializable

serialVersionUID: 4054964767812217460L

Serialized Fields

encoding

java.lang.String encoding

normalizationTable

java.util.List<E> normalizationTable

Class edu.stanford.nlp.process.CoreLabelTokenFactory extends java.lang.Object implements Serializable

serialVersionUID: 4L

Serialized Fields

addIndices

boolean addIndices

Class edu.stanford.nlp.process.DistSimClassifier extends java.lang.Object implements Serializable

serialVersionUID: 3L

Serialized Fields

lexicon

java.util.Map<K,V> lexicon

cased

boolean cased

numberEquivalence

boolean numberEquivalence

unknownWordClass

java.lang.String unknownWordClass

Package edu.stanford.nlp.semgraph

Class edu.stanford.nlp.semgraph.SemanticGraph extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

roots

java.util.Collection<E> roots

The distinguished root vertices, if known.

graph

DirectedMultiGraph<V,E> graph

Class edu.stanford.nlp.semgraph.SemanticGraphEdge extends java.lang.Object implements Serializable

serialVersionUID: 2L

Serialized Fields

relation

GrammaticalRelation relation

weight

double weight

isExtra

boolean isExtra

source

IndexedWord source

target

IndexedWord target

Package edu.stanford.nlp.sequences

Class edu.stanford.nlp.sequences.Clique extends java.lang.Object implements Serializable

serialVersionUID: -8109637472035159453L

Serialization Methods

readResolve

protected java.lang.Object readResolve()

Serialized Fields

relativeIndices

int[] relativeIndices

hashCode

int hashCode

Class edu.stanford.nlp.sequences.ColumnDocumentReaderAndWriter extends java.lang.Object implements Serializable

serialVersionUID: 3806263423697973704L

Serialized Fields

map

java.lang.String[] map

factory

IteratorFromReaderFactory<T> factory

num

int num

Class edu.stanford.nlp.sequences.ColumnTabDocumentReaderWriter extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

map

java.lang.String[] map

delimiterPattern

java.util.regex.Pattern delimiterPattern

whitespacePattern

java.util.regex.Pattern whitespacePattern

replaceWhitespace

boolean replaceWhitespace

tokensAnnotationClassName

java.lang.String tokensAnnotationClassName

tokenFactory

CoreTokenFactory<IN extends CoreMap> tokenFactory

Class edu.stanford.nlp.sequences.CoNLLDocumentReaderAndWriter extends java.lang.Object implements Serializable

serialVersionUID: 6281374154299530460L

Serialized Fields

flags

SeqClassifierFlags flags

Class edu.stanford.nlp.sequences.FeatureFactory extends java.lang.Object implements Serializable

serialVersionUID: 7249250071983091694L

Serialized Fields

flags

SeqClassifierFlags flags

Class edu.stanford.nlp.sequences.LibSVMReaderAndWriter extends java.lang.Object implements Serializable

serialVersionUID: -7997837004847909059L

Serialized Fields

flags

SeqClassifierFlags flags

factory

IteratorFromReaderFactory<T> factory

num

int num

Class edu.stanford.nlp.sequences.MalletFeatureFactory extends FeatureFactory<IN extends CoreLabel> implements Serializable

serialVersionUID: -5586998916869425417L

Class edu.stanford.nlp.sequences.MalletReaderAndWriter extends java.lang.Object implements Serializable

serialVersionUID: 3806263423691913704L

Serialized Fields

flags

SeqClassifierFlags flags

map

java.lang.String[] map

factory

IteratorFromReaderFactory<T> factory

num

int num

Class edu.stanford.nlp.sequences.MUCDocumentReaderAndWriter extends java.lang.Object implements Serializable

serialVersionUID: -8334720781758500037L

Serialized Fields

flags

SeqClassifierFlags flags

factory

IteratorFromReaderFactory<T> factory

Class edu.stanford.nlp.sequences.ObjectBankWrapper extends ObjectBank<java.util.List<IN extends CoreMap>> implements Serializable

serialVersionUID: -3838331732026362075L

Serialized Fields

flags

SeqClassifierFlags flags

wrapped

ObjectBank<E> wrapped

knownLCWords

java.util.Set<E> knownLCWords

monthDayPattern

java.util.regex.Pattern monthDayPattern

Class edu.stanford.nlp.sequences.PlainTextDocumentReaderAndWriter extends java.lang.Object implements Serializable

serialVersionUID: -2420535144980273136L

Serialized Fields

wts

WordToSentenceProcessor<IN> wts

flags

SeqClassifierFlags flags

tokenizerFactory

TokenizerFactory<T> tokenizerFactory

Class edu.stanford.nlp.sequences.SeqClassifierFlags extends java.lang.Object implements Serializable

serialVersionUID: -7076671761070232567L

Serialized Fields

stringRep

java.lang.String stringRep

useNGrams

boolean useNGrams

conjoinShapeNGrams

boolean conjoinShapeNGrams

lowercaseNGrams

boolean lowercaseNGrams

dehyphenateNGrams

boolean dehyphenateNGrams

usePrev

boolean usePrev

useNext

boolean useNext

useTags

boolean useTags

useWordPairs

boolean useWordPairs

useGazettes

boolean useGazettes

useSequences

boolean useSequences

usePrevSequences

boolean usePrevSequences

useNextSequences

boolean useNextSequences

useLongSequences

boolean useLongSequences

useBoundarySequences

boolean useBoundarySequences

useTaggySequences

boolean useTaggySequences

useExtraTaggySequences

boolean useExtraTaggySequences

dontExtendTaggy

boolean dontExtendTaggy

useTaggySequencesShapeInteraction

boolean useTaggySequencesShapeInteraction

strictlyZeroethOrder

boolean strictlyZeroethOrder

strictlyFirstOrder

boolean strictlyFirstOrder

strictlySecondOrder

boolean strictlySecondOrder

strictlyThirdOrder

boolean strictlyThirdOrder

entitySubclassification

java.lang.String entitySubclassification

retainEntitySubclassification

boolean retainEntitySubclassification

useGazettePhrases

boolean useGazettePhrases

makeConsistent

boolean makeConsistent

useWordLabelCounts

boolean useWordLabelCounts

useViterbi

boolean useViterbi

binnedLengths

int[] binnedLengths

verboseMode

boolean verboseMode

useSum

boolean useSum

tolerance

double tolerance

printFeatures

java.lang.String printFeatures

useSymTags

boolean useSymTags

useSymWordPairs

boolean useSymWordPairs

useSymWordPairs Has a small negative effect.

printClassifier

java.lang.String printClassifier

printClassifierParam

int printClassifierParam

intern

boolean intern

intern2

boolean intern2

selfTest

boolean selfTest

sloppyGazette

boolean sloppyGazette

cleanGazette

boolean cleanGazette

noMidNGrams

boolean noMidNGrams

maxNGramLeng

int maxNGramLeng

useReverse

boolean useReverse

greekifyNGrams

boolean greekifyNGrams

useParenMatching

boolean useParenMatching

useLemmas

boolean useLemmas

usePrevNextLemmas

boolean usePrevNextLemmas

normalizeTerms

boolean normalizeTerms

normalizeTimex

boolean normalizeTimex

useNB

boolean useNB

useQN

boolean useQN

useFloat

boolean useFloat

QNsize

int QNsize

QNsize2

int QNsize2

maxIterations

int maxIterations

wordShape

int wordShape

useShapeStrings

boolean useShapeStrings

useTypeSeqs

boolean useTypeSeqs

useTypeSeqs2

boolean useTypeSeqs2

useTypeSeqs3

boolean useTypeSeqs3

useDisjunctive

boolean useDisjunctive

disjunctionWidth

int disjunctionWidth

useDisjunctiveShapeInteraction

boolean useDisjunctiveShapeInteraction

useDisjShape

boolean useDisjShape

useWord

boolean useWord

useClassFeature

boolean useClassFeature

useShapeConjunctions

boolean useShapeConjunctions

useWordTag

boolean useWordTag

useNPHead

boolean useNPHead

useNPGovernor

boolean useNPGovernor

useHeadGov

boolean useHeadGov

useLastRealWord

boolean useLastRealWord

useNextRealWord

boolean useNextRealWord

useOccurrencePatterns

boolean useOccurrencePatterns

useTypeySequences

boolean useTypeySequences

justify

boolean justify

normalize

boolean normalize

priorType

java.lang.String priorType

sigma

double sigma

epsilon

double epsilon

beamSize

int beamSize

maxLeft

int maxLeft

maxRight

int maxRight

usePosition

boolean usePosition

useBeginSent

boolean useBeginSent

useGazFeatures

boolean useGazFeatures

useMoreGazFeatures

boolean useMoreGazFeatures

useAbbr

boolean useAbbr

useMinimalAbbr

boolean useMinimalAbbr

useAbbr1

boolean useAbbr1

useMinimalAbbr1

boolean useMinimalAbbr1

useMoreAbbr

boolean useMoreAbbr

deleteBlankLines

boolean deleteBlankLines

useGENIA

boolean useGENIA

useTOK

boolean useTOK

useABSTR

boolean useABSTR

useABSTRFreqDict

boolean useABSTRFreqDict

useABSTRFreq

boolean useABSTRFreq

useFREQ

boolean useFREQ

useABGENE

boolean useABGENE

useWEB

boolean useWEB

useWEBFreqDict

boolean useWEBFreqDict

useIsURL

boolean useIsURL

useURLSequences

boolean useURLSequences

useIsDateRange

boolean useIsDateRange

useEntityTypes

boolean useEntityTypes

useEntityTypeSequences

boolean useEntityTypeSequences

useEntityRule

boolean useEntityRule

useOrdinal

boolean useOrdinal

useACR

boolean useACR

useANTE

boolean useANTE

useMoreTags

boolean useMoreTags

useChunks

boolean useChunks

useChunkySequences

boolean useChunkySequences

usePrevVB

boolean usePrevVB

useNextVB

boolean useNextVB

useVB

boolean useVB

subCWGaz

boolean subCWGaz

documentReader

java.lang.String documentReader

map

java.lang.String map

useWideDisjunctive

boolean useWideDisjunctive

wideDisjunctionWidth

int wideDisjunctionWidth

useRadical

boolean useRadical

useBigramInTwoClique

boolean useBigramInTwoClique

morphFeatureFile

java.lang.String morphFeatureFile

useReverseAffix

boolean useReverseAffix

charHalfWindow

int charHalfWindow

useWord1

boolean useWord1

useWord2

boolean useWord2

useWord3

boolean useWord3

useWord4

boolean useWord4

useRad1

boolean useRad1

useRad2

boolean useRad2

useWordn

boolean useWordn

useCTBPre1

boolean useCTBPre1

useCTBSuf1

boolean useCTBSuf1

useASBCPre1

boolean useASBCPre1

useASBCSuf1

boolean useASBCSuf1

usePKPre1

boolean usePKPre1

usePKSuf1

boolean usePKSuf1

useHKPre1

boolean useHKPre1

useHKSuf1

boolean useHKSuf1

useCTBChar2

boolean useCTBChar2

useASBCChar2

boolean useASBCChar2

useHKChar2

boolean useHKChar2

usePKChar2

boolean usePKChar2

useRule2

boolean useRule2

useDict2

boolean useDict2

useOutDict2

boolean useOutDict2

outDict2

java.lang.String outDict2

useDictleng

boolean useDictleng

useDictCTB2

boolean useDictCTB2

useDictASBC2

boolean useDictASBC2

useDictPK2

boolean useDictPK2

useDictHK2

boolean useDictHK2

useBig5

boolean useBig5

useNegDict2

boolean useNegDict2

useNegDict3

boolean useNegDict3

useNegDict4

boolean useNegDict4

useNegCTBDict2

boolean useNegCTBDict2

useNegCTBDict3

boolean useNegCTBDict3

useNegCTBDict4

boolean useNegCTBDict4

useNegASBCDict2

boolean useNegASBCDict2

useNegASBCDict3

boolean useNegASBCDict3

useNegASBCDict4

boolean useNegASBCDict4

useNegHKDict2

boolean useNegHKDict2

useNegHKDict3

boolean useNegHKDict3

useNegHKDict4

boolean useNegHKDict4

useNegPKDict2

boolean useNegPKDict2

useNegPKDict3

boolean useNegPKDict3

useNegPKDict4

boolean useNegPKDict4

usePre

boolean usePre

useSuf

boolean useSuf

useRule

boolean useRule

useHk

boolean useHk

useMsr

boolean useMsr

useMSRChar2

boolean useMSRChar2

usePk

boolean usePk

useAs

boolean useAs

useFilter

boolean useFilter

largeChSegFile

boolean largeChSegFile

useRad2b

boolean useRad2b

keepEnglishWhitespaces

boolean keepEnglishWhitespaces

Keep the whitespace between English words in testFile when printing out answers. Doesn't really change the content of the CoreLabels. (For Chinese segmentation.)

keepAllWhitespaces

boolean keepAllWhitespaces

Keep all the whitespace words in testFile when printing out answers. Doesn't really change the content of the CoreLabels. (For Chinese segmentation.)

sighanPostProcessing

boolean sighanPostProcessing

useChPos

boolean useChPos

use POS information (an "open" feature for Chinese segmentation)

normalizationTable

java.lang.String normalizationTable

dictionary

java.lang.String dictionary

serializedDictionary

java.lang.String serializedDictionary

dictionary2

java.lang.String dictionary2

normTableEncoding

java.lang.String normTableEncoding

sighanCorporaDict

java.lang.String sighanCorporaDict

for Sighan bakeoff 2005, the path to the dictionary of bigrams appeared in corpus

useWordShapeGaz

boolean useWordShapeGaz

wordShapeGaz

java.lang.String wordShapeGaz

splitDocuments

boolean splitDocuments

printXML

boolean printXML

useSeenFeaturesOnly

boolean useSeenFeaturesOnly

lastNameList

java.lang.String lastNameList

maleNameList

java.lang.String maleNameList

femaleNameList

java.lang.String femaleNameList

inputEncoding

java.lang.String inputEncoding

bioSubmitOutput

boolean bioSubmitOutput

numRuns

int numRuns

answerFile

java.lang.String answerFile

altAnswerFile

java.lang.String altAnswerFile

dropGaz

java.lang.String dropGaz

printGazFeatures

java.lang.String printGazFeatures

numStartLayers

int numStartLayers

dump

boolean dump

mergeTags

boolean mergeTags

splitOnHead

boolean splitOnHead

featureCountThreshold

int featureCountThreshold

featureWeightThreshold

double featureWeightThreshold

featureFactory

java.lang.String featureFactory

featureFactoryArgs

java.lang.Object[] featureFactoryArgs

backgroundSymbol

java.lang.String backgroundSymbol

useObservedSequencesOnly

boolean useObservedSequencesOnly

maxDocSize

int maxDocSize

printProbs

boolean printProbs

printFirstOrderProbs

boolean printFirstOrderProbs

saveFeatureIndexToDisk

boolean saveFeatureIndexToDisk

removeBackgroundSingletonFeatures

boolean removeBackgroundSingletonFeatures

doGibbs

boolean doGibbs

numSamples

int numSamples

useNERPrior

boolean useNERPrior

useAcqPrior

boolean useAcqPrior

useUniformPrior

boolean useUniformPrior

If true and doGibbs also true, will do generic Gibbs inference without any priors

useMUCFeatures

boolean useMUCFeatures

annealingRate

double annealingRate

annealingType

java.lang.String annealingType

loadProcessedData

java.lang.String loadProcessedData

initViterbi

boolean initViterbi

useUnknown

boolean useUnknown

checkNameList

boolean checkNameList

useSemPrior

boolean useSemPrior

useFirstWord

boolean useFirstWord

useNumberFeature

boolean useNumberFeature

ocrFold

int ocrFold

classifierType

java.lang.String classifierType

svmModelFile

java.lang.String svmModelFile

inferenceType

java.lang.String inferenceType

useLemmaAsWord

boolean useLemmaAsWord

type

java.lang.String type

readerAndWriter

java.lang.String readerAndWriter

comboProps

java.util.List<E> comboProps

usePrediction

boolean usePrediction

useAltGazFeatures

boolean useAltGazFeatures

gazFilesFile

java.lang.String gazFilesFile

usePrediction2

boolean usePrediction2

baseTrainDir

java.lang.String baseTrainDir

baseTestDir

java.lang.String baseTestDir

trainFiles

java.lang.String trainFiles

trainFileList

java.lang.String trainFileList

testFiles

java.lang.String testFiles

trainDirs

java.lang.String trainDirs

testDirs

java.lang.String testDirs

useOnlySeenWeights

boolean useOnlySeenWeights

predProp

java.lang.String predProp

pad

CoreLabel pad

useObservedFeaturesOnly

boolean useObservedFeaturesOnly

distSimLexicon

java.lang.String distSimLexicon

useDistSim

boolean useDistSim

removeTopN

int removeTopN

numTimesRemoveTopN

int numTimesRemoveTopN

randomizedRatio

double randomizedRatio

removeTopNPercent

double removeTopNPercent

purgeFeatures

int purgeFeatures

booleanFeatures

boolean booleanFeatures

iobWrapper

boolean iobWrapper

iobTags

boolean iobTags

useSegmentation

boolean useSegmentation

memoryThrift

boolean memoryThrift

timitDatum

boolean timitDatum

serializeDatasetsDir

java.lang.String serializeDatasetsDir

loadDatasetsDir

java.lang.String loadDatasetsDir

pushDir

java.lang.String pushDir

purgeDatasets

boolean purgeDatasets

keepOBInMemory

boolean keepOBInMemory

fakeDataset

boolean fakeDataset

restrictTransitionsTimit

boolean restrictTransitionsTimit

numDatasetsPerFile

int numDatasetsPerFile

useTitle

boolean useTitle

lowerNewgeneThreshold

boolean lowerNewgeneThreshold

useEitherSideWord

boolean useEitherSideWord

useEitherSideDisjunctive

boolean useEitherSideDisjunctive

twoStage

boolean twoStage

crfType

java.lang.String crfType

featureThreshold

int featureThreshold

featThreshFile

java.lang.String featThreshFile

featureDiffThresh

double featureDiffThresh

numTimesPruneFeatures

int numTimesPruneFeatures

newgeneThreshold

double newgeneThreshold

doAdaptation

boolean doAdaptation

useInternal

boolean useInternal

useExternal

boolean useExternal

selfTrainConfidenceThreshold

double selfTrainConfidenceThreshold

selfTrainIterations

int selfTrainIterations

selfTrainWindowSize

int selfTrainWindowSize

useHuber

boolean useHuber

useQuartic

boolean useQuartic

adaptSigma

double adaptSigma

numFolds

int numFolds

startFold

int startFold

endFold

int endFold

cacheNGrams

boolean cacheNGrams

outputFormat

java.lang.String outputFormat

useSMD

boolean useSMD

useSGDtoQN

boolean useSGDtoQN

useStochasticQN

boolean useStochasticQN

useScaledSGD

boolean useScaledSGD

scaledSGDMethod

int scaledSGDMethod

SGDPasses

int SGDPasses

QNPasses

int QNPasses

tuneSGD

boolean tuneSGD

stochasticMethod

StochasticCalculateMethods stochasticMethod

initialGain

double initialGain

stochasticBatchSize

int stochasticBatchSize

useSGD

boolean useSGD

gainSGD

double gainSGD

useHybrid

boolean useHybrid

hybridCutoffIteration

int hybridCutoffIteration

outputIterationsToFile

boolean outputIterationsToFile

testObjFunction

boolean testObjFunction

testVariance

boolean testVariance

SGD2QNhessSamples

int SGD2QNhessSamples

testHessSamples

boolean testHessSamples

CRForder

int CRForder

CRFwindow

int CRFwindow

estimateInitial

boolean estimateInitial

outputEncoding

java.lang.String outputEncoding

useKBest

boolean useKBest

searchGraphPrefix

java.lang.String searchGraphPrefix

searchGraphPrune

double searchGraphPrune

kBest

int kBest

useFeaturesC4gram

boolean useFeaturesC4gram

useFeaturesC5gram

boolean useFeaturesC5gram

useFeaturesC6gram

boolean useFeaturesC6gram

useFeaturesCpC4gram

boolean useFeaturesCpC4gram

useFeaturesCpC5gram

boolean useFeaturesCpC5gram

useFeaturesCpC6gram

boolean useFeaturesCpC6gram

useUnicodeType

boolean useUnicodeType

useUnicodeType4gram

boolean useUnicodeType4gram

useUnicodeType5gram

boolean useUnicodeType5gram

use4Clique

boolean use4Clique

useUnicodeBlock

boolean useUnicodeBlock

useShapeStrings1

boolean useShapeStrings1

useShapeStrings3

boolean useShapeStrings3

useShapeStrings4

boolean useShapeStrings4

useShapeStrings5

boolean useShapeStrings5

useGoodForNamesCpC

boolean useGoodForNamesCpC

useDictionaryConjunctions

boolean useDictionaryConjunctions

expandMidDot

boolean expandMidDot

printFeaturesUpto

int printFeaturesUpto

useDictionaryConjunctions3

boolean useDictionaryConjunctions3

useWordUTypeConjunctions2

boolean useWordUTypeConjunctions2

useWordUTypeConjunctions3

boolean useWordUTypeConjunctions3

useWordShapeConjunctions2

boolean useWordShapeConjunctions2

useWordShapeConjunctions3

boolean useWordShapeConjunctions3

useMidDotShape

boolean useMidDotShape

augmentedDateChars

boolean augmentedDateChars

suppressMidDotPostprocessing

boolean suppressMidDotPostprocessing

printNR

boolean printNR

classBias

java.lang.String classBias

printLabelValue

boolean printLabelValue

useRobustQN

boolean useRobustQN

combo

boolean combo

useGenericFeatures

boolean useGenericFeatures

verboseForTrueCasing

boolean verboseForTrueCasing

trainHierarchical

java.lang.String trainHierarchical

domain

java.lang.String domain

baseline

boolean baseline

transferSigmas

java.lang.String transferSigmas

doFE

boolean doFE

restrictLabels

boolean restrictLabels

announceObjectBankEntries

boolean announceObjectBankEntries

usePos

boolean usePos

useAgreement

boolean useAgreement

useAccCase

boolean useAccCase

useInna

boolean useInna

useConcord

boolean useConcord

useFirstNgram

boolean useFirstNgram

useLastNgram

boolean useLastNgram

collapseNN

boolean collapseNN

useConjBreak

boolean useConjBreak

useAuxPairs

boolean useAuxPairs

usePPVBPairs

boolean usePPVBPairs

useAnnexing

boolean useAnnexing

useTemporalNN

boolean useTemporalNN

usePath

boolean usePath

innaPPAttach

boolean innaPPAttach

markProperNN

boolean markProperNN

markMasdar

boolean markMasdar

useSVO

boolean useSVO

numTags

int numTags

useTagsCpC

boolean useTagsCpC

useTagsCpCp2C

boolean useTagsCpCp2C

useTagsCpCp2Cp3C

boolean useTagsCpCp2Cp3C

useTagsCpCp2Cp3Cp4C

boolean useTagsCpCp2Cp3Cp4C

l1reg

double l1reg

mixedCaseMapFile

java.lang.String mixedCaseMapFile

auxTrueCaseModels

java.lang.String auxTrueCaseModels

use2W

boolean use2W

useLC

boolean useLC

useYetMoreCpCShapes

boolean useYetMoreCpCShapes

useIfInteger

boolean useIfInteger

exportFeatures

java.lang.String exportFeatures

useInPlaceSGD

boolean useInPlaceSGD

useTopics

boolean useTopics

evaluateIters

int evaluateIters

evalCmd

java.lang.String evalCmd

evaluateTrain

boolean evaluateTrain

tuneSampleSize

int tuneSampleSize

usePhraseFeatures

boolean usePhraseFeatures

usePhraseWords

boolean usePhraseWords

usePhraseWordTags

boolean usePhraseWordTags

usePhraseWordSpecialTags

boolean usePhraseWordSpecialTags

useCommonWordsFeature

boolean useCommonWordsFeature

useProtoFeatures

boolean useProtoFeatures

useWordnetFeatures

boolean useWordnetFeatures

tokenFactory

java.lang.String tokenFactory

tokenFactoryArgs

java.lang.Object[] tokenFactoryArgs

tokensAnnotationClassName

java.lang.String tokensAnnotationClassName

useCorefFeatures

boolean useCorefFeatures

wikiFeatureDbFile

java.lang.String wikiFeatureDbFile

useNoisyNonNoisyFeature

boolean useNoisyNonNoisyFeature

useYear

boolean useYear

useSentenceNumber

boolean useSentenceNumber

useLabelSource

boolean useLabelSource

casedDistSim

boolean casedDistSim

Whether to (not) lowercase tokens before looking them up in distsim lexicon. By default lowercasing was done, but now it doesn't have to be true :-).

distSimFileFormat

java.lang.String distSimFileFormat

The format of the distsim file. Known values are: alexClark = TSV file. word TAB clusterNumber [optional other content] terryKoo = TSV file. clusterBitString TAB word TAB frequency

distSimMaxBits

int distSimMaxBits

If this number is greater than 0, the distSim class is assume to be a bit string and is truncated at this many characters. Normal distSim features will then use this amount of resolution. Extra, special distsim features may work at a coarser level of resolution. Since the lexicon only stores this length of bit string, there is then no way to have finer-grained clusters.

numberEquivalenceDistSim

boolean numberEquivalenceDistSim

If this is set to true, all digit characters get mapped to '9' in a distsim lexicon and for lookup. This is a simple word shaping that can shrink distsim lexicons and improve their performance.

unknownWordDistSimClass

java.lang.String unknownWordDistSimClass

What class to assign to words not found in the dist sim lexicon. You might want to make it a known class, if one is the "default class.

useNeighborNGrams

boolean useNeighborNGrams

Use prefixes and suffixes from the previous and next word.

wordFunction

Function<T1,T2> wordFunction

This function maps words in the training or test data to new words. They are used at the feature extractor level, ie in the FeatureFactory. For now, only the NERFeatureFactory uses this.

plainTextDocumentReaderAndWriter

java.lang.String plainTextDocumentReaderAndWriter

useBagOfWords

boolean useBagOfWords

Use a bag of all words as a feature. Perhaps this will find some words that indicate certain types of entities are present.

evaluateBackground

boolean evaluateBackground

When scoring, count the background symbol stats too. Useful for things where the background symbol is particularly meaningful, such as truecase.

numLopExpert

int numLopExpert

Number of experts to be used in Logarithmic Opinion Pool (product of experts) training default value is 1

includeFullCRFInLOP

boolean includeFullCRFInLOP

backpropLopTraining

boolean backpropLopTraining

randomLopWeights

boolean randomLopWeights

randomLopFeatureSplit

boolean randomLopFeatureSplit

nonLinearCRF

boolean nonLinearCRF

secondOrderNonLinear

boolean secondOrderNonLinear

numHiddenUnits

int numHiddenUnits

useOutputLayer

boolean useOutputLayer

useHiddenLayer

boolean useHiddenLayer

gradientDebug

boolean gradientDebug

checkGradient

boolean checkGradient

useSigmoid

boolean useSigmoid

skipOutputRegularization

boolean skipOutputRegularization

sparseOutputLayer

boolean sparseOutputLayer

tieOutputLayer

boolean tieOutputLayer

blockInitialize

boolean blockInitialize

softmaxOutputLayer

boolean softmaxOutputLayer

loadBisequenceClassifierEn

java.lang.String loadBisequenceClassifierEn

Bisequence CRF parameters

loadBisequenceClassifierCh

java.lang.String loadBisequenceClassifierCh

bisequenceClassifierPropEn

java.lang.String bisequenceClassifierPropEn

bisequenceClassifierPropCh

java.lang.String bisequenceClassifierPropCh

bisequenceTestFileEn

java.lang.String bisequenceTestFileEn

bisequenceTestFileCh

java.lang.String bisequenceTestFileCh

bisequenceTestOutputEn

java.lang.String bisequenceTestOutputEn

bisequenceTestOutputCh

java.lang.String bisequenceTestOutputCh

bisequenceTestAlignmentFile

java.lang.String bisequenceTestAlignmentFile

bisequencePriorType

int bisequencePriorType

bisequenceAlignmentPriorPenaltyCh

java.lang.String bisequenceAlignmentPriorPenaltyCh

bisequenceAlignmentPriorPenaltyEn

java.lang.String bisequenceAlignmentPriorPenaltyEn

alignmentPruneThreshold

double alignmentPruneThreshold

factorInAlignmentProb

boolean factorInAlignmentProb

useChromaticSampling

boolean useChromaticSampling

useSequentialScanSampling

boolean useSequentialScanSampling

maxAllowedChromaticSize

int maxAllowedChromaticSize

keepEmptySentences

boolean keepEmptySentences

Whether or not to keep blank sentences when processing. Useful for systems such as the segmenter if you want to line up each line exactly, including blank lines.

useBilingualNERPrior

boolean useBilingualNERPrior

samplingSpeedUpThreshold

int samplingSpeedUpThreshold

entityMatrixCh

java.lang.String entityMatrixCh

entityMatrixEn

java.lang.String entityMatrixEn

multiThreadGibbs

int multiThreadGibbs

matchNERIncentive

boolean matchNERIncentive

useEmbedding

boolean useEmbedding

prependEmbedding

boolean prependEmbedding

embeddingWords

java.lang.String embeddingWords

embeddingVectors

java.lang.String embeddingVectors

transitionEdgeOnly

boolean transitionEdgeOnly

priorLambda

double priorLambda

addCapitalFeatures

boolean addCapitalFeatures

arbitraryInputLayerSize

int arbitraryInputLayerSize

noEdgeFeature

boolean noEdgeFeature

terminateOnEvalImprovement

boolean terminateOnEvalImprovement

terminateOnEvalImprovementNumOfEpoch

int terminateOnEvalImprovementNumOfEpoch

useMemoryEvaluator

boolean useMemoryEvaluator

suppressTestDebug

boolean suppressTestDebug

useOWLQN

boolean useOWLQN

printWeights

boolean printWeights

totalDataSlice

int totalDataSlice

numOfSlices

int numOfSlices

regularizeSoftmaxTieParam

boolean regularizeSoftmaxTieParam

softmaxTieLambda

double softmaxTieLambda

totalFeatureSlice

int totalFeatureSlice

numOfFeatureSlices

int numOfFeatureSlices

addBiasToEmbedding

boolean addBiasToEmbedding

hardcodeSoftmaxOutputWeights

boolean hardcodeSoftmaxOutputWeights

useNERPriorBIO

boolean useNERPriorBIO

entityMatrix

java.lang.String entityMatrix

multiThreadClassifier

int multiThreadClassifier

printFactorTable

boolean printFactorTable

useAdaGradFOBOS

boolean useAdaGradFOBOS

initRate

double initRate

groupByFeatureTemplate

boolean groupByFeatureTemplate

groupByOutputClass

boolean groupByOutputClass

priorAlpha

double priorAlpha

splitWordRegex

java.lang.String splitWordRegex

groupByInput

boolean groupByInput

groupByHiddenUnit

boolean groupByHiddenUnit

unigramLM

java.lang.String unigramLM

bigramLM

java.lang.String bigramLM

wordSegBeamSize

int wordSegBeamSize

vocabFile

java.lang.String vocabFile

averagePerceptron

boolean averagePerceptron

loadCRFSegmenterPath

java.lang.String loadCRFSegmenterPath

loadPCTSegmenterPath

java.lang.String loadPCTSegmenterPath

crfSegmenterProp

java.lang.String crfSegmenterProp

pctSegmenterProp

java.lang.String pctSegmenterProp

intermediateSegmenterOut

java.lang.String intermediateSegmenterOut

intermediateSegmenterModel

java.lang.String intermediateSegmenterModel

dualDecompMaxItr

int dualDecompMaxItr

dualDecompInitialStepSize

double dualDecompInitialStepSize

dualDecompDebug

boolean dualDecompDebug

useCWSWordFeatures

boolean useCWSWordFeatures

useCWSWordFeaturesAll

boolean useCWSWordFeaturesAll

useCWSWordFeaturesBigram

boolean useCWSWordFeaturesBigram

pctSegmenterLenAdjust

boolean pctSegmenterLenAdjust

useTrainLexicon

boolean useTrainLexicon

Class edu.stanford.nlp.sequences.TrueCasingForNISTDocumentReaderAndWriter extends java.lang.Object implements Serializable

serialVersionUID: -3000389291781534479L

Serialized Fields

factory

IteratorFromReaderFactory<T> factory

verboseForTrueCasing

java.lang.Boolean verboseForTrueCasing

Package edu.stanford.nlp.stats

Class edu.stanford.nlp.stats.ClassicCounter extends java.lang.Object implements Serializable

serialVersionUID: 4L

Serialized Fields

map

java.util.Map<K,V> map

mapFactory

MapFactory<K,V> mapFactory

totalCount

double totalCount

defaultValue

double defaultValue

Class edu.stanford.nlp.stats.Dirichlet extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

parameters

Counter<E> parameters

Class edu.stanford.nlp.stats.DirichletProcess extends java.lang.Object implements Serializable

serialVersionUID: -8653536087199951278L

Serialized Fields

baseMeasure

ProbabilityDistribution<E> baseMeasure

alpha

double alpha

sampled

ClassicCounter<E> sampled

Class edu.stanford.nlp.stats.Distribution extends java.lang.Object implements Serializable

serialVersionUID: 6707148234288637809L

Serialized Fields

numberOfKeys

int numberOfKeys

reservedMass

double reservedMass

counter

Counter<E> counter

Class edu.stanford.nlp.stats.Gamma extends java.lang.Object implements Serializable

serialVersionUID: -2992079318379176178L

Serialized Fields

alpha

double alpha

Class edu.stanford.nlp.stats.GeneralizedCounter extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

map

java.util.Map<K,V> map

depth

int depth

total

double total

Class edu.stanford.nlp.stats.IntCounter extends AbstractCounter<E> implements Serializable

serialVersionUID: 4L

Serialized Fields

map

java.util.Map<K,V> map

mapFactory

MapFactory<K,V> mapFactory

totalCount

int totalCount

defaultValue

int defaultValue

Class edu.stanford.nlp.stats.Multinomial extends java.lang.Object implements Serializable

serialVersionUID: -697457414113362926L

Serialized Fields

parameters

Counter<E> parameters

hashCode

int hashCode

Class edu.stanford.nlp.stats.ThreadsafeCounter extends java.lang.Object implements Serializable

serialVersionUID: -8077192206562696111L

Serialized Fields

map

java.util.concurrent.ConcurrentMap<K,V> map

totalCount

double totalCount

defaultReturnValue

double defaultReturnValue

Class edu.stanford.nlp.stats.TwoDimensionalCounter extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

map

java.util.Map<K,V> map

total

double total

outerMF

MapFactory<K,V> outerMF

innerMF

MapFactory<K,V> innerMF

defaultValue

double defaultValue

Class edu.stanford.nlp.stats.TwoDimensionalIntCounter extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

map

java.util.Map<K,V> map

total

int total

outerMF

MapFactory<K,V> outerMF

innerMF

MapFactory<K,V> innerMF

defaultValue

int defaultValue

Package edu.stanford.nlp.tagger.maxent

Class edu.stanford.nlp.tagger.maxent.DictionaryExtractor extends Extractor implements Serializable

serialVersionUID: 692763177746328195L

Class edu.stanford.nlp.tagger.maxent.Extractor extends java.lang.Object implements Serializable

serialVersionUID: -4694133872973560083L

Serialized Fields

position

int position

isTag

boolean isTag

Class edu.stanford.nlp.tagger.maxent.ExtractorDistsim extends Extractor implements Serializable

serialVersionUID: 1L

Serialized Fields

lexicon

java.util.Map<K,V> lexicon

Class edu.stanford.nlp.tagger.maxent.ExtractorDistsim.ExtractorDistsimConjunction extends Extractor implements Serializable

serialVersionUID: 1L

Serialized Fields

lexicon

java.util.Map<K,V> lexicon

left

int left

right

int right

name

java.lang.String name

Class edu.stanford.nlp.tagger.maxent.Extractors extends java.lang.Object implements Serializable

serialVersionUID: -4777107742414749890L

Serialized Fields

v

Extractor[] v

Class edu.stanford.nlp.tagger.maxent.ExtractorVerbalVBNZero extends DictionaryExtractor implements Serializable

serialVersionUID: -5881204185400060636L

Serialized Fields

bound

int bound

Class edu.stanford.nlp.tagger.maxent.MaxentTagger extends java.lang.Object implements Serializable

serialVersionUID: 2L

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Throws:: java.io.IOException; java.lang.ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException

Throws:: java.io.IOException

Serialized Fields

dict

Dictionary dict

prob

LambdaSolveTagger prob

fAssociations

java.util.List<E> fAssociations

extractors

Extractors extractors

extractorsRare

Extractors extractorsRare

ambClasses

AmbiguityClasses ambClasses

alltags

boolean alltags

tagTokens

java.util.Map<K,V> tagTokens

defaultScore

double defaultScore

defaultScores

double[] defaultScores

leftContext

int leftContext

rightContext

int rightContext

config

TaggerConfig config

rareWordThresh

int rareWordThresh

Determines which words are considered rare. All words with count in the training data strictly less than this number (standardly, < 5) are considered rare.

minFeatureThresh

int minFeatureThresh

Determines which features are included in the model. The model includes features that occurred strictly more times than this number (standardly, > 5) in the training data. Here I look only at the history (not the tag), so the history appearing this often is enough.

curWordMinFeatureThresh

int curWordMinFeatureThresh

This is a special threshold for the current word feature. Only words that have occurred strictly > this number of times in total will generate word features with all of their occurring tags. The traditional default was 2.

rareWordMinFeatureThresh

int rareWordMinFeatureThresh

Determines which rare word features are included in the model. The features for rare words have a strictly higher support than this number are included. Traditional default is 10.

veryCommonWordThresh

int veryCommonWordThresh

If using tag equivalence classes on following words, words that occur strictly more than this number of times (in total with any tag) are sufficiently frequent to form an equivalence class by themselves. (Not used unless using equivalence classes.) There are places in the code (ExtractorAmbiguityClass.java, for one) that assume this value is constant over the life of a tagger.

xSize

int xSize

ySize

int ySize

occurringTagsOnly

boolean occurringTagsOnly

possibleTagsOnly

boolean possibleTagsOnly

initted

boolean initted

VERBOSE

boolean VERBOSE

wordFunction

Function<T1,T2> wordFunction

This is a function used to preprocess all text before applying the tagger to it. For example, it could be a function to lowercase text, such as edu.stanford.nlp.util.LowercaseFunction (which makes the tagger case insensitive). It is applied in ReadDataTagged, which loads in the training data, and in TestSentence, which processes sentences for new queries. If any other classes are added or modified which use raw text, they must also use this function to keep results consistent.
An alternate design would have been to use the function at a lower level, such as at the extractor level. That would have require more invasive changes to the tagger, though, because other data structures such as the Dictionary would then be using raw text as well. This is also more efficient, in that the function is applied once at the start of the process.

Class edu.stanford.nlp.tagger.maxent.MaxentTaggerGUI extends javax.swing.JFrame implements Serializable

serialVersionUID: -2574711492469740892L

Serialized Fields

inputBox

javax.swing.JTextArea inputBox

outputBox

javax.swing.JTextArea outputBox

tagButton

javax.swing.JButton tagButton

Class edu.stanford.nlp.tagger.maxent.TaggerConfig extends java.util.Properties implements Serializable

serialVersionUID: -4136407850147157497L

Package edu.stanford.nlp.time

Class edu.stanford.nlp.time.JollyDayHolidays.JollyHoliday extends SUTime.Time implements Serializable

Serialized Fields

holidayManager

de.jollyday.HolidayManager holidayManager

base

de.jollyday.config.Holiday base

label

java.lang.String label

Class edu.stanford.nlp.time.SUTime.CompositePartialTime extends SUTime.PartialTime implements Serializable

serialVersionUID: 1L

Serialized Fields

tod

SUTime.Time tod

dow

SUTime.Time dow

poy

SUTime.Time poy

Class edu.stanford.nlp.time.SUTime.Duration extends SUTime.Temporal implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.time.SUTime.DurationRange extends SUTime.Duration implements Serializable

serialVersionUID: 1L

Serialized Fields

minDuration

SUTime.Duration minDuration

maxDuration

SUTime.Duration maxDuration

Class edu.stanford.nlp.time.SUTime.DurationWithFields extends SUTime.Duration implements Serializable

serialVersionUID: 1L

Serialized Fields

period

org.joda.time.ReadablePeriod period

Class edu.stanford.nlp.time.SUTime.DurationWithMillis extends SUTime.Duration implements Serializable

serialVersionUID: 1L

Serialized Fields

base

org.joda.time.ReadableDuration base

Class edu.stanford.nlp.time.SUTime.ExplicitTemporalSet extends SUTime.TemporalSet implements Serializable

serialVersionUID: 1L

Serialized Fields

temporals

java.util.Set<E> temporals

Class edu.stanford.nlp.time.SUTime.GroundedTime extends SUTime.Time implements Serializable

serialVersionUID: 1L

Serialized Fields

base

org.joda.time.ReadableInstant base

Class edu.stanford.nlp.time.SUTime.InexactDuration extends SUTime.DurationWithFields implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.time.SUTime.InexactTime extends SUTime.Time implements Serializable

serialVersionUID: 1L

Serialized Fields

base

SUTime.Time base

duration

SUTime.Duration duration

range

SUTime.Range range

Class edu.stanford.nlp.time.SUTime.IsoDate extends SUTime.PartialTime implements Serializable

serialVersionUID: 1L

Serialized Fields

era

int era

Era: BC is era 0, AD is era 1, Unknown is -1

year

int year

Year of Era

month

int month

Month of Year

day

int day

Day of Month

Class edu.stanford.nlp.time.SUTime.IsoDateTime extends SUTime.PartialTime implements Serializable

serialVersionUID: 1L

Serialized Fields

date

SUTime.IsoDate date

time

SUTime.IsoTime time

Class edu.stanford.nlp.time.SUTime.IsoTime extends SUTime.PartialTime implements Serializable

serialVersionUID: 1L

Serialized Fields

hour

int hour

minute

int minute

second

int second

millis

int millis

halfday

int halfday

Class edu.stanford.nlp.time.SUTime.OrdinalTime extends SUTime.Time implements Serializable

serialVersionUID: 1L

Serialized Fields

base

SUTime.Temporal base

n

int n

Class edu.stanford.nlp.time.SUTime.PartialTime extends SUTime.Time implements Serializable

serialVersionUID: 1L

Serialized Fields

base

org.joda.time.Partial base

dateTimeZone

org.joda.time.DateTimeZone dateTimeZone

Class edu.stanford.nlp.time.SUTime.PeriodicTemporalSet extends SUTime.TemporalSet implements Serializable

serialVersionUID: 1L

Serialized Fields

occursIn

SUTime.Range occursIn

Start and end times for when this set of times is suppose to be happening (e.g. 2011-09-01 to 2011-12-30)

base

SUTime.Temporal base

Temporal that re-occurs (e.g. Friday 2-3pm)

periodicity

SUTime.Duration periodicity

The periodicity of re-occurrence (e.g. week)

quant

java.lang.String quant

Quantifier - every, every other

freq

java.lang.String freq

String representation of frequency (3 days = P3D, 3 times = P3X)

Class edu.stanford.nlp.time.SUTime.Range extends SUTime.Temporal implements Serializable

serialVersionUID: 1L

Serialized Fields

begin

SUTime.Time begin

end

SUTime.Time end

duration

SUTime.Duration duration

Class edu.stanford.nlp.time.SUTime.RefTime extends SUTime.Time implements Serializable

serialVersionUID: 1L

Serialized Fields

label

java.lang.String label

Class edu.stanford.nlp.time.SUTime.RelativeTime extends SUTime.Time implements Serializable

serialVersionUID: 1L

Serialized Fields

base

SUTime.Time base

tempOp

SUTime.TemporalOp tempOp

tempArg

SUTime.Temporal tempArg

opFlags

int opFlags

Class edu.stanford.nlp.time.SUTime.SimpleTime extends SUTime.Time implements Serializable

serialVersionUID: 1L

Serialized Fields

label

java.lang.String label

Class edu.stanford.nlp.time.SUTime.Temporal extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

mod

java.lang.String mod

approx

boolean approx

standardTemporalType

SUTime.StandardTemporalType standardTemporalType

timeLabel

java.lang.String timeLabel

Class edu.stanford.nlp.time.SUTime.TemporalSet extends SUTime.Temporal implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.time.SUTime.Time extends SUTime.Temporal implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.time.SUTime.TimeWithRange extends SUTime.Time implements Serializable

serialVersionUID: 1L

Serialized Fields

range

SUTime.Range range

Class edu.stanford.nlp.time.SUTimeSimpleParser.SUTimeParsingError extends java.lang.Exception implements Serializable

serialVersionUID: 1L

Serialized Fields

timeExpression

java.lang.String timeExpression

Class edu.stanford.nlp.time.TimeExpressionExtractorFactory extends java.lang.Object implements Serializable

Serialized Fields

timeExpressionExtractorClass

java.lang.String timeExpressionExtractorClass

Class edu.stanford.nlp.time.Timex extends java.lang.Object implements Serializable

serialVersionUID: 385847729549981302L

Serialized Fields

xml

java.lang.String xml

XML representation of the TIMEX tag

val

java.lang.String val

TIMEX3 value attribute - Time value (given in extended ISO 8601 format).

altVal

java.lang.String altVal

Alternate representation for time value (not part of TIMEX3 standard). used when value of the time expression cannot be expressed as a standard TIMEX3 value.

text

java.lang.String text

Actual text that make up the time expression

type

java.lang.String type

TIMEX3 type attribute - Type of the time expression (DATE, TIME, DURATION, or SET)

tid

java.lang.String tid

TIMEX3 tid attribute - TimeID. ID to identify this time expression. Should have the format of t<integer>

beginPoint

int beginPoint

TIMEX3 beginPoint attribute - integer indicating the TimeID of the begin time that anchors this duration/range (-1 is not present).

endPoint

int endPoint

TIMEX3 beginPoint attribute - integer indicating the TimeID of the end time that anchors this duration/range (-1 is not present).

Package edu.stanford.nlp.trees

Class edu.stanford.nlp.trees.AbstractCollinsHeadFinder extends java.lang.Object implements Serializable

serialVersionUID: -6540278059442931087L

Serialized Fields

tlp

TreebankLanguagePack tlp

nonTerminalInfo

java.util.Map<K,V> nonTerminalInfo

defaultRule

java.lang.String[] defaultRule

Default direction if no rule is found for category (the head/parent). Subclasses can turn it on if they like. If they don't it is an error if no rule is defined for a category (null is returned).

defaultLeftRule

java.lang.String[] defaultLeftRule

These are built automatically from categoriesToAvoid and used in a fairly different fashion from defaultRule (above). These are used for categories that do have defined rules but where none of them have matched. Rather than picking the rightmost or leftmost child, we will use these to pick the the rightmost or leftmost child which isn't in categoriesToAvoid.

defaultRightRule

java.lang.String[] defaultRightRule

Class edu.stanford.nlp.trees.AbstractTreebankLanguagePack extends java.lang.Object implements Serializable

serialVersionUID: -6506749780512708352L

Serialized Fields

gfCharacter

char gfCharacter

Default character for indicating that something is a grammatical fn; probably should be overridden by lang specific ones

punctTagStringAcceptFilter

Filter<T> punctTagStringAcceptFilter

punctWordStringAcceptFilter

Filter<T> punctWordStringAcceptFilter

sFPunctTagStringAcceptFilter

Filter<T> sFPunctTagStringAcceptFilter

eIPunctTagStringAcceptFilter

Filter<T> eIPunctTagStringAcceptFilter

startSymbolAcceptFilter

Filter<T> startSymbolAcceptFilter

Class edu.stanford.nlp.trees.BobChrisTreeNormalizer extends TreeNormalizer implements Serializable

serialVersionUID: -1005188028979810143L

Serialized Fields

tlp

TreebankLanguagePack tlp

emptyFilter

Filter<T> emptyFilter

aOverAFilter

Filter<T> aOverAFilter

Class edu.stanford.nlp.trees.BobChrisTreeNormalizer.AOverAFilter extends java.lang.Object implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.trees.BobChrisTreeNormalizer.EmptyFilter extends java.lang.Object implements Serializable

serialVersionUID: 8914098359495987617L

Class edu.stanford.nlp.trees.CollinsDependency extends java.lang.Object implements Serializable

serialVersionUID: -4236496863919294754L

Serialized Fields

modifier

CoreLabel modifier

head

CoreLabel head

relation

edu.stanford.nlp.trees.CollinsRelation relation

Class edu.stanford.nlp.trees.CollinsHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: -8747319554557223437L

Class edu.stanford.nlp.trees.Dependencies.DependentPuncTagRejectFilter extends java.lang.Object implements Serializable

serialVersionUID: -7732189363171164852L

Serialized Fields

tagRejectFilter

Filter<T> tagRejectFilter

Class edu.stanford.nlp.trees.Dependencies.DependentPuncWordRejectFilter extends java.lang.Object implements Serializable

serialVersionUID: 1166489968248785287L

Serialized Fields

wordRejectFilter

Filter<T> wordRejectFilter

Class edu.stanford.nlp.trees.EnglishGrammaticalStructure extends GrammaticalStructure implements Serializable

serialVersionUID: -1866362375001969402L

Class edu.stanford.nlp.trees.GrammaticalFunctionTreeNormalizer extends TreeNormalizer implements Serializable

serialVersionUID: -2270472762938163327L

Serialized Fields

nodeCleanup

int nodeCleanup

root

java.lang.String root

tlp

TreebankLanguagePack tlp

Class edu.stanford.nlp.trees.GrammaticalRelation extends java.lang.Object implements Serializable

serialVersionUID: 892618003417550128L

Serialized Fields

language

GrammaticalRelation.Language language

shortName

java.lang.String shortName

longName

java.lang.String longName

parent

GrammaticalRelation parent

children

java.util.List<E> children

sourcePattern

java.util.regex.Pattern sourcePattern

targetPatterns

java.util.List<E> targetPatterns

specific

java.lang.String specific

Class edu.stanford.nlp.trees.GrammaticalStructure extends TreeGraph implements Serializable

serialVersionUID: 2286294455343892678L

Serialized Fields

dependencies

java.util.Set<E> dependencies

typedDependencies

java.util.List<E> typedDependencies

allTypedDependencies

java.util.List<E> allTypedDependencies

puncFilter

Filter<T> puncFilter

Class edu.stanford.nlp.trees.LabeledScoredTreeNode extends Tree implements Serializable

serialVersionUID: -8992385140984593817L

Serialized Fields

label

Label label

Label of the parse tree.

score

double score

Score of TreeNode

daughterTrees

Tree[] daughterTrees

Daughters of the parse tree.

Class edu.stanford.nlp.trees.LeftHeadFinder extends java.lang.Object implements Serializable

serialVersionUID: 8453889846239508208L

Class edu.stanford.nlp.trees.LengthTreeFilter extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

length

int length

Class edu.stanford.nlp.trees.ModCollinsHeadFinder extends CollinsHeadFinder implements Serializable

serialVersionUID: -5870387458902637256L

Class edu.stanford.nlp.trees.NamedDependency extends UnnamedDependency implements Serializable

serialVersionUID: -1635646451505721133L

Serialized Fields

name

java.lang.Object name

Class edu.stanford.nlp.trees.NPTmpRetainingTreeNormalizer extends BobChrisTreeNormalizer implements Serializable

serialVersionUID: 7548777133196579107L

Serialized Fields

temporalAnnotation

int temporalAnnotation

doSGappedStuff

boolean doSGappedStuff

leaveItAll

int leaveItAll

doAdverbialNP

boolean doAdverbialNP

headFinder

HeadFinder headFinder

Class edu.stanford.nlp.trees.OrderedCombinationTreeNormalizer extends TreeNormalizer implements Serializable

serialVersionUID: 326L

Serialized Fields

tns

java.util.List<E> tns

Class edu.stanford.nlp.trees.PennTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: 9081305982861675328L

Class edu.stanford.nlp.trees.SemanticHeadFinder extends ModCollinsHeadFinder implements Serializable

serialVersionUID: 5721799188009249808L

Serialized Fields

verbalAuxiliaries

java.util.Set<E> verbalAuxiliaries

copulars

java.util.Set<E> copulars

passiveAuxiliaries

java.util.Set<E> passiveAuxiliaries

verbalTags

java.util.Set<E> verbalTags

unambiguousAuxiliaryTags

java.util.Set<E> unambiguousAuxiliaryTags

Class edu.stanford.nlp.trees.SimpleTree extends Tree implements Serializable

serialVersionUID: -8075763706877132926L

Serialized Fields

daughterTrees

Tree[] daughterTrees

Daughters of the parse tree.

Class edu.stanford.nlp.trees.Tree extends java.util.AbstractCollection<Tree> implements Serializable

serialVersionUID: 5441849457648722744L

Class edu.stanford.nlp.trees.TreeFilters.HasMatchingChild extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

tlp

TreebankLanguagePack tlp

pattern

java.util.regex.Pattern pattern

Class edu.stanford.nlp.trees.TreeGraph extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

root

TreeGraphNode root

The root node of this treegraph.

indexMap

java.util.Map<K,V> indexMap

A map from arbitrary integer indices to nodes.

Class edu.stanford.nlp.trees.TreeGraphNode extends Tree implements Serializable

serialVersionUID: 5080098143617475328L

Serialized Fields

label

CoreLabel label

Label for this node.

parent

TreeGraphNode parent

Parent of this node.

children

TreeGraphNode[] children

Children of this node.

tg

TreeGraph tg

The TreeGraph of which this node is part.

Class edu.stanford.nlp.trees.TreeNormalizer extends java.lang.Object implements Serializable

serialVersionUID: 1540681875853883387L

Class edu.stanford.nlp.trees.TypedDependency extends java.lang.Object implements Serializable

serialVersionUID: -7690294213151279779L

Serialized Fields

reln

GrammaticalRelation reln

gov

TreeGraphNode gov

dep

TreeGraphNode dep

extra

boolean extra

Class edu.stanford.nlp.trees.UnnamedConcreteDependency extends UnnamedDependency implements Serializable

serialVersionUID: -8836949694741145222L

Serialized Fields

headIndex

int headIndex

depIndex

int depIndex

Class edu.stanford.nlp.trees.UnnamedDependency extends java.lang.Object implements Serializable

serialVersionUID: -3768440215342256085L

Serialized Fields

regentText

java.lang.String regentText

dependentText

java.lang.String dependentText

regent

Label regent

dependent

Label dependent

Package edu.stanford.nlp.trees.international.arabic

Class edu.stanford.nlp.trees.international.arabic.ArabicHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: 6203368998430280740L

Serialized Fields

tagSet

ArabicHeadFinder.TagSet tagSet

predPattern

java.util.regex.Pattern predPattern

Class edu.stanford.nlp.trees.international.arabic.ArabicTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: 9081305982861675328L

Serialized Fields

tf

TokenizerFactory<T> tf

TODO: there is no way to change this using options.

Class edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer extends BobChrisTreeNormalizer implements Serializable

serialVersionUID: -1592231121068698494L

Serialized Fields

retainNPTmp

boolean retainNPTmp

retainNPSbj

boolean retainNPSbj

markPRDverb

boolean markPRDverb

changeNoLabels

boolean changeNoLabels

retainPPClr

boolean retainPPClr

prdPattern

java.util.regex.Pattern prdPattern

prdVerbPattern

TregexPattern prdVerbPattern

npSbjPattern

TregexPattern npSbjPattern

rootLabel

java.lang.String rootLabel

lexMapper

Mapper lexMapper

Class edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer.ArabicEmptyFilter extends java.lang.Object implements Serializable

serialVersionUID: 7417844982953945964L

Class edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory extends java.lang.Object implements Serializable

serialVersionUID: 1973767605277873017L

Serialized Fields

retainNPTmp

boolean retainNPTmp

retainNPSbj

boolean retainNPSbj

retainPRD

boolean retainPRD

retainPPClr

boolean retainPPClr

changeNoLabels

boolean changeNoLabels

filterX

boolean filterX

noNormalization

boolean noNormalization

Class edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory.ArabicRawTreeReaderFactory extends ArabicTreeReaderFactory implements Serializable

serialVersionUID: -5693371540982097793L

Package edu.stanford.nlp.trees.international.french

Class edu.stanford.nlp.trees.international.french.AbishekFrenchHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: -7195627297254128427L

Class edu.stanford.nlp.trees.international.french.DybroFrenchHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: 8798606577201646967L

Class edu.stanford.nlp.trees.international.french.FrenchHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: 8747319554557223422L

Class edu.stanford.nlp.trees.international.french.FrenchTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: -7338244949063822519L

Class edu.stanford.nlp.trees.international.french.FrenchTreeNormalizer extends BobChrisTreeNormalizer implements Serializable

serialVersionUID: 7868735300308066991L

Serialized Fields

rootLabel

java.lang.String rootLabel

Class edu.stanford.nlp.trees.international.french.FrenchTreeNormalizer.FrenchAOverAFilter extends java.lang.Object implements Serializable

serialVersionUID: 793800623099852951L

Class edu.stanford.nlp.trees.international.french.FrenchTreeReaderFactory extends java.lang.Object implements Serializable

serialVersionUID: 6928967570430642163L

Serialized Fields

readPennFormat

boolean readPennFormat

Package edu.stanford.nlp.trees.international.hebrew

Class edu.stanford.nlp.trees.international.hebrew.HebrewTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: 4787589385598144401L

Class edu.stanford.nlp.trees.international.hebrew.HebrewTreeNormalizer extends BobChrisTreeNormalizer implements Serializable

serialVersionUID: -3129547164200725933L

Serialized Fields

hebrewEmptyFilter

Filter<T> hebrewEmptyFilter

Class edu.stanford.nlp.trees.international.hebrew.HebrewTreeNormalizer.HebrewEmptyFilter extends java.lang.Object implements Serializable

serialVersionUID: -7256461296718287280L

Class edu.stanford.nlp.trees.international.hebrew.HebrewTreeReaderFactory extends java.lang.Object implements Serializable

serialVersionUID: 818065349424602548L

Package edu.stanford.nlp.trees.international.negra

Class edu.stanford.nlp.trees.international.negra.NegraHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: -7253035927065152766L

Serialized Fields

coordSwitch

boolean coordSwitch

left

java.lang.String left

right

java.lang.String right

Class edu.stanford.nlp.trees.international.negra.NegraLabel extends StringLabel implements Serializable

serialVersionUID: 2847331882765391095L

Serialized Fields

edge

java.lang.String edge

features

java.util.Map<K,V> features

Class edu.stanford.nlp.trees.international.negra.NegraPennLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: 9081305982861675328L

Serialized Fields

leaveGF

boolean leaveGF

Class edu.stanford.nlp.trees.international.negra.NegraPennTreeNormalizer extends TreeNormalizer implements Serializable

serialVersionUID: 8529514903815041064L

Serialized Fields

nodeCleanup

int nodeCleanup

How to clean up node labels: 0 = do nothing, 1 = keep category and function, 2 = just category

tlp

TreebankLanguagePack tlp

insertNPinPP

boolean insertNPinPP

emptyFilter

Filter<T> emptyFilter

aOverAFilter

Filter<T> aOverAFilter

prepositionTags

java.util.Set<E> prepositionTags

postpositionTags

java.util.Set<E> postpositionTags

Class edu.stanford.nlp.trees.international.negra.NegraPennTreeReaderFactory extends java.lang.Object implements Serializable

serialVersionUID: 5731352106152470304L

Serialized Fields

nodeCleanup

int nodeCleanup

tlp

TreebankLanguagePack tlp

treeNormalizerInsertNPinPP

boolean treeNormalizerInsertNPinPP

Package edu.stanford.nlp.trees.international.pennchinese

Class edu.stanford.nlp.trees.international.pennchinese.BikelChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: -5445795668059315082L

Class edu.stanford.nlp.trees.international.pennchinese.CharacterLevelTagExtender extends BobChrisTreeNormalizer implements Serializable

serialVersionUID: 7893996593626523700L

Class edu.stanford.nlp.trees.international.pennchinese.ChineseEnglishWordMap extends java.lang.Object implements Serializable

serialVersionUID: 7655332268578049993L

Serialized Fields

map

java.util.Map<K,V> map

normalized

boolean normalized

Class edu.stanford.nlp.trees.international.pennchinese.ChineseGrammaticalStructure extends GrammaticalStructure implements Serializable

serialVersionUID: 8877651855167458256L

Class edu.stanford.nlp.trees.international.pennchinese.ChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: 6143632784691159283L

Class edu.stanford.nlp.trees.international.pennchinese.ChineseSemanticHeadFinder extends ChineseHeadFinder implements Serializable

serialVersionUID: 2L

Class edu.stanford.nlp.trees.international.pennchinese.ChineseTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable

serialVersionUID: 5757403475523638802L

Serialized Fields

tf

TokenizerFactory<T> tf

Class edu.stanford.nlp.trees.international.pennchinese.CTBErrorCorrectingTreeNormalizer extends BobChrisTreeNormalizer implements Serializable

serialVersionUID: -8203853817025401845L

Serialized Fields

tagExtender

TreeTransformer tagExtender

splitNPTMP

boolean splitNPTMP

splitPPTMP

boolean splitPPTMP

splitXPTMP

boolean splitXPTMP

chineseEmptyFilter

Filter<T> chineseEmptyFilter

Class edu.stanford.nlp.trees.international.pennchinese.FragmentTreeFilter extends java.lang.Object implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.trees.international.pennchinese.SunJurafskyChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable

serialVersionUID: -7942375587642755210L

Package edu.stanford.nlp.trees.tregex

Class edu.stanford.nlp.trees.tregex.ParseException extends java.lang.Exception implements Serializable

serialVersionUID: 1L

Serialized Fields

currentToken

edu.stanford.nlp.trees.tregex.Token currentToken

This is the last token that has been consumed successfully. If this object has been created due to a parse error, the token followng this token will (therefore) be the first error token.

expectedTokenSequences

int[][] expectedTokenSequences

Each entry in this array is an array of integers. Each array of integers represents a sequence of tokens (by their ordinal values) that is expected at this point of the parse.

tokenImage

java.lang.String[] tokenImage

This is a reference to the "tokenImage" array of the generated parser within which the parse error occurred. This array is defined in the generated ...Constants interface.

eol

java.lang.String eol

The end of line string for this machine.

Class edu.stanford.nlp.trees.tregex.TregexParseException extends java.lang.RuntimeException implements Serializable

Class edu.stanford.nlp.trees.tregex.TregexPattern extends java.lang.Object implements Serializable

serialVersionUID: 5060298043763944913L

Serialized Fields

neg

boolean neg

opt

boolean opt

patternString

java.lang.String patternString

Package edu.stanford.nlp.trees.tregex.tsurgeon

Class edu.stanford.nlp.trees.tregex.tsurgeon.ParseException extends java.lang.Exception implements Serializable

serialVersionUID: 1L

Serialized Fields

currentToken

edu.stanford.nlp.trees.tregex.tsurgeon.Token currentToken

This is the last token that has been consumed successfully. If this object has been created due to a parse error, the token followng this token will (therefore) be the first error token.

expectedTokenSequences

int[][] expectedTokenSequences

Each entry in this array is an array of integers. Each array of integers represents a sequence of tokens (by their ordinal values) that is expected at this point of the parse.

tokenImage

java.lang.String[] tokenImage

This is a reference to the "tokenImage" array of the generated parser within which the parse error occurred. This array is defined in the generated ...Constants interface.

eol

java.lang.String eol

The end of line string for this machine.

Class edu.stanford.nlp.trees.tregex.tsurgeon.TsurgeonParseException extends java.lang.RuntimeException implements Serializable

Package edu.stanford.nlp.util

Class edu.stanford.nlp.util.ArrayCoreMap extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialization Methods

writeObject

private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException

Overridden serialization method: compacts our map before writing.

Throws:: java.io.IOException - If IO error

Serialized Fields

keys

java.lang.Class<T>[] keys

Array of keys

values

java.lang.Object[] values

Array of values

size

int size

Total number of elements actually in keys,values

Class edu.stanford.nlp.util.ArrayMap extends java.util.AbstractMap<K,V> implements Serializable

serialVersionUID: 1L

Serialized Fields

entryArray

edu.stanford.nlp.util.ArrayMap.Entry<K,V>[] entryArray

capacity

int capacity

size

int size

hashCodeCache

int hashCodeCache

Class edu.stanford.nlp.util.ArrayStringFilter extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

words

java.lang.String[] words

length

int length

Class edu.stanford.nlp.util.BoundedPriorityQueue extends java.util.TreeSet<E> implements Serializable

Serialized Fields

remainingCapacity

int remainingCapacity

initialCapacity

int initialCapacity

Class edu.stanford.nlp.util.CacheMap extends java.util.LinkedHashMap<K,V> implements Serializable

serialVersionUID: 1L

Serialized Fields

backingFile

java.lang.String backingFile

CACHE_ENTRIES

int CACHE_ENTRIES

entriesSinceLastWritten

int entriesSinceLastWritten

frequencyToWrite

int frequencyToWrite

hits

int hits

misses

int misses

puts

int puts

Class edu.stanford.nlp.util.CollectionFactory extends java.lang.Object implements Serializable

serialVersionUID: 3711321773145894069L

Class edu.stanford.nlp.util.CollectionFactory.ArrayListFactory extends CollectionFactory<T> implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.util.CollectionFactory.HashSetFactory extends CollectionFactory<T> implements Serializable

serialVersionUID: -6268401669449458602L

Class edu.stanford.nlp.util.CollectionFactory.LinkedListFactory extends CollectionFactory<T> implements Serializable

serialVersionUID: -4236184979948498000L

Class edu.stanford.nlp.util.CollectionFactory.SizedArrayListFactory extends CollectionFactory<T> implements Serializable

serialVersionUID: 1L

Serialized Fields

defaultSize

int defaultSize

Class edu.stanford.nlp.util.CollectionFactory.TreeSetFactory extends CollectionFactory<T> implements Serializable

serialVersionUID: -3451920268219478134L

Class edu.stanford.nlp.util.CollectionValuedMap extends java.lang.Object implements Serializable

serialVersionUID: -9064664153962599076L

Serialized Fields

map

java.util.Map<K,V> map

cf

CollectionFactory<T> cf

treatCollectionsAsImmutable

boolean treatCollectionsAsImmutable

mf

MapFactory<K,V> mf

emptyValue

java.util.Collection<E> emptyValue

The empty collection to be returned when a get doesn't find the key. The collection returned should be empty, such as Collections.emptySet, for example.

Class edu.stanford.nlp.util.DeltaCollectionValuedMap extends CollectionValuedMap<K,V> implements Serializable

serialVersionUID: 1L

Serialized Fields

originalMap

CollectionValuedMap<K,V> originalMap

deltaMap

java.util.Map<K,V> deltaMap

Class edu.stanford.nlp.util.DeltaIndex extends java.util.AbstractCollection<E> implements Serializable

serialVersionUID: -1459230891686013411L

Serialized Fields

backingIndex

Index<E> backingIndex

spilloverIndex

Index<E> spilloverIndex

backingIndexSize

int backingIndexSize

locked

boolean locked

Class edu.stanford.nlp.util.Filters.ConjFilter extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

filters

java.util.List<E> filters

Class edu.stanford.nlp.util.Filters.DisjFilter extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

filters

java.util.List<E> filters

Class edu.stanford.nlp.util.Filters.RandomFilter extends java.lang.Object implements Serializable

Serialized Fields

random

java.util.Random random

fraction

double fraction

Class edu.stanford.nlp.util.FiveDimensionalMap extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

map

java.util.Map<K,V> map

Class edu.stanford.nlp.util.FixedPrioritiesPriorityQueue extends java.util.AbstractSet<E> implements Serializable

serialVersionUID: 1L

Serialized Fields

size

int size

capacity

int capacity

elements

java.util.List<E> elements

priorities

double[] priorities

Class edu.stanford.nlp.util.FourDimensionalMap extends java.lang.Object implements Serializable

serialVersionUID: 5635664746940978837L

Serialized Fields

map

java.util.Map<K,V> map

Class edu.stanford.nlp.util.FuzzyInterval extends Interval<E extends FuzzyInterval.FuzzyComparable<E>> implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.util.HashableCoreMap extends ArrayCoreMap implements Serializable

serialVersionUID: 1L

Serialized Fields

immutableKeys

java.util.Set<E> immutableKeys

Set of immutable keys

hashcode

int hashcode

Pre-computed hashcode

Class edu.stanford.nlp.util.HashableCoreMap.HashableCoreMapException extends java.lang.RuntimeException implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.util.HashIndex extends java.util.AbstractCollection<E> implements Serializable

serialVersionUID: 5398562825928375260L

Serialized Fields

objects

java.util.ArrayList<E> objects

indexes

java.util.Map<K,V> indexes

locked

boolean locked

semaphore

java.util.concurrent.Semaphore semaphore

Class edu.stanford.nlp.util.IdentityHashSet extends java.util.AbstractSet<E> implements Serializable

serialVersionUID: -5024744406713321676L

Serialization Methods

readObject

private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException

Deserialize this Object in a manner which is binary-compatible with the JDK.

Throws:: java.io.IOException; java.lang.ClassNotFoundException

writeObject

private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException

Serialize this Object in a manner which is binary-compatible with the JDK.

Throws:: java.io.IOException

Class edu.stanford.nlp.util.Interval extends Pair<E extends java.lang.Comparable<E>,E extends java.lang.Comparable<E>> implements Serializable

serialVersionUID: 1L

Serialized Fields

flags

int flags

Class edu.stanford.nlp.util.IntPair extends IntTuple implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.util.IntQuadruple extends IntTuple implements Serializable

serialVersionUID: 7154973101012473479L

Class edu.stanford.nlp.util.IntTriple extends IntTuple implements Serializable

serialVersionUID: -3744404627253652799L

Class edu.stanford.nlp.util.IntTuple extends java.lang.Object implements Serializable

serialVersionUID: 7266305463893511982L

Serialized Fields

elements

int[] elements

Class edu.stanford.nlp.util.IntUni extends IntTuple implements Serializable

serialVersionUID: -7182556672628741200L

Class edu.stanford.nlp.util.LowercaseFunction extends java.lang.Object implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.util.MapFactory extends java.lang.Object implements Serializable

serialVersionUID: 4529666940763477360L

Class edu.stanford.nlp.util.MetaClass.ClassCreationException extends java.lang.RuntimeException implements Serializable

serialVersionUID: -5980065992461870357L

Class edu.stanford.nlp.util.MetaClass.ConstructorNotFoundException extends MetaClass.ClassCreationException implements Serializable

serialVersionUID: -5980065992461870357L

Class edu.stanford.nlp.util.MutableDouble extends java.lang.Number implements Serializable

serialVersionUID: 624465615824626762L

Serialized Fields

d

double d

Class edu.stanford.nlp.util.MutableInteger extends java.lang.Number implements Serializable

serialVersionUID: 624465615824626762L

Serialized Fields

i

int i

Class edu.stanford.nlp.util.OneToOneMap extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

m_leftAsKey

java.util.Map<K,V> m_leftAsKey

m_rightAsKey

java.util.Map<K,V> m_rightAsKey

Class edu.stanford.nlp.util.OneToOneMap.OneToOneMapException extends java.lang.Exception implements Serializable

serialVersionUID: 7743164489912070054L

Class edu.stanford.nlp.util.PaddedList extends java.util.AbstractList<E> implements Serializable

serialVersionUID: 2064775966439971729L

Serialized Fields

l

java.util.List<E> l

padding

java.lang.Object padding

Class edu.stanford.nlp.util.Pair extends java.lang.Object implements Serializable

serialVersionUID: 1360822168806852921L

Serialized Fields

first

java.lang.Object first

Direct access is deprecated. Use first().

second

java.lang.Object second

Direct access is deprecated. Use second().

Class edu.stanford.nlp.util.Quadruple extends java.lang.Object implements Serializable

serialVersionUID: 6295043666955910662L

Serialized Fields

first

java.lang.Object first

second

java.lang.Object second

third

java.lang.Object third

fourth

java.lang.Object fourth

Class edu.stanford.nlp.util.ReflectionLoading.ReflectionLoadingException extends java.lang.RuntimeException implements Serializable

serialVersionUID: -3324911744277952585L

Class edu.stanford.nlp.util.RuntimeInterruptedException extends java.lang.RuntimeException implements Serializable

Class edu.stanford.nlp.util.ScoredComparator extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

ascending

boolean ascending

Class edu.stanford.nlp.util.StringParsingTask.ParserException extends java.lang.RuntimeException implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.util.SystemUtils.ProcessException extends java.lang.RuntimeException implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.util.ThreeDimensionalCollectionValuedMap extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

map

java.util.Map<K,V> map

Class edu.stanford.nlp.util.ThreeDimensionalMap extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

map

java.util.Map<K,V> map

Class edu.stanford.nlp.util.Triple extends java.lang.Object implements Serializable

serialVersionUID: -4182871682751645440L

Serialized Fields

first

java.lang.Object first

second

java.lang.Object second

third

java.lang.Object third

Class edu.stanford.nlp.util.TwoDimensionalCollectionValuedMap extends java.lang.Object implements Serializable

serialVersionUID: 1L

Serialized Fields

map

java.util.Map<K,V> map

mf

MapFactory<K,V> mf

cf

CollectionFactory<T> cf

treatCollectionsAsImmutable

boolean treatCollectionsAsImmutable

Class edu.stanford.nlp.util.TwoDimensionalMap extends java.lang.Object implements Serializable

serialVersionUID: 2L

Serialized Fields

mf1

MapFactory<K,V> mf1

mf2

MapFactory<K,V> mf2

map

java.util.Map<K,V> map

Class edu.stanford.nlp.util.TwoDimensionalSet extends java.lang.Object implements Serializable

serialVersionUID: 2L

Serialized Fields

backingMap

TwoDimensionalMap<K1,K2,V> backingMap

Class edu.stanford.nlp.util.UnorderedPair extends Pair<T1,T2> implements Serializable

serialVersionUID: 1L

Class edu.stanford.nlp.util.UTF8EquivalenceFunction extends java.lang.Object implements Serializable

serialVersionUID: 1L

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

Stanford NLP Group