Serialized Form (Stanford CoreNLP API)

Package edu.stanford.nlp.classify
- Class edu.stanford.nlp.classify.AbstractLinearClassifierFactory extends 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 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 Object implements Serializable
  
  serialVersionUID:
  
  7115357548209007944L
  - Serialized Fields
    - weightedVotes
```
boolean weightedVotes
```
    - instances
```
CollectionValuedMap<K,V> instances
```
    - classLookup
```
Map<K,V> classLookup
```
    - l2Normalize
```
boolean l2Normalize
```
    - k
```
int k
```
- Class edu.stanford.nlp.classify.LinearClassifier extends 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 Object implements Serializable
  
  serialVersionUID:
  
  6672245467246897192L
  - Serialized Fields
    - weights
```
double[] weights
```
    - featureIndex
```
Index<E> featureIndex
```
    - classes
```
Object[] classes
```
    - prior
```
LogPrior prior
```
      Deprecated.
    - biased
```
boolean biased
```
      Deprecated.
- Class edu.stanford.nlp.classify.LogisticClassifierFactory extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - weights
```
double[] weights
```
    - featureIndex
```
Index<E> featureIndex
```
    - classes
```
Object[] classes
```
- Class edu.stanford.nlp.classify.LogPrior extends 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 Object implements Serializable
  
  serialVersionUID:
  
  1544820342684024068L
  - Serialized Fields
    - weights
```
Counter<E> weights
```
    - priors
```
Counter<E> priors
```
    - features
```
Set<E> features
```
    - addZeroValued
```
boolean addZeroValued
```
    - priorZero
```
Counter<E> priorZero
```
    - labels
```
Set<E> labels
```
    - zero
```
Integer zero
```
- Class edu.stanford.nlp.classify.NaiveBayesClassifierFactory extends 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 Object implements Serializable
  
  serialVersionUID:
  
  -743792054415242776L
  - Serialized Fields
    - featureIndex
```
Index<E> featureIndex
```
    - labelIndex
```
Index<E> labelIndex
```
    - binaryClassifiers
```
Map<K,V> binaryClassifiers
```
    - defaultLabel
```
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
```
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 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
```
String svmLightLearn
```
    - svmStructLearn
```
String svmStructLearn
```
    - svmLightClassify
```
String svmLightClassify
```
    - svmStructClassify
```
String svmStructClassify
```
    - useAlphaFile
```
boolean useAlphaFile
```
    - alphaFile
```
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
```
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 Object implements Serializable
  
  serialVersionUID:
  
  3657691243506528L
  - Serialized Fields
    - chainID
```
int chainID
```
    - mentions
```
List<E> mentions
```
    - mentionMap
```
Map<K,V> mentionMap
```
    - representative
```
CorefChain.CorefMention representative
```
      The most representative mention in this cluster
- Class edu.stanford.nlp.dcoref.CorefChain.CorefMention extends 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
```
String mentionSpan
```
- Class edu.stanford.nlp.dcoref.CorefCluster extends Object implements Serializable
  
  serialVersionUID:
  
  8655265337578515592L
  - Serialized Fields
    - corefMentions
```
Set<E> corefMentions
```
    - clusterID
```
int clusterID
```
    - numbers
```
Set<E> numbers
```
    - genders
```
Set<E> genders
```
    - animacies
```
Set<E> animacies
```
    - nerStrings
```
Set<E> nerStrings
```
    - heads
```
Set<E> heads
```
    - words
```
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 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
```
List<E> goldOrderedMentionsBySentence
```
      The list of gold mentions
    - predictedOrderedMentionsBySentence
```
List<E> predictedOrderedMentionsBySentence
```
      The list of predicted mentions
    - corefClusters
```
Map<K,V> corefClusters
```
      Clusters for coreferent mentions
    - goldCorefClusters
```
Map<K,V> goldCorefClusters
```
      Gold Clusters for coreferent mentions
    - allPredictedMentions
```
Map<K,V> allPredictedMentions
```
      All mentions in a document mentionID -> mention
    - allGoldMentions
```
Map<K,V> allGoldMentions
```
    - roleSet
```
Set<E> roleSet
```
      Set of roles (in role apposition) in a document
    - positions
```
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)
    - allPositions
```
Map<K,V> allPositions
```
    - mentionheadPositions
```
Map<K,V> mentionheadPositions
```
    - goldLinks
```
List<E> goldLinks
```
      List of gold links in a document by positions
    - speakers
```
Map<K,V> speakers
```
      UtteranceAnnotation -> String (speaker): mention ID or speaker string
    - speakerPairs
```
Set<E> speakerPairs
```
      Pair of mention id, and the mention's speaker id
    - maxUtter
```
int maxUtter
```
    - numParagraph
```
int numParagraph
```
    - numSentences
```
int numSentences
```
    - incompatibles
```
TwoDimensionalSet<K1,K2> incompatibles
```
      Set of incompatible clusters pairs
    - incompatibleClusters
```
TwoDimensionalSet<K1,K2> incompatibleClusters
```
    - acronymCache
```
TwoDimensionalMap<K1,K2,V> acronymCache
```
- Class edu.stanford.nlp.dcoref.Mention extends 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
```
String headString
```
    - nerString
```
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
```
List<E> sentenceWords
```
    - originalSpan
```
List<E> originalSpan
```
    - mentionSubTree
```
Tree mentionSubTree
```
    - contextParseTree
```
Tree contextParseTree
```
    - headWord
```
CoreLabel headWord
```
    - dependency
```
SemanticGraph dependency
```
    - dependents
```
Set<E> dependents
```
    - preprocessedTerms
```
List<E> preprocessedTerms
```
    - synsets
```
Object synsets
```
    - appositions
```
Set<E> appositions
```
      Set of other mentions in the same sentence that are syntactic appositions to this
    - predicateNominatives
```
Set<E> predicateNominatives
```
    - relativePronouns
```
Set<E> relativePronouns
```
    - listMembers
```
Set<E> listMembers
```
      Set of other mentions in the same sentence that below to this list
    - belongToLists
```
Set<E> belongToLists
```
      Set of other mentions in the same sentence that I am a member of
    - speakerInfo
```
SpeakerInfo speakerInfo
```
Package edu.stanford.nlp.graph
- Class edu.stanford.nlp.graph.DirectedMultiGraph extends Object implements Serializable
  
  serialVersionUID:
  
  609823567298345145L
  - Serialized Fields
    - outgoingEdges
```
Map<K,V> outgoingEdges
```
    - incomingEdges
```
Map<K,V> incomingEdges
```
    - outerMapFactory
```
MapFactory<K,V> outerMapFactory
```
    - innerMapFactory
```
MapFactory<K,V> innerMapFactory
```
Package edu.stanford.nlp.ie
- Class edu.stanford.nlp.ie.ChineseMorphFeatureSets extends Object implements Serializable
  
  serialVersionUID:
  
  -1055526945031459198L
  - Serialized Fields
    - featIndex
```
Index<E> featIndex
```
    - singletonFeatures
```
Map<K,V> singletonFeatures
```
    - affixFeatures
```
Map<K,V> affixFeatures
```
- Class edu.stanford.nlp.ie.EmbeddingFeatureFactory extends FeatureFactory implements Serializable
- Class edu.stanford.nlp.ie.NERFeatureFactory extends FeatureFactory<IN extends CoreLabel> implements Serializable
  
  serialVersionUID:
  
  -2329726064739185544L
  - Serialized Fields
    - lexicon
```
Map<K,V> lexicon
```
    - wordToSubstrings
```
Map<K,V> wordToSubstrings
```
    - wordToGazetteEntries
```
Map<K,V> wordToGazetteEntries
```
    - wordToGazetteInfos
```
Map<K,V> wordToGazetteInfos
```
    - genericAnnotationKeys
```
Set<E> genericAnnotationKeys
```
    - lastNames
```
Set<E> lastNames
```
    - maleNames
```
Set<E> maleNames
```
    - femaleNames
```
Set<E> femaleNames
```
    - titlePattern
```
Pattern titlePattern
```
Package edu.stanford.nlp.ie.crf
- Class edu.stanford.nlp.ie.crf.CRFDatum extends Object implements Serializable
  
  serialVersionUID:
  
  -8345554365027671190L
  - Serialized Fields
    - features
```
List<E> features
```
      Features for this Datum.
    - label
```
Object label
```
    - featureVals
```
List<E> featureVals
```
- Class edu.stanford.nlp.ie.crf.CRFLabel extends Object implements Serializable
  
  serialVersionUID:
  
  7403010868396790276L
  - Serialized Fields
    - label
```
int[] label
```
    - hashCode
```
int hashCode
```
- Class edu.stanford.nlp.ie.crf.LabelDictionary extends Object implements Serializable
  
  serialVersionUID:
  
  6790400453922524056L
  - Serialized Fields
    - DEBUG
```
boolean DEBUG
```
    - DEFAULT_CAPACITY
```
int DEFAULT_CAPACITY
```
      Initial capacity of the bookkeeping data structures.
    - observationCounts
```
Counter<E> observationCounts
```
    - observedLabels
```
Map<K,V> observedLabels
```
    - observationIndex
```
Index<E> observationIndex
```
    - labelDictionary
```
int[][] labelDictionary
```
Package edu.stanford.nlp.ie.machinereading
- Class edu.stanford.nlp.ie.machinereading.BasicEntityExtractor extends Object implements Serializable
  
  serialVersionUID:
  
  -4011478706866593869L
  - Serialized Fields
    - classifier
```
CRFClassifier<IN extends CoreMap> classifier
```
    - gazetteerLocation
```
String gazetteerLocation
```
    - annotationsToSkip
```
Set<E> annotationsToSkip
```
    - useSubTypes
```
boolean useSubTypes
```
    - useBIO
```
boolean useBIO
```
    - entityMentionFactory
```
EntityMentionFactory entityMentionFactory
```
    - logger
```
Logger logger
```
    - useNERTags
```
boolean useNERTags
```
- Class edu.stanford.nlp.ie.machinereading.BasicRelationExtractor extends Object implements Serializable
  
  serialVersionUID:
  
  2606577772115897869L
  - Serialized Fields
    - classifier
```
LinearClassifier<L,F> classifier
```
    - featureCountThreshold
```
int featureCountThreshold
```
    - featureFactory
```
RelationFeatureFactory featureFactory
```
    - sigma
```
double sigma
```
      strength of the prior on the linear classifier (passed to LinearClassifierFactory) or the C constant if relationExtractorClassifierType=svm
    - relationExtractorClassifierType
```
String relationExtractorClassifierType
```
      which classifier to use (can be 'linear' or 'svm')
    - createUnrelatedRelations
```
boolean createUnrelatedRelations
```
      If true, it creates automatically negative examples by generating all combinations between EntityMentions in a sentence This is the common behavior, but for some domain (i.e., KBP) it must disabled. In these domains, the negative relation examples are created in the reader
    - validator
```
LabelValidator validator
```
      Verifies that predicted labels are compatible with the relation arguments
    - relationMentionFactory
```
RelationMentionFactory relationMentionFactory
```
- Class edu.stanford.nlp.ie.machinereading.BasicRelationFeatureFactory extends RelationFeatureFactory implements Serializable
  
  serialVersionUID:
  
  -7376668998622546620L
  - Serialized Fields
    - featureList
```
List<E> featureList
```
- Class edu.stanford.nlp.ie.machinereading.ExtractorMerger extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - extractors
```
Extractor[] extractors
```
- Class edu.stanford.nlp.ie.machinereading.NilLabelValidator extends Object implements Serializable
  
  serialVersionUID:
  
  1L
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 RuntimeException implements Serializable
  
  serialVersionUID:
  
  24362462L
Package edu.stanford.nlp.ie.machinereading.domains.roth
- Class edu.stanford.nlp.ie.machinereading.domains.roth.RothEntityExtractor extends BasicEntityExtractor implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - entityTagForNer
```
Map<K,V> entityTagForNer
```
Package edu.stanford.nlp.ie.machinereading.structure
- Class edu.stanford.nlp.ie.machinereading.structure.EntityMention extends ExtractionObject implements Serializable
  
  serialVersionUID:
  
  -2745903102654191527L
  - Serialized Fields
    - mentionType
```
String mentionType
```
      Mention type, if available, e.g., nominal
    - corefID
```
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
```
String normalizedName
```
- Class edu.stanford.nlp.ie.machinereading.structure.EntityMentionFactory extends Object implements Serializable
  
  serialVersionUID:
  
  47894791411048523L
- Class edu.stanford.nlp.ie.machinereading.structure.EventMention extends RelationMention implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - eventModification
```
String eventModification
```
      Modifier argument: used for BioNLP
    - anchor
```
ExtractionObject anchor
```
    - parents
```
Set<E> parents
```
- Class edu.stanford.nlp.ie.machinereading.structure.ExtractionDataSet extends Object implements Serializable
  
  serialVersionUID:
  
  201150461234284548L
  - Serialized Fields
    - sentences
```
List<E> sentences
```
- Class edu.stanford.nlp.ie.machinereading.structure.ExtractionObject extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - objectId
```
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
```
String type
```
      Type of this mention, e.g., GPE
    - subType
```
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.ExtractionSentence extends Object implements Serializable
  
  serialVersionUID:
  
  87958315651919036L
  - Serialized Fields
    - documentId
```
String documentId
```
    - textContent
```
String textContent
```
    - relationMentions
```
List<E> relationMentions
```
    - entityMentions
```
List<E> entityMentions
```
    - eventMentions
```
List<E> eventMentions
```
- Class edu.stanford.nlp.ie.machinereading.structure.RelationMention extends ExtractionObject implements Serializable
  
  serialVersionUID:
  
  8962289597607972827L
  - Serialized Fields
    - argNames
```
List<E> argNames
```
      List of argument names in this relation
    - args
```
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
```
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 Object implements Serializable
  
  serialVersionUID:
  
  -662846276208839290L
- Class edu.stanford.nlp.ie.machinereading.structure.Span extends 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 Object implements Serializable
  
  serialVersionUID:
  
  2752179429568209320L
- Class edu.stanford.nlp.international.arabic.Buckwalter extends 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
```
Map<K,V> u2bMap
```
    - b2uMap
```
Map<K,V> b2uMap
```
    - unmappable
```
ClassicCounter<E> unmappable
```
Package edu.stanford.nlp.international.arabic.pipeline
- Class edu.stanford.nlp.international.arabic.pipeline.DefaultLexicalMapper extends Object implements Serializable
  
  serialVersionUID:
  
  -3798804368296999785L
  - Serialized Fields
    - utf8ArabicChart
```
Pattern utf8ArabicChart
```
    - bwAlefChar
```
String bwAlefChar
```
    - bwDiacritics
```
Pattern bwDiacritics
```
    - bwTatweel
```
Pattern bwTatweel
```
    - bwAlef
```
Pattern bwAlef
```
    - bwQuran
```
Pattern bwQuran
```
    - bwNullAnaphoraMarker
```
Pattern bwNullAnaphoraMarker
```
    - latinPunc
```
Pattern latinPunc
```
    - arabicPunc
```
Pattern arabicPunc
```
    - arabicDigit
```
Pattern arabicDigit
```
    - utf8Diacritics
```
Pattern utf8Diacritics
```
    - utf8Tatweel
```
Pattern utf8Tatweel
```
    - utf8Alef
```
Pattern utf8Alef
```
    - utf8Quran
```
Pattern utf8Quran
```
    - utf8ProDrop
```
Pattern utf8ProDrop
```
    - segmentationMarker
```
Pattern segmentationMarker
```
    - morphemeBoundary
```
Pattern morphemeBoundary
```
    - hasDigit
```
Pattern hasDigit
```
    - useATBVocalizedSectionMapping
```
boolean useATBVocalizedSectionMapping
```
    - stripMorphemeMarkersInUTF8
```
boolean stripMorphemeMarkersInUTF8
```
    - stripSegmentationMarkersInUTF8
```
boolean stripSegmentationMarkersInUTF8
```
    - parentTagString
```
String parentTagString
```
    - parentTagsToEscape
```
Set<E> parentTagsToEscape
```
    - utf8CliticString
```
String utf8CliticString
```
    - bwClitics
```
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 Object implements Serializable
  
  serialVersionUID:
  
  3667837672769424178L
  - Serialized Fields
    - factory
```
IteratorFromReaderFactory<T> factory
```
    - tf
```
TokenizerFactory<T> tf
```
    - segMarker
```
Character segMarker
```
    - inputHasTags
```
boolean inputHasTags
```
    - inputHasDomainLabels
```
boolean inputHasDomainLabels
```
    - inputDomain
```
String inputDomain
```
    - shouldStripRewrites
```
boolean shouldStripRewrites
```
- Class edu.stanford.nlp.international.arabic.process.ArabicSegmenter extends Object implements Serializable
  
  serialVersionUID:
  
  -4791848633597417788L
  - Serialized Fields
    - flags
```
SeqClassifierFlags flags
```
    - tf
```
TokenizerFactory<T> tf
```
    - prefixMarker
```
String prefixMarker
```
    - suffixMarker
```
String suffixMarker
```
    - isTokenized
```
boolean isTokenized
```
    - tokenizerOptions
```
String tokenizerOptions
```
    - tedEvalPrefix
```
String tedEvalPrefix
```
    - hasDomainLabels
```
boolean hasDomainLabels
```
    - domain
```
String domain
```
    - noRewrites
```
boolean noRewrites
```
- 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 Object implements Serializable
  
  serialVersionUID:
  
  946818805507187330L
  - Serialized Fields
    - factory
```
LexedTokenFactory<T> factory
```
    - lexerProperties
```
Properties lexerProperties
```
- Class edu.stanford.nlp.international.arabic.process.BigWindowArabicSegmenterFeatureFactory extends ArabicSegmenterFeatureFactory<IN extends CoreLabel> implements Serializable
  
  serialVersionUID:
  
  6864940988019110930L
- Class edu.stanford.nlp.international.arabic.process.StartAndEndArabicSegmenterFeatureFactory extends ArabicSegmenterFeatureFactory<IN extends CoreLabel> implements Serializable
  
  serialVersionUID:
  
  6864940988019110930L
Package edu.stanford.nlp.international.french
- Class edu.stanford.nlp.international.french.FrenchMorphoFeatureSpecification extends MorphoFeatureSpecification implements Serializable
  
  serialVersionUID:
  
  -58379347760106784L
Package edu.stanford.nlp.international.french.process
- Class edu.stanford.nlp.international.french.process.FrenchTokenizer.FrenchTokenizerFactory extends Object implements Serializable
  
  serialVersionUID:
  
  946818805507187330L
  - Serialized Fields
    - factory
```
LexedTokenFactory<T> factory
```
    - lexerProperties
```
Properties lexerProperties
```
    - splitCompoundOption
```
boolean splitCompoundOption
```
Package edu.stanford.nlp.international.morph
- Class edu.stanford.nlp.international.morph.MorphoFeatures extends Object implements Serializable
  
  serialVersionUID:
  
  -3893316324305154940L
  - Serialized Fields
    - fSpec
```
Map<K,V> fSpec
```
    - altTag
```
String altTag
```
- Class edu.stanford.nlp.international.morph.MorphoFeatureSpecification extends Object implements Serializable
  
  serialVersionUID:
  
  -5720683653931585664L
  - Serialized Fields
    - activeFeatures
```
Set<E> activeFeatures
```
Package edu.stanford.nlp.international.spanish
- Class edu.stanford.nlp.international.spanish.SpanishVerbStripper extends Object implements Serializable
  
  serialVersionUID:
  
  -4780144226395772354L
  - Serialized Fields
    - dict
```
HashMap<K,V> dict
```
Package edu.stanford.nlp.international.spanish.process
- Class edu.stanford.nlp.international.spanish.process.SpanishTokenizer.SpanishTokenizerFactory extends Object implements Serializable
  
  serialVersionUID:
  
  946818805507187330L
  - Serialized Fields
    - factory
```
LexedTokenFactory<T> factory
```
    - lexerProperties
```
Properties lexerProperties
```
    - splitCompoundOption
```
boolean splitCompoundOption
```
    - splitVerbOption
```
boolean splitVerbOption
```
    - splitContractionOption
```
boolean splitContractionOption
```
Package edu.stanford.nlp.io
- Class edu.stanford.nlp.io.RuntimeIOException extends RuntimeException implements Serializable
  
  serialVersionUID:
  
  -8572218999165094626L
Package edu.stanford.nlp.ling
- Class edu.stanford.nlp.ling.BasicDatum extends Object implements Serializable
  
  serialVersionUID:
  
  -4857004070061779966L
  - Serialized Fields
    - features
```
Collection<E> features
```
      features for this Datum
    - labels
```
List<E> labels
```
      labels for this Datum. Invariant: always non-null
- Class edu.stanford.nlp.ling.BasicDocument extends ArrayList<Word> implements Serializable
  
  serialVersionUID:
  
  -24171720584352262L
  - Serialized Fields
    - title
```
String title
```
      title of this document (never null).
    - originalText
```
String originalText
```
      original text of this document (may be null).
    - labels
```
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
```
String word
```
    - tag
```
String tag
```
- Class edu.stanford.nlp.ling.CoreLabel extends ArrayCoreMap implements Serializable
  
  serialVersionUID:
  
  2L
- Class edu.stanford.nlp.ling.IndexedWord extends Object implements Serializable
  
  serialVersionUID:
  
  3739633991145239829L
  - Serialized Fields
    - label
```
CoreLabel label
```
- Class edu.stanford.nlp.ling.LabeledWord extends Word implements Serializable
  
  serialVersionUID:
  
  -7252006452127051085L
  - Serialized Fields
    - tag
```
Label tag
```
- Class edu.stanford.nlp.ling.MultiTokenTag extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - tag
```
MultiTokenTag.Tag tag
```
    - index
```
int index
```
- Class edu.stanford.nlp.ling.MultiTokenTag.Tag extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - name
```
String name
```
    - tag
```
String tag
```
    - length
```
int length
```
- Class edu.stanford.nlp.ling.RVFDatum extends Object implements Serializable
  
  serialVersionUID:
  
  -255312811814660438L
  - Serialized Fields
    - features
```
Counter<E> features
```
      features for this Datum
    - label
```
Object label
```
      labels for this Datum. Invariant: always non-null
    - id
```
String id
```
      Id of this instance
- Class edu.stanford.nlp.ling.StringLabel extends ValueLabel implements Serializable
  
  serialVersionUID:
  
  -4153619273767524247L
  - Serialized Fields
    - str
```
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
```
String tag
```
- Class edu.stanford.nlp.ling.ValueLabel extends Object implements Serializable
  
  serialVersionUID:
  
  -1413303679077285530L
- Class edu.stanford.nlp.ling.Word extends StringLabel implements Serializable
  
  serialVersionUID:
  
  -4817252915997034058L
- Class edu.stanford.nlp.ling.WordLemmaTag extends Object implements Serializable
  
  serialVersionUID:
  
  -5993410244163988138L
  - Serialized Fields
    - word
```
String word
```
    - lemma
```
String lemma
```
    - tag
```
String tag
```
- Class edu.stanford.nlp.ling.WordTag extends Object implements Serializable
  
  serialVersionUID:
  
  -1859527239216813742L
  - Serialized Fields
    - word
```
String word
```
    - tag
```
String tag
```
Package edu.stanford.nlp.ling.tokensregex
- Class edu.stanford.nlp.ling.tokensregex.PhraseTable extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - rootTree
```
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 Object implements Serializable
  - Serialized Fields
    - name
```
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
```
Class<T> annotationField
```
      Annotation field to apply rule over: text or tokens or numerizedtokens
    - tokensAnnotationField
```
Class<T> tokensAnnotationField
```
    - tokensResultAnnotationField
```
List<E> tokensResultAnnotationField
```
      Annotation field(s) on individual tokens to put new annotation
    - resultAnnotationField
```
List<E> resultAnnotationField
```
      Annotation field(s) to put new annotation
    - resultNestedAnnotationField
```
Class<T> resultNestedAnnotationField
```
      Annotation field for child/nested annotations
    - matchFindType
```
SequenceMatcher.FindType matchFindType
```
    - matchedExpressionGroup
```
int matchedExpressionGroup
```
    - matchWithResults
```
boolean matchWithResults
```
    - ruleType
```
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
```
java.util.function.Predicate<T> filterRule
```
- Class edu.stanford.nlp.ling.tokensregex.SequenceMatchRules.AnnotationMatchedFilter extends 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 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
```
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
```
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<Map<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
```
String function
```
    - params
```
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
```
List<E> exprs
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.MethodCallExpression extends Expressions.TypedExpression implements Serializable
  - Serialized Fields
    - function
```
String function
```
    - object
```
Expression object
```
    - params
```
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<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
```
Object value
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.SimpleValue extends Expressions.TypedExpression implements Serializable
  - Serialized Fields
    - value
```
Object value
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.TypedExpression extends Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - typename
```
String typename
```
    - tags
```
Tags tags
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.VarAssignmentExpression extends Expressions.TypedExpression implements Serializable
  - Serialized Fields
    - varName
```
String varName
```
    - valueExpr
```
Expression valueExpr
```
    - bindAsValue
```
boolean bindAsValue
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.VarExpression extends Expressions.SimpleExpression<String> implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Tags extends Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - tags
```
Map<K,V> tags
```
Package edu.stanford.nlp.math
- Class edu.stanford.nlp.math.ArrayMath.InvalidElementException extends RuntimeException implements Serializable
  
  serialVersionUID:
  
  1647150702529757545L
- Class edu.stanford.nlp.math.DoubleAD extends Number implements Serializable
  
  serialVersionUID:
  
  -5702334375099248894L
  - Serialized Fields
    - val
```
double val
```
    - dot
```
double dot
```
Package edu.stanford.nlp.neural
- Class edu.stanford.nlp.neural.SimpleTensor extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - slices
```
org.ejml.simple.SimpleMatrix[] slices
```
    - numRows
```
int numRows
```
    - numCols
```
int numCols
```
    - numSlices
```
int numSlices
```
Package edu.stanford.nlp.objectbank
- Class edu.stanford.nlp.objectbank.DelimitRegExIterator.DelimitRegExIteratorFactory extends Object implements Serializable
  
  serialVersionUID:
  
  6846060575832573082L
  - Serialized Fields
    - delim
```
String delim
```
    - op
```
java.util.function.Function<T,R> op
```
- Class edu.stanford.nlp.objectbank.LineIterator.LineIteratorFactory extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - oper
```
java.util.function.Function<T,R> oper
```
- Class edu.stanford.nlp.objectbank.ObjectBank extends Object implements Serializable
  
  serialVersionUID:
  
  -4030295596701541770L
  - Serialized Fields
    - rif
```
ReaderIteratorFactory rif
```
    - ifrf
```
IteratorFromReaderFactory<T> ifrf
```
    - contents
```
List<E> contents
```
    - keepInMemory
```
boolean keepInMemory
```
Package edu.stanford.nlp.optimization
- Class edu.stanford.nlp.optimization.QNMinimizer.SurpriseConvergence extends Throwable implements Serializable
  
  serialVersionUID:
  
  4290178321643529559L
- Class edu.stanford.nlp.optimization.ScaledSGDMinimizer.Weights extends Object implements Serializable
  
  serialVersionUID:
  
  814182172645533781L
  - Serialized Fields
    - w
```
double[] w
```
    - d
```
double[] d
```
- Class edu.stanford.nlp.optimization.SGDToQNMinimizer extends 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.common
- Class edu.stanford.nlp.parser.common.NoSuchParseException extends NoSuchElementException implements Serializable
  
  serialVersionUID:
  
  2L
- Class edu.stanford.nlp.parser.common.ParserConstraint extends Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - start
```
int start
```
    - end
```
int end
```
    - state
```
Pattern state
```
Package edu.stanford.nlp.parser.dvparser
- Class edu.stanford.nlp.parser.dvparser.CombinedDVModelReranker extends Object implements Serializable
  - Serialized Fields
    - op
```
Options op
```
    - models
```
List<E> models
```
- Class edu.stanford.nlp.parser.dvparser.DVModel extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException
```
      Throws:
      
      IOException
      
      ClassNotFoundException
  - Serialized Fields
    - binaryTransform
```
TwoDimensionalMap<K1,K2,V> binaryTransform
```
    - unaryTransform
```
Map<K,V> unaryTransform
```
    - binaryScore
```
TwoDimensionalMap<K1,K2,V> binaryScore
```
    - unaryScore
```
Map<K,V> unaryScore
```
    - wordVectors
```
Map<K,V> wordVectors
```
    - 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
```
Random rand
```
- Class edu.stanford.nlp.parser.dvparser.DVModelReranker extends Object implements Serializable
  
  serialVersionUID:
  
  7897546308624261207L
  - Serialized Fields
    - op
```
Options op
```
    - model
```
DVModel model
```
- Class edu.stanford.nlp.parser.dvparser.FilterConfusingRules extends Object implements Serializable
  - Serialized Fields
    - unaryRules
```
Set<E> unaryRules
```
    - binaryRules
```
TwoDimensionalSet<K1,K2> binaryRules
```
Package edu.stanford.nlp.parser.lexparser
- Class edu.stanford.nlp.parser.lexparser.AbstractDependencyGrammar extends Object implements Serializable
  
  serialVersionUID:
  
  3L
  - Serialization Methods
    - readObject
```
private void readObject(ObjectInputStream ois)
                 throws IOException,
                        ClassNotFoundException
```
      Throws:
      
      IOException
      
      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 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
```
String inputEncoding
```
    - outputEncoding
```
String outputEncoding
```
    - tlp
```
TreebankLanguagePack tlp
```
- Class edu.stanford.nlp.parser.lexparser.AbstractTreebankParserParams.AnnotatePunctuationFunction extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - key
```
String key
```
    - annotationMark
```
String annotationMark
```
- Class edu.stanford.nlp.parser.lexparser.ArabicTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  8853426784197984653L
  - Serialized Fields
    - optionsString
```
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
```
Map<K,V> annotationPatterns
```
    - activeAnnotations
```
List<E> activeAnnotations
```
    - morphoSpec
```
MorphoFeatureSpecification morphoSpec
```
    - baselineFeatures
```
List<E> baselineFeatures
```
      These are the annotations included when the user selects the -arabicFactored option.
    - additionalFeatures
```
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 Object implements Serializable
  
  serialVersionUID:
  
  40L
  - Serialization Methods
    - readObject
```
private void readObject(ObjectInputStream ois)
                 throws IOException,
                        ClassNotFoundException
```
      Throws:
      
      IOException
      
      ClassNotFoundException
  - Serialized Fields
    - uwModel
```
UnknownWordModel uwModel
```
    - uwModelTrainerClass
```
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
```
Map<K,V> baseTagCounts
```
      Only used when training, specifically when training on sentences that weren't part of annotated (e.g., markovized, etc.) data.
    - tagsToBaseTags
```
int[] tagsToBaseTags
```
- Class edu.stanford.nlp.parser.lexparser.BaseUnknownWordModel extends 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
```
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
```
Set<E> seenEnd
```
      This is the set of all signatures that we have seen.
    - unknownGT
```
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 Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(ObjectInputStream stream)
                 throws IOException,
                        ClassNotFoundException
```
      Throws:
      
      IOException
      
      ClassNotFoundException
  - Serialized Fields
    - index
```
Index<E> index
```
    - allRules
```
List<E> allRules
```
- Class edu.stanford.nlp.parser.lexparser.BinaryHeadFinder extends Object implements Serializable
  
  serialVersionUID:
  
  4794072338791804184L
  - Serialized Fields
    - fallbackHF
```
HeadFinder fallbackHF
```
- Class edu.stanford.nlp.parser.lexparser.BinaryRule extends 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 Object implements Serializable
  
  serialVersionUID:
  
  -5357655683145854069L
  - Serialized Fields
    - lengthPenalty
```
double lengthPenalty
```
    - penaltyType
```
int penaltyType
```
    - charDistributions
```
Map<K,V> charDistributions
```
    - knownChars
```
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 Object implements Serializable
  
  serialVersionUID:
  
  -6554995189795187918L
  - Serialized Fields
    - chineseLexicon
```
ChineseLexicon chineseLexicon
```
    - wordSegmenter
```
WordSegmenter wordSegmenter
```
    - op
```
Options op
```
- Class edu.stanford.nlp.parser.lexparser.ChineseMarkovWordSegmenter extends Object implements Serializable
  
  serialVersionUID:
  
  1559606198270645508L
  - Serialized Fields
    - initialPOSDist
```
Distribution<E> initialPOSDist
```
    - markovPOSDists
```
Map<K,V> markovPOSDists
```
    - lex
```
ChineseCharacterBasedLexicon lex
```
    - POSes
```
Set<E> POSes
```
    - wordIndex
```
Index<E> wordIndex
```
    - tagIndex
```
Index<E> tagIndex
```
- Class edu.stanford.nlp.parser.lexparser.ChineseMaxentLexicon extends 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
```
List<E> featureThresholds
```
    - universalThreshold
```
int universalThreshold
```
    - scorer
```
LinearClassifier<L,F> scorer
```
    - functionWordTags
```
Map<K,V> functionWordTags
```
    - tagDist
```
Distribution<E> tagDist
```
    - wordIndex
```
Index<E> wordIndex
```
    - tagIndex
```
Index<E> tagIndex
```
    - iteratorCutoffFactor
```
double iteratorCutoffFactor
```
    - initialWeightFile
```
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
```
Map<K,V> simArgMap
```
    - simHeadMap
```
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. todo [cdm 2013]: Just change to method that casts
    - 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
```
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
```
Set<E> seenFirst
```
- Class edu.stanford.nlp.parser.lexparser.ChineseWordFeatureExtractor extends 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
```
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 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 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
```
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 TregexPoweredTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  -6976724734594763986L
  - Serialized Fields
    - optionsString
```
StringBuilder optionsString
```
    - headFinder
```
HeadFinder headFinder
```
    - readPennFormat
```
boolean readPennFormat
```
    - collinizerRetainsPunctuation
```
boolean collinizerRetainsPunctuation
```
    - mwCounter
```
TwoDimensionalCounter<K1,K2> mwCounter
```
    - morphoSpec
```
MorphoFeatureSpecification morphoSpec
```
    - tagSpec
```
MorphoFeatureSpecification tagSpec
```
- 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
```
StringBuilder optionsString
```
- Class edu.stanford.nlp.parser.lexparser.IntDependency extends 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 Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - word
```
int word
```
    - tag
```
short tag
```
- Class edu.stanford.nlp.parser.lexparser.Lattice extends Object implements Serializable
  
  serialVersionUID:
  
  5135076134500512556L
  - Serialized Fields
    - constraints
```
List<E> constraints
```
    - edges
```
List<E> edges
```
    - nodes
```
Set<E> nodes
```
    - edgeStartsAt
```
Map<K,V> edgeStartsAt
```
    - maxNode
```
int maxNode
```
- Class edu.stanford.nlp.parser.lexparser.LatticeEdge extends Object implements Serializable
  
  serialVersionUID:
  
  4416189959485854286L
  - Serialized Fields
    - word
```
String word
```
    - label
```
String label
```
    - weight
```
double weight
```
    - start
```
int start
```
    - end
```
int end
```
    - attrs
```
Map<K,V> attrs
```
- Class edu.stanford.nlp.parser.lexparser.LexicalizedParser extends ParserGrammar 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 Object implements Serializable
  
  serialVersionUID:
  
  8260792244886911724L
  - Serialized Fields
    - words
```
Set<E> words
```
- Class edu.stanford.nlp.parser.lexparser.MLEDependencyGrammar extends AbstractDependencyGrammar implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(ObjectInputStream stream)
                 throws IOException,
                        ClassNotFoundException
```
      Throws:
      
      IOException
      
      ClassNotFoundException
    - writeObject
```
private void writeObject(ObjectOutputStream stream)
                  throws IOException
```
      Throws:
      
      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.Options extends Object implements Serializable
  
  serialVersionUID:
  
  4L
  - Serialization Methods
    - readObject
```
private void readObject(ObjectInputStream in)
                 throws IOException,
                        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:
      
      IOException
      
      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
```
java.util.function.Function<T,R> 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 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
```
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
```
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
```
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.SpanishTreebankParserParams extends TregexPoweredTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  -8734165273482119424L
  - Serialized Fields
    - optionsString
```
StringBuilder optionsString
```
    - headFinder
```
HeadFinder headFinder
```
- Class edu.stanford.nlp.parser.lexparser.SpanishUnknownWordModel extends BaseUnknownWordModel implements Serializable
  - Serialized Fields
    - smartMutation
```
boolean smartMutation
```
    - unknownSuffixSize
```
int unknownSuffixSize
```
    - unknownPrefixSize
```
int unknownPrefixSize
```
- Class edu.stanford.nlp.parser.lexparser.TaggerReranker extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - tagger
```
MaxentTagger tagger
```
    - op
```
Options op
```
    - weight
```
double weight
```
- Class edu.stanford.nlp.parser.lexparser.TestOptions extends 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
```
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
```
String outputFormat
```
      Determines format of output trees: choose among penn, oneline
    - outputFormatOptions
```
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
```
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
```
String outputFilesExtension
```
      If the writeOutputFiles option is true, then output files appear with this extension. Use "" for no extension.
    - outputFilesPrefix
```
String outputFilesPrefix
```
      If the writeOutputFiles option is true, then output files appear with this prefix.
    - outputkBestEquivocation
```
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
```
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.
    - quietEvaluation
```
boolean quietEvaluation
```
      When evaluating, don't print out tons of text. Only print out the final scores
- Class edu.stanford.nlp.parser.lexparser.TrainOptions extends Object implements Serializable
  
  serialVersionUID:
  
  72571349843538L
  - Serialized Fields
    - trainTreeFile
```
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
```
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
```
Set<E> splitters
```
      Set the splitter strings. These are a set of parent and/or grandparent annotated categories which should be split off.
    - postSplitters
```
Set<E> postSplitters
```
    - deleteSplitters
```
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
```
PrintWriter printAnnotatedPW
```
    - printBinarizedPW
```
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
```
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
```
    - trainingIterations
```
int trainingIterations
```
    - batchSize
```
int batchSize
```
    - 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
    - debugOutputFrequency
```
int debugOutputFrequency
```
      If larger than 0, the parser may choose to output debug information every X seconds, X iterations, or some other similar metric
    - randomSeed
```
long randomSeed
```
    - 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
```
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
```
      Specifically for the DVModel, uses words on either side of a context when combining constituents. Gives perhaps a microscopic improvement in performance but causes a large slowdown.
    - trainWordVectors
```
boolean trainWordVectors
```
      Do we want a model that uses word vectors (such as the DVParser) to train those word vectors when training the model?
      Note: models prior to 2014-02-13 may have incorrect values in this field, as it was originally a compile time constant
    - stalledIterationLimit
```
int stalledIterationLimit
```
      How many iterations to allow training to stall before taking the best model, if training in an iterative manner
    - markStrahler
```
boolean markStrahler
```
      Horton-Strahler number/dimension (Maximilian Schlund)
- Class edu.stanford.nlp.parser.lexparser.TregexPoweredTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  -1985603901694682420L
  - Serialized Fields
    - annotationPatterns
```
Map<K,V> annotationPatterns
```
      This data structure dictates how an arbitrary tree should be annotated. Subclasses should fill out the related member TregexPoweredTreebankParserParams.annotations. It is a collection of features: a map from feature name to behavior, where each behavior is a tuple (t, f). t is a Tregex pattern which matches subtrees corresponding to the feature, and f is a function which accepts such matches and generates an annotation which the matched subtree should be given.
      
      See Also:
      
      TregexPoweredTreebankParserParams.annotations
    - annotations
```
Map<K,V> annotations
```
      This data structure dictates how an arbitrary tree should be annotated. It is a collection of features: a map from feature name to behavior, where each behavior is a tuple (t, f). t is a string form of a TregexPattern which matches subtrees corresponding to the feature, and f is a function which accepts such matches and generates an annotation which the matched subtree should be given.
      
      See Also:
      
      TregexPoweredTreebankParserParams.annotationPatterns, TregexPoweredTreebankParserParams.SimpleStringFunction
    - features
```
Collection<E> features
```
      Extra features which have been requested. Use TregexPoweredTreebankParserParams.addFeature(String) to add features.
- Class edu.stanford.nlp.parser.lexparser.TregexPoweredTreebankParserParams.AnnotateHeadFunction extends Object implements Serializable
  
  serialVersionUID:
  
  -4213299755069618322L
  - Serialized Fields
    - headFinder
```
HeadFinder headFinder
```
    - lowerCase
```
boolean lowerCase
```
- Class edu.stanford.nlp.parser.lexparser.TregexPoweredTreebankParserParams.SimpleStringFunction extends Object implements Serializable
  
  serialVersionUID:
  
  6958776731059724396L
  - Serialized Fields
    - annotationMark
```
String annotationMark
```
- 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 Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(ObjectInputStream stream)
                 throws IOException,
                        ClassNotFoundException
```
      Throws:
      
      IOException
      
      ClassNotFoundException
  - Serialized Fields
    - index
```
Index<E> index
```
    - coreRules
```
Map<K,V> coreRules
```
      The basic list of UnaryRules. Really this is treated as a set
- Class edu.stanford.nlp.parser.lexparser.UnaryRule extends 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.parser.shiftreduce
- Class edu.stanford.nlp.parser.shiftreduce.BaseModel extends Object implements Serializable
  - Serialized Fields
    - op
```
ShiftReduceOptions op
```
    - transitionIndex
```
Index<E> transitionIndex
```
    - knownStates
```
Set<E> knownStates
```
    - rootStates
```
Set<E> rootStates
```
    - rootOnlyStates
```
Set<E> rootOnlyStates
```
- Class edu.stanford.nlp.parser.shiftreduce.BasicFeatureFactory extends FeatureFactory implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.parser.shiftreduce.BinaryTransition extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - label
```
String label
```
    - side
```
BinaryTransition.Side side
```
      Which side the head is on
- Class edu.stanford.nlp.parser.shiftreduce.CombinationFeatureFactory extends FeatureFactory implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - factories
```
FeatureFactory[] factories
```
- Class edu.stanford.nlp.parser.shiftreduce.CompoundUnaryTransition extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - labels
```
String[] labels
```
      labels[0] is the top of the unary chain. A unary chain that results in a ROOT will have labels[0] == ROOT, for example.
    - isRoot
```
boolean isRoot
```
      root transitions are illegal in the middle of the tree, naturally
- Class edu.stanford.nlp.parser.shiftreduce.DistsimFeatureFactory extends FeatureFactory implements Serializable
  
  serialVersionUID:
  
  -396152777907151063L
  - Serialized Fields
    - distsim
```
Distsim distsim
```
- Class edu.stanford.nlp.parser.shiftreduce.FeatureFactory extends Object implements Serializable
  
  serialVersionUID:
  
  -9086427962537286031L
- Class edu.stanford.nlp.parser.shiftreduce.FinalizeTransition extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - rootStates
```
Set<E> rootStates
```
- Class edu.stanford.nlp.parser.shiftreduce.IdleTransition extends Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.parser.shiftreduce.PerceptronModel extends BaseModel implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - featureWeights
```
Map<K,V> featureWeights
```
    - featureFactory
```
FeatureFactory featureFactory
```
- Class edu.stanford.nlp.parser.shiftreduce.ShiftReduceOptions extends Options implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - compoundUnaries
```
boolean compoundUnaries
```
    - featureFactoryClass
```
String featureFactoryClass
```
- Class edu.stanford.nlp.parser.shiftreduce.ShiftReduceParser extends ParserGrammar implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - op
```
ShiftReduceOptions op
```
    - model
```
BaseModel model
```
- Class edu.stanford.nlp.parser.shiftreduce.ShiftReduceTestOptions extends TestOptions implements Serializable
  - Serialized Fields
    - recordBinarized
```
String recordBinarized
```
    - recordDebinarized
```
String recordDebinarized
```
    - beamSize
```
int beamSize
```
- Class edu.stanford.nlp.parser.shiftreduce.ShiftReduceTrainOptions extends TrainOptions implements Serializable
  
  serialVersionUID:
  
  -8158249539308373819L
  - Serialized Fields
    - averagedModels
```
int averagedModels
```
      If set to 0, training outputs the last model produced, regardless of its score. Otherwise it takes the best k models and averages them together.
    - cvAveragedModels
```
boolean cvAveragedModels
```
      Cross-validate over the number of models to average, using the dev set, to figure out which number between 1 and averagedModels we actually want to use
    - trainingMethod
```
ShiftReduceTrainOptions.TrainingMethod trainingMethod
```
    - beamSize
```
int beamSize
```
    - featureFrequencyCutoff
```
int featureFrequencyCutoff
```
      How many times a feature must be seen when training. Less than this and it is filtered.
    - saveIntermediateModels
```
boolean saveIntermediateModels
```
      Saves intermediate models, but that takes up a lot of space
    - retrainAfterCutoff
```
boolean retrainAfterCutoff
```
      If we cut off features with featureFrequencyCutoff, this retrains with only the existing features
    - oracleShiftToBinary
```
boolean oracleShiftToBinary
```
      Does not seem to help... perhaps there is a logic bug in how to compensate for missed binary transitions
    - oracleBinaryToShift
```
boolean oracleBinaryToShift
```
      Does help, but makes the models much bigger for a miniscule gain
- Class edu.stanford.nlp.parser.shiftreduce.ShiftTransition extends Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.parser.shiftreduce.UnaryTransition extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - label
```
String label
```
    - isRoot
```
boolean isRoot
```
      root transitions are illegal in the middle of the tree, naturally
- Class edu.stanford.nlp.parser.shiftreduce.Weight extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - packed
```
long[] packed
```

Package edu.stanford.nlp.parser.ui

Class edu.stanford.nlp.parser.ui.Parser extends JFrame implements Serializable

serialVersionUID:: 7179757799978939358L

Serialized Fields

parserPanel

edu.stanford.nlp.parser.ui.ParserPanel parserPanel

untokEngItem
```
JCheckBoxMenuItem untokEngItem
```
tokChineseItem
```
JCheckBoxMenuItem tokChineseItem
```
untokChineseItem
```
JCheckBoxMenuItem untokChineseItem
```
jMenu2
```
JMenu jMenu2
```
loadParserItem
```
JMenuItem loadParserItem
```
loadDataItem
```
JMenuItem loadDataItem
```
jSeparator1
```
JSeparator jSeparator1
```
jMenu1
```
JMenu jMenu1
```
exitItem
```
JMenuItem exitItem
```
jMenuBar1
```
JMenuBar jMenuBar1
```

Class edu.stanford.nlp.parser.ui.ParserPanel extends JPanel implements Serializable

serialVersionUID:: -2118491857333662471L

Serialized Fields

encoding
```
String encoding
```
jfc
```
JFileChooser jfc
```

jfcLocation

edu.stanford.nlp.parser.ui.ParserPanel.JFileChooserLocation jfcLocation

chooseJarParser

edu.stanford.nlp.ui.JarFileChooser chooseJarParser

pageDialog

edu.stanford.nlp.io.ui.OpenPageDialog pageDialog

normalStyle
```
SimpleAttributeSet normalStyle
```
highlightStyle
```
SimpleAttributeSet highlightStyle
```
startIndex
```
int startIndex
```
endIndex
```
int endIndex
```
treePanel
```
TreeJPanel treePanel
```
parser
```
LexicalizedParser parser
```

lpThread

edu.stanford.nlp.parser.ui.ParserPanel.LoadParserThread lpThread

parseThread

edu.stanford.nlp.parser.ui.ParserPanel.ParseThread parseThread

timer
```
Timer timer
```
count
```
int count
```
glassPane
```
Component glassPane
```
scrollWhenDone
```
boolean scrollWhenDone
```
dataFileLabel
```
JLabel dataFileLabel
```
treeContainer
```
JPanel treeContainer
```
topPanel
```
JPanel topPanel
```
textScrollPane
```
JScrollPane textScrollPane
```
backButton
```
JButton backButton
```
statusLabel
```
JLabel statusLabel
```
loadFileButton
```
JButton loadFileButton
```
loadButtonPanel
```
JPanel loadButtonPanel
```
buttonsAndFilePanel
```
JPanel buttonsAndFilePanel
```
parseButton
```
JButton parseButton
```
parseNextButton
```
JButton parseNextButton
```
forwardButton
```
JButton forwardButton
```
parserFileLabel
```
JLabel parserFileLabel
```
clearButton
```
JButton clearButton
```
splitPane
```
JSplitPane splitPane
```
statusPanel
```
JPanel statusPanel
```
dataFilePanel
```
JPanel dataFilePanel
```
buttonPanel
```
JPanel buttonPanel
```
textPane
```
JTextPane textPane
```
progressBar
```
JProgressBar progressBar
```
parserFilePanel
```
JPanel parserFilePanel
```
loadParserButton
```
JButton loadParserButton
```
saveOutputButton
```
JButton saveOutputButton
```

Class edu.stanford.nlp.parser.ui.TreeJPanel extends JPanel implements Serializable
- Serialized Fields
  - VERTICAL_ALIGN
```
int VERTICAL_ALIGN
```
  - HORIZONTAL_ALIGN
```
int HORIZONTAL_ALIGN
```
  - maxFontSize
```
int maxFontSize
```
  - minFontSize
```
int minFontSize
```
  - tree
```
Tree tree
```

Package edu.stanford.nlp.patterns.surface
- Class edu.stanford.nlp.patterns.surface.ConstantsAndVariables extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - numIterationsForPatterns
```
Integer numIterationsForPatterns
```
      Maximum number of iterations to run
    - numPatterns
```
int numPatterns
```
      Maximum number of patterns learned in each iteration
    - outDir
```
String outDir
```
      The output directory where the justifications of learning patterns and phrases would be saved. These are needed for visualization
    - allPatternsDir
```
String allPatternsDir
```
      Cached file of all patterns for all tokens
    - computeAllPatterns
```
boolean computeAllPatterns
```
      If all patterns should be computed. Otherwise patterns are read from allPatternsFile
    - patternScoring
```
GetPatternsFromDataMultiClass.PatternScoring patternScoring
```
      Pattern Scoring mechanism. See GetPatternsFromDataMultiClass.PatternScoring for options.
    - thresholdSelectPattern
```
double thresholdSelectPattern
```
      Threshold for learning a pattern
    - restrictToMatched
```
boolean restrictToMatched
```
      Currently, does not work correctly. TODO: make this work. Ideally this would label words only when they occur in the context of any learned pattern. This comment seems old. Test it!
    - usePatternResultAsLabel
```
boolean usePatternResultAsLabel
```
      Label words that are learned so that in further iterations we have more information
    - debug
```
int debug
```
      Debug flag for learning patterns. 0 means no output, 1 means necessary output, 2 means necessary output+some justification, 3 means extreme debug output
    - identifier
```
String identifier
```
      Save this run as ...
    - useMatchingPhrase
```
boolean useMatchingPhrase
```
      Use the actual dictionary matching phrase(s) instead of the token word or lemma in calculating the stats
    - tuneThresholdKeepRunning
```
boolean tuneThresholdKeepRunning
```
      Reduce pattern threshold (=0.8*current_value) to extract as many patterns as possible (still restricted by numPatterns)
    - maxExtractNumWords
```
int maxExtractNumWords
```
      Maximum number of words to learn
    - useOtherLabelsWordsasNegative
```
boolean useOtherLabelsWordsasNegative
```
      use the seed dictionaries and the new words learned for the other labels in the previous iterations as negative
    - markedOutputTextFile
```
String markedOutputTextFile
```
      If not null, write the output like "w1 w2 w3 w4 w5 ... " if w3 w4 have label1 and w4 has label 2
    - columnOutputFile
```
String columnOutputFile
```
      If you want output of form "word\tlabels-separated-by-comma" in newlines
    - useLemmaContextTokens
```
boolean useLemmaContextTokens
```
      Use lemma instead of words for the context tokens
    - matchLowerCaseContext
```
boolean matchLowerCaseContext
```
      Lowercase the context words/lemmas
    - useTargetNERRestriction
```
boolean useTargetNERRestriction
```
      Add NER restriction to the target phrase in the patterns
    - targetAllowedTagsInitialsStr
```
String targetAllowedTagsInitialsStr
```
      Initials of all POS tags to use if usePOS4Pattern is true, separated by comma.
    - allowedTagsInitials
```
Map<K,V> allowedTagsInitials
```
    - targetAllowedNERs
```
String targetAllowedNERs
```
      Allowed NERs for labels. Format is label1,NER1,NER11;label2,NER2,NER21,NER22;label3,... useTargetNERRestriction flag should be true
    - allowedNERsforLabels
```
Map<K,V> allowedNERsforLabels
```
    - useTargetParserParentRestriction
```
boolean useTargetParserParentRestriction
```
      Adds the parent's tag from the parse tree to the target phrase in the patterns
    - useContextNERRestriction
```
boolean useContextNERRestriction
```
      If the NER tag of the context tokens is not the background symbol, generalize the token with the NER tag
    - numWordsToAdd
```
int numWordsToAdd
```
      Number of words to learn in each iteration
    - thresholdNumPatternsApplied
```
double thresholdNumPatternsApplied
```
    - wordScoring
```
edu.stanford.nlp.patterns.surface.GetPatternsFromDataMultiClass.WordScoring wordScoring
```
    - thresholdWordExtract
```
double thresholdWordExtract
```
    - justify
```
boolean justify
```
    - LRSigma
```
double LRSigma
```
      Sigma for L2 regularization in Logisitic regression, if a classifier is used to score phrases
    - englishWordsFiles
```
String englishWordsFiles
```
      English words that are not labeled when labeling using seed dictionaries
    - englishWords
```
Set<E> englishWords
```
    - commonWordsPatternFiles
```
String commonWordsPatternFiles
```
      Words to be ignored when learning phrases if removePhrasesWithStopWords or removeStopWordsFromSelectedPhrases is true. Also, these words are considered negative when scoring a pattern (similar to othersemanticclasses).
    - commonEngWords
```
Set<E> commonEngWords
```
    - otherSemanticClassesFiles
```
String otherSemanticClassesFiles
```
      List of dictionary phrases that are negative for all labels to be learned. Format is file_1,file_2,... where file_i has each phrase in a different line
    - otherSemanticClassesWords
```
Set<E> otherSemanticClassesWords
```
    - labelDictionary
```
Map<K,V> labelDictionary
```
      Seed dictionary, set in the class that uses this class
    - labels
```
Set<E> labels
```
      Just the set of labels
    - answerClass
```
Map<K,V> answerClass
```
    - ignoreWordswithClassesDuringSelection
```
Map<K,V> ignoreWordswithClassesDuringSelection
```
      Can be used only when using the API - using the appropriate constructor. Tokens with specified classes set (has to be boolean return value, even though this variable says object) will be ignored.
    - generalizeClasses
```
Map<K,V> generalizeClasses
```
      These classes will be generalized. It can only be used via the API using the appropriate constructor. All label classes are by default generalized.
    - minLen4FuzzyForPattern
```
int minLen4FuzzyForPattern
```
      Minimum length of words that can be matched fuzzily
    - wordIgnoreRegex
```
String wordIgnoreRegex
```
      Do not learn phrases that match this regex.
    - numThreads
```
int numThreads
```
      Number of threads
    - stopWordsPatternFiles
```
String stopWordsPatternFiles
```
      Words that are not learned. Patterns are not created around these words. And, if useStopWordsBeforeTerm in CreatePatterns is true.
    - stopWords
```
Set<E> stopWords
```
    - fillerWords
```
List<E> fillerWords
```
    - env
```
Map<K,V> env
```
      Environment for TokenSequencePattern
    - ignoreWordRegex
```
Pattern ignoreWordRegex
```
      by default doesn't ignore anything. What phrases to ignore.
    - removeStopWordsFromSelectedPhrases
```
boolean removeStopWordsFromSelectedPhrases
```
    - removePhrasesWithStopWords
```
boolean removePhrasesWithStopWords
```
    - alreadySetUp
```
boolean alreadySetUp
```
    - wordClassClusterFile
```
String wordClassClusterFile
```
      Cluster file, in which each line is word/phraseclusterid
    - wordClassClusters
```
Map<K,V> wordClassClusters
```
    - generalWordClassClusterFile
```
String generalWordClassClusterFile
```
      General cluster file, if you wanna use it somehow, in which each line is word/phraseclusterid
    - generalWordClassClusters
```
Map<K,V> generalWordClassClusters
```
    - includeExternalFeatures
```
boolean includeExternalFeatures
```
    - externalFeatureWeightsFile
```
String externalFeatureWeightsFile
```
    - doNotApplyPatterns
```
boolean doNotApplyPatterns
```
    - numWordsCompound
```
int numWordsCompound
```
    - sqrtPatScore
```
boolean sqrtPatScore
```
      If score for a pattern is square rooted
    - minUnlabPhraseSupportForPat
```
int minUnlabPhraseSupportForPat
```
      Remove patterns that have number of unlabeled words is less than this.
    - minPosPhraseSupportForPat
```
int minPosPhraseSupportForPat
```
      Remove patterns that have number of positive words less than this.
    - addIndvWordsFromPhrasesExceptLastAsNeg
```
boolean addIndvWordsFromPhrasesExceptLastAsNeg
```
      For example, if positive seed dict contains "cancer" and "breast cancer" then "breast" is included as negative
    - editDistanceFromEnglishWords
```
ConcurrentHashMap<K,V> editDistanceFromEnglishWords
```
      Cached files
    - editDistanceFromEnglishWordsMatches
```
ConcurrentHashMap<K,V> editDistanceFromEnglishWordsMatches
```
      Cached files
    - editDistanceFromOtherSemanticClasses
```
ConcurrentHashMap<K,V> editDistanceFromOtherSemanticClasses
```
      Cached files
    - editDistanceFromOtherSemanticClassesMatches
```
ConcurrentHashMap<K,V> editDistanceFromOtherSemanticClassesMatches
```
      Cached files
    - editDistanceFromThisClass
```
ConcurrentHashMap<K,V> editDistanceFromThisClass
```
      Cached files
    - editDistanceFromThisClassMatches
```
ConcurrentHashMap<K,V> editDistanceFromThisClassMatches
```
      Cached files
    - wordShapesForLabels
```
Map<K,V> wordShapesForLabels
```
    - channelNameLogger
```
String channelNameLogger
```
    - distSimWeights
```
Map<K,V> distSimWeights
```
    - dictOddsWeights
```
Map<K,V> dictOddsWeights
```
    - invertedIndexClass
```
Class<T> invertedIndexClass
```
    - invertedIndexDirectory
```
String invertedIndexDirectory
```
      Where the inverted index (either in memory or lucene) is stored
    - clubNeighboringLabeledWords
```
boolean clubNeighboringLabeledWords
```
    - removeOverLappingLabelsFromSeed
```
boolean removeOverLappingLabelsFromSeed
```
      Keeps only one label for each token, whichever has the longest
    - usePhraseEvalWordClass
```
boolean usePhraseEvalWordClass
```
      Only works if you have single label. And the word classes are given.
    - usePhraseEvalGoogleNgram
```
boolean usePhraseEvalGoogleNgram
```
      use google tf-idf for learning phrases
    - usePhraseEvalDomainNgram
```
boolean usePhraseEvalDomainNgram
```
      use domain tf-idf for learning phrases
    - usePhraseEvalPatWtByFreq
```
boolean usePhraseEvalPatWtByFreq
```
      use \sum_allpat pattern_wt_that_extracted_phrase/phrase_freq for learning phrases
    - usePhraseEvalSemanticOdds
```
boolean usePhraseEvalSemanticOdds
```
      odds of the phrase freq in the label dictionary vs other dictionaries
    - usePhraseEvalEditDistSame
```
boolean usePhraseEvalEditDistSame
```
      Edit distance between this phrase and the other phrases in the label dictionary
    - usePhraseEvalEditDistOther
```
boolean usePhraseEvalEditDistOther
```
      Edit distance between this phrase and other phrases in other dictionaries
    - usePhraseEvalWordShape
```
boolean usePhraseEvalWordShape
```
    - usePatternEvalWordClass
```
boolean usePatternEvalWordClass
```
      Used only if ConstantsAndVariables.patternScoring is PhEvalInPat or PhEvalInPat. See usePhrase* for meanings.
    - usePatternEvalWordShape
```
boolean usePatternEvalWordShape
```
      Used only if ConstantsAndVariables.patternScoring is PhEvalInPat or PhEvalInPat. See usePhrase* for meanings.
    - usePatternEvalGoogleNgram
```
boolean usePatternEvalGoogleNgram
```
      Used only if ConstantsAndVariables.patternScoring is PhEvalInPat or PhEvalInPat. See usePhrase* for meanings.
    - usePatternEvalDomainNgram
```
boolean usePatternEvalDomainNgram
```
      Used only if ConstantsAndVariables.patternScoring is PhEvalInPat or PhEvalInPat. See usePhrase* for meanings.
    - usePatternEvalSemanticOdds
```
boolean usePatternEvalSemanticOdds
```
      Used only if ConstantsAndVariables.patternScoring is PhEvalInPat or PhEvalInPat. See usePhrase* for meanings.
    - usePatternEvalEditDistSame
```
boolean usePatternEvalEditDistSame
```
      Used only if ConstantsAndVariables.patternScoring is PhEvalInPat or PhEvalInPat. See usePhrase* for meanings.
    - usePatternEvalEditDistOther
```
boolean usePatternEvalEditDistOther
```
      Used only if ConstantsAndVariables.patternScoring is PhEvalInPat or PhEvalInPat. See usePhrase* for meanings.
    - perSelectRand
```
double perSelectRand
```
      These are used to learn weights for features if using logistic regression. Percentage of non-labeled tokens selected as negative.
    - perSelectNeg
```
double perSelectNeg
```
      These are used to learn weights for features if using logistic regression. Percentage of negative tokens selected as negative.
    - doNotExtractPhraseAnyWordLabeledOtherClass
```
boolean doNotExtractPhraseAnyWordLabeledOtherClass
```
      Especially useful for multi word phrase extraction. Do not extract a phrase if any word is labeled with any other class.
    - saveInvertedIndex
```
boolean saveInvertedIndex
```
      You can save the inverted index. Lucene index is saved by default to invertedIndexDirectory if given.
    - loadInvertedIndex
```
boolean loadInvertedIndex
```
      You can load the inverted index using this file. If false and using lucene index, the existing directory is deleted and new index is made.
    - storePatsForEachToken
```
ConstantsAndVariables.PatternForEachTokenWay storePatsForEachToken
```
    - sampleSentencesForSufficientStats
```
double sampleSentencesForSufficientStats
```
    - backgroundSymbol
```
String backgroundSymbol
```
    - wordShaper
```
int wordShaper
```
    - wordShapeCache
```
Map<K,V> wordShapeCache
```
    - invertedIndex
```
SentenceIndex invertedIndex
```
    - patternIndex
```
ConcurrentHashIndex<E> patternIndex
```
    - props
```
Properties props
```
    - editDistMax
```
double editDistMax
```
    - batchProcessSents
```
boolean batchProcessSents
```
      Use this option if you are limited by memory ; ignored if fileFormat is ser.
    - writeMatchedTokensFiles
```
boolean writeMatchedTokensFiles
```
- Class edu.stanford.nlp.patterns.surface.GetPatternsFromDataMultiClass extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - patsForEachToken
```
PatternsForEachToken patsForEachToken
```
    - wordsForOtherClass
```
Map<K,V> wordsForOtherClass
```
    - writtenPatInJustification
```
Map<K,V> writtenPatInJustification
```
    - learnedPatterns
```
Map<K,V> learnedPatterns
```
    - learnedWords
```
Map<K,V> learnedWords
```
    - wordsPatExtracted
```
Map<K,V> wordsPatExtracted
```
    - props
```
Properties props
```
    - scorePhrases
```
ScorePhrases scorePhrases
```
    - constVars
```
ConstantsAndVariables constVars
```
    - createPats
```
CreatePatterns createPats
```
    - df
```
DecimalFormat df
```
    - notComputedAllPatternsYet
```
boolean notComputedAllPatternsYet
```
    - patternsandWords
```
Map<K,V> patternsandWords
```
    - currentPatternWeights
```
Map<K,V> currentPatternWeights
```
    - phInPatScoresCache
```
TwoDimensionalCounter<K1,K2> phInPatScoresCache
```
- Class edu.stanford.nlp.patterns.surface.InvertedIndexByTokens extends SentenceIndex implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - index
```
Map<K,V> index
```
- Class edu.stanford.nlp.patterns.surface.PatternsAnnotations extends Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.patterns.surface.PatternToken extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - tag
```
String tag
```
    - useTag
```
boolean useTag
```
    - numWordsCompound
```
int numWordsCompound
```
    - useNER
```
boolean useNER
```
    - nerTag
```
String nerTag
```
    - useTargetParserParentRestriction
```
boolean useTargetParserParentRestriction
```
    - grandparentParseTag
```
String grandparentParseTag
```
- Class edu.stanford.nlp.patterns.surface.SurfacePattern extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - prevContext
```
Token[] prevContext
```
    - nextContext
```
Token[] nextContext
```
    - token
```
PatternToken token
```
    - hashcode
```
int hashcode
```
    - genre
```
SurfacePattern.Genre genre
```
- Class edu.stanford.nlp.patterns.surface.Token extends Object implements Serializable
  - Serialized Fields
    - classORrestrictions
```
Map<K,V> classORrestrictions
```
    - envBindBooleanRestriction
```
String envBindBooleanRestriction
```
    - alphaNumeric
```
Pattern alphaNumeric
```
    - numMinOcc
```
int numMinOcc
```
    - numMaxOcc
```
int numMaxOcc
```
- Class edu.stanford.nlp.patterns.surface.Token.ClassComparator extends Object implements Serializable
Package edu.stanford.nlp.pipeline
- Class edu.stanford.nlp.pipeline.Annotation extends ArrayCoreMap implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.pipeline.AnnotatorFactory extends Object implements Serializable
  
  serialVersionUID:
  
  -1554647325549869340L
  - Serialized Fields
    - properties
```
Properties properties
```
    - implementations
```
AnnotatorImplementations implementations
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.CorefChain extends com.google.protobuf.GeneratedMessage implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - chainID_
```
int chainID_
```
    - mention_
```
List<E> mention_
```
    - representative_
```
int representative_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
    - memoizedSerializedSize
```
int memoizedSerializedSize
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.CorefChain.CorefMention extends com.google.protobuf.GeneratedMessage implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - mentionID_
```
int mentionID_
```
    - mentionType_
```
Object mentionType_
```
    - number_
```
Object number_
```
    - gender_
```
Object gender_
```
    - animacy_
```
Object animacy_
```
    - startIndex_
```
int startIndex_
```
    - endIndex_
```
int endIndex_
```
    - headIndex_
```
int headIndex_
```
    - sentenceIndex_
```
int sentenceIndex_
```
    - position_
```
int position_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
    - memoizedSerializedSize
```
int memoizedSerializedSize
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyGraph extends com.google.protobuf.GeneratedMessage implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - node_
```
List<E> node_
```
    - edge_
```
List<E> edge_
```
    - root_
```
List<E> root_
```
    - rootMemoizedSerializedSize
```
int rootMemoizedSerializedSize
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
    - memoizedSerializedSize
```
int memoizedSerializedSize
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyGraph.Edge extends com.google.protobuf.GeneratedMessage implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - source_
```
int source_
```
    - target_
```
int target_
```
    - dep_
```
Object dep_
```
    - isExtra_
```
boolean isExtra_
```
    - sourceCopy_
```
int sourceCopy_
```
    - targetCopy_
```
int targetCopy_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
    - memoizedSerializedSize
```
int memoizedSerializedSize
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyGraph.Node extends com.google.protobuf.GeneratedMessage implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - sentenceIndex_
```
int sentenceIndex_
```
    - index_
```
int index_
```
    - copyAnnotation_
```
int copyAnnotation_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
    - memoizedSerializedSize
```
int memoizedSerializedSize
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Document extends com.google.protobuf.GeneratedMessage.ExtendableMessage<edu.stanford.nlp.pipeline.CoreNLPProtos.Document> implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - text_
```
Object text_
```
    - sentence_
```
List<E> sentence_
```
    - corefChain_
```
List<E> corefChain_
```
    - docID_
```
Object docID_
```
    - sentencelessToken_
```
List<E> sentencelessToken_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
    - memoizedSerializedSize
```
int memoizedSerializedSize
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Entity extends com.google.protobuf.GeneratedMessage implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - headStart_
```
int headStart_
```
    - headEnd_
```
int headEnd_
```
    - mentionType_
```
Object mentionType_
```
    - normalizedName_
```
Object normalizedName_
```
    - headTokenIndex_
```
int headTokenIndex_
```
    - corefID_
```
Object corefID_
```
    - objectID_
```
Object objectID_
```
    - extentStart_
```
int extentStart_
```
    - extentEnd_
```
int extentEnd_
```
    - type_
```
Object type_
```
    - subtype_
```
Object subtype_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
    - memoizedSerializedSize
```
int memoizedSerializedSize
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.ParseTree extends com.google.protobuf.GeneratedMessage implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - child_
```
List<E> child_
```
    - value_
```
Object value_
```
    - yieldBeginIndex_
```
int yieldBeginIndex_
```
    - yieldEndIndex_
```
int yieldEndIndex_
```
    - score_
```
double score_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
    - memoizedSerializedSize
```
int memoizedSerializedSize
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Relation extends com.google.protobuf.GeneratedMessage implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - argName_
```
com.google.protobuf.LazyStringList argName_
```
    - arg_
```
List<E> arg_
```
    - signature_
```
Object signature_
```
    - objectID_
```
Object objectID_
```
    - extentStart_
```
int extentStart_
```
    - extentEnd_
```
int extentEnd_
```
    - type_
```
Object type_
```
    - subtype_
```
Object subtype_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
    - memoizedSerializedSize
```
int memoizedSerializedSize
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Sentence extends com.google.protobuf.GeneratedMessage.ExtendableMessage<edu.stanford.nlp.pipeline.CoreNLPProtos.Sentence> implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - token_
```
List<E> token_
```
    - tokenOffsetBegin_
```
int tokenOffsetBegin_
```
    - tokenOffsetEnd_
```
int tokenOffsetEnd_
```
    - sentenceIndex_
```
int sentenceIndex_
```
    - characterOffsetBegin_
```
int characterOffsetBegin_
```
    - characterOffsetEnd_
```
int characterOffsetEnd_
```
    - parseTree_
```
edu.stanford.nlp.pipeline.CoreNLPProtos.ParseTree parseTree_
```
    - basicDependencies_
```
edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyGraph basicDependencies_
```
    - collapsedDependencies_
```
edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyGraph collapsedDependencies_
```
    - collapsedCCProcessedDependencies_
```
edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyGraph collapsedCCProcessedDependencies_
```
    - paragraph_
```
int paragraph_
```
    - text_
```
Object text_
```
    - hasRelationAnnotations_
```
boolean hasRelationAnnotations_
```
    - entity_
```
List<E> entity_
```
    - relation_
```
List<E> relation_
```
    - hasNumerizedTokensAnnotation_
```
boolean hasNumerizedTokensAnnotation_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
    - memoizedSerializedSize
```
int memoizedSerializedSize
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Timex extends com.google.protobuf.GeneratedMessage implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - value_
```
Object value_
```
    - altValue_
```
Object altValue_
```
    - text_
```
Object text_
```
    - type_
```
Object type_
```
    - tid_
```
Object tid_
```
    - beginPoint_
```
int beginPoint_
```
    - endPoint_
```
int endPoint_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
    - memoizedSerializedSize
```
int memoizedSerializedSize
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Token extends com.google.protobuf.GeneratedMessage.ExtendableMessage<edu.stanford.nlp.pipeline.CoreNLPProtos.Token> implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialization Methods
    - writeReplace
```
protected Object writeReplace()
                       throws ObjectStreamException
```
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - word_
```
Object word_
```
    - pos_
```
Object pos_
```
    - value_
```
Object value_
```
    - category_
```
Object category_
```
    - before_
```
Object before_
```
    - after_
```
Object after_
```
    - originalText_
```
Object originalText_
```
    - ner_
```
Object ner_
```
    - normalizedNER_
```
Object normalizedNER_
```
    - lemma_
```
Object lemma_
```
    - beginChar_
```
int beginChar_
```
    - endChar_
```
int endChar_
```
    - utterance_
```
int utterance_
```
    - speaker_
```
Object speaker_
```
    - beginIndex_
```
int beginIndex_
```
    - endIndex_
```
int endIndex_
```
    - tokenBeginIndex_
```
int tokenBeginIndex_
```
    - tokenEndIndex_
```
int tokenEndIndex_
```
    - timexValue_
```
edu.stanford.nlp.pipeline.CoreNLPProtos.Timex timexValue_
```
    - hasXmlContext_
```
boolean hasXmlContext_
```
    - xmlContext_
```
com.google.protobuf.LazyStringList xmlContext_
```
    - corefClusterID_
```
int corefClusterID_
```
    - answer_
```
Object answer_
```
    - gender_
```
Object gender_
```
    - trueCase_
```
Object trueCase_
```
    - trueCaseText_
```
Object trueCaseText_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
    - memoizedSerializedSize
```
int memoizedSerializedSize
```
- Class edu.stanford.nlp.pipeline.ProtobufAnnotationSerializer.LossySerializationException extends RuntimeException implements Serializable
Package edu.stanford.nlp.process
- Class edu.stanford.nlp.process.AmericanizeFunction extends Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.process.ChineseDocumentToSentenceProcessor extends Object implements Serializable
  
  serialVersionUID:
  
  4054964767812217460L
  - Serialized Fields
    - encoding
```
String encoding
```
    - normalizationTable
```
List<E> normalizationTable
```
- Class edu.stanford.nlp.process.CoreLabelTokenFactory extends Object implements Serializable
  
  serialVersionUID:
  
  4L
  - Serialized Fields
    - addIndices
```
boolean addIndices
```
- Class edu.stanford.nlp.process.DistSimClassifier extends Object implements Serializable
  
  serialVersionUID:
  
  3L
  - Serialized Fields
    - lexicon
```
Map<K,V> lexicon
```
    - cased
```
boolean cased
```
    - numberEquivalence
```
boolean numberEquivalence
```
    - unknownWordClass
```
String unknownWordClass
```
- Class edu.stanford.nlp.process.LowercaseAndAmericanizeFunction extends Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.process.LowercaseFunction extends Object implements Serializable
  
  serialVersionUID:
  
  1L
Package edu.stanford.nlp.semgraph
- Class edu.stanford.nlp.semgraph.SemanticGraph extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - roots
```
Collection<E> roots
```
      The distinguished root vertices, if known.
    - graph
```
DirectedMultiGraph<V,E> graph
```
- Class edu.stanford.nlp.semgraph.SemanticGraphEdge extends 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.semgraph.semgrex
- Class edu.stanford.nlp.semgraph.semgrex.CoordinationPattern extends SemgrexPattern implements Serializable
  
  serialVersionUID:
  
  -3122330899634961002L
  - Serialized Fields
    - isConj
```
boolean isConj
```
    - isNodeCoord
```
boolean isNodeCoord
```
    - children
```
List<E> children
```
- Class edu.stanford.nlp.semgraph.semgrex.NodePattern extends SemgrexPattern implements Serializable
  
  serialVersionUID:
  
  -5981133879119233896L
  - Serialized Fields
    - reln
```
edu.stanford.nlp.semgraph.semgrex.GraphRelation reln
```
    - negDesc
```
boolean negDesc
```
    - attributes
```
Map<K,V> attributes
```
    - isRoot
```
boolean isRoot
```
    - isLink
```
boolean isLink
```
    - isEmpty
```
boolean isEmpty
```
    - name
```
String name
```
    - descString
```
String descString
```
    - child
```
SemgrexPattern child
```
    - variableGroups
```
List<E> variableGroups
```
- Class edu.stanford.nlp.semgraph.semgrex.ParseException extends Exception implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - currentToken
```
edu.stanford.nlp.semgraph.semgrex.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
```
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
```
String eol
```
      The end of line string for this machine.
- Class edu.stanford.nlp.semgraph.semgrex.SemgrexParseException extends RuntimeException implements Serializable
- Class edu.stanford.nlp.semgraph.semgrex.SemgrexPattern extends Object implements Serializable
  
  serialVersionUID:
  
  1722052832350596732L
  - Serialized Fields
    - neg
```
boolean neg
```
    - opt
```
boolean opt
```
    - patternString
```
String patternString
```
Package edu.stanford.nlp.sentiment
- Class edu.stanford.nlp.sentiment.RNNOptions extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(ObjectInputStream in)
                 throws IOException,
                        ClassNotFoundException
```
      Throws:
      
      IOException
      
      ClassNotFoundException
  - Serialized Fields
    - randomSeed
```
int randomSeed
```
      The random seed the random number generator is initialized with.
    - wordVectors
```
String wordVectors
```
      Filename for the word vectors
    - unkWord
```
String unkWord
```
      In the wordVectors file, what word represents unknown?
    - randomWordVectors
```
boolean randomWordVectors
```
      By default, initialize random word vectors instead of reading from a file
    - numHid
```
int numHid
```
      Size of vectors to use. Must be at most the size of the vectors in the word vector file. If a smaller size is specified, vectors will be truncated.
    - numClasses
```
int numClasses
```
      Number of classes to build the RNN for
    - lowercaseWordVectors
```
boolean lowercaseWordVectors
```
    - useTensors
```
boolean useTensors
```
    - langpack
```
TreebankLanguagePack langpack
```
    - simplifiedModel
```
boolean simplifiedModel
```
      No syntactic untying - use the same matrix/tensor for all categories. This results in all nodes getting the same matrix (and tensor, where applicable)
    - combineClassification
```
boolean combineClassification
```
      If this option is true, then the binary and unary classification matrices are combined. Only makes sense if simplifiedModel is true. If combineClassification is set to true, simplifiedModel will also be set to true. If simplifiedModel is set to false, this will be set to false.
    - trainOptions
```
RNNTrainOptions trainOptions
```
    - classNames
```
String[] classNames
```
    - equivalenceClasses
```
int[][] equivalenceClasses
```
      The following option represents classes which can be treated as equivalent when scoring. There will be two separate scorings, one with equivalence used and one without. Default is set for the sentiment project.
    - equivalenceClassNames
```
String[] equivalenceClassNames
```
    - testOptions
```
RNNTestOptions testOptions
```
- Class edu.stanford.nlp.sentiment.RNNTestOptions extends Object implements Serializable
  - Serialized Fields
    - ngramRecordSize
```
int ngramRecordSize
```
    - ngramRecordMaximumLength
```
int ngramRecordMaximumLength
```
    - printLengthAccuracies
```
boolean printLengthAccuracies
```
- Class edu.stanford.nlp.sentiment.RNNTrainOptions extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - batchSize
```
int batchSize
```
    - epochs
```
int epochs
```
      Number of times through all the trees
    - debugOutputEpochs
```
int debugOutputEpochs
```
    - maxTrainTimeSeconds
```
int maxTrainTimeSeconds
```
    - learningRate
```
double learningRate
```
    - scalingForInit
```
double scalingForInit
```
    - classWeights
```
double[] classWeights
```
    - regTransformMatrix
```
double regTransformMatrix
```
      Regularization cost for the transform matrix
    - regClassification
```
double regClassification
```
      Regularization cost for the classification matrices
    - regWordVector
```
double regWordVector
```
      Regularization cost for the word vectors
    - initialAdagradWeight
```
double initialAdagradWeight
```
      The value to set the learning rate for each parameter when initializing adagrad.
    - adagradResetFrequency
```
int adagradResetFrequency
```
      How many epochs between resets of the adagrad learning rates. Set to 0 to never reset.
    - regTransformTensor
```
double regTransformTensor
```
      Regularization cost for the transform tensor
- Class edu.stanford.nlp.sentiment.SentimentModel extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - binaryTransform
```
TwoDimensionalMap<K1,K2,V> binaryTransform
```
      Nx2N+1, where N is the size of the word vectors
    - binaryTensors
```
TwoDimensionalMap<K1,K2,V> binaryTensors
```
      2Nx2NxN, where N is the size of the word vectors
    - binaryClassification
```
TwoDimensionalMap<K1,K2,V> binaryClassification
```
      CxN+1, where N = size of word vectors, C is the number of classes
    - unaryClassification
```
Map<K,V> unaryClassification
```
      CxN+1, where N = size of word vectors, C is the number of classes
    - wordVectors
```
Map<K,V> wordVectors
```
    - numClasses
```
int numClasses
```
      How many classes the RNN is built to test against
    - numHid
```
int numHid
```
      Dimension of hidden layers, size of word vectors, etc
    - numBinaryMatrices
```
int numBinaryMatrices
```
      Cached here for easy calculation of the model size; TwoDimensionalMap does not return that in O(1) time
    - binaryTransformSize
```
int binaryTransformSize
```
      How many elements a transformation matrix has
    - binaryTensorSize
```
int binaryTensorSize
```
      How many elements the binary transformation tensors have
    - binaryClassificationSize
```
int binaryClassificationSize
```
      How many elements a classification matrix has
    - numUnaryMatrices
```
int numUnaryMatrices
```
      Cached here for easy calculation of the model size; TwoDimensionalMap does not return that in O(1) time
    - unaryClassificationSize
```
int unaryClassificationSize
```
      How many elements a classification matrix has
    - rand
```
Random rand
```
      A random number generator - keeping it here lets us reproduce results
    - op
```
RNNOptions op
```
      Will store various options specific to this model

Package edu.stanford.nlp.sequences

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

serialVersionUID:

-8109637472035159453L
- Serialization Methods
  - readResolve
```
protected Object readResolve()
```
- Serialized Fields
  - relativeIndices
```
int[] relativeIndices
```
  - hashCode
```
int hashCode
```
Class edu.stanford.nlp.sequences.ColumnDocumentReaderAndWriter extends Object implements Serializable

serialVersionUID:

3806263423697973704L
- Serialized Fields
  - map
```
String[] map
```
  - factory
```
IteratorFromReaderFactory<T> factory
```
  - num
```
int num
```
Class edu.stanford.nlp.sequences.ColumnTabDocumentReaderWriter extends Object implements Serializable

serialVersionUID:

1L
- Serialized Fields
  - map
```
String[] map
```
  - delimiterPattern
```
Pattern delimiterPattern
```
  - whitespacePattern
```
Pattern whitespacePattern
```
  - replaceWhitespace
```
boolean replaceWhitespace
```
  - tokensAnnotationClassName
```
String tokensAnnotationClassName
```
  - tokenFactory
```
CoreTokenFactory<IN extends CoreMap> tokenFactory
```
Class edu.stanford.nlp.sequences.CoNLLDocumentReaderAndWriter extends Object implements Serializable

serialVersionUID:

6281374154299530460L
- Serialized Fields
  - flags
```
SeqClassifierFlags flags
```
Class edu.stanford.nlp.sequences.FeatureFactory extends Object implements Serializable

serialVersionUID:

7249250071983091694L
- Serialized Fields
  - flags
```
SeqClassifierFlags flags
```
Class edu.stanford.nlp.sequences.LibSVMReaderAndWriter extends 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 Object implements Serializable

serialVersionUID:

3806263423691913704L
- Serialized Fields
  - flags
```
SeqClassifierFlags flags
```
  - map
```
String[] map
```
  - factory
```
IteratorFromReaderFactory<T> factory
```
  - num
```
int num
```
Class edu.stanford.nlp.sequences.MUCDocumentReaderAndWriter extends Object implements Serializable

serialVersionUID:

-8334720781758500037L
- Serialized Fields
  - flags
```
SeqClassifierFlags flags
```
  - factory
```
IteratorFromReaderFactory<T> factory
```
Class edu.stanford.nlp.sequences.ObjectBankWrapper extends ObjectBank<List<IN extends CoreMap>> implements Serializable

serialVersionUID:

-3838331732026362075L
- Serialized Fields
  - flags
```
SeqClassifierFlags flags
```
  - wrapped
```
ObjectBank<E> wrapped
```
  - knownLCWords
```
Set<E> knownLCWords
```
  - monthDayPattern
```
Pattern monthDayPattern
```
Class edu.stanford.nlp.sequences.PlainTextDocumentReaderAndWriter extends 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 Object implements Serializable

serialVersionUID:: -7076671761070232567L

Serialized Fields

stringRep
```
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
```
String entitySubclassification
```
retainEntitySubclassification
```
boolean retainEntitySubclassification
```
useGazettePhrases
```
boolean useGazettePhrases
```
makeConsistent
```
boolean makeConsistent
```
useViterbi
```
boolean useViterbi
```
binnedLengths
```
int[] binnedLengths
```
verboseMode
```
boolean verboseMode
```
useSum
```
boolean useSum
```
tolerance
```
double tolerance
```
printFeatures
```
String printFeatures
```
useSymTags
```
boolean useSymTags
```
useSymWordPairs
```
boolean useSymWordPairs
```
useSymWordPairs Has a small negative effect.
printClassifier
```
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
```
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
```
String documentReader
```
map
```
String map
```
useWideDisjunctive
```
boolean useWideDisjunctive
```
wideDisjunctionWidth
```
int wideDisjunctionWidth
```
useRadical
```
boolean useRadical
```
useBigramInTwoClique
```
boolean useBigramInTwoClique
```
morphFeatureFile
```
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
```
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
```
String normalizationTable
```
dictionary
```
String dictionary
```
serializedDictionary
```
String serializedDictionary
```
dictionary2
```
String dictionary2
```
normTableEncoding
```
String normTableEncoding
```
sighanCorporaDict
```
String sighanCorporaDict
```
for Sighan bakeoff 2005, the path to the dictionary of bigrams appeared in corpus
useWordShapeGaz
```
boolean useWordShapeGaz
```
wordShapeGaz
```
String wordShapeGaz
```
splitDocuments
```
boolean splitDocuments
```
printXML
```
boolean printXML
```
useSeenFeaturesOnly
```
boolean useSeenFeaturesOnly
```
lastNameList
```
String lastNameList
```
maleNameList
```
String maleNameList
```
femaleNameList
```
String femaleNameList
```
inputEncoding
```
String inputEncoding
```
bioSubmitOutput
```
boolean bioSubmitOutput
```
numRuns
```
int numRuns
```
answerFile
```
String answerFile
```
altAnswerFile
```
String altAnswerFile
```
dropGaz
```
String dropGaz
```
printGazFeatures
```
String printGazFeatures
```
numStartLayers
```
int numStartLayers
```
dump
```
boolean dump
```
mergeTags
```
boolean mergeTags
```
splitOnHead
```
boolean splitOnHead
```
featureCountThreshold
```
int featureCountThreshold
```
featureWeightThreshold
```
double featureWeightThreshold
```
featureFactory
```
String featureFactory
```
featureFactoryArgs
```
Object[] featureFactoryArgs
```
backgroundSymbol
```
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
```
useMUCFeatures
```
boolean useMUCFeatures
```
annealingRate
```
double annealingRate
```
annealingType
```
String annealingType
```
loadProcessedData
```
String loadProcessedData
```
initViterbi
```
boolean initViterbi
```
useUnknown
```
boolean useUnknown
```
checkNameList
```
boolean checkNameList
```
useSemPrior
```
boolean useSemPrior
```
useFirstWord
```
boolean useFirstWord
```
useNumberFeature
```
boolean useNumberFeature
```
ocrFold
```
int ocrFold
```
classifierType
```
String classifierType
```
svmModelFile
```
String svmModelFile
```
inferenceType
```
String inferenceType
```
useLemmaAsWord
```
boolean useLemmaAsWord
```
type
```
String type
```
readerAndWriter
```
String readerAndWriter
```
comboProps
```
List<E> comboProps
```
usePrediction
```
boolean usePrediction
```
useAltGazFeatures
```
boolean useAltGazFeatures
```
gazFilesFile
```
String gazFilesFile
```
usePrediction2
```
boolean usePrediction2
```
baseTrainDir
```
String baseTrainDir
```
baseTestDir
```
String baseTestDir
```
trainFiles
```
String trainFiles
```
trainFileList
```
String trainFileList
```
testFiles
```
String testFiles
```
trainDirs
```
String trainDirs
```
testDirs
```
String testDirs
```
useOnlySeenWeights
```
boolean useOnlySeenWeights
```
predProp
```
String predProp
```
pad
```
CoreLabel pad
```
useObservedFeaturesOnly
```
boolean useObservedFeaturesOnly
```
distSimLexicon
```
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
```
String serializeDatasetsDir
```
loadDatasetsDir
```
String loadDatasetsDir
```
pushDir
```
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
```
String crfType
```
featureThreshold
```
int featureThreshold
```
featThreshFile
```
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
```
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
```
String outputEncoding
```
useKBest
```
boolean useKBest
```
searchGraphPrefix
```
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
```
String classBias
```
printLabelValue
```
boolean printLabelValue
```
useRobustQN
```
boolean useRobustQN
```
combo
```
boolean combo
```
useGenericFeatures
```
boolean useGenericFeatures
```
verboseForTrueCasing
```
boolean verboseForTrueCasing
```
trainHierarchical
```
String trainHierarchical
```
domain
```
String domain
```
baseline
```
boolean baseline
```
transferSigmas
```
String transferSigmas
```
doFE
```
boolean doFE
```
restrictLabels
```
boolean restrictLabels
```
announceObjectBankEntries
```
boolean announceObjectBankEntries
```
l1reg
```
double l1reg
```
mixedCaseMapFile
```
String mixedCaseMapFile
```
auxTrueCaseModels
```
String auxTrueCaseModels
```
use2W
```
boolean use2W
```
useLC
```
boolean useLC
```
useYetMoreCpCShapes
```
boolean useYetMoreCpCShapes
```
useIfInteger
```
boolean useIfInteger
```
exportFeatures
```
String exportFeatures
```
useInPlaceSGD
```
boolean useInPlaceSGD
```
useTopics
```
boolean useTopics
```
evaluateIters
```
int evaluateIters
```
evalCmd
```
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
```
String tokenFactory
```
tokenFactoryArgs
```
Object[] tokenFactoryArgs
```
tokensAnnotationClassName
```
String tokensAnnotationClassName
```
useCorefFeatures
```
boolean useCorefFeatures
```
wikiFeatureDbFile
```
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
```
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
```
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
```
java.util.function.Function<T,R> 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
```
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
```
String loadBisequenceClassifierEn
```
Bisequence CRF parameters
loadBisequenceClassifierCh
```
String loadBisequenceClassifierCh
```
bisequenceClassifierPropEn
```
String bisequenceClassifierPropEn
```
bisequenceClassifierPropCh
```
String bisequenceClassifierPropCh
```
bisequenceTestFileEn
```
String bisequenceTestFileEn
```
bisequenceTestFileCh
```
String bisequenceTestFileCh
```
bisequenceTestOutputEn
```
String bisequenceTestOutputEn
```
bisequenceTestOutputCh
```
String bisequenceTestOutputCh
```
bisequenceTestAlignmentFile
```
String bisequenceTestAlignmentFile
```
bisequenceAlignmentTestOutput
```
String bisequenceAlignmentTestOutput
```
bisequencePriorType
```
int bisequencePriorType
```

bisequenceAlignmentPriorPenaltyCh

String bisequenceAlignmentPriorPenaltyCh

bisequenceAlignmentPriorPenaltyEn

String bisequenceAlignmentPriorPenaltyEn

alignmentPruneThreshold
```
double alignmentPruneThreshold
```
alignmentDecodeThreshold
```
double alignmentDecodeThreshold
```
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
```
String entityMatrixCh
```
entityMatrixEn
```
String entityMatrixEn
```
multiThreadGibbs
```
int multiThreadGibbs
```
matchNERIncentive
```
boolean matchNERIncentive
```
useEmbedding
```
boolean useEmbedding
```
prependEmbedding
```
boolean prependEmbedding
```
embeddingWords
```
String embeddingWords
```
embeddingVectors
```
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
```
String entityMatrix
```
multiThreadClassifier
```
int multiThreadClassifier
```
useDualDecomp
```
boolean useDualDecomp
```
biAlignmentPriorIsPMI
```
boolean biAlignmentPriorIsPMI
```
dampDDStepSizeWithAlignmentProb
```
boolean dampDDStepSizeWithAlignmentProb
```
dualDecompAlignment
```
boolean dualDecompAlignment
```

dualDecompInitialStepSizeAlignment

double dualDecompInitialStepSizeAlignment

dualDecompNotBIO
```
boolean dualDecompNotBIO
```
berkeleyAlignerLoadPath
```
String berkeleyAlignerLoadPath
```
useBerkeleyAlignerForViterbi
```
boolean useBerkeleyAlignerForViterbi
```
useBerkeleyCompetitivePosterior
```
boolean useBerkeleyCompetitivePosterior
```
useDenero
```
boolean useDenero
```
alignDDAlpha
```
double alignDDAlpha
```
factorInBiEdgePotential
```
boolean factorInBiEdgePotential
```
noNeighborConstraints
```
boolean noNeighborConstraints
```
includeC2EViterbi
```
boolean includeC2EViterbi
```
initWithPosterior
```
boolean initWithPosterior
```
nerSkipFirstK
```
int nerSkipFirstK
```
nerSlowerTimes
```
int nerSlowerTimes
```
powerAlignProb
```
boolean powerAlignProb
```
powerAlignProbAsAddition
```
boolean powerAlignProbAsAddition
```
initWithNERPosterior
```
boolean initWithNERPosterior
```
applyNERPenalty
```
boolean applyNERPenalty
```
printFactorTable
```
boolean printFactorTable
```
useAdaGradFOBOS
```
boolean useAdaGradFOBOS
```
initRate
```
double initRate
```
groupByFeatureTemplate
```
boolean groupByFeatureTemplate
```
groupByOutputClass
```
boolean groupByOutputClass
```
priorAlpha
```
double priorAlpha
```
splitWordRegex
```
String splitWordRegex
```
groupByInput
```
boolean groupByInput
```
groupByHiddenUnit
```
boolean groupByHiddenUnit
```
unigramLM
```
String unigramLM
```
bigramLM
```
String bigramLM
```
wordSegBeamSize
```
int wordSegBeamSize
```
vocabFile
```
String vocabFile
```
normalizedFile
```
String normalizedFile
```
averagePerceptron
```
boolean averagePerceptron
```
loadCRFSegmenterPath
```
String loadCRFSegmenterPath
```
loadPCTSegmenterPath
```
String loadPCTSegmenterPath
```
crfSegmenterProp
```
String crfSegmenterProp
```
pctSegmenterProp
```
String pctSegmenterProp
```
intermediateSegmenterOut
```
String intermediateSegmenterOut
```
intermediateSegmenterModel
```
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
```
useCWSFeatures
```
boolean useCWSFeatures
```
appendLC
```
boolean appendLC
```
perceptronDebug
```
boolean perceptronDebug
```
pctSegmenterScaleByCRF
```
boolean pctSegmenterScaleByCRF
```
pctSegmenterScale
```
double pctSegmenterScale
```
separateASCIIandRange
```
boolean separateASCIIandRange
```
dropoutRate
```
double dropoutRate
```
dropoutScale
```
double dropoutScale
```
multiThreadGrad
```
int multiThreadGrad
```
maxQNItr
```
int maxQNItr
```
dropoutApprox
```
boolean dropoutApprox
```
unsupDropoutFile
```
String unsupDropoutFile
```
unsupDropoutScale
```
double unsupDropoutScale
```
startEvaluateIters
```
int startEvaluateIters
```
multiThreadPerceptron
```
int multiThreadPerceptron
```
lazyUpdate
```
boolean lazyUpdate
```
featureCountThresh
```
int featureCountThresh
```
geDebug
```
boolean geDebug
```
doFeatureDiscovery
```
boolean doFeatureDiscovery
```
learnCHBasedOnEN
```
boolean learnCHBasedOnEN
```
learnENBasedOnCH
```
boolean learnENBasedOnCH
```
loadWeightsFromEN
```
String loadWeightsFromEN
```
loadWeightsFromCH
```
String loadWeightsFromCH
```
serializeToEN
```
String serializeToEN
```
serializeToCH
```
String serializeToCH
```
testFileEN
```
String testFileEN
```
testFileCH
```
String testFileCH
```
unsupFileEN
```
String unsupFileEN
```
unsupFileCH
```
String unsupFileCH
```
unsupAlignFile
```
String unsupAlignFile
```
supFileEN
```
String supFileEN
```
supFileCH
```
String supFileCH
```
loadFeatureIndexFromEN
```
String loadFeatureIndexFromEN
```
loadFeatureIndexFromCH
```
String loadFeatureIndexFromCH
```
lambdaEN
```
double lambdaEN
```
lambdaCH
```
double lambdaCH
```
alternateTraining
```
boolean alternateTraining
```
weightByEntropy
```
boolean weightByEntropy
```
useKL
```
boolean useKL
```
useHardGE
```
boolean useHardGE
```
useCRFforUnsup
```
boolean useCRFforUnsup
```
useGEforSup
```
boolean useGEforSup
```
useKnownLCWords
```
boolean useKnownLCWords
```
featureFactories
```
String[] featureFactories
```
featureFactoriesArgs
```
List<E> featureFactoriesArgs
```
useNoisyLabel
```
boolean useNoisyLabel
```
errorMatrix
```
String errorMatrix
```
printTrainLabels
```
boolean printTrainLabels
```
labelDictionaryCutoff
```
int labelDictionaryCutoff
```
useAdaDelta
```
boolean useAdaDelta
```
useAdaDiff
```
boolean useAdaDiff
```
adaGradEps
```
double adaGradEps
```
adaDeltaRho
```
double adaDeltaRho
```
useRandomSeed
```
boolean useRandomSeed
```
terminateOnAvgImprovement
```
boolean terminateOnAvgImprovement
```
strictGoodCoNLL
```
boolean strictGoodCoNLL
```
removeStrictGoodCoNLLDuplicates
```
boolean removeStrictGoodCoNLLDuplicates
```
priorModelFactory
```
String priorModelFactory
```
A class name for a factory that vends a prior NER model that implements both SequenceModel and SequenceListener, and which is used in the Gibbs sampling sequence model inference.

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

serialVersionUID:

-3000389291781534479L
- Serialized Fields
  - factory
```
IteratorFromReaderFactory<T> factory
```
  - verboseForTrueCasing
```
Boolean verboseForTrueCasing
```

Package edu.stanford.nlp.stats
- Class edu.stanford.nlp.stats.ClassicCounter extends Object implements Serializable
  
  serialVersionUID:
  
  4L
  - Serialized Fields
    - map
```
Map<K,V> map
```
    - mapFactory
```
MapFactory<K,V> mapFactory
```
    - totalCount
```
double totalCount
```
    - defaultValue
```
double defaultValue
```
- Class edu.stanford.nlp.stats.Dirichlet extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - parameters
```
Counter<E> parameters
```
- Class edu.stanford.nlp.stats.DirichletProcess extends 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 Object implements Serializable
  
  serialVersionUID:
  
  6707148234288637809L
  - Serialized Fields
    - numberOfKeys
```
int numberOfKeys
```
    - reservedMass
```
double reservedMass
```
    - counter
```
Counter<E> counter
```
- Class edu.stanford.nlp.stats.Gamma extends Object implements Serializable
  
  serialVersionUID:
  
  -2992079318379176178L
  - Serialized Fields
    - alpha
```
double alpha
```
- Class edu.stanford.nlp.stats.GeneralizedCounter extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
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
```
Map<K,V> map
```
    - mapFactory
```
MapFactory<K,V> mapFactory
```
    - totalCount
```
int totalCount
```
    - defaultValue
```
int defaultValue
```
- Class edu.stanford.nlp.stats.Multinomial extends Object implements Serializable
  
  serialVersionUID:
  
  -697457414113362926L
  - Serialized Fields
    - parameters
```
Counter<E> parameters
```
    - hashCode
```
int hashCode
```
- Class edu.stanford.nlp.stats.TwoDimensionalCounter extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
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 Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
Map<K,V> map
```
    - total
```
int total
```
    - outerMF
```
MapFactory<K,V> outerMF
```
    - innerMF
```
MapFactory<K,V> innerMF
```
    - defaultValue
```
int defaultValue
```
Package edu.stanford.nlp.swing
- Class edu.stanford.nlp.swing.TooltipJList extends JList implements Serializable
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.Distsim extends Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - lexicon
```
Map<K,V> lexicon
```
    - unk
```
String unk
```
    - mapdigits
```
boolean mapdigits
```
- Class edu.stanford.nlp.tagger.maxent.Extractor extends 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:
  
  2L
  - Serialized Fields
    - lexicon
```
Distsim lexicon
```
- Class edu.stanford.nlp.tagger.maxent.ExtractorDistsimConjunction extends Extractor implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - lexicon
```
Distsim lexicon
```
    - left
```
int left
```
    - right
```
int right
```
    - name
```
String name
```
- Class edu.stanford.nlp.tagger.maxent.Extractors extends 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 Tagger implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - dict
```
Dictionary dict
```
    - tags
```
TTags tags
```
    - prob
```
LambdaSolveTagger prob
```
    - fAssociations
```
List<E> fAssociations
```
    - extractors
```
Extractors extractors
```
    - extractorsRare
```
Extractors extractorsRare
```
    - ambClasses
```
AmbiguityClasses ambClasses
```
    - alltags
```
boolean alltags
```
    - tagTokens
```
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
```
java.util.function.Function<T,R> 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 JFrame implements Serializable
  
  serialVersionUID:
  
  -2574711492469740892L
  - Serialized Fields
    - inputBox
```
JTextArea inputBox
```
    - outputBox
```
JTextArea outputBox
```
    - tagButton
```
JButton tagButton
```
- Class edu.stanford.nlp.tagger.maxent.TaggerConfig extends 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
```
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
```
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
```
String quant
```
      Quantifier - every, every other
    - freq
```
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
```
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
```
String label
```
- Class edu.stanford.nlp.time.SUTime.Temporal extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - mod
```
String mod
```
    - approx
```
boolean approx
```
    - standardTemporalType
```
SUTime.StandardTemporalType standardTemporalType
```
    - timeLabel
```
String timeLabel
```
    - uncertaintyGranularity
```
SUTime.Duration uncertaintyGranularity
```
- 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 Exception implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - timeExpression
```
String timeExpression
```
- Class edu.stanford.nlp.time.TimeExpressionExtractorFactory extends Object implements Serializable
  - Serialized Fields
    - timeExpressionExtractorClass
```
String timeExpressionExtractorClass
```
- Class edu.stanford.nlp.time.Timex extends Object implements Serializable
  
  serialVersionUID:
  
  385847729549981302L
  - Serialized Fields
    - xml
```
String xml
```
      XML representation of the TIMEX tag
    - val
```
String val
```
      TIMEX3 value attribute - Time value (given in extended ISO 8601 format).
    - altVal
```
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
```
String text
```
      Actual text that make up the time expression
    - type
```
String type
```
      TIMEX3 type attribute - Type of the time expression (DATE, TIME, DURATION, or SET)
    - tid
```
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 Object implements Serializable
  
  serialVersionUID:
  
  -6540278059442931087L
  - Serialized Fields
    - tlp
```
TreebankLanguagePack tlp
```
    - nonTerminalInfo
```
Map<K,V> nonTerminalInfo
```
    - defaultRule
```
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
```
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
```
String[] defaultRightRule
```
- Class edu.stanford.nlp.trees.AbstractTreebankLanguagePack extends 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
```
java.util.function.Predicate<T> punctTagStringAcceptFilter
```
    - punctWordStringAcceptFilter
```
java.util.function.Predicate<T> punctWordStringAcceptFilter
```
    - sFPunctTagStringAcceptFilter
```
java.util.function.Predicate<T> sFPunctTagStringAcceptFilter
```
    - eIPunctTagStringAcceptFilter
```
java.util.function.Predicate<T> eIPunctTagStringAcceptFilter
```
    - startSymbolAcceptFilter
```
java.util.function.Predicate<T> startSymbolAcceptFilter
```
- Class edu.stanford.nlp.trees.BobChrisTreeNormalizer extends TreeNormalizer implements Serializable
  
  serialVersionUID:
  
  -1005188028979810143L
  - Serialized Fields
    - tlp
```
TreebankLanguagePack tlp
```
    - emptyFilter
```
java.util.function.Predicate<T> emptyFilter
```
    - aOverAFilter
```
java.util.function.Predicate<T> aOverAFilter
```
- Class edu.stanford.nlp.trees.BobChrisTreeNormalizer.AOverAFilter extends Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.trees.BobChrisTreeNormalizer.EmptyFilter extends Object implements Serializable
  
  serialVersionUID:
  
  8914098359495987617L
- Class edu.stanford.nlp.trees.CollinsDependency extends 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 Object implements Serializable
  
  serialVersionUID:
  
  -7732189363171164852L
  - Serialized Fields
    - tagRejectFilter
```
java.util.function.Predicate<T> tagRejectFilter
```
- Class edu.stanford.nlp.trees.Dependencies.DependentPuncWordRejectFilter extends Object implements Serializable
  
  serialVersionUID:
  
  1166489968248785287L
  - Serialized Fields
    - wordRejectFilter
```
java.util.function.Predicate<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
```
      How to clean up node labels: 0 = do nothing, 1 = keep category and function, 2 = just category.
    - root
```
String root
```
    - tlp
```
TreebankLanguagePack tlp
```
- Class edu.stanford.nlp.trees.GrammaticalRelation extends Object implements Serializable
  
  serialVersionUID:
  
  892618003417550128L
  - Serialization Methods
    - readResolve
```
protected Object readResolve()
                      throws ObjectStreamException
```
      When deserializing a GrammaticalRelation, it needs to be matched up with the existing singleton relation of the same type. TODO: there are a bunch of things wrong with this. For one thing, it's crazy slow, since it goes through all the existing relations in an array. For another, it would be cleaner to have subclasses for the English and Chinese relations
      
      Throws:
      
      ObjectStreamException
  - Serialized Fields
    - language
```
GrammaticalRelation.Language language
```
    - shortName
```
String shortName
```
    - longName
```
String longName
```
    - parent
```
GrammaticalRelation parent
```
    - children
```
List<E> children
```
    - sourcePattern
```
Pattern sourcePattern
```
    - targetPatterns
```
List<E> targetPatterns
```
    - specific
```
String specific
```
- Class edu.stanford.nlp.trees.GrammaticalStructure extends Object implements Serializable
  
  serialVersionUID:
  
  2286294455343892678L
  - Serialized Fields
    - typedDependencies
```
List<E> typedDependencies
```
    - allTypedDependencies
```
List<E> allTypedDependencies
```
    - puncFilter
```
java.util.function.Predicate<T> puncFilter
```
    - root
```
TreeGraphNode root
```
      The root Tree node for this GrammaticalStructure.
    - indexMap
```
Map<K,V> indexMap
```
      A map from arbitrary integer indices to nodes.
- 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 Object implements Serializable
  
  serialVersionUID:
  
  8453889846239508208L
- Class edu.stanford.nlp.trees.LengthTreeFilter extends 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
```
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
```
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
```
Set<E> verbalAuxiliaries
```
    - copulars
```
Set<E> copulars
```
    - passiveAuxiliaries
```
Set<E> passiveAuxiliaries
```
    - verbalTags
```
Set<E> verbalTags
```
    - unambiguousAuxiliaryTags
```
Set<E> unambiguousAuxiliaryTags
```
    - makeCopulaHead
```
boolean makeCopulaHead
```
- 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 AbstractCollection<Tree> implements Serializable
  
  serialVersionUID:
  
  5441849457648722744L
- Class edu.stanford.nlp.trees.TreeFilters.HasMatchingChild extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - tlp
```
TreebankLanguagePack tlp
```
    - pattern
```
Pattern pattern
```
- 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
```
GrammaticalStructure tg
```
      The GrammaticalStructure of which this node is part.
- Class edu.stanford.nlp.trees.TreeNormalizer extends Object implements Serializable
  
  serialVersionUID:
  
  1540681875853883387L
- Class edu.stanford.nlp.trees.TypedDependency extends Object implements Serializable
  
  serialVersionUID:
  
  -7690294213151279779L
  - Serialized Fields
    - reln
```
GrammaticalRelation reln
```
    - gov
```
IndexedWord gov
```
    - dep
```
IndexedWord 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 Object implements Serializable
  
  serialVersionUID:
  
  -3768440215342256085L
  - Serialized Fields
    - regentText
```
String regentText
```
    - dependentText
```
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
```
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
```
Pattern prdPattern
```
    - prdVerbPattern
```
TregexPattern prdVerbPattern
```
    - npSbjPattern
```
TregexPattern npSbjPattern
```
    - rootLabel
```
String rootLabel
```
    - lexMapper
```
Mapper lexMapper
```
- Class edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer.ArabicEmptyFilter extends Object implements Serializable
  
  serialVersionUID:
  
  7417844982953945964L
- Class edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory extends 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
```
String rootLabel
```
    - morpho
```
MorphoFeatureSpecification morpho
```
    - ccTagset
```
boolean ccTagset
```
- Class edu.stanford.nlp.trees.international.french.FrenchTreeNormalizer.FrenchAOverAFilter extends Object implements Serializable
  
  serialVersionUID:
  
  793800623099852951L
- Class edu.stanford.nlp.trees.international.french.FrenchTreeReaderFactory extends Object implements Serializable
  
  serialVersionUID:
  
  8943534517L
- Class edu.stanford.nlp.trees.international.french.FrenchXMLTreeReaderFactory extends Object implements Serializable
  
  serialVersionUID:
  
  578942679136874L
  - Serialized Fields
    - ccTagset
```
boolean ccTagset
```
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
```
java.util.function.Predicate<T> hebrewEmptyFilter
```
- Class edu.stanford.nlp.trees.international.hebrew.HebrewTreeNormalizer.HebrewEmptyFilter extends Object implements Serializable
  
  serialVersionUID:
  
  -7256461296718287280L
- Class edu.stanford.nlp.trees.international.hebrew.HebrewTreeReaderFactory extends 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
```
String left
```
    - right
```
String right
```
- Class edu.stanford.nlp.trees.international.negra.NegraLabel extends StringLabel implements Serializable
  
  serialVersionUID:
  
  2847331882765391095L
  - Serialized Fields
    - edge
```
String edge
```
    - features
```
Map<K,V> features
```
- Class edu.stanford.nlp.trees.international.negra.NegraPennLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  9081305982861675328L
  - Serialized Fields
    - leaveGF
```
boolean leaveGF
```
      Grammatical function parameters. If this is true, keep subj, obj, iobj functional tags, only.
- 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
```
java.util.function.Predicate<T> emptyFilter
```
    - aOverAFilter
```
java.util.function.Predicate<T> aOverAFilter
```
    - prepositionTags
```
Set<E> prepositionTags
```
    - postpositionTags
```
Set<E> postpositionTags
```
- Class edu.stanford.nlp.trees.international.negra.NegraPennTreeReaderFactory extends 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 Object implements Serializable
  
  serialVersionUID:
  
  7655332268578049993L
  - Serialized Fields
    - map
```
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
```
java.util.function.Predicate<T> chineseEmptyFilter
```
- Class edu.stanford.nlp.trees.international.pennchinese.FragmentTreeFilter extends Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.trees.international.pennchinese.SunJurafskyChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -7942375587642755210L
Package edu.stanford.nlp.trees.international.spanish
- Class edu.stanford.nlp.trees.international.spanish.SpanishHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -841219428125220698L
- Class edu.stanford.nlp.trees.international.spanish.SpanishSplitTreeNormalizer extends SpanishTreeNormalizer implements Serializable
- Class edu.stanford.nlp.trees.international.spanish.SpanishTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  -7059939700276532428L
- Class edu.stanford.nlp.trees.international.spanish.SpanishTreeNormalizer extends BobChrisTreeNormalizer implements Serializable
  - Serialized Fields
    - simplifiedTagset
```
boolean simplifiedTagset
```
    - aggressiveNormalization
```
boolean aggressiveNormalization
```
    - retainNER
```
boolean retainNER
```
- Class edu.stanford.nlp.trees.international.spanish.SpanishTreeReaderFactory extends Object implements Serializable
  
  serialVersionUID:
  
  8L
- Class edu.stanford.nlp.trees.international.spanish.SpanishXMLTreeReaderFactory extends Object implements Serializable
  
  serialVersionUID:
  
  2019486878175311263L
  - Serialized Fields
    - simplifiedTagset
```
boolean simplifiedTagset
```
    - aggressiveNormalization
```
boolean aggressiveNormalization
```
    - retainNER
```
boolean retainNER
```
    - detailedAnnotations
```
boolean detailedAnnotations
```
Package edu.stanford.nlp.trees.international.tuebadz
- Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - left
```
String left
```
    - right
```
String right
```
    - coordSwitch
```
boolean coordSwitch
```
    - headMarkedPattern
```
Pattern headMarkedPattern
```
    - headMarkedPattern2
```
Pattern headMarkedPattern2
```
- Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  2697418320262700673L
  - Serialized Fields
    - limitedGF
```
boolean limitedGF
```
    - leaveGF
```
boolean leaveGF
```
- Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZPennTreeNormalizer extends TreeNormalizer implements Serializable
  
  serialVersionUID:
  
  8009544230321390490L
  - Serialized Fields
    - nodeCleanup
```
int nodeCleanup
```
      How to clean up node labels: 0 = do nothing, 1 = keep category and function, 2 = just category.
    - root
```
String root
```
    - tlp
```
TreebankLanguagePack tlp
```
    - tns
```
List<E> tns
```
- Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZTreeReaderFactory extends Object implements Serializable
  
  serialVersionUID:
  
  1614799885744961795L
  - Serialized Fields
    - tlp
```
TreebankLanguagePack tlp
```
    - nodeCleanup
```
int nodeCleanup
```
Package edu.stanford.nlp.trees.tregex
- Class edu.stanford.nlp.trees.tregex.ParseException extends 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
```
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
```
String eol
```
      The end of line string for this machine.
- Class edu.stanford.nlp.trees.tregex.TregexParseException extends RuntimeException implements Serializable
- Class edu.stanford.nlp.trees.tregex.TregexPattern extends Object implements Serializable
  
  serialVersionUID:
  
  5060298043763944913L
  - Serialized Fields
    - neg
```
boolean neg
```
    - opt
```
boolean opt
```
    - patternString
```
String patternString
```
Package edu.stanford.nlp.trees.tregex.gui
- Class edu.stanford.nlp.trees.tregex.gui.DisplayMatchesPanel extends JPanel implements Serializable
  - Serialized Fields
    - scroller
```
JScrollPane scroller
```
    - firstMouseEvent
```
MouseEvent firstMouseEvent
```
    - fontName
```
String fontName
```
    - fontSize
```
int fontSize
```
    - defaultColor
```
Color defaultColor
```
    - matchedColor
```
Color matchedColor
```
    - tjp
```
ScrollableTreeJPanel tjp
```
    - matchedPartCoordinates
```
List<E> matchedPartCoordinates
```
    - matchedPartCoordinateIdx
```
int matchedPartCoordinateIdx
```
- Class edu.stanford.nlp.trees.tregex.gui.FilePanel extends JPanel implements Serializable
  
  serialVersionUID:
  
  -2229250395240163264L
  - Serialized Fields
    - tree
```
JTree tree
```
    - treeModel
```
FileTreeModel treeModel
```
- Class edu.stanford.nlp.trees.tregex.gui.FileTreeModel extends DefaultTreeModel implements Serializable
  - Serialized Fields
    - listeners
```
List<E> listeners
```
    - root
```
FileTreeNode root
```
    - treeStructure
```
Map<K,V> treeStructure
```
- Class edu.stanford.nlp.trees.tregex.gui.FileTreeNode extends DefaultMutableTreeNode implements Serializable
  - Serialized Fields
    - file
```
File file
```
    - check
```
JCheckBox check
```
    - label
```
JLabel label
```
    - t
```
Treebank t
```
    - listeners
```
ArrayList<E> listeners
```
- Class edu.stanford.nlp.trees.tregex.gui.InputPanel extends JPanel implements Serializable
  
  serialVersionUID:
  
  -8219840036914495876L
  - Serialized Fields
    - foundStats
```
JLabel foundStats
```
    - findMatches
```
JButton findMatches
```
    - cancel
```
JButton cancel
```
    - help
```
JButton help
```
    - tregexPattern
```
JTextArea tregexPattern
```
    - recentTregexPatterns
```
JComboBox<E> recentTregexPatterns
```
    - recentTregexPatternsModel
```
DefaultComboBoxModel<E> recentTregexPatternsModel
```
    - numRecentPatterns
```
int numRecentPatterns
```
    - tsurgeonScript
```
JTextArea tsurgeonScript
```
    - compiler
```
TregexPatternCompiler compiler
```
    - historyList
```
List<E> historyList
```
    - historyFrame
```
JFrame historyFrame
```
    - scriptLabel
```
JLabel scriptLabel
```
    - tsurgeonEnabled
```
boolean tsurgeonEnabled
```
    - tsurgeonHelp
```
JButton tsurgeonHelp
```
    - cancelTsurgeon
```
JButton cancelTsurgeon
```
    - searchThread
```
Thread searchThread
```
    - historyButton
```
JButton historyButton
```
    - progressBar
```
JProgressBar progressBar
```
    - browseButton
```
JButton browseButton
```
    - helpFrame
```
JFrame helpFrame
```
    - tsurgeonHelpFrame
```
JFrame tsurgeonHelpFrame
```
    - runScript
```
JButton runScript
```
- Class edu.stanford.nlp.trees.tregex.gui.MatchesPanel extends JPanel implements Serializable
  - Serialized Fields
    - list
```
JList<E> list
```
    - matchedParts
```
Map<K,V> matchedParts
```
    - listeners
```
List<E> listeners
```
    - highlightColor
```
Color highlightColor
```
    - showOnlyMatchedPortion
```
boolean showOnlyMatchedPortion
```
    - lastSelected
```
JTextField lastSelected
```
    - firstMouseEvent
```
MouseEvent firstMouseEvent
```
    - maxMatches
```
int maxMatches
```
- Class edu.stanford.nlp.trees.tregex.gui.PreferencesPanel extends JDialog implements Serializable
  - Serialized Fields
    - gui
```
TregexGUI gui
```
    - highlightButton
```
JButton highlightButton
```
    - setEncoding
```
JTextField setEncoding
```
- Class edu.stanford.nlp.trees.tregex.gui.ScrollableTreeJPanel extends TreeJPanel implements Serializable
  - Serialized Fields
    - fontSize
```
int fontSize
```
    - defaultColor
```
Color defaultColor
```
    - matchedColor
```
Color matchedColor
```
    - tdiffColor
```
Color tdiffColor
```
    - fontName
```
String fontName
```
    - style
```
int style
```
    - preferredSize
```
Dimension preferredSize
```
    - matchedParts
```
List<E> matchedParts
```
    - matchedPartCoordinates
```
List<E> matchedPartCoordinates
```
    - leafCtr
```
int leafCtr
```
    - yieldHeight
```
double yieldHeight
```
    - yieldOffsets
```
float[] yieldOffsets
```
    - diffConstituents
```
Set<E> diffConstituents
```
- Class edu.stanford.nlp.trees.tregex.gui.TregexGUI extends JFrame implements Serializable
  - Serialized Fields
    - preferences
```
JMenuItem preferences
```
    - loadFiles
```
JMenuItem loadFiles
```
    - saveMatches
```
JMenuItem saveMatches
```
    - saveSentences
```
JMenuItem saveSentences
```
    - saveHistory
```
JMenuItem saveHistory
```
    - loadTsurgeon
```
JMenuItem loadTsurgeon
```
    - tDiff
```
JMenuItem tDiff
```
    - quit
```
JMenuItem quit
```
    - copy
```
JMenuItem copy
```
    - searchMenuItem
```
JMenuItem searchMenuItem
```
    - prevMatch
```
JMenuItem prevMatch
```
    - nextMatch
```
JMenuItem nextMatch
```
    - prevTreeMatch
```
JMenuItem prevTreeMatch
```
    - nextTreeMatch
```
JMenuItem nextTreeMatch
```
    - clearFileList
```
JMenuItem clearFileList
```
    - chooser
```
JFileChooser chooser
```
    - transformer
```
TreeTransformer transformer
```
    - preferenceDialog
```
PreferencesPanel preferenceDialog
```
    - aboutBox
```
JDialog aboutBox
```
    - doTdiff
```
boolean doTdiff
```
Package edu.stanford.nlp.trees.tregex.tsurgeon
- Class edu.stanford.nlp.trees.tregex.tsurgeon.ParseException extends 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
```
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
```
String eol
```
      The end of line string for this machine.
- Class edu.stanford.nlp.trees.tregex.tsurgeon.TsurgeonParseException extends RuntimeException implements Serializable
  
  serialVersionUID:
  
  -4417368416943652737L
- Class edu.stanford.nlp.trees.tregex.tsurgeon.TsurgeonRuntimeException extends RuntimeException implements Serializable
  
  serialVersionUID:
  
  1L
Package edu.stanford.nlp.util
- Class edu.stanford.nlp.util.ArrayCoreMap extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - writeObject
```
private void writeObject(ObjectOutputStream out)
                  throws IOException
```
      Overridden serialization method: compacts our map before writing.
      
      Throws:
      
      IOException - If IO error
  - Serialized Fields
    - keys
```
Class<T>[] keys
```
      Array of keys
    - values
```
Object[] values
```
      Array of values
    - size
```
int size
```
      Total number of elements actually in keys,values
- Class edu.stanford.nlp.util.ArrayMap extends 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 Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - words
```
String[] words
```
    - length
```
int length
```
    - mode
```
ArrayStringFilter.Mode mode
```
- Class edu.stanford.nlp.util.BoundedPriorityQueue extends TreeSet<E> implements Serializable
  - Serialized Fields
    - remainingCapacity
```
int remainingCapacity
```
    - initialCapacity
```
int initialCapacity
```
- Class edu.stanford.nlp.util.CacheMap extends LinkedHashMap<K,V> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - backingFile
```
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 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 Object implements Serializable
  
  serialVersionUID:
  
  -9064664153962599076L
  - Serialized Fields
    - map
```
Map<K,V> map
```
    - cf
```
CollectionFactory<T> cf
```
    - treatCollectionsAsImmutable
```
boolean treatCollectionsAsImmutable
```
    - mf
```
MapFactory<K,V> mf
```
    - emptyValue
```
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
```
Map<K,V> deltaMap
```
- Class edu.stanford.nlp.util.DeltaIndex extends 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 Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - filters
```
List<E> filters
```
- Class edu.stanford.nlp.util.Filters.DisjFilter extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - filters
```
List<E> filters
```
- Class edu.stanford.nlp.util.Filters.RandomFilter extends Object implements Serializable
  - Serialized Fields
    - random
```
Random random
```
    - fraction
```
double fraction
```
- Class edu.stanford.nlp.util.FiveDimensionalMap extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
Map<K,V> map
```
- Class edu.stanford.nlp.util.FixedPrioritiesPriorityQueue extends AbstractSet<E> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - size
```
int size
```
    - capacity
```
int capacity
```
    - elements
```
List<E> elements
```
    - priorities
```
double[] priorities
```
- Class edu.stanford.nlp.util.FourDimensionalMap extends Object implements Serializable
  
  serialVersionUID:
  
  5635664746940978837L
  - Serialized Fields
    - map
```
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
```
Set<E> immutableKeys
```
      Set of immutable keys
    - hashcode
```
int hashcode
```
      Pre-computed hashcode
- Class edu.stanford.nlp.util.HashableCoreMap.HashableCoreMapException extends RuntimeException implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.HashIndex extends AbstractCollection<E> implements Serializable
  
  serialVersionUID:
  
  5398562825928375260L
  - Serialized Fields
    - objects
```
ArrayList<E> objects
```
    - indexes
```
Map<K,V> indexes
```
    - locked
```
boolean locked
```
    - semaphore
```
Semaphore semaphore
```
- Class edu.stanford.nlp.util.IdentityHashSet extends AbstractSet<E> implements Serializable
  
  serialVersionUID:
  
  -5024744406713321676L
  - Serialization Methods
    - readObject
```
private void readObject(ObjectInputStream s)
                 throws IOException,
                        ClassNotFoundException
```
      Deserialize this Object in a manner which is binary-compatible with the JDK.
      
      Throws:
      
      IOException
      
      ClassNotFoundException
    - writeObject
```
private void writeObject(ObjectOutputStream s)
                  throws IOException
```
      Serialize this Object in a manner which is binary-compatible with the JDK.
      
      Throws:
      
      IOException
- Class edu.stanford.nlp.util.Interval extends Pair<E extends Comparable<E>,E extends 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 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.MapFactory extends Object implements Serializable
  
  serialVersionUID:
  
  4529666940763477360L
- Class edu.stanford.nlp.util.MetaClass.ClassCreationException extends 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 Number implements Serializable
  
  serialVersionUID:
  
  624465615824626762L
  - Serialized Fields
    - d
```
double d
```
- Class edu.stanford.nlp.util.MutableInteger extends Number implements Serializable
  
  serialVersionUID:
  
  624465615824626762L
  - Serialized Fields
    - i
```
int i
```
- Class edu.stanford.nlp.util.MutableLong extends Number implements Serializable
  
  serialVersionUID:
  
  624465615824626762L
  - Serialized Fields
    - i
```
long i
```
- Class edu.stanford.nlp.util.OneToOneMap extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - m_leftAsKey
```
Map<K,V> m_leftAsKey
```
    - m_rightAsKey
```
Map<K,V> m_rightAsKey
```
- Class edu.stanford.nlp.util.OneToOneMap.OneToOneMapException extends Exception implements Serializable
  
  serialVersionUID:
  
  7743164489912070054L
- Class edu.stanford.nlp.util.PaddedList extends AbstractList<E> implements Serializable
  
  serialVersionUID:
  
  2064775966439971729L
  - Serialized Fields
    - l
```
List<E> l
```
    - padding
```
Object padding
```
- Class edu.stanford.nlp.util.Pair extends Object implements Serializable
  
  serialVersionUID:
  
  1360822168806852921L
  - Serialized Fields
    - first
```
Object first
```
      Direct access is deprecated. Use first().
    - second
```
Object second
```
      Direct access is deprecated. Use second().
- Class edu.stanford.nlp.util.Quadruple extends Object implements Serializable
  
  serialVersionUID:
  
  6295043666955910662L
  - Serialized Fields
    - first
```
Object first
```
    - second
```
Object second
```
    - third
```
Object third
```
    - fourth
```
Object fourth
```
- Class edu.stanford.nlp.util.ReflectionLoading.ReflectionLoadingException extends RuntimeException implements Serializable
  
  serialVersionUID:
  
  -3324911744277952585L
- Class edu.stanford.nlp.util.RegexStringFilter extends Object implements Serializable
  - Serialized Fields
    - pattern
```
Pattern pattern
```
- Class edu.stanford.nlp.util.RuntimeInterruptedException extends RuntimeException implements Serializable
- Class edu.stanford.nlp.util.ScoredComparator extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - ascending
```
boolean ascending
```
- Class edu.stanford.nlp.util.ScoredObject extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - score
```
double score
```
    - object
```
Object object
```
- Class edu.stanford.nlp.util.StringParsingTask.ParserException extends RuntimeException implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.SystemUtils.ProcessException extends RuntimeException implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.ThreeDimensionalCollectionValuedMap extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
Map<K,V> map
```
- Class edu.stanford.nlp.util.ThreeDimensionalMap extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
Map<K,V> map
```
- Class edu.stanford.nlp.util.Triple extends Object implements Serializable
  
  serialVersionUID:
  
  -4182871682751645440L
  - Serialized Fields
    - first
```
Object first
```
    - second
```
Object second
```
    - third
```
Object third
```
- Class edu.stanford.nlp.util.TwoDimensionalCollectionValuedMap extends Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
Map<K,V> map
```
    - mf
```
MapFactory<K,V> mf
```
    - cf
```
CollectionFactory<T> cf
```
    - treatCollectionsAsImmutable
```
boolean treatCollectionsAsImmutable
```
- Class edu.stanford.nlp.util.TwoDimensionalMap extends Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - mf1
```
MapFactory<K,V> mf1
```
    - mf2
```
MapFactory<K,V> mf2
```
    - map
```
Map<K,V> map
```
- Class edu.stanford.nlp.util.TwoDimensionalSet extends 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 Object implements Serializable
  
  serialVersionUID:
  
  1L
Package edu.stanford.nlp.util.concurrent
- Class edu.stanford.nlp.util.concurrent.AtomicDouble extends Number implements Serializable
  
  serialVersionUID:
  
  -8405198993435143622L
  - Serialization Methods
    - readObject
```
private void readObject(ObjectInputStream arg0)
                 throws IOException,
                        ClassNotFoundException
```
      Throws:
      
      IOException
      
      ClassNotFoundException
    - writeObject
```
private void writeObject(ObjectOutputStream arg0)
                  throws IOException
```
      Throws:
      
      IOException
- Class edu.stanford.nlp.util.concurrent.ConcurrentHashCounter extends Object implements Serializable
  
  serialVersionUID:
  
  -8077192206562696111L
  - Serialized Fields
    - map
```
ConcurrentMap<K,V> map
```
    - totalCount
```
edu.stanford.nlp.util.concurrent.AtomicDouble totalCount
```
    - defaultReturnValue
```
double defaultReturnValue
```
- Class edu.stanford.nlp.util.concurrent.ConcurrentHashIndex extends AbstractCollection<E> implements Serializable
  
  serialVersionUID:
  
  6465313844985269109L
  - Serialized Fields
    - item2Index
```
ConcurrentHashMap<K,V> item2Index
```
    - indexSize
```
int indexSize
```
    - lock
```
ReentrantLock lock
```
    - index2Item
```
AtomicReference<V> index2Item
```
Package edu.stanford.nlp.wordseg
- Class edu.stanford.nlp.wordseg.ChineseSegmenterFeatureFactory extends FeatureFactory<IN extends CoreLabel> implements Serializable
  
  serialVersionUID:
  
  3387166382968763350L
- Class edu.stanford.nlp.wordseg.Gale2007ChineseSegmenterFeatureFactory extends FeatureFactory<IN extends CoreLabel> implements Serializable
  
  serialVersionUID:
  
  8197648719208850960L
- Class edu.stanford.nlp.wordseg.MaxMatchSegmenter extends Object implements Serializable
  
  serialVersionUID:
  
  8263734344886904724L
  - Serialized Fields
    - words
```
Set<E> words
```
    - len
```
int len
```
    - edgesNb
```
int edgesNb
```
    - states
```
List<E> states
```
    - lattice
```
DFSA<T,S> lattice
```
- Class edu.stanford.nlp.wordseg.Sighan2005DocumentReaderAndWriter extends Object implements Serializable
  
  serialVersionUID:
  
  3260295150250263237L
  - Serialized Fields
    - separatingPuncChars
```
Pattern separatingPuncChars
```
    - ambiguousPuncChars
```
Pattern ambiguousPuncChars
```
    - midDotPattern
```
Pattern midDotPattern
```
    - cdtos
```
ChineseDocumentToSentenceProcessor cdtos
```
    - cdict
```
ChineseDictionary cdict
```
    - cdict2
```
ChineseDictionary cdict2
```
    - flags
```
SeqClassifierFlags flags
```
    - factory
```
IteratorFromReaderFactory<T> factory
```

Serialized Form

Package edu.stanford.nlp.classify

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

Serialized Fields

labelIndex

featureIndex

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

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

Serialized Fields

labelIndex

featureIndex

labels

data

size

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

Serialized Fields

weightedVotes

instances

classLookup

l2Normalize

k

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

Serialized Fields

weights

labelIndex

featureIndex

intern

thresholds

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

Serialized Fields

TOL

mem

verbose

logPrior

tuneSigmaHeldOut

tuneSigmaCV

folds

min

max

retrainFromScratchAfterSigmaTuning

minimizerCreator

evalIters

evaluators

heldOutSearcher

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

Serialized Fields

weights

featureIndex

classes

prior

biased

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

Serialized Fields

weights

featureIndex

classes

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

Serialized Fields

means

otherPrior

type

sigmaSqM

sigmaQuM

sigmaSq

sigmaQu

epsilon

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

Serialized Fields

weights

priors

features

addZeroValued

priorZero

labels

zero

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

Serialized Fields

kind

alphaClass

alphaFeature