Serialized Form (Stanford JavaNLP API)

Package edu.stanford.nlp.classify
- Class edu.stanford.nlp.classify.AbstractLinearClassifierFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - labelIndex
```
Index<E> labelIndex
```
    - featureIndex
```
Index<E> featureIndex
```
- Class edu.stanford.nlp.classify.Dataset extends GeneralDataset<L,F> implements Serializable
  
  serialVersionUID:
  
  -3883164942879961091L
- Class edu.stanford.nlp.classify.GeneralDataset extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  19157757130054829L
  - Serialized Fields
    - labelIndex
```
Index<E> labelIndex
```
    - featureIndex
```
Index<E> featureIndex
```
    - labels
```
int[] labels
```
    - data
```
int[][] data
```
    - size
```
int size
```
- Class edu.stanford.nlp.classify.KNNClassifier extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7115357548209007944L
  - Serialized Fields
    - weightedVotes
```
boolean weightedVotes
```
    - instances
```
CollectionValuedMap<K,V> instances
```
    - classLookup
```
java.util.Map<K,V> classLookup
```
    - l2Normalize
```
boolean l2Normalize
```
    - k
```
int k
```
- Class edu.stanford.nlp.classify.LinearClassifier extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  8499574525453275255L
  - Serialized Fields
    - weights
```
double[][] weights
```
      Classifier weights. First index is the featureIndex value and second index is the labelIndex value.
    - labelIndex
```
Index<E> labelIndex
```
    - featureIndex
```
Index<E> featureIndex
```
    - intern
```
boolean intern
```
    - thresholds
```
double[] thresholds
```
- Class edu.stanford.nlp.classify.LinearClassifierFactory extends AbstractLinearClassifierFactory<L,F> implements Serializable
  
  serialVersionUID:
  
  7893768984379107397L
  - Serialized Fields
    - TOL
```
double TOL
```
    - mem
```
int mem
```
    - verbose
```
boolean verbose
```
    - logPrior
```
LogPrior logPrior
```
    - tuneSigmaHeldOut
```
boolean tuneSigmaHeldOut
```
    - tuneSigmaCV
```
boolean tuneSigmaCV
```
    - folds
```
int folds
```
    - min
```
double min
```
    - max
```
double max
```
    - retrainFromScratchAfterSigmaTuning
```
boolean retrainFromScratchAfterSigmaTuning
```
    - minimizerCreator
```
Factory<T> minimizerCreator
```
    - evalIters
```
int evalIters
```
    - evaluators
```
Evaluator[] evaluators
```
    - heldOutSearcher
```
LineSearcher heldOutSearcher
```
- Class edu.stanford.nlp.classify.LogisticClassifier extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  6672245467246897192L
  - Serialized Fields
    - weights
```
double[] weights
```
    - featureIndex
```
Index<E> featureIndex
```
    - classes
```
java.lang.Object[] classes
```
    - prior
```
LogPrior prior
```
      Deprecated.
    - biased
```
boolean biased
```
      Deprecated.
- Class edu.stanford.nlp.classify.LogisticClassifierFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - weights
```
double[] weights
```
    - featureIndex
```
Index<E> featureIndex
```
    - classes
```
java.lang.Object[] classes
```
- Class edu.stanford.nlp.classify.LogPrior extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7826853908892790965L
  - Serialized Fields
    - means
```
double[] means
```
    - otherPrior
```
LogPrior otherPrior
```
    - type
```
LogPrior.LogPriorType type
```
    - sigmaSqM
```
double[] sigmaSqM
```
    - sigmaQuM
```
double[] sigmaQuM
```
    - sigmaSq
```
double sigmaSq
```
    - sigmaQu
```
double sigmaQu
```
    - epsilon
```
double epsilon
```
- Class edu.stanford.nlp.classify.MultinomialLogisticClassifier extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - weights
```
double[][] weights
```
    - featureIndex
```
Index<E> featureIndex
```
    - labelIndex
```
Index<E> labelIndex
```
- Class edu.stanford.nlp.classify.NaiveBayesClassifier extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1544820342684024068L
  - Serialized Fields
    - weights
```
Counter<E> weights
```
    - priors
```
Counter<E> priors
```
    - features
```
java.util.Set<E> features
```
    - addZeroValued
```
boolean addZeroValued
```
    - priorZero
```
Counter<E> priorZero
```
    - labels
```
java.util.Set<E> labels
```
    - zero
```
java.lang.Integer zero
```
- Class edu.stanford.nlp.classify.NaiveBayesClassifierFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -8164165428834534041L
  - Serialized Fields
    - kind
```
int kind
```
    - alphaClass
```
double alphaClass
```
    - alphaFeature
```
double alphaFeature
```
    - sigma
```
double sigma
```
    - prior
```
int prior
```
    - labelIndex
```
Index<E> labelIndex
```
    - featureIndex
```
Index<E> featureIndex
```
- Class edu.stanford.nlp.classify.NBLinearClassifierFactory extends AbstractLinearClassifierFactory<L,F> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - sigma
```
double sigma
```
    - interpretAlwaysOnFeatureAsPrior
```
boolean interpretAlwaysOnFeatureAsPrior
```
    - tuneSigma
```
boolean tuneSigma
```
    - folds
```
int folds
```
- Class edu.stanford.nlp.classify.OneVsAllClassifier extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -743792054415242776L
  - Serialized Fields
    - featureIndex
```
Index<E> featureIndex
```
    - labelIndex
```
Index<E> labelIndex
```
    - binaryClassifiers
```
java.util.Map<K,V> binaryClassifiers
```
    - defaultLabel
```
java.lang.Object defaultLabel
```
- Class edu.stanford.nlp.classify.RVFDataset extends GeneralDataset<L,F> implements Serializable
  
  serialVersionUID:
  
  -3841757837680266182L
  - Serialized Fields
    - values
```
double[][] values
```
    - minValues
```
double[] minValues
```
    - maxValues
```
double[] maxValues
```
    - means
```
double[] means
```
    - stdevs
```
double[] stdevs
```
    - sourcesAndIds
```
java.util.ArrayList<E> sourcesAndIds
```
- Class edu.stanford.nlp.classify.ShiftParamsLogisticClassifierFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -8977510677251295037L
  - Serialized Fields
    - data
```
int[][] data
```
    - dataValues
```
double[][] dataValues
```
    - labels
```
int[] labels
```
    - numClasses
```
int numClasses
```
    - numFeatures
```
int numFeatures
```
    - prior
```
LogPrior prior
```
    - lambda
```
double lambda
```
- Class edu.stanford.nlp.classify.SVMLightClassifier extends LinearClassifier<L,F> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - platt
```
LinearClassifier<L,F> platt
```
- Class edu.stanford.nlp.classify.SVMLightClassifierFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - C
```
double C
```
      C can be tuned using held-out set or cross-validation. For binary SVM, if C=0, svmlight uses default of 1/(avg x*x).
    - useSigmoid
```
boolean useSigmoid
```
    - verbose
```
boolean verbose
```
    - svmLightLearn
```
java.lang.String svmLightLearn
```
    - svmStructLearn
```
java.lang.String svmStructLearn
```
    - svmPerfLearn
```
java.lang.String svmPerfLearn
```
    - svmLightClassify
```
java.lang.String svmLightClassify
```
    - svmStructClassify
```
java.lang.String svmStructClassify
```
    - svmPerfClassify
```
java.lang.String svmPerfClassify
```
    - useAlphaFile
```
boolean useAlphaFile
```
    - alphaFile
```
java.io.File alphaFile
```
    - deleteTempFilesOnExit
```
boolean deleteTempFilesOnExit
```
    - svmLightVerbosity
```
int svmLightVerbosity
```
    - doEval
```
boolean doEval
```
    - useSVMPerf
```
boolean useSVMPerf
```
    - tuneHeldOut
```
boolean tuneHeldOut
```
    - tuneCV
```
boolean tuneCV
```
    - scorer
```
Scorer<L> scorer
```
    - tuneMinimizer
```
LineSearcher tuneMinimizer
```
    - folds
```
int folds
```
    - heldOutPercent
```
double heldOutPercent
```
    - whitespacePattern
```
java.util.regex.Pattern whitespacePattern
```
- Class edu.stanford.nlp.classify.WeightedDataset extends Dataset<L,F> implements Serializable
  
  serialVersionUID:
  
  -5435125789127705430L
  - Serialized Fields
    - weights
```
float[] weights
```
- Class edu.stanford.nlp.classify.WeightedRVFDataset extends RVFDataset<L,F> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - weights
```
float[] weights
```
Package edu.stanford.nlp.coref.data
- Class edu.stanford.nlp.coref.data.CorefChain extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3657691243506528L
  - Serialized Fields
    - chainID
```
int chainID
```
    - mentions
```
java.util.List<E> mentions
```
    - mentionMap
```
java.util.Map<K,V> mentionMap
```
    - representative
```
CorefChain.CorefMention representative
```
      The most representative mention in this cluster
- Class edu.stanford.nlp.coref.data.CorefChain.CorefMention extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3657691243504173L
  - Serialized Fields
    - mentionType
```
Dictionaries.MentionType mentionType
```
    - number
```
Dictionaries.Number number
```
    - gender
```
Dictionaries.Gender gender
```
    - animacy
```
Dictionaries.Animacy animacy
```
    - startIndex
```
int startIndex
```
      Starting word number within the sentence, indexed from 1
    - endIndex
```
int endIndex
```
      One past the end word number within the sentence, indexed from 1
    - headIndex
```
int headIndex
```
      Head word of the mention
    - corefClusterID
```
int corefClusterID
```
    - mentionID
```
int mentionID
```
    - sentNum
```
int sentNum
```
      Sentence number in the document containing this mention, indexed from 1.
    - position
```
IntTuple position
```
      Position is a binary tuple of (sentence number, mention number in that sentence). This is used for indexing by mention.
    - mentionSpan
```
java.lang.String mentionSpan
```
- Class edu.stanford.nlp.coref.data.CorefCluster extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  8655265337578515592L
  - Serialized Fields
    - corefMentions
```
java.util.Set<E> corefMentions
```
    - clusterID
```
int clusterID
```
    - numbers
```
java.util.Set<E> numbers
```
    - genders
```
java.util.Set<E> genders
```
    - animacies
```
java.util.Set<E> animacies
```
    - nerStrings
```
java.util.Set<E> nerStrings
```
    - heads
```
java.util.Set<E> heads
```
    - words
```
java.util.Set<E> words
```
      All words in this cluster - for word inclusion feature
    - firstMention
```
Mention firstMention
```
      The first mention in this cluster
    - representative
```
Mention representative
```
      Return the most representative mention in the chain. A proper noun mention or a mention with more pre-modifiers is preferred.
- Class edu.stanford.nlp.coref.data.Document extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4139866807494603953L
  - Serialized Fields
    - docType
```
Document.DocType docType
```
      The type of document: conversational or article
    - annotation
```
Annotation annotation
```
      Document annotation
    - conllDoc
```
CoNLLDocumentReader.CoNLLDocument conllDoc
```
      for conll shared task 2011
    - goldMentions
```
java.util.List<E> goldMentions
```
      The list of gold mentions
    - predictedMentions
```
java.util.List<E> predictedMentions
```
      The list of predicted mentions
    - corefClusters
```
java.util.Map<K,V> corefClusters
```
      Clusters for coreferent mentions
    - goldCorefClusters
```
java.util.Map<K,V> goldCorefClusters
```
      Gold Clusters for coreferent mentions
    - predictedMentionsByID
```
java.util.Map<K,V> predictedMentionsByID
```
      All mentions in a document mentionID -> mention
    - goldMentionsByID
```
java.util.Map<K,V> goldMentionsByID
```
    - roleSet
```
java.util.Set<E> roleSet
```
      Set of roles (in role apposition) in a document
    - positions
```
java.util.Map<K,V> positions
```
      Position of each mention in the input matrix Each mention occurrence with sentence # and position within sentence (Nth mention, not Nth token)
    - allPositions
```
java.util.Map<K,V> allPositions
```
    - mentionheadPositions
```
java.util.Map<K,V> mentionheadPositions
```
    - goldLinks
```
java.util.List<E> goldLinks
```
      List of gold links in a document by positions
    - speakers
```
java.util.Map<K,V> speakers
```
      UtteranceAnnotation -> String (speaker): mention ID or speaker string e.g., the value can be "34" (mentionID), "Larry" (speaker string), or "PER3" (autoassigned speaker string)
    - speakerPairs
```
java.util.Set<E> speakerPairs
```
      Pair of mention id, and the mention's speaker id the second value is the "speaker mention"'s id. e.g., Larry said, "San Francisco is a city.": (id(Larry), id(San Francisco))
    - speakerInfoGiven
```
boolean speakerInfoGiven
```
    - maxUtter
```
int maxUtter
```
    - numParagraph
```
int numParagraph
```
    - numSentences
```
int numSentences
```
    - incompatibles
```
java.util.Set<E> incompatibles
```
      Set of incompatible clusters pairs
    - incompatibleClusters
```
java.util.Set<E> incompatibleClusters
```
    - acronymCache
```
java.util.Map<K,V> acronymCache
```
    - speakerInfoMap
```
java.util.Map<K,V> speakerInfoMap
```
      Map of speaker name/id to speaker info the key is the value of the variable 'speakers'
    - docInfo
```
java.util.Map<K,V> docInfo
```
      Additional information about the document. Can be used as features
    - filterMentionSet
```
java.util.Set<E> filterMentionSet
```
- Class edu.stanford.nlp.coref.data.Mention extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -7524485803945717057L
  - Serialized Fields
    - mentionType
```
Dictionaries.MentionType mentionType
```
    - number
```
Dictionaries.Number number
```
    - gender
```
Dictionaries.Gender gender
```
    - animacy
```
Dictionaries.Animacy animacy
```
    - person
```
Dictionaries.Person person
```
    - headString
```
java.lang.String headString
```
    - nerString
```
java.lang.String nerString
```
    - startIndex
```
int startIndex
```
    - endIndex
```
int endIndex
```
    - headIndex
```
int headIndex
```
    - mentionID
```
int mentionID
```
    - originalRef
```
int originalRef
```
    - headIndexedWord
```
IndexedWord headIndexedWord
```
    - goldCorefClusterID
```
int goldCorefClusterID
```
    - corefClusterID
```
int corefClusterID
```
    - mentionNum
```
int mentionNum
```
    - sentNum
```
int sentNum
```
    - utter
```
int utter
```
    - paragraph
```
int paragraph
```
    - isSubject
```
boolean isSubject
```
    - isDirectObject
```
boolean isDirectObject
```
    - isIndirectObject
```
boolean isIndirectObject
```
    - isPrepositionObject
```
boolean isPrepositionObject
```
    - dependingVerb
```
IndexedWord dependingVerb
```
    - hasTwin
```
boolean hasTwin
```
    - generic
```
boolean generic
```
    - isSingleton
```
boolean isSingleton
```
    - sentenceWords
```
java.util.List<E> sentenceWords
```
    - originalSpan
```
java.util.List<E> originalSpan
```
    - mentionSubTree
```
Tree mentionSubTree
```
    - contextParseTree
```
Tree contextParseTree
```
    - headWord
```
CoreLabel headWord
```
    - basicDependency
```
SemanticGraph basicDependency
```
    - enhancedDependency
```
SemanticGraph enhancedDependency
```
    - dependents
```
java.util.Set<E> dependents
```
    - preprocessedTerms
```
java.util.List<E> preprocessedTerms
```
    - synsets
```
java.lang.Object synsets
```
    - appositions
```
java.util.Set<E> appositions
```
      Set of other mentions in the same sentence that are syntactic appositions to this
    - predicateNominatives
```
java.util.Set<E> predicateNominatives
```
    - relativePronouns
```
java.util.Set<E> relativePronouns
```
    - listMembers
```
java.util.Set<E> listMembers
```
      Set of other mentions in the same sentence that below to this list
    - belongToLists
```
java.util.Set<E> belongToLists
```
      Set of other mentions in the same sentence that I am a member of
    - speakerInfo
```
SpeakerInfo speakerInfo
```
    - antecedentOrdering
```
IntCounter<E> antecedentOrdering
```
    - headParent
```
IndexedWord headParent
```
    - headChildren
```
java.util.Collection<E> headChildren
```
    - headSiblings
```
java.util.Collection<E> headSiblings
```
    - headPathToRoot
```
java.util.List<E> headPathToRoot
```
- Class edu.stanford.nlp.coref.data.SpeakerInfo extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7776098967746458031L
  - Serialized Fields
    - speakerId
```
java.lang.String speakerId
```
    - speakerName
```
java.lang.String speakerName
```
    - speakerNameStrings
```
java.lang.String[] speakerNameStrings
```
    - speakerDesc
```
java.lang.String speakerDesc
```
    - mentions
```
java.util.Set<E> mentions
```
    - speakerIdIsNumber
```
boolean speakerIdIsNumber
```
    - speakerIdIsAutoDetermined
```
boolean speakerIdIsAutoDetermined
```
Package edu.stanford.nlp.coref.docreader
- Class edu.stanford.nlp.coref.docreader.CoNLLDocumentReader.CoNLLDocument extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  6287339385357914531L
  - Serialized Fields
    - documentIdPart
```
java.lang.String documentIdPart
```
    - documentID
```
java.lang.String documentID
```
    - partNo
```
java.lang.String partNo
```
    - filename
```
java.lang.String filename
```
    - sentenceWordLists
```
java.util.List<E> sentenceWordLists
```
    - annotation
```
Annotation annotation
```
    - corefChainMap
```
CollectionValuedMap<K,V> corefChainMap
```
    - nerChunks
```
java.util.List<E> nerChunks
```

Package edu.stanford.nlp.coref.fastneural

Class edu.stanford.nlp.coref.fastneural.FastNeuralCorefModel extends java.lang.Object implements Serializable

serialVersionUID:: 8663264823377059140L

Serialized Fields

embeddingExtractor
```
EmbeddingExtractor embeddingExtractor
```
pairFeatureIds
```
java.util.Map<K,V> pairFeatureIds
```
mentionFeatureIds
```
java.util.Map<K,V> mentionFeatureIds
```

anaphorKernel

org.ejml.simple.SimpleMatrix anaphorKernel

anaphorBias

org.ejml.simple.SimpleMatrix anaphorBias

antecedentKernel

org.ejml.simple.SimpleMatrix antecedentKernel

antecedentBias

org.ejml.simple.SimpleMatrix antecedentBias

pairFeaturesKernel

org.ejml.simple.SimpleMatrix pairFeaturesKernel

pairFeaturesBias

org.ejml.simple.SimpleMatrix pairFeaturesBias

NARepresentation

org.ejml.simple.SimpleMatrix NARepresentation

networkLayers
```
java.util.List<E> networkLayers
```

Package edu.stanford.nlp.coref.hybrid.rf
- Class edu.stanford.nlp.coref.hybrid.rf.DecisionTree extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4198470422641238244L
  - Serialized Fields
    - root
```
DecisionTreeNode root
```
    - featureIndex
```
Index<E> featureIndex
```
- Class edu.stanford.nlp.coref.hybrid.rf.DecisionTreeNode extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  8566766017320577273L
  - Serialized Fields
    - idx
```
int idx
```
    - split
```
float split
```
    - children
```
DecisionTreeNode[] children
```
- Class edu.stanford.nlp.coref.hybrid.rf.RandomForest extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -2736377471905671276L
  - Serialized Fields
    - trees
```
DecisionTree[] trees
```
    - featureIndex
```
Index<E> featureIndex
```
Package edu.stanford.nlp.coref.hybrid.sieve
- Class edu.stanford.nlp.coref.hybrid.sieve.AliasMatch extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.ChineseHeadMatch extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.CorefDictionaryMatch extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.DeterministicCorefSieve extends Sieve implements Serializable
  - Serialized Fields
    - flags
```
DcorefSieveOptions flags
```
- Class edu.stanford.nlp.coref.hybrid.sieve.DiscourseMatch extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.ExactStringMatch extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.LexicalChainMatch extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.MarkRole extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.NameMatch extends DeterministicCorefSieve implements Serializable
  - Serialized Fields
    - mentionMatcher
```
MentionMatcher mentionMatcher
```
    - minTokens
```
int minTokens
```
    - ignoreGender
```
boolean ignoreGender
```
    - supportedNerTypes
```
java.util.Set<E> supportedNerTypes
```
- Class edu.stanford.nlp.coref.hybrid.sieve.NameMatchPrecise extends NameMatch implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.OracleSieve extends Sieve implements Serializable
  
  serialVersionUID:
  
  3510248899162246138L
- Class edu.stanford.nlp.coref.hybrid.sieve.PreciseConstructs extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.PronounMatch extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.RelaxedExactStringMatch extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.RelaxedHeadMatch extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.RFSieve extends Sieve implements Serializable
  
  serialVersionUID:
  
  -4090017054885920527L
  - Serialized Fields
    - rf
```
RandomForest rf
```
    - thresMerge
```
double thresMerge
```
      the probability threshold for merging two mentions
- Class edu.stanford.nlp.coref.hybrid.sieve.Sieve extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3986463332365306868L
  - Serialized Fields
    - classifierType
```
Sieve.ClassifierType classifierType
```
    - lang
```
java.util.Locale lang
```
    - sievename
```
java.lang.String sievename
```
    - maxSentDist
```
int maxSentDist
```
      the maximum sentence distance for linking two mentions
    - mType
```
java.util.Set<E> mType
```
      type of mention we want to resolve. e.g., if mType is PRONOMINAL, we only resolve pronoun mentions
    - aType
```
java.util.Set<E> aType
```
      type of mention we want to compare to. e.g., if aType is PROPER, the resolution can be done only with PROPER antecedent
    - mTypeStr
```
java.util.Set<E> mTypeStr
```
    - aTypeStr
```
java.util.Set<E> aTypeStr
```
    - props
```
java.util.Properties props
```
- Class edu.stanford.nlp.coref.hybrid.sieve.SpeakerMatch extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.StrictHeadMatch1 extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.StrictHeadMatch2 extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.StrictHeadMatch3 extends DeterministicCorefSieve implements Serializable
- Class edu.stanford.nlp.coref.hybrid.sieve.StrictHeadMatch4 extends DeterministicCorefSieve implements Serializable
Package edu.stanford.nlp.coref.md
- Class edu.stanford.nlp.coref.md.MentionDetectionClassifier extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4100580709477023158L
  - Serialized Fields
    - rf
```
RandomForest rf
```
Package edu.stanford.nlp.coref.neural
- Class edu.stanford.nlp.coref.neural.EmbeddingExtractor extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -663338564691488202L
  - Serialized Fields
    - conll
```
boolean conll
```
    - staticWordEmbeddings
```
Embedding staticWordEmbeddings
```
    - tunedWordEmbeddings
```
Embedding tunedWordEmbeddings
```
    - naEmbedding
```
java.lang.String naEmbedding
```
- Class edu.stanford.nlp.coref.neural.NeuralCorefModel extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2139427931784505653L
  - Serialized Fields
    - antecedentMatrix
```
org.ejml.simple.SimpleMatrix antecedentMatrix
```
    - anaphorMatrix
```
org.ejml.simple.SimpleMatrix anaphorMatrix
```
    - pairFeaturesMatrix
```
org.ejml.simple.SimpleMatrix pairFeaturesMatrix
```
    - pairwiseFirstLayerBias
```
org.ejml.simple.SimpleMatrix pairwiseFirstLayerBias
```
    - anaphoricityModel
```
java.util.List<E> anaphoricityModel
```
    - pairwiseModel
```
java.util.List<E> pairwiseModel
```
    - wordEmbeddings
```
Embedding wordEmbeddings
```
Package edu.stanford.nlp.coref.statistical
- Class edu.stanford.nlp.coref.statistical.CompressedFeatureVector extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -8889507443653366753L
  - Serialized Fields
    - keys
```
java.util.List<E> keys
```
    - values
```
java.util.List<E> values
```
- Class edu.stanford.nlp.coref.statistical.Compressor extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  364548642855692442L
  - Serialized Fields
    - index
```
java.util.Map<K,V> index
```
    - inverse
```
java.util.Map<K,V> inverse
```
- Class edu.stanford.nlp.coref.statistical.DocumentExamples extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -2474306699767791493L
  - Serialized Fields
    - id
```
int id
```
    - examples
```
java.util.List<E> examples
```
    - mentionFeatures
```
java.util.Map<K,V> mentionFeatures
```
- Class edu.stanford.nlp.coref.statistical.Example extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1104263558466004590L
  - Serialized Fields
    - docId
```
int docId
```
    - label
```
double label
```
    - pairwiseFeatures
```
CompressedFeatureVector pairwiseFeatures
```
    - mentionId1
```
int mentionId1
```
    - mentionId2
```
int mentionId2
```
    - mentionType1
```
Dictionaries.MentionType mentionType1
```
    - mentionType2
```
Dictionaries.MentionType mentionType2
```
Package edu.stanford.nlp.dcoref
- Class edu.stanford.nlp.dcoref.CorefChain extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3657691243506528L
  - Serialized Fields
    - chainID
```
int chainID
```
    - mentions
```
java.util.List<E> mentions
```
    - mentionMap
```
java.util.Map<K,V> mentionMap
```
    - representative
```
CorefChain.CorefMention representative
```
      The most representative mention in this cluster
- Class edu.stanford.nlp.dcoref.CorefChain.CorefMention extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3657691243504173L
  - Serialized Fields
    - mentionType
```
Dictionaries.MentionType mentionType
```
    - number
```
Dictionaries.Number number
```
    - gender
```
Dictionaries.Gender gender
```
    - animacy
```
Dictionaries.Animacy animacy
```
    - startIndex
```
int startIndex
```
      Starting word number, indexed from 1
    - endIndex
```
int endIndex
```
      One past the end word number, indexed from 1
    - headIndex
```
int headIndex
```
      Head word of the mention
    - corefClusterID
```
int corefClusterID
```
    - mentionID
```
int mentionID
```
    - sentNum
```
int sentNum
```
      Sentence number in the document containing this mention, indexed from 1.
    - position
```
IntTuple position
```
      Position is a binary tuple of (sentence number, mention number in that sentence). This is used for indexing by mention.
    - mentionSpan
```
java.lang.String mentionSpan
```
- Class edu.stanford.nlp.dcoref.CorefCluster extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  8655265337578515592L
  - Serialized Fields
    - corefMentions
```
java.util.Set<E> corefMentions
```
    - clusterID
```
int clusterID
```
    - numbers
```
java.util.Set<E> numbers
```
    - genders
```
java.util.Set<E> genders
```
    - animacies
```
java.util.Set<E> animacies
```
    - nerStrings
```
java.util.Set<E> nerStrings
```
    - heads
```
java.util.Set<E> heads
```
    - words
```
java.util.Set<E> words
```
      All words in this cluster - for word inclusion feature
    - firstMention
```
Mention firstMention
```
      The first mention in this cluster
    - representative
```
Mention representative
```
      Return the most representative mention in the chain. A proper noun mention or a mention with more pre-modifiers is preferred.
- Class edu.stanford.nlp.dcoref.Document extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4139866807494603953L
  - Serialized Fields
    - docType
```
Document.DocType docType
```
      The type of document: conversational or article
    - annotation
```
Annotation annotation
```
      Document annotation
    - conllDoc
```
CoNLL2011DocumentReader.Document conllDoc
```
      for conll shared task 2011
    - goldOrderedMentionsBySentence
```
java.util.List<E> goldOrderedMentionsBySentence
```
      The list of gold mentions
    - predictedOrderedMentionsBySentence
```
java.util.List<E> predictedOrderedMentionsBySentence
```
      The list of predicted mentions
    - corefClusters
```
java.util.Map<K,V> corefClusters
```
      Clusters for coreferent mentions
    - goldCorefClusters
```
java.util.Map<K,V> goldCorefClusters
```
      Gold Clusters for coreferent mentions
    - allPredictedMentions
```
java.util.Map<K,V> allPredictedMentions
```
      For all mentions in a document, map mentionID to mention.
    - allGoldMentions
```
java.util.Map<K,V> allGoldMentions
```
    - roleSet
```
java.util.Set<E> roleSet
```
      Set of roles (in role apposition) in a document
    - positions
```
java.util.Map<K,V> positions
```
      Position of each mention in the input matrix Each mention occurrence with sentence # and position within sentence (Nth mention, not Nth token)
    - allPositions
```
java.util.Map<K,V> allPositions
```
    - mentionheadPositions
```
java.util.Map<K,V> mentionheadPositions
```
    - goldLinks
```
java.util.List<E> goldLinks
```
      List of gold links in a document by positions
    - speakers
```
java.util.Map<K,V> speakers
```
      Map UtteranceAnnotation to String (speaker): mention ID or speaker string
    - speakerPairs
```
java.util.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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -7524485803945717057L
  - Serialized Fields
    - mentionType
```
Dictionaries.MentionType mentionType
```
    - number
```
Dictionaries.Number number
```
    - gender
```
Dictionaries.Gender gender
```
    - animacy
```
Dictionaries.Animacy animacy
```
    - person
```
Dictionaries.Person person
```
    - headString
```
java.lang.String headString
```
    - nerString
```
java.lang.String nerString
```
    - startIndex
```
int startIndex
```
    - endIndex
```
int endIndex
```
    - headIndex
```
int headIndex
```
    - mentionID
```
int mentionID
```
    - originalRef
```
int originalRef
```
    - headIndexedWord
```
IndexedWord headIndexedWord
```
    - goldCorefClusterID
```
int goldCorefClusterID
```
    - corefClusterID
```
int corefClusterID
```
    - sentNum
```
int sentNum
```
    - utter
```
int utter
```
    - paragraph
```
int paragraph
```
    - isSubject
```
boolean isSubject
```
    - isDirectObject
```
boolean isDirectObject
```
    - isIndirectObject
```
boolean isIndirectObject
```
    - isPrepositionObject
```
boolean isPrepositionObject
```
    - dependingVerb
```
IndexedWord dependingVerb
```
    - twinless
```
boolean twinless
```
    - generic
```
boolean generic
```
    - isSingleton
```
boolean isSingleton
```
    - sentenceWords
```
java.util.List<E> sentenceWords
```
    - originalSpan
```
java.util.List<E> originalSpan
```
    - mentionSubTree
```
Tree mentionSubTree
```
    - contextParseTree
```
Tree contextParseTree
```
    - headWord
```
CoreLabel headWord
```
    - dependency
```
SemanticGraph dependency
```
    - dependents
```
java.util.Set<E> dependents
```
    - preprocessedTerms
```
java.util.List<E> preprocessedTerms
```
    - synsets
```
java.lang.Object synsets
```
    - appositions
```
java.util.Set<E> appositions
```
      Set of other mentions in the same sentence that are syntactic appositions to this
    - predicateNominatives
```
java.util.Set<E> predicateNominatives
```
    - relativePronouns
```
java.util.Set<E> relativePronouns
```
    - listMembers
```
java.util.Set<E> listMembers
```
      Set of other mentions in the same sentence that below to this list
    - belongToLists
```
java.util.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.CyclicGraphException extends java.lang.IllegalStateException implements Serializable
  - Serialized Fields
    - error
```
java.lang.String error
```
    - graph
```
DirectedMultiGraph<V,E> graph
```
- Class edu.stanford.nlp.graph.DirectedMultiGraph extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  609823567298345145L
  - Serialized Fields
    - outgoingEdges
```
java.util.Map<K,V> outgoingEdges
```
    - incomingEdges
```
java.util.Map<K,V> incomingEdges
```
    - outerMapFactory
```
MapFactory<K,V> outerMapFactory
```
    - innerMapFactory
```
MapFactory<K,V> innerMapFactory
```
Package edu.stanford.nlp.ie
- Class edu.stanford.nlp.ie.ChineseMorphFeatureSets extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -1055526945031459198L
  - Serialized Fields
    - featIndex
```
Index<E> featIndex
```
    - singletonFeatures
```
java.util.Map<K,V> singletonFeatures
```
    - affixFeatures
```
java.util.Map<K,V> affixFeatures
```
- Class edu.stanford.nlp.ie.EmbeddingFeatureFactory extends FeatureFactory implements Serializable
- Class edu.stanford.nlp.ie.KBPStatisticalExtractor extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - classifier
```
Classifier<L,F> classifier
```
      The implementing classifier of this extractor.
- Class edu.stanford.nlp.ie.NERFeatureFactory extends FeatureFactory<IN extends CoreLabel> implements Serializable
  
  serialVersionUID:
  
  -2329726064739185544L
  - Serialized Fields
    - lexicon
```
java.util.Map<K,V> lexicon
```
    - wordToSubstrings
```
java.util.Map<K,V> wordToSubstrings
```
    - wordToGazetteEntries
```
java.util.Map<K,V> wordToGazetteEntries
```
    - wordToGazetteInfos
```
java.util.Map<K,V> wordToGazetteInfos
```
    - genericAnnotationKeys
```
java.util.Set<E> genericAnnotationKeys
```
    - lastNames
```
java.util.Set<E> lastNames
```
    - maleNames
```
java.util.Set<E> maleNames
```
    - femaleNames
```
java.util.Set<E> femaleNames
```
    - titlePattern
```
java.util.regex.Pattern titlePattern
```
Package edu.stanford.nlp.ie.crf
- Class edu.stanford.nlp.ie.crf.CRFDatum extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -8345554365027671190L
  - Serialized Fields
    - features
```
java.util.List<E> features
```
      Features for this Datum.
    - label
```
java.lang.Object label
```
    - featureVals
```
java.util.List<E> featureVals
```
- Class edu.stanford.nlp.ie.crf.CRFLabel extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7403010868396790276L
  - Serialized Fields
    - label
```
int[] label
```
    - hashCode
```
int hashCode
```
- Class edu.stanford.nlp.ie.crf.LabelDictionary extends java.lang.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
```
java.util.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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4011478706866593869L
  - Serialized Fields
    - classifier
```
CRFClassifier<IN extends CoreMap> classifier
```
    - gazetteerLocation
```
java.lang.String gazetteerLocation
```
    - annotationsToSkip
```
java.util.Set<E> annotationsToSkip
```
    - useSubTypes
```
boolean useSubTypes
```
    - useBIO
```
boolean useBIO
```
    - entityMentionFactory
```
EntityMentionFactory entityMentionFactory
```
    - logger
```
java.util.logging.Logger logger
```
    - useNERTags
```
boolean useNERTags
```
- Class edu.stanford.nlp.ie.machinereading.BasicRelationExtractor extends java.lang.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
```
java.lang.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
```
java.util.List<E> featureList
```
- Class edu.stanford.nlp.ie.machinereading.ExtractorMerger extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - extractors
```
Extractor[] extractors
```
- Class edu.stanford.nlp.ie.machinereading.NilLabelValidator extends java.lang.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 java.lang.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
```
java.util.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
```
java.lang.String mentionType
```
      Mention type, if available, e.g., nominal
    - corefID
```
java.lang.String corefID
```
    - headTokenSpan
```
Span headTokenSpan
```
      Offsets the head span, e.g., "George Bush" in the extent "the president George Bush" The offsets are relative to the sentence containing this mention
    - syntacticHeadTokenPosition
```
int syntacticHeadTokenPosition
```
      Position of the syntactic head word of this mention, e.g., "Bush" for the head span "George Bush" The offset is relative the sentence containing this mention Note: use headTokenSpan when sequence tagging entity mentions not this. This is meant to be used only for event/relation feature extraction!
    - normalizedName
```
java.lang.String normalizedName
```
- Class edu.stanford.nlp.ie.machinereading.structure.EntityMentionFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  47894791411048523L
- Class edu.stanford.nlp.ie.machinereading.structure.EventMention extends RelationMention implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - eventModification
```
java.lang.String eventModification
```
      Modifier argument: used for BioNLP
    - anchor
```
ExtractionObject anchor
```
    - parents
```
java.util.Set<E> parents
```
- Class edu.stanford.nlp.ie.machinereading.structure.ExtractionDataSet extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  201150461234284548L
  - Serialized Fields
    - sentences
```
java.util.List<E> sentences
```
- Class edu.stanford.nlp.ie.machinereading.structure.ExtractionObject extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - objectId
```
java.lang.String objectId
```
      Unique identifier of the object in its document
    - sentence
```
CoreMap sentence
```
      Sentence that contains this object This assumes that each extraction object is intra-sentential (true in ACE, Roth, BioNLP, MR)
    - type
```
java.lang.String type
```
      Type of this mention, e.g., GPE
    - subType
```
java.lang.String subType
```
      Subtype, if available, e.g., GPE.CITY
    - extentTokenSpan
```
Span extentTokenSpan
```
      Maximal token span relevant for this object, e.g., the largest NP for an entity mention The offsets are relative to the sentence that contains this object
    - attributeMap
```
CoreMap attributeMap
```
      This stores any optional attributes of ExtractionObjects
    - typeProbabilities
```
Counter<E> typeProbabilities
```
      Probabilities associated with this object We report probability values for each possible type for this object
- Class edu.stanford.nlp.ie.machinereading.structure.ExtractionSentence extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  87958315651919036L
  - Serialized Fields
    - documentId
```
java.lang.String documentId
```
      Id of the textual document containing this sentence
    - textContent
```
java.lang.String textContent
```
      Text of this sentence
    - relationMentions
```
java.util.List<E> relationMentions
```
      List of relation mentions in this sentence There are no ordering guarantees
    - entityMentions
```
java.util.List<E> entityMentions
```
      List of entity mentions in this sentence There are no ordering guarantees
    - eventMentions
```
java.util.List<E> eventMentions
```
      List of event mentions in this sentence There are no ordering guarantees
- Class edu.stanford.nlp.ie.machinereading.structure.RelationMention extends ExtractionObject implements Serializable
  
  serialVersionUID:
  
  8962289597607972827L
  - Serialized Fields
    - argNames
```
java.util.List<E> argNames
```
      List of argument names in this relation
    - args
```
java.util.List<E> args
```
      List of arguments in this relation If unnamed, arguments MUST be stored in semantic order, e.g., ARG0 must be a person in a employed-by relation
    - signature
```
java.lang.String signature
```
      A signature for a given relation mention, e.g., a concatenation of type and argument strings This is used in KBP, where we merge all RelationMentions corresponding to the same abstract relation
- Class edu.stanford.nlp.ie.machinereading.structure.RelationMentionFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -662846276208839290L
- Class edu.stanford.nlp.ie.machinereading.structure.Span extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -3861451490217976693L
  - Serialized Fields
    - start
```
int start
```
    - end
```
int end
```
Package edu.stanford.nlp.ie.ner.webapp
- Class edu.stanford.nlp.ie.ner.webapp.NERServlet extends javax.servlet.http.HttpServlet implements Serializable
  
  serialVersionUID:
  
  1584102147050497227L
  - Serialized Fields
    - format
```
java.lang.String format
```
    - spacing
```
boolean spacing
```
    - defaultClassifier
```
java.lang.String defaultClassifier
```
    - classifiers
```
java.util.List<E> classifiers
```
    - ners
```
java.util.Map<K,V> ners
```
Package edu.stanford.nlp.ie.util
- Class edu.stanford.nlp.ie.util.RelationTriple extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  43758623469716523L
  - Serialized Fields
    - subject
```
java.util.List<E> subject
```
      The subject (first argument) of this triple
    - canonicalSubject
```
java.util.List<E> canonicalSubject
```
      The subject (first argument) of this triple, in its canonical mention (i.e., coref resolved)
    - relation
```
java.util.List<E> relation
```
      The relation (second argument) of this triple. Note that this is only the part of the relation that can be grounded in the sentence itself. Often, for a standalone readable relation string, you want to attach additional modifiers otherwise stored in the dependnecy arc. Therefore, for getting a String form of the relation, we recommend using RelationTriple.relationGloss() or RelationTriple.relationLemmaGloss().
    - object
```
java.util.List<E> object
```
      The object (third argument) of this triple
    - canonicalObject
```
java.util.List<E> canonicalObject
```
      The object (third argument) of this triple, in its canonical mention (i.e., coref resolved).
    - istmod
```
boolean istmod
```
      A marker for the relation expressing a tmod not grounded in a word in the sentence.
    - prefixBe
```
boolean prefixBe
```
      A marker for the relation expressing a prefix "be" not grounded in a word in the sentence.
    - suffixBe
```
boolean suffixBe
```
      A marker for the relation expressing a suffix "be" not grounded in a word in the sentence.
    - suffixOf
```
boolean suffixOf
```
      A marker for the relation expressing a suffix "of" not grounded in a word in the sentence.
    - confidence
```
double confidence
```
      An optional score (confidence) for this triple
- Class edu.stanford.nlp.ie.util.RelationTriple.WithLink extends RelationTriple.WithTree implements Serializable
  - Serialized Fields
    - subjectLink
```
java.util.Optional<T> subjectLink
```
      The canonical entity link of the subject
    - objectLink
```
java.util.Optional<T> objectLink
```
      The canonical entity link of the object
- Class edu.stanford.nlp.ie.util.RelationTriple.WithTree extends RelationTriple implements Serializable
  - Serialized Fields
    - sourceTree
```
SemanticGraph sourceTree
```
Package edu.stanford.nlp.international.arabic
- Class edu.stanford.nlp.international.arabic.ArabicMorphoFeatureSpecification extends MorphoFeatureSpecification implements Serializable
  
  serialVersionUID:
  
  4448045447200922076L
- Class edu.stanford.nlp.international.arabic.ArabicMorphoFeatureSpecification.ArabicMorphoFeatures extends MorphoFeatures implements Serializable
  
  serialVersionUID:
  
  -4611776415583633186L
- Class edu.stanford.nlp.international.arabic.ArabicWordLists extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2752179429568209320L
- Class edu.stanford.nlp.international.arabic.Buckwalter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4351710914246859336L
  - Serialized Fields
    - outputUnicodeValues
```
boolean outputUnicodeValues
```
      If true (include flag "-o"), outputs space separated unicode values (e.g., "ء" rather than the character version of those values. Only applicable for Buckwalter to Arabic conversion.
    - unicode2Buckwalter
```
boolean unicode2Buckwalter
```
    - u2bMap
```
java.util.Map<K,V> u2bMap
```
    - b2uMap
```
java.util.Map<K,V> b2uMap
```
    - unmappable
```
ClassicCounter<E> unmappable
```

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

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

serialVersionUID:: -3798804368296999785L

Serialized Fields

utf8ArabicChart
```
java.util.regex.Pattern utf8ArabicChart
```
bwAlefChar
```
java.lang.String bwAlefChar
```
bwDiacritics
```
java.util.regex.Pattern bwDiacritics
```
bwTatweel
```
java.util.regex.Pattern bwTatweel
```
bwAlef
```
java.util.regex.Pattern bwAlef
```
bwQuran
```
java.util.regex.Pattern bwQuran
```

bwNullAnaphoraMarker

java.util.regex.Pattern bwNullAnaphoraMarker

latinPunc
```
java.util.regex.Pattern latinPunc
```
arabicPunc
```
java.util.regex.Pattern arabicPunc
```
arabicDigit
```
java.util.regex.Pattern arabicDigit
```
utf8Diacritics
```
java.util.regex.Pattern utf8Diacritics
```
utf8Tatweel
```
java.util.regex.Pattern utf8Tatweel
```
utf8Alef
```
java.util.regex.Pattern utf8Alef
```
utf8Quran
```
java.util.regex.Pattern utf8Quran
```
utf8ProDrop
```
java.util.regex.Pattern utf8ProDrop
```

segmentationMarker

java.util.regex.Pattern segmentationMarker

morphemeBoundary

java.util.regex.Pattern morphemeBoundary

hasDigit
```
java.util.regex.Pattern hasDigit
```
useATBVocalizedSectionMapping
```
boolean useATBVocalizedSectionMapping
```
stripMorphemeMarkersInUTF8
```
boolean stripMorphemeMarkersInUTF8
```
stripSegmentationMarkersInUTF8
```
boolean stripSegmentationMarkersInUTF8
```
parentTagString
```
java.lang.String parentTagString
```
parentTagsToEscape
```
java.util.Set<E> parentTagsToEscape
```
utf8CliticString
```
java.lang.String utf8CliticString
```
bwClitics
```
java.util.Set<E> bwClitics
```

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

serialVersionUID:

-8702531532523913125L

Package edu.stanford.nlp.international.arabic.process
- Class edu.stanford.nlp.international.arabic.process.ArabicDocumentReaderAndWriter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3667837672769424178L
  - Serialized Fields
    - factory
```
IteratorFromReaderFactory<T> factory
```
    - tf
```
TokenizerFactory<T> tf
```
    - segMarker
```
java.lang.Character segMarker
```
    - inputHasTags
```
boolean inputHasTags
```
    - inputHasDomainLabels
```
boolean inputHasDomainLabels
```
    - inputDomain
```
java.lang.String inputDomain
```
    - shouldStripRewrites
```
boolean shouldStripRewrites
```
- Class edu.stanford.nlp.international.arabic.process.ArabicSegmenter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4791848633597417788L
  - Serialized Fields
    - flags
```
SeqClassifierFlags flags
```
    - tf
```
TokenizerFactory<T> tf
```
    - prefixMarker
```
java.lang.String prefixMarker
```
    - suffixMarker
```
java.lang.String suffixMarker
```
    - isTokenized
```
boolean isTokenized
```
    - tokenizerOptions
```
java.lang.String tokenizerOptions
```
    - tedEvalPrefix
```
java.lang.String tedEvalPrefix
```
    - hasDomainLabels
```
boolean hasDomainLabels
```
    - domain
```
java.lang.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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  946818805507187330L
  - Serialized Fields
    - factory
```
LexedTokenFactory<T> factory
```
    - lexerProperties
```
java.util.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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  946818805507187330L
  - Serialized Fields
    - factory
```
LexedTokenFactory<T> factory
```
    - lexerProperties
```
java.util.Properties lexerProperties
```
    - splitCompoundOption
```
boolean splitCompoundOption
```
    - splitContractionOption
```
boolean splitContractionOption
```
Package edu.stanford.nlp.international.morph
- Class edu.stanford.nlp.international.morph.MorphoFeatures extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -3893316324305154940L
  - Serialized Fields
    - fSpec
```
java.util.Map<K,V> fSpec
```
    - altTag
```
java.lang.String altTag
```
- Class edu.stanford.nlp.international.morph.MorphoFeatureSpecification extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -5720683653931585664L
  - Serialized Fields
    - activeFeatures
```
java.util.Set<E> activeFeatures
```
Package edu.stanford.nlp.international.spanish
- Class edu.stanford.nlp.international.spanish.SpanishVerbStripper extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4780144226395772354L
  - Serialized Fields
    - dict
```
java.util.HashMap<K,V> dict
```
Package edu.stanford.nlp.international.spanish.process
- Class edu.stanford.nlp.international.spanish.process.SpanishTokenizer.SpanishTokenizerFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  946818805507187330L
  - Serialized Fields
    - factory
```
LexedTokenFactory<T> factory
```
    - lexerProperties
```
java.util.Properties lexerProperties
```
    - splitCompoundOption
```
boolean splitCompoundOption
```
    - splitVerbOption
```
boolean splitVerbOption
```
    - splitContractionOption
```
boolean splitContractionOption
```
Package edu.stanford.nlp.io
- Class edu.stanford.nlp.io.RuntimeIOException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  -8572218999165094626L

Package edu.stanford.nlp.io.ui

Class edu.stanford.nlp.io.ui.OpenPageDialog extends javax.swing.JDialog implements Serializable

serialVersionUID:: -7987625449997527926L

Serialized Fields

jfc
```
javax.swing.JFileChooser jfc
```
status
```
int status
```
urlTextField
```
javax.swing.JTextField urlTextField
```
openButton
```
javax.swing.JButton openButton
```
jLabel1
```
javax.swing.JLabel jLabel1
```
jPanel3
```
javax.swing.JPanel jPanel3
```
jLabel2
```
javax.swing.JLabel jLabel2
```
jPanel2
```
javax.swing.JPanel jPanel2
```
cancelButton
```
javax.swing.JButton cancelButton
```
browseButton
```
javax.swing.JButton browseButton
```
jPanel1
```
javax.swing.JPanel jPanel1
```

Package edu.stanford.nlp.ling
- Class edu.stanford.nlp.ling.BasicDatum extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4857004070061779966L
  - Serialized Fields
    - features
```
java.util.Collection<E> features
```
      features for this Datum
    - labels
```
java.util.List<E> labels
```
      labels for this Datum. Invariant: always non-null
- Class edu.stanford.nlp.ling.BasicDocument extends java.util.ArrayList<Word> implements Serializable
  
  serialVersionUID:
  
  -24171720584352262L
  - Serialized Fields
    - title
```
java.lang.String title
```
      title of this document (never null).
    - originalText
```
java.lang.String originalText
```
      original text of this document (may be null).
    - labels
```
java.util.List<E> labels
```
      Label(s) for this document.
    - tokenizerFactory
```
TokenizerFactory<T> tokenizerFactory
```
      TokenizerFactory used to convert the text into words inside BasicDocument.parse(String).
- Class edu.stanford.nlp.ling.CategoryWordTag extends StringLabel implements Serializable
  
  serialVersionUID:
  
  -745085381666943254L
  - Serialized Fields
    - word
```
java.lang.String word
```
    - tag
```
java.lang.String tag
```
- Class edu.stanford.nlp.ling.CoreLabel extends ArrayCoreMap implements Serializable
  
  serialVersionUID:
  
  2L
- Class edu.stanford.nlp.ling.IndexedWord extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3739633991145239829L
  - Serialized Fields
    - label
```
CoreLabel label
```
    - copyCount
```
int copyCount
```
    - numCopies
```
int numCopies
```
    - original
```
IndexedWord original
```
      Stores the original IndexedWord when you make copy nodes.
    - pseudoPosition
```
double pseudoPosition
```
      Useful for specifying a fine-grained position when butchering parse trees. The canonical use case for this is resolving coreference in the OpenIE system, where we want to move nodes between sentences, but do not want to change their index annotation (plus, we need to have multiple nodes fit into the space of one pronoun).
    - cachedHashCode
```
int cachedHashCode
```
- Class edu.stanford.nlp.ling.LabeledWord extends Word implements Serializable
  
  serialVersionUID:
  
  -7252006452127051085L
  - Serialized Fields
    - tag
```
Label tag
```
- Class edu.stanford.nlp.ling.MultiTokenTag extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - tag
```
MultiTokenTag.Tag tag
```
    - index
```
int index
```
- Class edu.stanford.nlp.ling.MultiTokenTag.Tag extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - name
```
java.lang.String name
```
    - tag
```
java.lang.String tag
```
    - length
```
int length
```
- Class edu.stanford.nlp.ling.RVFDatum extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -255312811814660438L
  - Serialized Fields
    - features
```
Counter<E> features
```
      features for this Datum
    - label
```
java.lang.Object label
```
      labels for this Datum. Invariant: always non-null
    - id
```
java.lang.String id
```
      Id of this instance
- Class edu.stanford.nlp.ling.StringLabel extends ValueLabel implements Serializable
  
  serialVersionUID:
  
  -4153619273767524247L
  - Serialized Fields
    - str
```
java.lang.String str
```
    - beginPosition
```
int beginPosition
```
      Start position of the word in the original input string
    - endPosition
```
int endPosition
```
      End position of the word in the original input string
- Class edu.stanford.nlp.ling.Tag extends StringLabel implements Serializable
  
  serialVersionUID:
  
  1143434026005416755L
- Class edu.stanford.nlp.ling.TaggedWord extends Word implements Serializable
  
  serialVersionUID:
  
  -7252006452127051085L
  - Serialized Fields
    - tag
```
java.lang.String tag
```
- Class edu.stanford.nlp.ling.ValueLabel extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -1413303679077285530L
- Class edu.stanford.nlp.ling.Word extends StringLabel implements Serializable
  
  serialVersionUID:
  
  -4817252915997034058L
- Class edu.stanford.nlp.ling.WordLemmaTag extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -5993410244163988138L
  - Serialized Fields
    - word
```
java.lang.String word
```
    - lemma
```
java.lang.String lemma
```
    - tag
```
java.lang.String tag
```
- Class edu.stanford.nlp.ling.WordTag extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -1859527239216813742L
  - Serialized Fields
    - word
```
java.lang.String word
```
    - tag
```
java.lang.String tag
```
Package edu.stanford.nlp.ling.tokensregex
- Class edu.stanford.nlp.ling.tokensregex.ComplexNodePattern extends NodePattern<M> implements Serializable
  - Serialized Fields
    - annotationPatterns
```
java.util.List<E> annotationPatterns
```
    - getter
```
java.util.function.BiFunction<T,U,R> getter
```
- Class edu.stanford.nlp.ling.tokensregex.ComplexNodePattern.AbstractStringAnnotationPattern extends NodePattern<java.lang.String> implements Serializable
  - Serialized Fields
    - flags
```
int flags
```
- Class edu.stanford.nlp.ling.tokensregex.ComplexNodePattern.IntegerAnnotationPattern extends NodePattern<java.lang.Integer> implements Serializable
  - Serialized Fields
    - value
```
int value
```
- Class edu.stanford.nlp.ling.tokensregex.ComplexNodePattern.NilAnnotationPattern extends NodePattern<java.lang.Object> implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.ComplexNodePattern.NotNilAnnotationPattern extends NodePattern<java.lang.Object> implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.ComplexNodePattern.NumericAnnotationPattern extends NodePattern<java.lang.Object> implements Serializable
  - Serialized Fields
    - cmpType
```
edu.stanford.nlp.ling.tokensregex.ComplexNodePattern.NumericAnnotationPattern.CmpType cmpType
```
    - value
```
double value
```
- Class edu.stanford.nlp.ling.tokensregex.ComplexNodePattern.SequenceRegexPattern extends NodePattern<java.util.List<T>> implements Serializable
  - Serialized Fields
    - pattern
```
SequencePattern<T> pattern
```
- Class edu.stanford.nlp.ling.tokensregex.ComplexNodePattern.StringAnnotationPattern extends ComplexNodePattern.AbstractStringAnnotationPattern implements Serializable
  - Serialized Fields
    - target
```
java.lang.String target
```
- Class edu.stanford.nlp.ling.tokensregex.ComplexNodePattern.StringAnnotationRegexPattern extends NodePattern<java.lang.String> implements Serializable
  - Serialized Fields
    - pattern
```
java.util.regex.Pattern pattern
```
- Class edu.stanford.nlp.ling.tokensregex.ComplexNodePattern.StringInSetAnnotationPattern extends ComplexNodePattern.AbstractStringAnnotationPattern implements Serializable
  - Serialized Fields
    - targets
```
java.util.Set<E> targets
```
- Class edu.stanford.nlp.ling.tokensregex.CoreMapExpressionNodePattern extends NodePattern<CoreMap> implements Serializable
  - Serialized Fields
    - env
```
Env env
```
    - expression
```
Expression expression
```
- Class edu.stanford.nlp.ling.tokensregex.CoreMapNodePattern extends ComplexNodePattern<CoreMap,java.lang.Class> implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.MapNodePattern extends ComplexNodePattern<M extends java.util.Map<K,java.lang.Object>,K> implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.NodePattern extends java.lang.Object implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.NodePattern.AnyNodePattern extends NodePattern<T> implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.NodePattern.ConjNodePattern extends NodePattern<T> implements Serializable
  - Serialized Fields
    - nodePatterns
```
java.util.List<E> nodePatterns
```
- Class edu.stanford.nlp.ling.tokensregex.NodePattern.DisjNodePattern extends NodePattern<T> implements Serializable
  - Serialized Fields
    - nodePatterns
```
java.util.List<E> nodePatterns
```
- Class edu.stanford.nlp.ling.tokensregex.NodePattern.EqualsNodePattern extends NodePattern<T> implements Serializable
  - Serialized Fields
    - t
```
java.lang.Object t
```
- Class edu.stanford.nlp.ling.tokensregex.NodePattern.NegateNodePattern extends NodePattern<T> implements Serializable
  - Serialized Fields
    - p
```
NodePattern<T> p
```
- Class edu.stanford.nlp.ling.tokensregex.PhraseTable extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - rootTree
```
java.util.Map<K,V> rootTree
```
    - normalize
```
boolean normalize
```
    - caseInsensitive
```
boolean caseInsensitive
```
    - ignorePunctuation
```
boolean ignorePunctuation
```
    - ignorePunctuationTokens
```
boolean ignorePunctuationTokens
```
    - tokenizer
```
Annotator tokenizer
```
    - nPhrases
```
int nPhrases
```
    - nStrings
```
int nStrings
```
    - MAX_LIST_SIZE
```
int MAX_LIST_SIZE
```
- Class edu.stanford.nlp.ling.tokensregex.SequenceMatchRules.AnnotationExtractRule extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -2148125332223720424L
  - Serialized Fields
    - name
```
java.lang.String name
```
      Name of the rule
    - stage
```
int stage
```
      Stage in which this rule should be applied with respect to others
    - priority
```
double priority
```
      Priority in which this rule should be applied with respect to others
    - weight
```
double weight
```
      Weight given to the rule (how likely is this rule to fire)
    - annotationField
```
java.lang.Class<T> annotationField
```
      Annotation field to apply rule over: text or tokens or numerizedtokens
    - tokensAnnotationField
```
java.lang.Class<T> tokensAnnotationField
```
    - tokensResultAnnotationField
```
java.util.List<E> tokensResultAnnotationField
```
      Annotation field(s) on individual tokens to put new annotation
    - resultAnnotationField
```
java.util.List<E> resultAnnotationField
```
      Annotation field(s) to put new annotation
    - resultNestedAnnotationField
```
java.lang.Class<T> resultNestedAnnotationField
```
      Annotation field for child/nested annotations
    - matchFindType
```
SequenceMatcher.FindType matchFindType
```
    - matchedExpressionGroup
```
int matchedExpressionGroup
```
      Which group to take as the matched expression - default is 0
    - matchWithResults
```
boolean matchWithResults
```
    - ruleType
```
java.lang.String ruleType
```
      Type of rule to apply: token string match, pattern string match
    - isComposite
```
boolean isComposite
```
    - includeNested
```
boolean includeNested
```
    - active
```
boolean active
```
    - extractRule
```
SequenceMatchRules.ExtractRule<I,O> extractRule
```
      Actual rule performing the extraction (converting annotation to MatchedExpression)
    - filterRule
```
java.util.function.Predicate<T> filterRule
```
    - pattern
```
java.lang.Object pattern
```
      Pattern - the type of which is dependent on the rule type
    - result
```
Expression result
```
- Class edu.stanford.nlp.ling.tokensregex.SequenceMatchRules.AnnotationMatchedFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -2085736376364259354L
  - Serialized Fields
    - extractor
```
MatchedExpression.SingleAnnotationExtractor extractor
```
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3484918485303693833L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream ois)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
    - writeObject
```
private void writeObject(java.io.ObjectOutputStream oos)
                  throws java.io.IOException
```
      Throws:
      
      java.io.IOException
  - Serialized Fields
    - patternStr
```
java.lang.String patternStr
```
    - patternExpr
```
SequencePattern.PatternExpr patternExpr
```
    - action
```
SequenceMatchAction<T> action
```
    - root
```
edu.stanford.nlp.ling.tokensregex.SequencePattern.State root
```
    - totalGroups
```
int totalGroups
```
    - varGroupBindings
```
edu.stanford.nlp.ling.tokensregex.SequencePattern.VarGroupBindings varGroupBindings
```
    - priority
```
double priority
```
    - weight
```
double weight
```
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.AndPatternExpr extends SequencePattern.PatternExpr implements Serializable
  
  serialVersionUID:
  
  -5470437627660213806L
  - Serialized Fields
    - patterns
```
java.util.List<E> patterns
```
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.BackRefPatternExpr extends SequencePattern.PatternExpr implements Serializable
  
  serialVersionUID:
  
  -4649629486266561619L
  - Serialized Fields
    - matcher
```
SequencePattern.NodesMatchChecker<T> matcher
```
    - captureGroupId
```
int captureGroupId
```
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.GroupPatternExpr extends SequencePattern.PatternExpr implements Serializable
  
  serialVersionUID:
  
  -6477601300665620926L
  - Serialized Fields
    - pattern
```
SequencePattern.PatternExpr pattern
```
    - capture
```
boolean capture
```
    - captureGroupId
```
int captureGroupId
```
    - varname
```
java.lang.String varname
```
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.MultiNodePatternExpr extends SequencePattern.PatternExpr implements Serializable
  - Serialized Fields
    - multiNodePattern
```
MultiNodePattern<T> multiNodePattern
```
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.NodePatternExpr extends SequencePattern.PatternExpr implements Serializable
  - Serialized Fields
    - nodePattern
```
NodePattern<T> nodePattern
```
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.OrPatternExpr extends SequencePattern.PatternExpr implements Serializable
  
  serialVersionUID:
  
  2566259662702631896L
  - Serialized Fields
    - patterns
```
java.util.List<E> patterns
```
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.PatternExpr extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7610237291757954879L
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.RepeatPatternExpr extends SequencePattern.PatternExpr implements Serializable
  
  serialVersionUID:
  
  3935482630250147745L
  - Serialized Fields
    - pattern
```
SequencePattern.PatternExpr pattern
```
    - minMatch
```
int minMatch
```
    - maxMatch
```
int maxMatch
```
    - greedyMatch
```
boolean greedyMatch
```
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.SequenceEndPatternExpr extends SequencePattern.SpecialNodePatternExpr implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.SequencePatternExpr extends SequencePattern.PatternExpr implements Serializable
  
  serialVersionUID:
  
  7446769896088599604L
  - Serialized Fields
    - patterns
```
java.util.List<E> patterns
```
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.SequenceStartPatternExpr extends SequencePattern.SpecialNodePatternExpr implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.SpecialNodePatternExpr extends SequencePattern.PatternExpr implements Serializable
  
  serialVersionUID:
  
  3347587132602082616L
  - Serialized Fields
    - name
```
java.lang.String name
```
    - stateFactory
```
Factory<T> stateFactory
```
- Class edu.stanford.nlp.ling.tokensregex.SequencePattern.ValuePatternExpr extends SequencePattern.PatternExpr implements Serializable
  - Serialized Fields
    - expr
```
SequencePattern.PatternExpr expr
```
    - value
```
java.lang.Object value
```
- Class edu.stanford.nlp.ling.tokensregex.TokenSequencePattern extends SequencePattern<CoreMap> implements Serializable
  
  serialVersionUID:
  
  -4760710834202406916L
Package edu.stanford.nlp.ling.tokensregex.parser
- Class edu.stanford.nlp.ling.tokensregex.parser.ParseException extends java.lang.Exception implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - currentToken
```
edu.stanford.nlp.ling.tokensregex.parser.Token currentToken
```
      This is the last token that has been consumed successfully. If this object has been created due to a parse error, the token following this token will (therefore) be the first error token.
    - expectedTokenSequences
```
int[][] expectedTokenSequences
```
      Each entry in this array is an array of integers. Each array of integers represents a sequence of tokens (by their ordinal values) that is expected at this point of the parse.
    - tokenImage
```
java.lang.String[] tokenImage
```
      This is a reference to the "tokenImage" array of the generated parser within which the parse error occurred. This array is defined in the generated ...Constants interface.
- Class edu.stanford.nlp.ling.tokensregex.parser.TokenSequenceParseException extends java.lang.Exception implements Serializable
Package edu.stanford.nlp.ling.tokensregex.types
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.AndExpression extends Expressions.FunctionCallExpression implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.AssignableFunctionCallExpression extends Expressions.FunctionCallExpression implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.CompositeValue extends Expressions.SimpleCachedExpression<java.util.Map<java.lang.String,Expression>> implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.FieldExpression extends Expressions.AssignableFunctionCallExpression implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.FunctionCallExpression extends Expressions.TypedExpression implements Serializable
  - Serialized Fields
    - function
```
java.lang.String function
```
    - params
```
java.util.List<E> params
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.IfExpression extends Expressions.TypedExpression implements Serializable
  - Serialized Fields
    - condExpr
```
Expression condExpr
```
    - trueExpr
```
Expression trueExpr
```
    - falseExpr
```
Expression falseExpr
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.IndexedExpression extends Expressions.AssignableFunctionCallExpression implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.ListExpression extends Expressions.TypedExpression implements Serializable
  - Serialized Fields
    - exprs
```
java.util.List<E> exprs
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.MethodCallExpression extends Expressions.TypedExpression implements Serializable
  - Serialized Fields
    - function
```
java.lang.String function
```
    - object
```
Expression object
```
    - params
```
java.util.List<E> params
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.NotExpression extends Expressions.FunctionCallExpression implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.OrExpression extends Expressions.FunctionCallExpression implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.PrimitiveValue extends Expressions.SimpleValue<T> implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.RegexMatchResultVarExpression extends Expressions.SimpleExpression implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.RegexMatchVarExpression extends Expressions.SimpleExpression implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.RegexValue extends Expressions.SimpleValue<java.lang.String> implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.SimpleCachedExpression extends Expressions.SimpleExpression<T> implements Serializable
  - Serialized Fields
    - evaluated
```
Value<T> evaluated
```
    - disableCaching
```
boolean disableCaching
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.SimpleExpression extends Expressions.TypedExpression implements Serializable
  - Serialized Fields
    - value
```
java.lang.Object value
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.SimpleValue extends Expressions.TypedExpression implements Serializable
  - Serialized Fields
    - value
```
java.lang.Object value
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.TypedExpression extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - typename
```
java.lang.String typename
```
    - tags
```
Tags tags
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.VarAssignmentExpression extends Expressions.TypedExpression implements Serializable
  - Serialized Fields
    - varName
```
java.lang.String varName
```
    - valueExpr
```
Expression valueExpr
```
    - bindAsValue
```
boolean bindAsValue
```
- Class edu.stanford.nlp.ling.tokensregex.types.Expressions.VarExpression extends Expressions.SimpleExpression<java.lang.String> implements Serializable
- Class edu.stanford.nlp.ling.tokensregex.types.Tags extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - tags
```
java.util.Map<K,V> tags
```
Package edu.stanford.nlp.loglinear.model.proto
- Class edu.stanford.nlp.loglinear.model.proto.ConcatVectorProto.ConcatVector extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - component_
```
java.util.List<E> component_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.loglinear.model.proto.ConcatVectorProto.ConcatVector.Component extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - sparse_
```
boolean sparse_
```
    - data_
```
com.google.protobuf.Internal.DoubleList data_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.loglinear.model.proto.ConcatVectorTableProto.ConcatVectorTable extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - dimensionSize_
```
com.google.protobuf.Internal.IntList dimensionSize_
```
    - factorTable_
```
java.util.List<E> factorTable_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.loglinear.model.proto.GraphicalModelProto.Factor extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - featuresTable_
```
ConcatVectorTableProto.ConcatVectorTable featuresTable_
```
    - neighbor_
```
com.google.protobuf.Internal.IntList neighbor_
```
    - metaData_
```
GraphicalModelProto.MetaData metaData_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.loglinear.model.proto.GraphicalModelProto.GraphicalModel extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - factor_
```
java.util.List<E> factor_
```
    - variableMetaData_
```
java.util.List<E> variableMetaData_
```
    - metaData_
```
GraphicalModelProto.MetaData metaData_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.loglinear.model.proto.GraphicalModelProto.MetaData extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - key_
```
com.google.protobuf.LazyStringList key_
```
    - value_
```
com.google.protobuf.LazyStringList value_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
Package edu.stanford.nlp.loglinear.storage
- Class edu.stanford.nlp.loglinear.storage.ModelBatch extends java.util.ArrayList<GraphicalModel> implements Serializable
Package edu.stanford.nlp.math
- Class edu.stanford.nlp.math.ArrayMath.InvalidElementException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  1647150702529757545L
- Class edu.stanford.nlp.math.DoubleAD extends java.lang.Number implements Serializable
  
  serialVersionUID:
  
  -5702334375099248894L
  - Serialized Fields
    - val
```
double val
```
    - dot
```
double dot
```
Package edu.stanford.nlp.naturalli
- Class edu.stanford.nlp.naturalli.NotTreeException extends java.lang.RuntimeException implements Serializable
  - Serialized Fields
    - brokenGraph
```
SemanticGraph brokenGraph
```
    - originalGraph
```
SemanticGraph originalGraph
```
Package edu.stanford.nlp.naturalli.demo
- Class edu.stanford.nlp.naturalli.demo.OpenIEServlet extends javax.servlet.http.HttpServlet implements Serializable
  - Serialized Fields
    - pipeline
```
StanfordCoreNLP pipeline
```
    - backoff
```
StanfordCoreNLP backoff
```
Package edu.stanford.nlp.neural
- Class edu.stanford.nlp.neural.Embedding extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4925779982530239054L
  - Serialized Fields
    - wordVectors
```
java.util.Map<K,V> wordVectors
```
    - embeddingSize
```
int embeddingSize
```
- Class edu.stanford.nlp.neural.SimpleTensor extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - slices
```
org.ejml.simple.SimpleMatrix[] slices
```
    - numRows
```
int numRows
```
    - numCols
```
int numCols
```
    - numSlices
```
int numSlices
```
- Class edu.stanford.nlp.neural.VectorMap extends java.util.HashMap<java.lang.String,float[]> implements Serializable
Package edu.stanford.nlp.objectbank
- Class edu.stanford.nlp.objectbank.DelimitRegExIterator.DelimitRegExIteratorFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  6846060575832573082L
  - Serialized Fields
    - delim
```
java.lang.String delim
```
    - op
```
java.util.function.Function<T,R> op
```
- Class edu.stanford.nlp.objectbank.LineIterator.LineIteratorFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - function
```
java.util.function.Function<T,R> function
```
- Class edu.stanford.nlp.objectbank.ObjectBank extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4030295596701541770L
  - Serialized Fields
    - rif
```
ReaderIteratorFactory rif
```
    - ifrf
```
IteratorFromReaderFactory<T> ifrf
```
    - contents
```
java.util.List<E> contents
```
    - keepInMemory
```
boolean keepInMemory
```
Package edu.stanford.nlp.optimization
- Class edu.stanford.nlp.optimization.QNMinimizer.SurpriseConvergence extends java.lang.Exception implements Serializable
  
  serialVersionUID:
  
  4290178321643529559L
- Class edu.stanford.nlp.optimization.ScaledSGDMinimizer.Weights extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  814182172645533781L
  - Serialized Fields
    - w
```
double[] w
```
    - d
```
double[] d
```
- Class edu.stanford.nlp.optimization.SGDToQNMinimizer extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -7551807670291500396L
  - Serialized Fields
    - bSize
```
int bSize
```
    - quiet
```
boolean quiet
```
    - outputIterationsToFile
```
boolean outputIterationsToFile
```
    - gain
```
double gain
```
    - SGDPasses
```
int SGDPasses
```
    - QNPasses
```
int QNPasses
```
    - hessSampleSize
```
int hessSampleSize
```
    - QNMem
```
int QNMem
```
Package edu.stanford.nlp.parser.common
- Class edu.stanford.nlp.parser.common.NoSuchParseException extends java.util.NoSuchElementException implements Serializable
  
  serialVersionUID:
  
  2L
- Class edu.stanford.nlp.parser.common.ParserConstraint extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - start
```
int start
```
    - end
```
int end
```
    - state
```
java.util.regex.Pattern state
```
Package edu.stanford.nlp.parser.dvparser
- Class edu.stanford.nlp.parser.dvparser.CombinedDVModelReranker extends java.lang.Object implements Serializable
  - Serialized Fields
    - op
```
Options op
```
    - models
```
java.util.List<E> models
```
- Class edu.stanford.nlp.parser.dvparser.DVModel extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - binaryTransform
```
TwoDimensionalMap<K1,K2,V> binaryTransform
```
    - unaryTransform
```
java.util.Map<K,V> unaryTransform
```
    - binaryScore
```
TwoDimensionalMap<K1,K2,V> binaryScore
```
    - unaryScore
```
java.util.Map<K,V> unaryScore
```
    - wordVectors
```
java.util.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
```
java.util.Random rand
```
- Class edu.stanford.nlp.parser.dvparser.DVModelReranker extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7897546308624261207L
  - Serialized Fields
    - op
```
Options op
```
    - model
```
DVModel model
```
- Class edu.stanford.nlp.parser.dvparser.FilterConfusingRules extends java.lang.Object implements Serializable
  - Serialized Fields
    - unaryRules
```
java.util.Set<E> unaryRules
```
    - binaryRules
```
TwoDimensionalSet<K1,K2> binaryRules
```
Package edu.stanford.nlp.parser.lexparser
- Class edu.stanford.nlp.parser.lexparser.AbstractDependencyGrammar extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream ois)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
  - Serialized Fields
    - tagProjection
```
TagProjection tagProjection
```
    - tagIndex
```
Index<E> tagIndex
```
    - wordIndex
```
Index<E> wordIndex
```
    - numTagBins
```
int numTagBins
```
    - tagBin
```
int[] tagBin
```
    - tlp
```
TreebankLanguagePack tlp
```
    - directional
```
boolean directional
```
    - useDistance
```
boolean useDistance
```
    - useCoarseDistance
```
boolean useCoarseDistance
```
    - lex
```
Lexicon lex
```
    - stopTW
```
IntTaggedWord stopTW
```
    - wildTW
```
IntTaggedWord wildTW
```
    - coarseDistanceBins
```
int[] coarseDistanceBins
```
    - regDistanceBins
```
int[] regDistanceBins
```
    - op
```
Options op
```
- Class edu.stanford.nlp.parser.lexparser.AbstractTreebankParserParams extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4299501909017975915L
  - Serialized Fields
    - evalGF
```
boolean evalGF
```
      If true, then evaluation is over grammatical functions as well as the labels If false, then grammatical functions are stripped for evaluation. This really only makes sense if you've trained with grammatical functions but want to evaluate without them.
    - inputEncoding
```
java.lang.String inputEncoding
```
    - outputEncoding
```
java.lang.String outputEncoding
```
    - tlp
```
TreebankLanguagePack tlp
```
    - generateOriginalDependencies
```
boolean generateOriginalDependencies
```
- Class edu.stanford.nlp.parser.lexparser.AbstractTreebankParserParams.AnnotatePunctuationFunction extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - key
```
java.lang.String key
```
    - annotationMark
```
java.lang.String annotationMark
```
- Class edu.stanford.nlp.parser.lexparser.ArabicTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  8853426784197984653L
  - Serialized Fields
    - optionsString
```
java.lang.StringBuilder optionsString
```
    - retainNPTmp
```
boolean retainNPTmp
```
    - retainNPSbj
```
boolean retainNPSbj
```
    - retainPRD
```
boolean retainPRD
```
    - retainPPClr
```
boolean retainPPClr
```
    - changeNoLabels
```
boolean changeNoLabels
```
    - collinizerRetainsPunctuation
```
boolean collinizerRetainsPunctuation
```
    - discardX
```
boolean discardX
```
    - headFinder
```
HeadFinder headFinder
```
    - annotationPatterns
```
java.util.Map<K,V> annotationPatterns
```
    - activeAnnotations
```
java.util.List<E> activeAnnotations
```
    - morphoSpec
```
MorphoFeatureSpecification morphoSpec
```
    - baselineFeatures
```
java.util.List<E> baselineFeatures
```
      These are the annotations included when the user selects the -arabicFactored option.
    - additionalFeatures
```
java.util.List<E> additionalFeatures
```
- Class edu.stanford.nlp.parser.lexparser.ArabicUnknownWordModel extends BaseUnknownWordModel implements Serializable
  
  serialVersionUID:
  
  4825624957364628771L
  - Serialized Fields
    - smartMutation
```
boolean smartMutation
```
    - unknownSuffixSize
```
int unknownSuffixSize
```
    - unknownPrefixSize
```
int unknownPrefixSize
```
- Class edu.stanford.nlp.parser.lexparser.BaseLexicon extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  40L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream ois)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
  - Serialized Fields
    - uwModel
```
UnknownWordModel uwModel
```
    - uwModelTrainerClass
```
java.lang.String uwModelTrainerClass
```
    - trainOptions
```
TrainOptions trainOptions
```
    - testOptions
```
TestOptions testOptions
```
    - op
```
Options op
```
    - smoothInUnknownsThreshold
```
int smoothInUnknownsThreshold
```
      If a word has been seen more than this many times, then relative frequencies of tags are used for POS assignment; if not, they are smoothed with tag priors.
    - smartMutation
```
boolean smartMutation
```
      Have tags changeable based on statistics on word types having various taggings.
    - wordIndex
```
Index<E> wordIndex
```
    - tagIndex
```
Index<E> tagIndex
```
    - seenCounter
```
ClassicCounter<E> seenCounter
```
      Records the number of times word/tag pair was seen in training data. Includes word/tag pairs where one is a wildcard not a real word/tag.
    - smooth
```
double[] smooth
```
    - flexiTag
```
boolean flexiTag
```
    - useSignatureForKnownSmoothing
```
boolean useSignatureForKnownSmoothing
```
    - baseTagCounts
```
java.util.Map<K,V> baseTagCounts
```
      Only used when training, specifically when training on sentences that weren't part of annotated (e.g., markovized, etc.) data.
    - tagsToBaseTags
```
int[] tagsToBaseTags
```
- Class edu.stanford.nlp.parser.lexparser.BaseUnknownWordModel extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  6355171148751673822L
  - Serialized Fields
    - useFirst
```
boolean useFirst
```
    - useEnd
```
boolean useEnd
```
    - useGT
```
boolean useGT
```
    - useFirstCap
```
boolean useFirstCap
```
    - endLength
```
int endLength
```
    - unknownLevel
```
int unknownLevel
```
      What type of equivalence classing is done in getSignature
    - trainOptions
```
TrainOptions trainOptions
```
    - wordIndex
```
Index<E> wordIndex
```
    - tagIndex
```
Index<E> tagIndex
```
    - unSeenCounter
```
ClassicCounter<E> unSeenCounter
```
      Has counts for taggings in terms of unseen signatures. The IntTagWords are for (tag,sig), (tag,null), (null,sig), (null,null). (None for basic UNK if there are signatures.)
    - tagHash
```
java.util.Map<K,V> tagHash
```
      This maps from a tag (as a label) to a Counter from word signatures to their P(sig|tag), as estimated in the model. For Chinese, the word signature is just the first character or its unicode type for things that aren't Chinese characters.
    - seenEnd
```
java.util.Set<E> seenEnd
```
      This is the set of all signatures that we have seen.
    - unknownGT
```
java.util.Map<K,V> unknownGT
```
    - lex
```
Lexicon lex
```
      All classes that implement UnknownWordModel must call the constructor that initializes this variable.
- Class edu.stanford.nlp.parser.lexparser.BasicCategoryTagProjection extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -2322431101811335089L
  - Serialized Fields
    - tlp
```
TreebankLanguagePack tlp
```
- Class edu.stanford.nlp.parser.lexparser.BinaryGrammar extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
  - Serialized Fields
    - index
```
Index<E> index
```
    - allRules
```
java.util.List<E> allRules
```
- Class edu.stanford.nlp.parser.lexparser.BinaryHeadFinder extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4794072338791804184L
  - Serialized Fields
    - fallbackHF
```
HeadFinder fallbackHF
```
- Class edu.stanford.nlp.parser.lexparser.BinaryRule extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - parent
```
int parent
```
    - score
```
float score
```
      Score should be a log probability
    - leftChild
```
int leftChild
```
    - rightChild
```
int rightChild
```
    - hashCode
```
int hashCode
```
- Class edu.stanford.nlp.parser.lexparser.ChineseCharacterBasedLexicon extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -5357655683145854069L
  - Serialized Fields
    - lengthPenalty
```
double lengthPenalty
```
    - penaltyType
```
int penaltyType
```
    - charDistributions
```
java.util.Map<K,V> charDistributions
```
    - knownChars
```
java.util.Set<E> knownChars
```
    - POSDistribution
```
Distribution<E> POSDistribution
```
    - useUnknownCharacterModel
```
boolean useUnknownCharacterModel
```
    - wordIndex
```
Index<E> wordIndex
```
    - tagIndex
```
Index<E> tagIndex
```
- Class edu.stanford.nlp.parser.lexparser.ChineseLexicon extends BaseLexicon implements Serializable
  
  serialVersionUID:
  
  -7836464391021114960L
  - Serialized Fields
    - useCharBasedUnknownWordModel
```
boolean useCharBasedUnknownWordModel
```
    - useGoodTuringUnknownWordModel
```
boolean useGoodTuringUnknownWordModel
```
    - probRandomWalk
```
edu.stanford.nlp.parser.lexparser.RandomWalk probRandomWalk
```
- Class edu.stanford.nlp.parser.lexparser.ChineseLexiconAndWordSegmenter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -6554995189795187918L
  - Serialized Fields
    - chineseLexicon
```
ChineseLexicon chineseLexicon
```
    - wordSegmenter
```
WordSegmenter wordSegmenter
```
    - op
```
Options op
```
- Class edu.stanford.nlp.parser.lexparser.ChineseMarkovWordSegmenter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1559606198270645508L
  - Serialized Fields
    - initialPOSDist
```
Distribution<E> initialPOSDist
```
    - markovPOSDists
```
java.util.Map<K,V> markovPOSDists
```
    - lex
```
ChineseCharacterBasedLexicon lex
```
    - POSes
```
java.util.Set<E> POSes
```
    - wordIndex
```
Index<E> wordIndex
```
    - tagIndex
```
Index<E> tagIndex
```
- Class edu.stanford.nlp.parser.lexparser.ChineseMaxentLexicon extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  238834703409896852L
  - Serialized Fields
    - featExtractor
```
ChineseWordFeatureExtractor featExtractor
```
    - wordThreshold
```
Pair<T1,T2> wordThreshold
```
    - charThreshold
```
Pair<T1,T2> charThreshold
```
    - bigramThreshold
```
Pair<T1,T2> bigramThreshold
```
    - conjThreshold
```
Pair<T1,T2> conjThreshold
```
    - featureThresholds
```
java.util.List<E> featureThresholds
```
    - universalThreshold
```
int universalThreshold
```
    - scorer
```
LinearClassifier<L,F> scorer
```
    - functionWordTags
```
java.util.Map<K,V> functionWordTags
```
    - tagDist
```
Distribution<E> tagDist
```
    - wordIndex
```
Index<E> wordIndex
```
    - tagIndex
```
Index<E> tagIndex
```
    - iteratorCutoffFactor
```
double iteratorCutoffFactor
```
    - initialWeightFile
```
java.lang.String initialWeightFile
```
    - trainFloat
```
boolean trainFloat
```
    - tol
```
double tol
```
    - sigma
```
double sigma
```
    - featureLevel
```
int featureLevel
```
    - trainOnLowCount
```
boolean trainOnLowCount
```
    - trainByType
```
boolean trainByType
```
    - tlpParams
```
TreebankLangParserParams tlpParams
```
    - ctlp
```
TreebankLanguagePack ctlp
```
    - op
```
Options op
```
    - tagsForWord
```
CollectionValuedMap<K,V> tagsForWord
```
- Class edu.stanford.nlp.parser.lexparser.ChineseSimWordAvgDepGrammar extends MLEDependencyGrammar implements Serializable
  
  serialVersionUID:
  
  -1845503582705055342L
  - Serialized Fields
    - simArgMap
```
java.util.Map<K,V> simArgMap
```
    - simHeadMap
```
java.util.Map<K,V> simHeadMap
```
    - 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
```
java.lang.String segmenterClass
```
    - lex
```
Lexicon lex
```
    - segmenter
```
WordSegmenter segmenter
```
    - headFinder
```
HeadFinder headFinder
```
    - chineseSplitDouHao
```
boolean chineseSplitDouHao
```
      Chinese: Split the dou hao (a punctuation mark separating members of a list) from other punctuation. Good but included below.
    - chineseSplitPunct
```
boolean chineseSplitPunct
```
      Chinese: split Chinese punctuation several ways, along the lines of English punctuation plus another category for the dou hao. Good.
    - chineseSplitPunctLR
```
boolean chineseSplitPunctLR
```
      Chinese: split left right/paren quote (if chineseSplitPunct is also true. Only very marginal gains, but seems positive.
    - markVVsisterIP
```
boolean markVVsisterIP
```
      Chinese: mark VVs that are sister of IP (communication & small-clause-taking verbs). Good: give 0.5%
    - markPsisterIP
```
boolean markPsisterIP
```
      Chinese: mark P's that are sister of IP. Negative effect
    - markIPsisterVVorP
```
boolean markIPsisterVVorP
```
      Chinese: mark IP's that are sister of VV or P. These rarely have punctuation. Small positive effect.
    - markADgrandchildOfIP
```
boolean markADgrandchildOfIP
```
      Chinese: mark ADs that are grandchild of IP.
    - gpaAD
```
boolean gpaAD
```
      Grandparent annotate all AD. Seems slightly negative.
    - chineseVerySelectiveTagPA
```
boolean chineseVerySelectiveTagPA
```
    - chineseSelectiveTagPA
```
boolean chineseSelectiveTagPA
```
    - markIPsisterBA
```
boolean markIPsisterBA
```
      Chinese: mark IPs that are sister of BA. These always have overt NP. Very slightly positive.
    - markVPadjunct
```
boolean markVPadjunct
```
      Chinese: mark phrases that are adjuncts of VP (these tend to be locatives/temporals, and have a specific distribution). Necessary even with chineseSplitVP==3 and parent annotation because parent annotation happens with unsplit parent categories. Slightly positive.
    - markNPmodNP
```
boolean markNPmodNP
```
      Chinese: mark NP modifiers of NPs. Quite positive (0.5%)
    - markModifiedNP
```
boolean markModifiedNP
```
      Chinese: mark left-modified NPs (rightmost NPs with a left-side mod). Slightly positive.
    - markNPconj
```
boolean markNPconj
```
      Chinese: mark NPs that are conjuncts. Negative on small set.
    - markMultiNtag
```
boolean markMultiNtag
```
      Chinese: mark nominal tags that are part of multi-nominal rewrites. Doesn't seem any good.
    - markIPsisDEC
```
boolean markIPsisDEC
```
      Chinese: mark IPs that are part of prenominal modifiers. Negative.
    - markIPconj
```
boolean markIPconj
```
      Chinese: mark IPs that are conjuncts. Or those that have (adjuncts or subjects)
    - markIPadjsubj
```
boolean markIPadjsubj
```
    - chineseSplitVP
```
int chineseSplitVP
```
      Chinese VP splitting. 0 = none; 1 = mark with -BA a VP that directly dominates a BA; 2 = mark with -BA a VP that directly dominates a BA or a VP that directly dominates a BA 3 = split VPs into VP-COMP, VP-CRD, VP-ADJ. (Negative value.)
    - mergeNNVV
```
boolean mergeNNVV
```
      Chinese: merge NN and VV. A lark.
    - unaryIP
```
boolean unaryIP
```
      Chinese: unary category marking
    - unaryCP
```
boolean unaryCP
```
    - paRootDtr
```
boolean paRootDtr
```
      Chinese: parent annotate daughter of root. Meant only for selectivesplit=false.
    - markPostverbalP
```
boolean markPostverbalP
```
      Chinese: mark P with a left aunt VV, and PP with a left sister VV. Note that it's necessary to mark both to thread the context-marking. Used to identify post-verbal P's, which are rare.
    - markPostverbalPP
```
boolean markPostverbalPP
```
    - splitBaseNP
```
boolean splitBaseNP
```
      Mark base NPs. Good.
    - tagWordSize
```
boolean tagWordSize
```
      Annotate tags for number of characters contained.
    - markCC
```
boolean markCC
```
      Mark phrases which are conjunctions. Appears negative, even with 200K words training data.
    - splitNPTMP
```
boolean splitNPTMP
```
      Whether to retain the -TMP functional tag on various phrasal categories. On 80K words training, minutely helpful; on 200K words, best option gives 0.6%. Doing splitNPTMP and splitPPTMP (but not splitXPTMP) is best.
    - splitPPTMP
```
boolean splitPPTMP
```
    - splitXPTMP
```
boolean splitXPTMP
```
    - dominatesV
```
boolean dominatesV
```
      Verbal distance -- mark whether symbol dominates a verb (V*). Seems bad for Chinese.
    - useGoodTuringUnknownWordModel
```
boolean useGoodTuringUnknownWordModel
```
    - useCharBasedUnknownWordModel
```
boolean useCharBasedUnknownWordModel
```
    - lengthPenalty
```
double lengthPenalty
```
      Parameters for a ChineseCharacterBasedLexicon
    - useUnknownCharacterModel
```
boolean useUnknownCharacterModel
```
    - penaltyType
```
int penaltyType
```
      penaltyType should be set as follows: 0: no length penalty 1: quadratic length penalty 2: penalty for continuation chars only TODO: make this an enum
    - depGramFeatureLevel
```
int depGramFeatureLevel
```
- Class edu.stanford.nlp.parser.lexparser.ChineseUnknownWordModel extends BaseUnknownWordModel implements Serializable
  
  serialVersionUID:
  
  221L
  - Serialized Fields
    - useUnicodeType
```
boolean useUnicodeType
```
    - seenFirst
```
java.util.Set<E> seenFirst
```
- Class edu.stanford.nlp.parser.lexparser.ChineseWordFeatureExtractor extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4327267414095852504L
  - Serialized Fields
    - morpho
```
boolean morpho
```
    - chars
```
boolean chars
```
    - rads
```
boolean rads
```
    - useLength
```
boolean useLength
```
    - useFreq
```
boolean useFreq
```
    - bigrams
```
boolean bigrams
```
    - conjunctions
```
boolean conjunctions
```
    - mildConjunctions
```
boolean mildConjunctions
```
    - turnOffWordFeatures
```
boolean turnOffWordFeatures
```
    - wordCounter
```
IntCounter<E> wordCounter
```
    - cmfs
```
ChineseMorphFeatureSets cmfs
```
    - threshedFeatures
```
java.util.Collection<E> threshedFeatures
```
- Class edu.stanford.nlp.parser.lexparser.EnglishTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  4153878351331522581L
  - Serialized Fields
    - headFinder
```
HeadFinder headFinder
```
    - englishTrain
```
EnglishTreebankParserParams.EnglishTrain englishTrain
```
    - englishTest
```
EnglishTreebankParserParams.EnglishTest englishTest
```
- Class edu.stanford.nlp.parser.lexparser.EnglishTreebankParserParams.EnglishTest extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  183157656745674521L
  - Serialized Fields
    - retainNPTMPSubcategories
```
boolean retainNPTMPSubcategories
```
    - retainTMPSubcategories
```
boolean retainTMPSubcategories
```
    - retainADVSubcategories
```
boolean retainADVSubcategories
```
    - makeCopulaHead
```
boolean makeCopulaHead
```
- Class edu.stanford.nlp.parser.lexparser.EnglishTreebankParserParams.EnglishTrain extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1831576434872643L
  - Serialized Fields
    - leaveItAll
```
int leaveItAll
```
      if true, leave all PTB (functional tag) annotations (bad)
    - splitIN
```
int splitIN
```
      Annotate prepositions into subcategories. Values: 0 = no annotation 1 = IN with a ^S.* parent (putative subordinating conjunctions) marked differently from others (real prepositions). OK. 2 = Annotate IN prepositions 3 ways: ^S.* parent, ^N.* parent or rest (generally predicative ADJP, VP). Better than sIN=1. Good. 3 = Annotate prepositions 6 ways: real feature engineering. Great. 4 = Refinement of 3: allows -SC under SINV, WHADVP for -T and no -SCC if the parent is an NP. 5 = Like 4 but maps TO to IN in a "nominal" (N*, P*, A*) context. 6 = 4, but mark V/A complement and leave noun ones unmarked instead.
    - splitQuotes
```
boolean splitQuotes
```
      Mark quote marks for single vs. double so don't get mismatched ones.
    - splitSFP
```
boolean splitSFP
```
      Separate out sentence final punct. (. ! ?). Doesn't help.
    - splitPercent
```
boolean splitPercent
```
      Mark the nouns that are percent signs. Slightly good.
    - splitNPpercent
```
int splitNPpercent
```
      Mark phrases that are headed by %. A value of 0 = do nothing, 1 = only NP, 2 = NP and ADJP, 3 = NP, ADJP and QP, 4 = any phrase.
    - tagRBGPA
```
boolean tagRBGPA
```
      Grand parent annotate RB to try to distinguish sentential ones and ones in places like NP post modifier (things like 'very' are already distinguished as their parent is ADJP).
    - splitNNP
```
int splitNNP
```
      Mark NNP words as to position in phrase (single, left, right, inside) or subcategorizes NNP(S) as initials or initial/final in NP.
    - joinPound
```
boolean joinPound
```
      Join pound with dollar.
    - joinJJ
```
boolean joinJJ
```
      Joint comparative and superlative adjective with positive.
    - joinNounTags
```
boolean joinNounTags
```
      Join proper nouns with common nouns. This isn't to improve performance, but because Genia doesn't use proper noun tags in general.
    - splitPPJJ
```
boolean splitPPJJ
```
      A special test for "such" mainly ("such as Fred"). A wash, so omit
    - splitTRJJ
```
boolean splitTRJJ
```
      Put a special tag on 'transitive adjectives' with NP complement, like 'due May 15' -- it also catches 'such' in 'such as NP', which may be a good. Matches 658 times in 2-21 training corpus. Wash.
    - splitJJCOMP
```
boolean splitJJCOMP
```
      Put a special tag on 'adjectives with complements'. This acts as a general subcat feature for adjectives.
    - splitMoreLess
```
boolean splitMoreLess
```
      Specially mark the comparative/superlative words: less, least, more, most
    - unaryDT
```
boolean unaryDT
```
      Mark "Intransitive" DT. Good.
    - unaryRB
```
boolean unaryRB
```
      Mark "Intransitive" RB. Good.
    - unaryPRP
```
boolean unaryPRP
```
      "Intransitive" PRP. Wash -- basically a no-op really.
    - markReflexivePRP
```
boolean markReflexivePRP
```
      Mark reflexive PRP words.
    - unaryIN
```
boolean unaryIN
```
      Mark "Intransitive" IN. Minutely negative.
    - splitCC
```
int splitCC
```
      Provide annotation of conjunctions. Gives modest gains (numbers shown F1 increase with respect to goodPCFG in June 2005). A value of 1 annotates both "and" and "or" as "CC-C" (+0.29%), 2 annotates "but" and "&" separately (+0.17%), 3 annotates just "and" (equalsIgnoreCase) (+0.11%), 0 annotates nothing (+0.00%).
    - splitNOT
```
boolean splitNOT
```
      Annotates forms of "not" specially as tag "NOT". BAD
    - splitRB
```
boolean splitRB
```
      Split modifier (NP, AdjP) adverbs from others. This does nothing if you're already doing tagPA.
    - splitAux
```
int splitAux
```
      Make special tags for forms of BE and HAVE (and maybe DO/HELP, etc.). A value of 0 is do nothing. A value of 1 is the basic form. Positive PCFG effect, but neutral to negative in Factored, and impossible if you use gPA. A value of 2 adds in "s" = "'s" and delves further to disambiguate "'s" as BE or HAVE. Theoretically good, but no practical gains. A value of 3 adds DO. A value of 4 adds HELP (which also takes VB form complement) as DO. A value of 5 adds LET (which also takes VB form complement) as DO. A value of 6 adds MAKE (which also takes VB form complement) as DO. A value of 7 adds WATCH, SEE (which also take VB form complement) as DO. A value of 8 adds come, go, but not inflections (which colloquially can take a VB form complement) as DO. A value of 9 adds GET as BE. Differences are small. You get about 0.3 F1 by doing something; the best appear to be 2 or 3 for sentence exact and 7 or 8 for LP/LR F1.
    - vpSubCat
```
boolean vpSubCat
```
      Pitiful attempt at marking V* preterms with their surface subcat frames. Bad so far.
    - markDitransV
```
int markDitransV
```
      Attempt to record ditransitive verbs. The value 0 means do nothing; 1 records two or more NP or S* arguments, and 2 means to only record two or more NP arguments (that aren't NP-TMP). 1 gave neutral to bad results.
    - splitVP
```
int splitVP
```
      Add (head) tags to VPs. An argument of 0 = no head-subcategorization of VPs, 1 = add head tags (anything, as given by HeadFinder), 2 = add head tags, but collapse finite verb tags (VBP, VBD, VBZ, MD) together, 3 = only annotate verbal tags, and collapse finite verb tags (annotation is VBF, TO, VBG, VBN, VB, or zero), 4 = only split on categories of VBF, TO, VBG, VBN, VB, and map cases that are not headed by a verbal category to an appropriate category based on word suffix (ing, d, t, s, to) or to VB otherwise. We usually use a value of 3; 2 or 3 is much better than 0. See also splitVPNPAgr. If it is true, its effects override any value set for this parameter.
    - splitVPNPAgr
```
boolean splitVPNPAgr
```
      Put enough marking on VP and NP to permit "agreement".
    - splitSTag
```
int splitSTag
```
      Mark S/SINV/SQ nodes according to verbal tag. Meanings are: 0 = no subcategorization. 1 = mark with head tag 2 = mark only -VBF if VBZ/VBD/VBP/MD tag 3 = as 2 and mark -VBNF if TO/VBG/VBN/VB 4 = as 2 but only mark S not SINV/SQ 5 = as 3 but only mark S not SINV/SQ Previously seen as bad. Option 4 might be promising now.
    - markContainedVP
```
boolean markContainedVP
```
    - splitNPPRP
```
boolean splitNPPRP
```
    - dominatesV
```
int dominatesV
```
      Verbal distance -- mark whether symbol dominates a verb (V*, MD). Very good.
    - dominatesI
```
boolean dominatesI
```
      Verbal distance -- mark whether symbol dominates a preposition (IN)
    - dominatesC
```
boolean dominatesC
```
      Verbal distance -- mark whether symbol dominates a conjunction (CC)
    - markCC
```
int markCC
```
      Mark phrases which are conjunctions. 0 = No marking 1 = Any phrase with a CC daughter that isn't first or last. Possibly marginally positive. 2 = As 0 but also a non-marginal CONJP daughter. In principle good, but no gains. 3 = More like Charniak. Not yet implemented. Need to annotate _before_ annotate children! np or vp with two or more np/vp children, a comma, cc or conjp, and nothing else.
    - splitSGapped
```
int splitSGapped
```
      Mark specially S nodes with "gapped" subject (control, raising). 1 is basic version. 2 is better mark S nodes with "gapped" subject. 3 seems best on small training set, but all of these are too similar; 4 can't be differentiated. 5 is done on tree before empty splitting. (Bad!?)
    - splitNumNP
```
boolean splitNumNP
```
      Mark "numeric NPs". Probably bad?
    - splitPoss
```
int splitPoss
```
      Give a special tag to NPs which are possessive NPs (end in 's). A value of 0 means do nothing, 1 means tagging possessive NPs with "-P", 2 means restructure possessive NPs so that they introduce a POSSP node that takes as children the POS and a regularly structured NP. I.e., recover standard good linguistic practice circa 1985. This seems a good idea, but is almost a no-op (modulo fine points of markovization), since the previous NP-P phrase already uniquely captured what is now a POSSP.
    - splitBaseNP
```
int splitBaseNP
```
      Mark base NPs. A value of 0 = no marking, 1 = marking baseNP (ones which rewrite just as preterminals), and 2 = doing Collins-style marking, where an extra NP node is inserted above a baseNP, if it isn't already in an NP over NP construction, as in Collins 1999. This option shouldn't really be in EnglishTrain since it's needed at parsing time. But we don't currently use it.... A value of 1 is good.
    - splitTMP
```
int splitTMP
```
      Retain NP-TMP (or maybe PP-TMP) annotation. Good. The values for this parameter are defined in NPTmpRetainingTreeNormalizer.
    - splitSbar
```
int splitSbar
```
      Split SBAR nodes. 1 = mark 'in order to' purpose clauses; this is actually a small and inconsistent part of what is marked SBAR-PRP in the treebank, which is mainly 'because' reason clauses. 2 = mark all infinitive SBAR. 3 = do 1 and 2. A value of 1 seems minutely positive; 2 and 3 seem negative. Also get 'in case Sfin', 'In order to', and on one occasion 'in order that'
    - splitNPADV
```
int splitNPADV
```
      Retain NP-ADV annotation. 0 means strip "-ADV" annotation. 1 means to retain it, and to percolate it down to a head tag providing it can do it through a path of only NP nodes.
    - splitNPNNP
```
int splitNPNNP
```
      Mark NP-NNP. 0 is nothing; 1 is only NNP head, 2 is NNP and NNPS head; 3 is NNP or NNPS anywhere in local NP. All bad!
    - correctTags
```
boolean correctTags
```
      'Correct' tags to produce verbs in VPs, etc. where possible
    - rightPhrasal
```
boolean rightPhrasal
```
      Right edge has a phrasal node. Bad?
    - sisterSplitLevel
```
int sisterSplitLevel
```
      Set the support * KL cutoff level (1-4) for sister splitting -- don't use it, as far as we can tell so far
    - gpaRootVP
```
boolean gpaRootVP
```
      Grand-parent annotate (root mark) VP below ROOT. Seems negative.
    - makePPTOintoIN
```
int makePPTOintoIN
```
      Change TO inside PP to IN.
    - collapseWhCategories
```
int collapseWhCategories
```
      Collapse WHPP with PP, etc., in training and perhaps in evaluation. 1 = collapse phrasal categories. 2 = collapse POS categories. 4 = restore them in output (not yet implemented)
- Class edu.stanford.nlp.parser.lexparser.EnglishUnknownWordModel extends BaseUnknownWordModel implements Serializable
  
  serialVersionUID:
  
  4825624957364628770L
  - Serialized Fields
    - smartMutation
```
boolean smartMutation
```
    - unknownSuffixSize
```
int unknownSuffixSize
```
    - unknownPrefixSize
```
int unknownPrefixSize
```
    - wordClassesFile
```
java.lang.String wordClassesFile
```
- Class edu.stanford.nlp.parser.lexparser.FactoredLexicon extends BaseLexicon implements Serializable
  
  serialVersionUID:
  
  -744693222804176489L
  - Serialized Fields
    - morphoSpec
```
MorphoFeatureSpecification morphoSpec
```
    - morphIndex
```
Index<E> morphIndex
```
    - wordTag
```
TwoDimensionalIntCounter<K1,K2> wordTag
```
    - wordTagUnseen
```
Counter<E> wordTagUnseen
```
    - lemmaTag
```
TwoDimensionalIntCounter<K1,K2> lemmaTag
```
    - lemmaTagUnseen
```
Counter<E> lemmaTagUnseen
```
    - morphTag
```
TwoDimensionalIntCounter<K1,K2> morphTag
```
    - morphTagUnseen
```
Counter<E> morphTagUnseen
```
    - tagCounter
```
Counter<E> tagCounter
```
- Class edu.stanford.nlp.parser.lexparser.FrenchTreebankParserParams extends TregexPoweredTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  -6976724734594763986L
  - Serialized Fields
    - optionsString
```
java.lang.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
```
java.lang.StringBuilder optionsString
```
- Class edu.stanford.nlp.parser.lexparser.HungarianTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  5652324513L
  - Serialized Fields
    - headFinder
```
HeadFinder headFinder
```
    - normalizer
```
TreeNormalizer normalizer
```
- Class edu.stanford.nlp.parser.lexparser.HungarianTreebankParserParams.HungarianSubcategoryStripper extends TreeNormalizer implements Serializable
- Class edu.stanford.nlp.parser.lexparser.IntDependency extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - head
```
IntTaggedWord head
```
    - arg
```
IntTaggedWord arg
```
    - leftHeaded
```
boolean leftHeaded
```
    - distance
```
short distance
```
- Class edu.stanford.nlp.parser.lexparser.IntTaggedWord extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - word
```
int word
```
    - tag
```
short tag
```
- Class edu.stanford.nlp.parser.lexparser.ItalianTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  9824524678L
  - Serialized Fields
    - headFinder
```
HeadFinder headFinder
```
    - normalizer
```
TreeNormalizer normalizer
```
- Class edu.stanford.nlp.parser.lexparser.ItalianTreebankParserParams.ItalianSubcategoryStripper extends TreeNormalizer implements Serializable
- Class edu.stanford.nlp.parser.lexparser.Lattice extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  5135076134500512556L
  - Serialized Fields
    - constraints
```
java.util.List<E> constraints
```
    - edges
```
java.util.List<E> edges
```
    - nodes
```
java.util.Set<E> nodes
```
    - edgeStartsAt
```
java.util.Map<K,V> edgeStartsAt
```
    - maxNode
```
int maxNode
```
- Class edu.stanford.nlp.parser.lexparser.LatticeEdge extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4416189959485854286L
  - Serialized Fields
    - word
```
java.lang.String word
```
    - label
```
java.lang.String label
```
    - weight
```
double weight
```
    - start
```
int start
```
    - end
```
int end
```
    - attrs
```
java.util.Map<K,V> attrs
```
- Class edu.stanford.nlp.parser.lexparser.LexicalizedParser extends 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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  8260792244886911724L
  - Serialized Fields
    - words
```
java.util.Set<E> words
```
- Class edu.stanford.nlp.parser.lexparser.MLEDependencyGrammar extends AbstractDependencyGrammar implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
    - writeObject
```
private void writeObject(java.io.ObjectOutputStream stream)
                  throws java.io.IOException
```
      Throws:
      
      java.io.IOException
  - Serialized Fields
    - useSmoothTagProjection
```
boolean useSmoothTagProjection
```
    - useUnigramWordSmoothing
```
boolean useUnigramWordSmoothing
```
    - numWordTokens
```
int numWordTokens
```
    - argCounter
```
ClassicCounter<E> argCounter
```
      Stores all the counts for dependencies (with and without the word being a wildcard) in the reduced tag space.
    - stopCounter
```
ClassicCounter<E> stopCounter
```
    - smooth_aT_hTWd
```
double smooth_aT_hTWd
```
      Bayesian m-estimate prior for aT given hTWd against base distribution of aT given hTd. TODO: Note that these values are overwritten in the constructor. Find what is best and then maybe remove these defaults!
    - smooth_aTW_hTWd
```
double smooth_aTW_hTWd
```
      Bayesian m-estimate prior for aTW given hTWd against base distribution of aTW given hTd.
    - smooth_stop
```
double smooth_stop
```
    - interp
```
double interp
```
      Interpolation between model that directly predicts aTW and model that predicts aT and then aW given aT. This percent of the mass is on the model directly predicting aTW.
    - smooth_aTW_aT
```
double smooth_aTW_aT
```
    - smooth_aTW_hTd
```
double smooth_aTW_hTd
```
    - smooth_aT_hTd
```
double smooth_aT_hTd
```
    - smooth_aPTW_aPT
```
double smooth_aPTW_aPT
```
    - smoothTP
```
TagProjection smoothTP
```
    - smoothTPIndex
```
Index<E> smoothTPIndex
```
- Class edu.stanford.nlp.parser.lexparser.NegraPennTreebankParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  757812264219400466L
  - Serialized Fields
    - markRC
```
boolean markRC
```
    - markZuVP
```
boolean markZuVP
```
    - markLP
```
boolean markLP
```
    - markColon
```
boolean markColon
```
    - markKonjParent
```
boolean markKonjParent
```
    - markHDParent
```
boolean markHDParent
```
    - markContainsV
```
boolean markContainsV
```
    - nodeCleanup
```
int nodeCleanup
```
      Node cleanup is how node names are normalized. The known values are: 0 = do nothing; 1 = keep category and function; 2 = keep only category
    - headFinder
```
HeadFinder headFinder
```
    - treeNormalizerInsertNPinPP
```
boolean treeNormalizerInsertNPinPP
```
    - treeNormalizerLeaveGF
```
boolean treeNormalizerLeaveGF
```
    - treeReaderFactory
```
NegraPennTreeReaderFactory treeReaderFactory
```
- Class edu.stanford.nlp.parser.lexparser.Options extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Making the TestOptions transient means it won't even be constructed when you deserialize an Options, so we need to construct it on our own when deserializing
      
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
  - Serialized Fields
    - lexOptions
```
Options.LexOptions lexOptions
```
    - tlpParams
```
TreebankLangParserParams tlpParams
```
      The treebank-specific parser parameters to use.
    - forceCNF
```
boolean forceCNF
```
      Forces parsing with strictly CNF grammar -- unary chains are converted to XP&YP symbols and back
    - doPCFG
```
boolean doPCFG
```
      Do a PCFG parse of the sentence. If both variables are on, also do a combined parse of the sentence.
    - doDep
```
boolean doDep
```
      Do a dependency parse of the sentence.
    - freeDependencies
```
boolean freeDependencies
```
      if true, any child can be the head (seems rather bad!)
    - directional
```
boolean directional
```
      Whether dependency grammar considers left/right direction. Good.
    - genStop
```
boolean genStop
```
    - useSmoothTagProjection
```
boolean useSmoothTagProjection
```
    - useUnigramWordSmoothing
```
boolean useUnigramWordSmoothing
```
    - distance
```
boolean distance
```
      Use distance bins in the dependency calculations
    - coarseDistance
```
boolean coarseDistance
```
      Use coarser distance (4 bins) in dependency calculations
    - dcTags
```
boolean dcTags
```
      "double count" tags rewrites as word in PCFG and Dep parser. Good for combined parsing only (it used to not kick in for PCFG parsing). This option is only used at Test time, but it is now in Options, so the correct choice for a grammar is recorded by a serialized parser. You should turn this off for a vanilla PCFG parser.
    - nodePrune
```
boolean nodePrune
```
      If true, inside the factored parser, remove any node from the final chosen tree which improves the PCFG score. This was added as the dependency factor tends to encourage 'deep' trees.
    - trainOptions
```
TrainOptions trainOptions
```
    - wordFunction
```
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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2805351374506855632L
  - Serialized Fields
    - useUnknownWordSignatures
```
int useUnknownWordSignatures
```
      Whether to use suffix and capitalization information for unknowns. Within the BaseLexicon model options have the following meaning: 0 means a single unknown token. 1 uses suffix, and capitalization. 2 uses a variant (richer) form of signature. Good. Use this one. Using the richer signatures in versions 3 or 4 seems to have very marginal or no positive value. 3 uses a richer form of signature that mimics the NER word type patterns. 4 is a variant of 2. 5 is another with more English specific morphology (good for English unknowns!). 6-9 are options for Arabic. 9 codes some patterns for numbers and derivational morphology, but also supports unknownPrefixSize and unknownSuffixSize. For German, 0 means a single unknown token, and non-zero means to use capitalization of first letter and a suffix of length unknownSuffixSize.
    - wordVectorFile
```
java.lang.String wordVectorFile
```
    - numHid
```
int numHid
```
      Number of hidden units in the word vectors. As setting of 0 will make it try to extract the size from the data file.
    - smoothInUnknownsThreshold
```
int smoothInUnknownsThreshold
```
      Words more common than this are tagged with MLE P(t|w). Default 100. The smoothing is sufficiently slight that changing this has little effect. But set this to 0 to be able to use the parser as a vanilla PCFG with no smoothing (not as a practical parser but for exposition or debugging).
    - smartMutation
```
boolean smartMutation
```
      Smarter smoothing for rare words.
    - useUnicodeType
```
boolean useUnicodeType
```
      Make use of unicode code point types in smoothing.
    - unknownSuffixSize
```
int unknownSuffixSize
```
      For certain Lexicons, a certain number of word-final letters are used to subclassify the unknown token. This gives the number of letters.
    - unknownPrefixSize
```
int unknownPrefixSize
```
      For certain Lexicons, a certain number of word-initial letters are used to subclassify the unknown token. This gives the number of letters.
    - uwModelTrainer
```
java.lang.String uwModelTrainer
```
      Model for unknown words that the lexicon should use. This is the name of a class.
    - flexiTag
```
boolean flexiTag
```
    - useSignatureForKnownSmoothing
```
boolean useSignatureForKnownSmoothing
```
      Whether to use signature rather than just being unknown as prior in known word smoothing. Currently only works if turned on for English.
    - wordClassesFile
```
java.lang.String wordClassesFile
```
      A file of word class data which may be used for smoothing, normally instead of hand-specified signatures.
- Class edu.stanford.nlp.parser.lexparser.SpanishTreebankParserParams extends TregexPoweredTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  -8734165273482119424L
  - Serialized Fields
    - optionsString
```
java.lang.StringBuilder optionsString
```
    - headFinder
```
HeadFinder headFinder
```
- Class edu.stanford.nlp.parser.lexparser.SpanishUnknownWordModel extends BaseUnknownWordModel implements Serializable
  
  serialVersionUID:
  
  5370429530690606644L
  - Serialized Fields
    - smartMutation
```
boolean smartMutation
```
    - unknownSuffixSize
```
int unknownSuffixSize
```
    - unknownPrefixSize
```
int unknownPrefixSize
```
- Class edu.stanford.nlp.parser.lexparser.TaggerReranker extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - tagger
```
MaxentTagger tagger
```
    - op
```
Options op
```
    - weight
```
double weight
```
- Class edu.stanford.nlp.parser.lexparser.TestOptions extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7256526346598L
  - Serialized Fields
    - noRecoveryTagging
```
boolean noRecoveryTagging
```
      If false, then failure of the PCFG parser to parse a sentence will trigger allowing all tags for words in parse recovery mode, with a log probability of -1000. If true, these extra taggings are not added. It is false by default. Use option -noRecoveryTagging to set to true.
    - doRecovery
```
boolean doRecovery
```
      If true, then failure of the PCFG factor to parse a sentence will trigger parse recovery mode.
    - useN5
```
boolean useN5
```
      If true, the n^4 "speed-up" is not used with the Factored Parser.
    - useFastFactored
```
boolean useFastFactored
```
      If true, use approximate factored algorithm, which just rescores PCFG k best, rather than exact factored algorithm. This algorithm requires the dependency grammar to exist for rescoring, but not for the dependency grammar to be run. Hence the correct usage for guarding code only required for exact A* factored parsing is now if (op.doPCFG && op.doDep && ! Test.useFastFactored).
    - iterativeCKY
```
boolean iterativeCKY
```
      If true, use faster iterative deepening CKY algorithm.
    - maxLength
```
int maxLength
```
      The maximum sentence length (including punctuation, etc.) to parse.
    - MAX_ITEMS
```
int MAX_ITEMS
```
      The maximum number of edges and hooks combined that the factored parser will build before giving up. This number should probably be relative to the sentence length parsed. In general, though, if the parser cannot parse a sentence after this much work then there is no good parse consistent between the PCFG and Dependency parsers. (Normally, depending on other flags), the parser will then just return the best PCFG parse.)
    - unseenSmooth
```
double unseenSmooth
```
      The amount of smoothing put in (as an m-estimate) for unknown words. If negative, set by the code in the lexicon class.
    - increasingLength
```
boolean increasingLength
```
      Parse trees in test treebank in order of increasing length.
    - preTag
```
boolean preTag
```
      Tag the sentences first, then parse given those (coarse) tags.
    - forceTags
```
boolean forceTags
```
      Parse using only tags given from correct answer or the POS tagger
    - forceTagBeginnings
```
boolean forceTagBeginnings
```
    - taggerSerializedFile
```
java.lang.String taggerSerializedFile
```
      POS tagger model used when preTag is enabled.
    - noFunctionalForcing
```
boolean noFunctionalForcing
```
      Only valid with force tags - strips away functionals when forcing the tags, meaning tags have to start appropriately but the parser will assign the functional part.
    - evalb
```
boolean evalb
```
      Write EvalB-readable output files.
    - verbose
```
boolean verbose
```
      Print a lot of extra output as you parse.
    - exhaustiveTest
```
boolean exhaustiveTest
```
    - pcfgThreshold
```
boolean pcfgThreshold
```
      If this variable is true, and the sum of the inside and outside score for a constituent is worse than the best known score for a sentence by more than pcfgThresholdValue, then -Inf is returned as the outside Score by oScore() (while otherwise the true outside score is returned).
    - pcfgThresholdValue
```
double pcfgThresholdValue
```
    - printAllBestParses
```
boolean printAllBestParses
```
      Print out all best PCFG parses.
    - depWeight
```
double depWeight
```
      Weighting on dependency log probs. The dependency grammar negative log probability scores are simply multiplied by this number.
    - prunePunc
```
boolean prunePunc
```
    - addMissingFinalPunctuation
```
boolean addMissingFinalPunctuation
```
      If a token list does not have sentence final punctuation near the end, then automatically add the default one. This might help parsing if the treebank is all punctuated. Not done if reading a treebank.
    - outputFormat
```
java.lang.String outputFormat
```
      Determines format of output trees: choose among penn, oneline
    - outputFormatOptions
```
java.lang.String outputFormatOptions
```
    - writeOutputFiles
```
boolean writeOutputFiles
```
      If true, write files parsed to a new file with the same name except for an added ".stp" extension.
    - outputFilesDirectory
```
java.lang.String outputFilesDirectory
```
      If the writeOutputFiles option is true, then output files appear in this directory. An unset value (null) means to use the directory of the source files. Use "" or . for the current directory.
    - outputFilesExtension
```
java.lang.String outputFilesExtension
```
      If the writeOutputFiles option is true, then output files appear with this extension. Use "" for no extension.
    - outputFilesPrefix
```
java.lang.String outputFilesPrefix
```
      If the writeOutputFiles option is true, then output files appear with this prefix.
    - outputkBestEquivocation
```
java.lang.String outputkBestEquivocation
```
      If this option is not null, output the k-best equivocation. Must be specified with printPCFGkBest.
    - maxSpanForTags
```
int maxSpanForTags
```
      The largest span to consider for word-hood. Used for parsing unsegmented Chinese text and parsing lattices. Keep it at 1 unless you know what you're doing.
    - lengthNormalization
```
boolean lengthNormalization
```
      Turns on normalizing scores for sentence length. Makes no difference (except decreased efficiency) unless maxSpanForTags is greater than one. Works only for PCFG (so far).
    - sample
```
boolean sample
```
      Used when you want to generate sample parses instead of finding the best parse. (NOT YET USED.)
    - printPCFGkBest
```
int printPCFGkBest
```
      Printing k-best parses from PCFG, when k > 0.
    - evalPCFGkBest
```
int evalPCFGkBest
```
      If using a kBest eval, use this many trees.
    - printFactoredKGood
```
int printFactoredKGood
```
      Printing k-best parses from PCFG, when k > 0.
    - evals
```
java.util.Properties evals
```
      What evaluations to report and how to report them (using LexicalizedParser). Known evaluations are: pcfgLB, pcfgCB, pcfgDA, pcfgTA, pcfgLL, pcfgRUO, pcfgCUO, pcfgCatE, pcfgChildSpecific, depDA, depTA, depLL, factLB, factCB, factDA, factTA, factLL, factChildSpecific. The default is pcfgLB,depDA,factLB,factTA. You need to negate those ones out (e.g., -evals "depDA=false") if you don't want them. LB = ParseEval labeled bracketing,
      CB = crossing brackets and zero crossing bracket rate,
      DA = dependency accuracy, TA = tagging accuracy,
      LL = log likelihood score,
      RUO/CUO = rules/categories under and over proposed,
      CatE = evaluation by phrasal category.
      ChildSpecific: supply an argument with =. F1 will be returned for only the nodes which have at least one child that matches this regular expression.
      Known styles are: runningAverages, summary, tsv.
      The default style is summary. You need to negate it out if you don't want it. Invalid names in the argument to this option are not reported!
    - fastFactoredCandidateMultiplier
```
int fastFactoredCandidateMultiplier
```
      This variable says to find k good fast factored parses, how many times k of the best PCFG parses should be examined.
    - fastFactoredCandidateAddend
```
int fastFactoredCandidateAddend
```
      This variable says to find k good factored parses, how many added on best PCFG parses should be examined.
    - useLexiconToScoreDependencyPwGt
```
boolean useLexiconToScoreDependencyPwGt
```
      If this is true, the Lexicon is used to score P(w|t) in the backoff inside the dependency grammar. (Otherwise, a MLE is used is w is seen, and a constant if w is unseen.
    - useNonProjectiveDependencyParser
```
boolean useNonProjectiveDependencyParser
```
      If this is true, perform non-projective dependency parsing.
    - testingThreads
```
int testingThreads
```
      Number of threads to use at test time. For example, -testTreebank can use this to go X times faster, with the negative consequence that output is not quite as nicely ordered.
    - quietEvaluation
```
boolean quietEvaluation
```
      When evaluating, don't print out tons of text. Only print out the final scores
- Class edu.stanford.nlp.parser.lexparser.TestTagProjection extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  9161675508802284114L
- Class edu.stanford.nlp.parser.lexparser.TrainOptions extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  72571349843538L
  - Serialized Fields
    - trainTreeFile
```
java.lang.String trainTreeFile
```
    - trainLengthLimit
```
int trainLengthLimit
```
    - cheatPCFG
```
boolean cheatPCFG
```
      Add all test set trees to training data for PCFG. (Currently only supported in FactoredParser main.)
    - markovFactor
```
boolean markovFactor
```
      Whether to do "horizontal Markovization" (as in ACL 2003 paper). False means regular PCFG expansions.
    - markovOrder
```
int markovOrder
```
    - hSelSplit
```
boolean hSelSplit
```
    - HSEL_CUT
```
int HSEL_CUT
```
    - markFinalStates
```
boolean markFinalStates
```
      Whether or not to mark final states in binarized grammar. This must be off to get most value out of grammar compaction.
    - openClassTypesThreshold
```
int openClassTypesThreshold
```
      A POS tag has to have been attributed to more than this number of word types before it is regarded as an open-class tag. Unknown words will only possibly be tagged as open-class tags (unless flexiTag is on). If flexiTag is on, unknown words will be able to be tagged any POS for which the unseenMap has nonzero count (that is, the tag was seen for a new word after unseen signature counting was started).
    - fractionBeforeUnseenCounting
```
double fractionBeforeUnseenCounting
```
      Start to aggregate signature-tag pairs only for words unseen in the first this fraction of the data.
    - PA
```
boolean PA
```
      This variable controls doing parent annotation of phrasal nodes. Good.
    - gPA
```
boolean gPA
```
      This variable controls doing 2 levels of parent annotation. Bad.
    - postPA
```
boolean postPA
```
    - postGPA
```
boolean postGPA
```
    - selectiveSplit
```
boolean selectiveSplit
```
      Only split the "common high KL divergence" parent categories.... Good.
    - selectiveSplitCutOff
```
double selectiveSplitCutOff
```
    - selectivePostSplit
```
boolean selectivePostSplit
```
    - selectivePostSplitCutOff
```
double selectivePostSplitCutOff
```
    - postSplitWithBaseCategory
```
boolean postSplitWithBaseCategory
```
      Whether, in post-splitting of categories, nodes are annotated with the (grand)parent's base category or with its complete subcategorized category.
    - sisterAnnotate
```
boolean sisterAnnotate
```
      Selective Sister annotation.
    - sisterSplitters
```
java.util.Set<E> sisterSplitters
```
    - markUnary
```
int markUnary
```
      Mark all unary nodes specially. Good for just PCFG. Bad for factored. markUnary affects phrasal nodes. A value of 0 means to do nothing; a value of 1 means to mark the parent (higher) node of a unary rewrite. A value of 2 means to mark the child (lower) node of a unary rewrie. Values of 1 and 2 only apply if the child (lower) node is phrasal. (A value of 1 is better than 2 in combos.) A value of 1 corresponds to the old boolean -unary flag.
    - markUnaryTags
```
boolean markUnaryTags
```
      Mark POS tags which are the sole member of their phrasal constituent. This is like markUnary=2, applied to POS tags.
    - splitPrePreT
```
boolean splitPrePreT
```
      Mark all pre-preterminals (also does splitBaseNP: don't need both)
    - tagPA
```
boolean tagPA
```
      Parent annotation on tags. Good (for PCFG?)
    - tagSelectiveSplit
```
boolean tagSelectiveSplit
```
      Do parent annotation on tags selectively. Neutral, but less splits.
    - tagSelectiveSplitCutOff
```
double tagSelectiveSplitCutOff
```
    - tagSelectivePostSplit
```
boolean tagSelectivePostSplit
```
    - tagSelectivePostSplitCutOff
```
double tagSelectivePostSplitCutOff
```
    - rightRec
```
boolean rightRec
```
      Right edge is right-recursive (X << X) Bad. (NP only is good)
    - leftRec
```
boolean leftRec
```
      Left edge is right-recursive (X << X) Bad.
    - collinsPunc
```
boolean collinsPunc
```
      Promote/delete punctuation like Collins. Bad (!)
    - splitters
```
java.util.Set<E> splitters
```
      Set the splitter strings. These are a set of parent and/or grandparent annotated categories which should be split off.
    - postSplitters
```
java.util.Set<E> postSplitters
```
    - deleteSplitters
```
java.util.Set<E> deleteSplitters
```
    - printTreeTransformations
```
int printTreeTransformations
```
      Just for debugging: check that your tree transforms work correctly. This will print the transformations of the first printTreeTransformations trees.
    - printAnnotatedPW
```
java.io.PrintWriter printAnnotatedPW
```
    - printBinarizedPW
```
java.io.PrintWriter printBinarizedPW
```
    - printStates
```
boolean printStates
```
    - compactGrammar
```
int compactGrammar
```
      How to compact grammars as FSMs. 0 = no compaction [uses makeSyntheticLabel1], 1 = no compaction but use label names that wrap from right to left in binarization [uses makeSyntheticLabel2], 2 = wrapping labels and materialize unary at top rewriting passive to active, 3 = ExactGrammarCompactor, 4 = LossyGrammarCompactor, 5 = CategoryMergingGrammarCompactor. (May 2007 CDM note: options 4 and 5 don't seem to be functioning sensibly. 0, 1, and 3 seem to be the 'good' options. 2 is only useful as input to 3. There seems to be no reason not to use 0, despite the default.)
    - leftToRight
```
boolean leftToRight
```
    - noTagSplit
```
boolean noTagSplit
```
    - ruleSmoothing
```
boolean ruleSmoothing
```
      Enables linear rule smoothing during grammar extraction but before grammar compaction. The alpha term is the same as that described in Petrov et al. (2006), and has range [0,1].
    - ruleSmoothingAlpha
```
double ruleSmoothingAlpha
```
    - smoothing
```
boolean smoothing
```
      TODO wsg2011: This is the old grammar smoothing parameter that no longer does anything in the parser. It should be removed.
    - ruleDiscount
```
double ruleDiscount
```
      Discounts the count of BinaryRule's (only, apparently) in training data.
    - printAnnotatedRuleCounts
```
boolean printAnnotatedRuleCounts
```
    - printAnnotatedStateCounts
```
boolean printAnnotatedStateCounts
```
    - basicCategoryTagsInDependencyGrammar
```
boolean basicCategoryTagsInDependencyGrammar
```
      Where to use the basic or split tags in the dependency grammar
    - preTransformer
```
TreeTransformer preTransformer
```
      A transformer to use on the training data before any other processing step. This is specified by using the -preTransformer flag when training the parser. A comma separated list of classes will be turned into a CompositeTransformer. This can be used to strip subcategories, to run a tsurgeon pattern, or any number of other useful operations.
    - taggedFiles
```
java.lang.String taggedFiles
```
      A set of files to use as extra information in the lexicon. This can provide tagged words which are not part of trees
    - predictSplits
```
boolean predictSplits
```
      Use the method reported by Berkeley for splitting and recombining states. This is an experimental and still in development reimplementation of that work.
    - splitCount
```
int splitCount
```
      If we are predicting splits, we loop this many times
    - splitRecombineRate
```
double splitRecombineRate
```
      If we are predicting splits, we recombine states at this rate every loop
    - simpleBinarizedLabels
```
boolean simpleBinarizedLabels
```
      When binarizing trees, don't annotate the labels with anything
    - noRebinarization
```
boolean noRebinarization
```
      When binarizing trees, don't binarize trees with two children. Only applies when using inside markov binarization for now.
    - trainingThreads
```
int trainingThreads
```
      If the training algorithm allows for parallelization, how many threads to use
    - dvKBest
```
int dvKBest
```
    - 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
```
java.lang.String unkWord
```
      Some models will use external data sources which contain information about unknown words. This variable is a way to provide the name of the unknown word in the external data source.
    - lowercaseWordVectors
```
boolean lowercaseWordVectors
```
      Whether or not to lowercase word vectors
    - transformMatrixType
```
TrainOptions.TransformMatrixType transformMatrixType
```
    - useContextWords
```
boolean useContextWords
```
      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
```
java.util.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
```
java.util.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
```
java.util.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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4213299755069618322L
  - Serialized Fields
    - headFinder
```
HeadFinder headFinder
```
    - lowerCase
```
boolean lowerCase
```
- Class edu.stanford.nlp.parser.lexparser.TregexPoweredTreebankParserParams.SimpleStringFunction extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  6958776731059724396L
  - Serialized Fields
    - annotationMark
```
java.lang.String annotationMark
```
- Class edu.stanford.nlp.parser.lexparser.TueBaDZParserParams extends AbstractTreebankParserParams implements Serializable
  
  serialVersionUID:
  
  7303189408025355170L
  - Serialized Fields
    - hf
```
HeadFinder hf
```
    - nodeCleanup
```
int nodeCleanup
```
      How to clean up node labels: 0 = do nothing, 1 = keep category and function, 2 = just category.
    - markKonjParent
```
boolean markKonjParent
```
    - markContainsV
```
boolean markContainsV
```
    - markZu
```
boolean markZu
```
    - markColons
```
boolean markColons
```
    - leftPhrasal
```
boolean leftPhrasal
```
    - markHDParent
```
boolean markHDParent
```
    - leaveGF
```
boolean leaveGF
```
- Class edu.stanford.nlp.parser.lexparser.UnaryGrammar extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
  - Serialized Fields
    - index
```
Index<E> index
```
    - coreRules
```
java.util.Map<K,V> coreRules
```
      The basic list of UnaryRules. Really this is treated as a set
- Class edu.stanford.nlp.parser.lexparser.UnaryRule extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - parent
```
int parent
```
    - score
```
float score
```
      Score should be a log probability
    - child
```
int child
```
Package edu.stanford.nlp.parser.shiftreduce
- Class edu.stanford.nlp.parser.shiftreduce.BaseModel extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -175375535849840611L
  - Serialized Fields
    - op
```
ShiftReduceOptions op
```
    - transitionIndex
```
Index<E> transitionIndex
```
    - knownStates
```
java.util.Set<E> knownStates
```
    - rootStates
```
java.util.Set<E> rootStates
```
    - rootOnlyStates
```
java.util.Set<E> rootOnlyStates
```
- Class edu.stanford.nlp.parser.shiftreduce.BasicFeatureFactory extends FeatureFactory implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.parser.shiftreduce.BinaryTransition extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - label
```
java.lang.String label
```
    - side
```
BinaryTransition.Side side
```
      Which side the head is on
    - isRoot
```
boolean isRoot
```
      root transitions are illegal in the middle of the tree, naturally
- 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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - labels
```
java.lang.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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -9086427962537286031L
- Class edu.stanford.nlp.parser.shiftreduce.FinalizeTransition extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - rootStates
```
java.util.Set<E> rootStates
```
- Class edu.stanford.nlp.parser.shiftreduce.IdleTransition extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.parser.shiftreduce.PerceptronModel extends BaseModel implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - learningRate
```
float learningRate
```
    - featureWeights
```
WeightMap featureWeights
```
    - featureFactory
```
FeatureFactory featureFactory
```
- Class edu.stanford.nlp.parser.shiftreduce.ShiftReduceOptions extends Options implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - compoundUnaries
```
boolean compoundUnaries
```
    - featureFactoryClass
```
java.lang.String featureFactoryClass
```
- Class edu.stanford.nlp.parser.shiftreduce.ShiftReduceParser extends ParserGrammar implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - op
```
ShiftReduceOptions op
```
    - model
```
PerceptronModel model
```
- Class edu.stanford.nlp.parser.shiftreduce.ShiftReduceTestOptions extends TestOptions implements Serializable
  - Serialized Fields
    - recordBinarized
```
java.lang.String recordBinarized
```
    - recordDebinarized
```
java.lang.String recordDebinarized
```
    - beamSize
```
int beamSize
```
    - recordTransitionTypes
```
boolean recordTransitionTypes
```
- 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
    - decayLearningRate
```
double decayLearningRate
```
      If positive, every 10 iterations, multiply the learning rate by this amount.
    - l1Reg
```
float l1Reg
```
      If positive, after every iteration, weights are moved by this much back towards 0.
    - l2Reg
```
float l2Reg
```
      If positive, after every iteration, weights are scaled by this ratio back towards 0.
    - retrainShards
```
int retrainShards
```
      If more than one, retrains this many "shards" after the initial training and then averages them together
    - retrainShardFeatureDrop
```
double retrainShardFeatureDrop
```
      Shards 2..n will have this many features dropped. Shard 1 will be the full model, which guarantees that every feature appears at least once.
    - augmentSubsentences
```
float augmentSubsentences
```
      Some training trees will be repeated, with gold transitions given for the first several steps to ensure the parser starts from a good place. For some datasets, such as the English training set, 0.5 is excessively large.
- Class edu.stanford.nlp.parser.shiftreduce.ShiftTransition extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.parser.shiftreduce.UnaryTransition extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - label
```
java.lang.String label
```
    - isRoot
```
boolean isRoot
```
      root transitions are illegal in the middle of the tree, naturally
- Class edu.stanford.nlp.parser.shiftreduce.Weight extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3L
  - Serialized Fields
    - packed
```
short[] packed
```
- Class edu.stanford.nlp.parser.shiftreduce.WeightMap extends java.lang.Object implements Serializable
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
    - writeObject
```
private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException
```
      Throws:
      
      java.io.IOException
  - Serialized Fields
    - weights
```
java.util.HashMap<K,V> weights
```

Package edu.stanford.nlp.parser.ui

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

serialVersionUID:: 7179757799978939358L

Serialized Fields

parserPanel
```
ParserPanel parserPanel
```

untokEngItem

javax.swing.JCheckBoxMenuItem untokEngItem

tokChineseItem

javax.swing.JCheckBoxMenuItem tokChineseItem

untokChineseItem

javax.swing.JCheckBoxMenuItem untokChineseItem

jMenu2
```
javax.swing.JMenu jMenu2
```
loadParserItem
```
javax.swing.JMenuItem loadParserItem
```
loadDataItem
```
javax.swing.JMenuItem loadDataItem
```
jSeparator1
```
javax.swing.JSeparator jSeparator1
```
jMenu1
```
javax.swing.JMenu jMenu1
```
exitItem
```
javax.swing.JMenuItem exitItem
```
jMenuBar1
```
javax.swing.JMenuBar jMenuBar1
```

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

serialVersionUID:: -2118491857333662471L

Serialized Fields

encoding
```
java.lang.String encoding
```
jfc
```
javax.swing.JFileChooser jfc
```

jfcLocation

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

chooseJarParser
```
JarFileChooser chooseJarParser
```
pageDialog
```
OpenPageDialog pageDialog
```

normalStyle

javax.swing.text.SimpleAttributeSet normalStyle

highlightStyle

javax.swing.text.SimpleAttributeSet highlightStyle

startIndex
```
int startIndex
```
endIndex
```
int endIndex
```
treePanel
```
TreeJPanel treePanel
```
parser
```
ParserGrammar parser
```

lpThread

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

parseThread

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

timer
```
javax.swing.Timer timer
```
count
```
int count
```
glassPane
```
java.awt.Component glassPane
```
scrollWhenDone
```
boolean scrollWhenDone
```
Whether to scroll one sentence forward after parsing.
dataFileLabel
```
javax.swing.JLabel dataFileLabel
```
treeContainer
```
javax.swing.JPanel treeContainer
```
topPanel
```
javax.swing.JPanel topPanel
```
textScrollPane
```
javax.swing.JScrollPane textScrollPane
```
backButton
```
javax.swing.JButton backButton
```
statusLabel
```
javax.swing.JLabel statusLabel
```
loadFileButton
```
javax.swing.JButton loadFileButton
```
loadButtonPanel
```
javax.swing.JPanel loadButtonPanel
```
buttonsAndFilePanel
```
javax.swing.JPanel buttonsAndFilePanel
```
parseButton
```
javax.swing.JButton parseButton
```
parseNextButton
```
javax.swing.JButton parseNextButton
```
forwardButton
```
javax.swing.JButton forwardButton
```
parserFileLabel
```
javax.swing.JLabel parserFileLabel
```
clearButton
```
javax.swing.JButton clearButton
```
splitPane
```
javax.swing.JSplitPane splitPane
```
statusPanel
```
javax.swing.JPanel statusPanel
```
dataFilePanel
```
javax.swing.JPanel dataFilePanel
```
buttonPanel
```
javax.swing.JPanel buttonPanel
```
textPane
```
javax.swing.JTextPane textPane
```
progressBar
```
javax.swing.JProgressBar progressBar
```
parserFilePanel
```
javax.swing.JPanel parserFilePanel
```
loadParserButton
```
javax.swing.JButton loadParserButton
```
saveOutputButton
```
javax.swing.JButton saveOutputButton
```

Class edu.stanford.nlp.parser.ui.TreeJPanel extends javax.swing.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
- Class edu.stanford.nlp.patterns.CandidatePhrase extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  42L
  - Serialized Fields
    - phrase
```
java.lang.String phrase
```
    - phraseLemma
```
java.lang.String phraseLemma
```
    - features
```
Counter<E> features
```
    - hashCode
```
int hashCode
```
- Class edu.stanford.nlp.patterns.ConstantsAndVariables extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - numIterationsForPatterns
```
java.lang.Integer numIterationsForPatterns
```
      Maximum number of iterations to run
    - numPatterns
```
int numPatterns
```
      Maximum number of patterns learned in each iteration
    - outDir
```
java.lang.String outDir
```
      The output directory where the justifications of learning patterns and phrases would be saved. These are needed for visualization
    - allPatternsDir
```
java.lang.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
```
java.lang.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
```
java.lang.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
```
java.lang.String columnOutputFile
```
      If you want output of form "word\tlabels-separated-by-comma" in newlines
    - targetAllowedTagsInitialsStr
```
java.lang.String targetAllowedTagsInitialsStr
```
      Initials of all POS tags to use if usePOS4Pattern is true, separated by comma.
    - allowedTagsInitials
```
java.util.Map<K,V> allowedTagsInitials
```
    - targetAllowedNERs
```
java.lang.String targetAllowedNERs
```
      Allowed NERs for labels. Format is label1,NER1,NER11;label2,NER2,NER21,NER22;label3,... useTargetNERRestriction flag should be true
    - allowedNERsforLabels
```
java.util.Map<K,V> allowedNERsforLabels
```
    - numWordsToAdd
```
int numWordsToAdd
```
      Number of words to learn in each iteration
    - thresholdNumPatternsApplied
```
double thresholdNumPatternsApplied
```
    - wordScoring
```
edu.stanford.nlp.patterns.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
```
java.lang.String englishWordsFiles
```
      English words that are not labeled when labeling using seed dictionaries
    - englishWords
```
java.util.Set<E> englishWords
```
    - commonWordsPatternFiles
```
java.lang.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
```
java.util.Set<E> commonEngWords
```
    - otherSemanticClassesFiles
```
java.lang.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
```
java.util.Set<E> otherSemanticClassesWords
```
    - seedLabelDictionary
```
java.util.Map<K,V> seedLabelDictionary
```
      Seed dictionary, set in the class that uses this class
    - labels
```
java.util.Set<E> labels
```
      Just the set of labels
    - answerClass
```
java.util.Map<K,V> answerClass
```
    - ignoreWordswithClassesDuringSelection
```
java.util.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.
    - minLen4FuzzyForPattern
```
int minLen4FuzzyForPattern
```
      Minimum length of words that can be matched fuzzily
    - wordIgnoreRegex
```
java.lang.String wordIgnoreRegex
```
      Do not learn phrases that match this regex.
    - numThreads
```
int numThreads
```
      Number of threads
    - stopWordsPatternFiles
```
java.lang.String stopWordsPatternFiles
```
      Words that are not learned. Patterns are not created around these words. And, if useStopWordsBeforeTerm in CreatePatterns is true.
    - env
```
java.util.Map<K,V> env
```
      Environment for TokenSequencePattern
    - removeStopWordsFromSelectedPhrases
```
boolean removeStopWordsFromSelectedPhrases
```
    - removePhrasesWithStopWords
```
boolean removePhrasesWithStopWords
```
    - alreadySetUp
```
boolean alreadySetUp
```
    - wordClassClusterFile
```
java.lang.String wordClassClusterFile
```
      Cluster file, in which each line is word/phraseclusterid
    - wordClassClusters
```
java.util.Map<K,V> wordClassClusters
```
    - generalWordClassClusterFile
```
java.lang.String generalWordClassClusterFile
```
      General cluster file, if you wanna use it somehow, in which each line is word/phraseclusterid
    - generalWordClassClusters
```
java.util.Map<K,V> generalWordClassClusters
```
    - externalFeatureWeightsDir
```
java.lang.String externalFeatureWeightsDir
```
    - doNotApplyPatterns
```
boolean doNotApplyPatterns
```
    - 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
```
java.util.concurrent.ConcurrentHashMap<K,V> editDistanceFromEnglishWords
```
      Cached files
    - editDistanceFromEnglishWordsMatches
```
java.util.concurrent.ConcurrentHashMap<K,V> editDistanceFromEnglishWordsMatches
```
      Cached files
    - editDistanceFromOtherSemanticClasses
```
java.util.concurrent.ConcurrentHashMap<K,V> editDistanceFromOtherSemanticClasses
```
      Cached files
    - editDistanceFromOtherSemanticClassesMatches
```
java.util.concurrent.ConcurrentHashMap<K,V> editDistanceFromOtherSemanticClassesMatches
```
      Cached files
    - editDistanceFromThisClass
```
java.util.concurrent.ConcurrentHashMap<K,V> editDistanceFromThisClass
```
      Cached files
    - editDistanceFromThisClassMatches
```
java.util.concurrent.ConcurrentHashMap<K,V> editDistanceFromThisClassMatches
```
      Cached files
    - wordShapesForLabels
```
java.util.concurrent.ConcurrentHashMap<K,V> wordShapesForLabels
```
    - channelNameLogger
```
java.lang.String channelNameLogger
```
    - distSimWeights
```
java.util.Map<K,V> distSimWeights
```
    - dictOddsWeights
```
java.util.Map<K,V> dictOddsWeights
```
    - invertedIndexClass
```
java.lang.Class<T> invertedIndexClass
```
    - invertedIndexDirectory
```
java.lang.String invertedIndexDirectory
```
      Where the inverted index (either in memory or lucene) is stored
    - clubNeighboringLabeledWords
```
boolean clubNeighboringLabeledWords
```
    - patternType
```
PatternFactory.PatternType patternType
```
    - subsampleUnkAsNegUsingSim
```
boolean subsampleUnkAsNegUsingSim
```
    - expandPositivesWhenSampling
```
boolean expandPositivesWhenSampling
```
    - expandNegativesWhenSampling
```
boolean expandNegativesWhenSampling
```
    - similarityThresholdHighPrecision
```
double similarityThresholdHighPrecision
```
    - positiveSimilarityThresholdLowPrecision
```
double positiveSimilarityThresholdLowPrecision
```
    - wordVectorFile
```
java.lang.String wordVectorFile
```
    - useWordVectorsToComputeSim
```
boolean useWordVectorsToComputeSim
```
    - logFileVectorSimilarity
```
java.lang.String logFileVectorSimilarity
```
    - goldEntitiesEvalFiles
```
java.lang.String goldEntitiesEvalFiles
```
    - evaluate
```
boolean evaluate
```
    - goldEntities
```
java.util.Map<K,V> goldEntities
```
    - featureCountThreshold
```
int featureCountThreshold
```
    - expandPhrasesNumTopSimilar
```
int expandPhrasesNumTopSimilar
```
    - fuzzyMatch
```
boolean fuzzyMatch
```
      Whether to do a fuzzy matching when matching seeds to text. You can tune minLen4FuzzyForPattern parameter.
    - ignoreCaseSeedMatch
```
java.util.Map<K,V> ignoreCaseSeedMatch
```
      Ignore case when matching seed words. It's a map so something like {name->true,place->false}
    - sentsOutFile
```
java.lang.String sentsOutFile
```
    - savePatternsWordsDir
```
boolean savePatternsWordsDir
```
    - learn
```
boolean learn
```
    - 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.
    - usePhraseEvalWordVector
```
boolean usePhraseEvalWordVector
```
      Only works if you have single label. And the word vectors are given.
    - usePhraseEvalGoogleNgram
```
boolean usePhraseEvalGoogleNgram
```
      use google tf-idf for learning phrases. Need to also provide googleNgram_dbname, googleNgram_username and googleNgram_host
    - 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
```
    - usePhraseEvalWordShapeStr
```
boolean usePhraseEvalWordShapeStr
```
    - usePhraseEvalFirstCapital
```
boolean usePhraseEvalFirstCapital
```
    - usePhraseEvalBOW
```
boolean usePhraseEvalBOW
```
      use bag of words
    - 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.
    - usePatternEvalWordShapeStr
```
boolean usePatternEvalWordShapeStr
```
    - usePatternEvalFirstCapital
```
boolean usePatternEvalFirstCapital
```
    - 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. Need to also provide googleNgram_dbname, googleNgram_username and googleNgram_host
    - usePatternEvalSemanticOdds
```
boolean usePatternEvalSemanticOdds
```
      Used only if ConstantsAndVariables.patternScoring is PhEvalInPat or PhEvalInPatLogP. See usePhrase* for meanings.
    - usePatternEvalEditDistSame
```
boolean usePatternEvalEditDistSame
```
      Used only if ConstantsAndVariables.patternScoring is PhEvalInPat or PhEvalInPatLogP. See usePhrase* for meanings.
    - usePatternEvalEditDistOther
```
boolean usePatternEvalEditDistOther
```
      Used only if ConstantsAndVariables.patternScoring is PhEvalInPat or PhEvalInPatLogP. See usePhrase* for meanings.
    - usePatternEvalBOW
```
boolean usePatternEvalBOW
```
      use bag of words
    - 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
```
    - wordShaper
```
int wordShaper
```
    - wordShapeCache
```
java.util.concurrent.ConcurrentHashMap<K,V> wordShapeCache
```
    - invertedIndex
```
SentenceIndex<E extends Pattern> invertedIndex
```
    - props
```
java.util.Properties props
```
    - functionWords
```
java.util.List<E> functionWords
```
    - learnedWordsEachIter
```
java.util.Map<K,V> learnedWordsEachIter
```
    - editDistMax
```
double editDistMax
```
    - batchProcessSents
```
boolean batchProcessSents
```
      Use this option if you are limited by memory ; ignored if fileFormat is ser.
    - writeMatchedTokensFiles
```
boolean writeMatchedTokensFiles
```
    - writeMatchedTokensIdsForEachPhrase
```
boolean writeMatchedTokensIdsForEachPhrase
```
- Class edu.stanford.nlp.patterns.DataInstance extends java.lang.Object implements Serializable
- Class edu.stanford.nlp.patterns.GetPatternsFromDataMultiClass extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - patsForEachToken
```
PatternsForEachToken<E> patsForEachToken
```
    - wordsForOtherClass
```
java.util.Map<K,V> wordsForOtherClass
```
    - writtenPatInJustification
```
java.util.Map<K,V> writtenPatInJustification
```
    - learnedPatterns
```
java.util.Map<K,V> learnedPatterns
```
    - learnedPatternsEachIter
```
java.util.Map<K,V> learnedPatternsEachIter
```
    - matchedSeedWords
```
java.util.Map<K,V> matchedSeedWords
```
    - wordsPatExtracted
```
java.util.Map<K,V> wordsPatExtracted
```
    - props
```
java.util.Properties props
```
    - scorePhrases
```
ScorePhrases<E extends Pattern> scorePhrases
```
    - constVars
```
ConstantsAndVariables constVars
```
    - createPats
```
CreatePatterns<E> createPats
```
    - df
```
java.text.DecimalFormat df
```
    - notComputedAllPatternsYet
```
boolean notComputedAllPatternsYet
```
    - patternsandWords
```
java.util.Map<K,V> patternsandWords
```
    - currentPatternWeights
```
java.util.Map<K,V> currentPatternWeights
```
    - phInPatScoresCache
```
TwoDimensionalCounter<K1,K2> phInPatScoresCache
```
- Class edu.stanford.nlp.patterns.InvertedIndexByTokens extends SentenceIndex<E extends Pattern> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - index
```
java.util.Map<K,V> index
```
- Class edu.stanford.nlp.patterns.Pattern extends java.lang.Object implements Serializable
  - Serialized Fields
    - type
```
PatternFactory.PatternType type
```
- Class edu.stanford.nlp.patterns.PatternsAnnotations extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.patterns.SPIEDServlet extends javax.servlet.http.HttpServlet implements Serializable
  - Serialized Fields
    - logger
```
java.util.logging.Logger logger
```
    - testPropertiesFile
```
java.lang.String testPropertiesFile
```
    - modelNametoDirName
```
java.util.Map<K,V> modelNametoDirName
```
Package edu.stanford.nlp.patterns.dep
- Class edu.stanford.nlp.patterns.dep.DataInstanceDep extends DataInstance implements Serializable
  - Serialized Fields
    - graph
```
SemanticGraph graph
```
    - tokens
```
java.util.List<E> tokens
```
- Class edu.stanford.nlp.patterns.dep.DepPattern extends Pattern implements Serializable
  - Serialized Fields
    - hashCode
```
int hashCode
```
    - relations
```
java.util.List<E> relations
```
- Class edu.stanford.nlp.patterns.dep.ExtractedPhrase extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - startIndex
```
int startIndex
```
    - endIndex
```
int endIndex
```
    - pattern
```
SemgrexPattern pattern
```
    - value
```
java.lang.String value
```
    - confidence
```
double confidence
```
    - articleId
```
java.lang.String articleId
```
    - sentId
```
java.lang.Integer sentId
```
    - features
```
Counter<E> features
```
Package edu.stanford.nlp.patterns.surface
- Class edu.stanford.nlp.patterns.surface.DataInstanceSurface extends DataInstance implements Serializable
  - Serialized Fields
    - tokens
```
java.util.List<E> tokens
```
- Class edu.stanford.nlp.patterns.surface.PatternToken extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - tag
```
java.lang.String tag
```
    - useTag
```
boolean useTag
```
    - numWordsCompound
```
int numWordsCompound
```
    - useNER
```
boolean useNER
```
    - nerTag
```
java.lang.String nerTag
```
    - useTargetParserParentRestriction
```
boolean useTargetParserParentRestriction
```
    - grandparentParseTag
```
java.lang.String grandparentParseTag
```
- Class edu.stanford.nlp.patterns.surface.SurfacePattern extends Pattern implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - prevContext
```
Token[] prevContext
```
    - nextContext
```
Token[] nextContext
```
    - token
```
PatternToken token
```
    - hashcode
```
int hashcode
```
    - genre
```
SurfacePatternFactory.Genre genre
```
- Class edu.stanford.nlp.patterns.surface.Token extends java.lang.Object implements Serializable
  - Serialized Fields
    - classORrestrictions
```
java.util.Map<K,V> classORrestrictions
```
    - envBindBooleanRestriction
```
java.lang.String envBindBooleanRestriction
```
    - alphaNumeric
```
java.util.regex.Pattern alphaNumeric
```
    - numMinOcc
```
int numMinOcc
```
    - numMaxOcc
```
int numMaxOcc
```
    - type
```
PatternFactory.PatternType type
```
- Class edu.stanford.nlp.patterns.surface.Token.ClassComparator extends java.lang.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.CoreNLPProtos.CorefChain extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - chainID_
```
int chainID_
```
    - mention_
```
java.util.List<E> mention_
```
    - representative_
```
int representative_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.CorefChain.CorefMention extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - mentionID_
```
int mentionID_
```
    - mentionType_
```
java.lang.Object mentionType_
```
    - number_
```
java.lang.Object number_
```
    - gender_
```
java.lang.Object gender_
```
    - animacy_
```
java.lang.Object animacy_
```
    - beginIndex_
```
int beginIndex_
```
    - endIndex_
```
int endIndex_
```
    - headIndex_
```
int headIndex_
```
    - sentenceIndex_
```
int sentenceIndex_
```
    - position_
```
int position_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyConverterRequest extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - trees_
```
java.util.List<E> trees_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyConverterResponse extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - conversions_
```
java.util.List<E> conversions_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyConverterResponse.DependencyConversion extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - graph_
```
CoreNLPProtos.DependencyGraph graph_
```
    - tree_
```
CoreNLPProtos.FlattenedParseTree tree_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyEnhancerRequest extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - refCase_
```
int refCase_
```
    - ref_
```
java.lang.Object ref_
```
    - document_
```
CoreNLPProtos.Document document_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyGraph extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - node_
```
java.util.List<E> node_
```
    - edge_
```
java.util.List<E> edge_
```
    - root_
```
com.google.protobuf.Internal.IntList root_
```
    - rootMemoizedSerializedSize
```
int rootMemoizedSerializedSize
```
    - token_
```
java.util.List<E> token_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyGraph.Edge extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - source_
```
int source_
```
    - target_
```
int target_
```
    - dep_
```
java.lang.Object dep_
```
    - isExtra_
```
boolean isExtra_
```
    - sourceCopy_
```
int sourceCopy_
```
    - targetCopy_
```
int targetCopy_
```
    - language_
```
int language_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.DependencyGraph.Node extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - sentenceIndex_
```
int sentenceIndex_
```
    - index_
```
int index_
```
    - copyAnnotation_
```
int copyAnnotation_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Document extends com.google.protobuf.GeneratedMessageV3.ExtendableMessage<CoreNLPProtos.Document> implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - text_
```
java.lang.Object text_
```
    - sentence_
```
java.util.List<E> sentence_
```
    - corefChain_
```
java.util.List<E> corefChain_
```
    - docID_
```
java.lang.Object docID_
```
    - docDate_
```
java.lang.Object docDate_
```
    - calendar_
```
long calendar_
```
    - sentencelessToken_
```
java.util.List<E> sentencelessToken_
```
    - character_
```
java.util.List<E> character_
```
    - quote_
```
java.util.List<E> quote_
```
    - mentions_
```
java.util.List<E> mentions_
```
    - hasEntityMentionsAnnotation_
```
boolean hasEntityMentionsAnnotation_
```
    - xmlDoc_
```
boolean xmlDoc_
```
    - sections_
```
java.util.List<E> sections_
```
    - mentionsForCoref_
```
java.util.List<E> mentionsForCoref_
```
    - hasCorefMentionAnnotation_
```
boolean hasCorefMentionAnnotation_
```
    - hasCorefAnnotation_
```
boolean hasCorefAnnotation_
```
    - corefMentionToEntityMentionMappings_
```
com.google.protobuf.Internal.IntList corefMentionToEntityMentionMappings_
```
    - entityMentionToCorefMentionMappings_
```
com.google.protobuf.Internal.IntList entityMentionToCorefMentionMappings_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Entity extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - headStart_
```
int headStart_
```
    - headEnd_
```
int headEnd_
```
    - mentionType_
```
java.lang.Object mentionType_
```
    - normalizedName_
```
java.lang.Object normalizedName_
```
    - headTokenIndex_
```
int headTokenIndex_
```
    - corefID_
```
java.lang.Object corefID_
```
    - objectID_
```
java.lang.Object objectID_
```
    - extentStart_
```
int extentStart_
```
    - extentEnd_
```
int extentEnd_
```
    - type_
```
java.lang.Object type_
```
    - subtype_
```
java.lang.Object subtype_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.EvaluateParserRequest extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - treebank_
```
java.util.List<E> treebank_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.EvaluateParserRequest.ParseResult extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - gold_
```
CoreNLPProtos.FlattenedParseTree gold_
```
    - predicted_
```
java.util.List<E> predicted_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.EvaluateParserResponse extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - f1_
```
double f1_
```
    - kbestF1_
```
double kbestF1_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.FlattenedParseTree extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - nodes_
```
java.util.List<E> nodes_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.FlattenedParseTree.Node extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - contentsCase_
```
int contentsCase_
```
    - contents_
```
java.lang.Object contents_
```
    - score_
```
double score_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.IndexedWord extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - sentenceNum_
```
int sentenceNum_
```
    - tokenIndex_
```
int tokenIndex_
```
    - docID_
```
int docID_
```
    - copyCount_
```
int copyCount_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.MapIntString extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - key_
```
com.google.protobuf.Internal.IntList key_
```
    - value_
```
com.google.protobuf.LazyStringList value_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.MapStringString extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - key_
```
com.google.protobuf.LazyStringList key_
```
    - value_
```
com.google.protobuf.LazyStringList value_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Mention extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - mentionID_
```
int mentionID_
```
    - mentionType_
```
java.lang.Object mentionType_
```
    - number_
```
java.lang.Object number_
```
    - gender_
```
java.lang.Object gender_
```
    - animacy_
```
java.lang.Object animacy_
```
    - person_
```
java.lang.Object person_
```
    - startIndex_
```
int startIndex_
```
    - endIndex_
```
int endIndex_
```
    - headIndex_
```
int headIndex_
```
    - headString_
```
java.lang.Object headString_
```
    - nerString_
```
java.lang.Object nerString_
```
    - originalRef_
```
int originalRef_
```
    - goldCorefClusterID_
```
int goldCorefClusterID_
```
    - corefClusterID_
```
int corefClusterID_
```
    - mentionNum_
```
int mentionNum_
```
    - sentNum_
```
int sentNum_
```
    - utter_
```
int utter_
```
    - paragraph_
```
int paragraph_
```
    - isSubject_
```
boolean isSubject_
```
    - isDirectObject_
```
boolean isDirectObject_
```
    - isIndirectObject_
```
boolean isIndirectObject_
```
    - isPrepositionObject_
```
boolean isPrepositionObject_
```
    - hasTwin_
```
boolean hasTwin_
```
    - generic_
```
boolean generic_
```
    - isSingleton_
```
boolean isSingleton_
```
    - hasBasicDependency_
```
boolean hasBasicDependency_
```
    - hasEnhancedDependency_
```
boolean hasEnhancedDependency_
```
    - hasContextParseTree_
```
boolean hasContextParseTree_
```
    - headIndexedWord_
```
CoreNLPProtos.IndexedWord headIndexedWord_
```
    - dependingVerb_
```
CoreNLPProtos.IndexedWord dependingVerb_
```
    - headWord_
```
CoreNLPProtos.IndexedWord headWord_
```
    - speakerInfo_
```
CoreNLPProtos.SpeakerInfo speakerInfo_
```
    - sentenceWords_
```
java.util.List<E> sentenceWords_
```
    - originalSpan_
```
java.util.List<E> originalSpan_
```
    - dependents_
```
com.google.protobuf.LazyStringList dependents_
```
    - preprocessedTerms_
```
com.google.protobuf.LazyStringList preprocessedTerms_
```
    - appositions_
```
com.google.protobuf.Internal.IntList appositions_
```
    - predicateNominatives_
```
com.google.protobuf.Internal.IntList predicateNominatives_
```
    - relativePronouns_
```
com.google.protobuf.Internal.IntList relativePronouns_
```
    - listMembers_
```
com.google.protobuf.Internal.IntList listMembers_
```
    - belongToLists_
```
com.google.protobuf.Internal.IntList belongToLists_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.MorphologyRequest extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - words_
```
java.util.List<E> words_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.MorphologyRequest.TaggedWord extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - word_
```
java.lang.Object word_
```
    - xpos_
```
java.lang.Object xpos_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.MorphologyResponse extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - words_
```
java.util.List<E> words_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.MorphologyResponse.WordTagLemma extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - word_
```
java.lang.Object word_
```
    - xpos_
```
java.lang.Object xpos_
```
    - lemma_
```
java.lang.Object lemma_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.NERMention extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - sentenceIndex_
```
int sentenceIndex_
```
    - tokenStartInSentenceInclusive_
```
int tokenStartInSentenceInclusive_
```
    - tokenEndInSentenceExclusive_
```
int tokenEndInSentenceExclusive_
```
    - ner_
```
java.lang.Object ner_
```
    - normalizedNER_
```
java.lang.Object normalizedNER_
```
    - entityType_
```
java.lang.Object entityType_
```
    - timex_
```
CoreNLPProtos.Timex timex_
```
    - wikipediaEntity_
```
java.lang.Object wikipediaEntity_
```
    - gender_
```
java.lang.Object gender_
```
    - entityMentionIndex_
```
int entityMentionIndex_
```
    - canonicalEntityMentionIndex_
```
int canonicalEntityMentionIndex_
```
    - entityMentionText_
```
java.lang.Object entityMentionText_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Operator extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - name_
```
java.lang.Object name_
```
    - quantifierSpanBegin_
```
int quantifierSpanBegin_
```
    - quantifierSpanEnd_
```
int quantifierSpanEnd_
```
    - subjectSpanBegin_
```
int subjectSpanBegin_
```
    - subjectSpanEnd_
```
int subjectSpanEnd_
```
    - objectSpanBegin_
```
int objectSpanBegin_
```
    - objectSpanEnd_
```
int objectSpanEnd_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.ParseTree extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - child_
```
java.util.List<E> child_
```
    - value_
```
java.lang.Object value_
```
    - yieldBeginIndex_
```
int yieldBeginIndex_
```
    - yieldEndIndex_
```
int yieldEndIndex_
```
    - score_
```
double score_
```
    - sentiment_
```
int sentiment_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Polarity extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - projectEquivalence_
```
int projectEquivalence_
```
    - projectForwardEntailment_
```
int projectForwardEntailment_
```
    - projectReverseEntailment_
```
int projectReverseEntailment_
```
    - projectNegation_
```
int projectNegation_
```
    - projectAlternation_
```
int projectAlternation_
```
    - projectCover_
```
int projectCover_
```
    - projectIndependence_
```
int projectIndependence_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Quote extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - text_
```
java.lang.Object text_
```
    - begin_
```
int begin_
```
    - end_
```
int end_
```
    - sentenceBegin_
```
int sentenceBegin_
```
    - sentenceEnd_
```
int sentenceEnd_
```
    - tokenBegin_
```
int tokenBegin_
```
    - tokenEnd_
```
int tokenEnd_
```
    - docid_
```
java.lang.Object docid_
```
    - index_
```
int index_
```
    - author_
```
java.lang.Object author_
```
    - mention_
```
java.lang.Object mention_
```
    - mentionBegin_
```
int mentionBegin_
```
    - mentionEnd_
```
int mentionEnd_
```
    - mentionType_
```
java.lang.Object mentionType_
```
    - mentionSieve_
```
java.lang.Object mentionSieve_
```
    - speaker_
```
java.lang.Object speaker_
```
    - speakerSieve_
```
java.lang.Object speakerSieve_
```
    - canonicalMention_
```
java.lang.Object canonicalMention_
```
    - canonicalMentionBegin_
```
int canonicalMentionBegin_
```
    - canonicalMentionEnd_
```
int canonicalMentionEnd_
```
    - attributionDependencyGraph_
```
CoreNLPProtos.DependencyGraph attributionDependencyGraph_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Relation extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - argName_
```
com.google.protobuf.LazyStringList argName_
```
    - arg_
```
java.util.List<E> arg_
```
    - signature_
```
java.lang.Object signature_
```
    - objectID_
```
java.lang.Object objectID_
```
    - extentStart_
```
int extentStart_
```
    - extentEnd_
```
int extentEnd_
```
    - type_
```
java.lang.Object type_
```
    - subtype_
```
java.lang.Object subtype_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.RelationTriple extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - subject_
```
java.lang.Object subject_
```
    - relation_
```
java.lang.Object relation_
```
    - object_
```
java.lang.Object object_
```
    - confidence_
```
double confidence_
```
    - subjectTokens_
```
java.util.List<E> subjectTokens_
```
    - relationTokens_
```
java.util.List<E> relationTokens_
```
    - objectTokens_
```
java.util.List<E> objectTokens_
```
    - tree_
```
CoreNLPProtos.DependencyGraph tree_
```
    - istmod_
```
boolean istmod_
```
    - prefixBe_
```
boolean prefixBe_
```
    - suffixBe_
```
boolean suffixBe_
```
    - suffixOf_
```
boolean suffixOf_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Section extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - charBegin_
```
int charBegin_
```
    - charEnd_
```
int charEnd_
```
    - author_
```
java.lang.Object author_
```
    - sentenceIndexes_
```
com.google.protobuf.Internal.IntList sentenceIndexes_
```
    - datetime_
```
java.lang.Object datetime_
```
    - quotes_
```
java.util.List<E> quotes_
```
    - authorCharBegin_
```
int authorCharBegin_
```
    - authorCharEnd_
```
int authorCharEnd_
```
    - xmlTag_
```
CoreNLPProtos.Token xmlTag_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SemgrexRequest extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - semgrex_
```
com.google.protobuf.LazyStringList semgrex_
```
    - query_
```
java.util.List<E> query_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SemgrexRequest.Dependencies extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - token_
```
java.util.List<E> token_
```
    - graph_
```
CoreNLPProtos.DependencyGraph graph_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SemgrexResponse extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - result_
```
java.util.List<E> result_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SemgrexResponse.GraphResult extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - result_
```
java.util.List<E> result_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SemgrexResponse.Match extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - matchIndex_
```
int matchIndex_
```
    - node_
```
java.util.List<E> node_
```
    - reln_
```
java.util.List<E> reln_
```
    - edge_
```
java.util.List<E> edge_
```
    - graphIndex_
```
int graphIndex_
```
    - semgrexIndex_
```
int semgrexIndex_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SemgrexResponse.NamedEdge extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - name_
```
java.lang.Object name_
```
    - source_
```
int source_
```
    - target_
```
int target_
```
    - reln_
```
java.lang.Object reln_
```
    - isExtra_
```
boolean isExtra_
```
    - sourceCopy_
```
int sourceCopy_
```
    - targetCopy_
```
int targetCopy_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SemgrexResponse.NamedNode extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - name_
```
java.lang.Object name_
```
    - matchIndex_
```
int matchIndex_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SemgrexResponse.NamedRelation extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - name_
```
java.lang.Object name_
```
    - reln_
```
java.lang.Object reln_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SemgrexResponse.SemgrexResult extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - match_
```
java.util.List<E> match_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Sentence extends com.google.protobuf.GeneratedMessageV3.ExtendableMessage<CoreNLPProtos.Sentence> implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - bitField1_
```
int bitField1_
```
    - token_
```
java.util.List<E> token_
```
    - tokenOffsetBegin_
```
int tokenOffsetBegin_
```
    - tokenOffsetEnd_
```
int tokenOffsetEnd_
```
    - sentenceIndex_
```
int sentenceIndex_
```
    - characterOffsetBegin_
```
int characterOffsetBegin_
```
    - characterOffsetEnd_
```
int characterOffsetEnd_
```
    - parseTree_
```
CoreNLPProtos.ParseTree parseTree_
```
    - binarizedParseTree_
```
CoreNLPProtos.ParseTree binarizedParseTree_
```
    - annotatedParseTree_
```
CoreNLPProtos.ParseTree annotatedParseTree_
```
    - sentiment_
```
java.lang.Object sentiment_
```
    - kBestParseTrees_
```
java.util.List<E> kBestParseTrees_
```
    - basicDependencies_
```
CoreNLPProtos.DependencyGraph basicDependencies_
```
    - collapsedDependencies_
```
CoreNLPProtos.DependencyGraph collapsedDependencies_
```
    - collapsedCCProcessedDependencies_
```
CoreNLPProtos.DependencyGraph collapsedCCProcessedDependencies_
```
    - alternativeDependencies_
```
CoreNLPProtos.DependencyGraph alternativeDependencies_
```
    - openieTriple_
```
java.util.List<E> openieTriple_
```
    - kbpTriple_
```
java.util.List<E> kbpTriple_
```
    - entailedSentence_
```
java.util.List<E> entailedSentence_
```
    - entailedClause_
```
java.util.List<E> entailedClause_
```
    - enhancedDependencies_
```
CoreNLPProtos.DependencyGraph enhancedDependencies_
```
    - enhancedPlusPlusDependencies_
```
CoreNLPProtos.DependencyGraph enhancedPlusPlusDependencies_
```
    - character_
```
java.util.List<E> character_
```
    - paragraph_
```
int paragraph_
```
    - text_
```
java.lang.Object text_
```
    - lineNumber_
```
int lineNumber_
```
    - hasRelationAnnotations_
```
boolean hasRelationAnnotations_
```
    - entity_
```
java.util.List<E> entity_
```
    - relation_
```
java.util.List<E> relation_
```
    - hasNumerizedTokensAnnotation_
```
boolean hasNumerizedTokensAnnotation_
```
    - mentions_
```
java.util.List<E> mentions_
```
    - mentionsForCoref_
```
java.util.List<E> mentionsForCoref_
```
    - hasCorefMentionsAnnotation_
```
boolean hasCorefMentionsAnnotation_
```
    - sentenceID_
```
java.lang.Object sentenceID_
```
    - sectionDate_
```
java.lang.Object sectionDate_
```
    - sectionIndex_
```
int sectionIndex_
```
    - sectionName_
```
java.lang.Object sectionName_
```
    - sectionAuthor_
```
java.lang.Object sectionAuthor_
```
    - docID_
```
java.lang.Object docID_
```
    - sectionQuoted_
```
boolean sectionQuoted_
```
    - hasEntityMentionsAnnotation_
```
boolean hasEntityMentionsAnnotation_
```
    - hasKBPTriplesAnnotation_
```
boolean hasKBPTriplesAnnotation_
```
    - hasOpenieTriplesAnnotation_
```
boolean hasOpenieTriplesAnnotation_
```
    - chapterIndex_
```
int chapterIndex_
```
    - paragraphIndex_
```
int paragraphIndex_
```
    - enhancedSentence_
```
CoreNLPProtos.Sentence enhancedSentence_
```
    - speaker_
```
java.lang.Object speaker_
```
    - speakerType_
```
java.lang.Object speakerType_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SentenceFragment extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - tokenIndex_
```
com.google.protobuf.Internal.IntList tokenIndex_
```
    - root_
```
int root_
```
    - assumedTruth_
```
boolean assumedTruth_
```
    - score_
```
double score_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Span extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - begin_
```
int begin_
```
    - end_
```
int end_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SpeakerInfo extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - speakerName_
```
java.lang.Object speakerName_
```
    - mentions_
```
com.google.protobuf.Internal.IntList mentions_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SsurgeonRequest extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - ssurgeon_
```
java.util.List<E> ssurgeon_
```
    - graph_
```
java.util.List<E> graph_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SsurgeonRequest.Ssurgeon extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - semgrex_
```
java.lang.Object semgrex_
```
    - operation_
```
com.google.protobuf.LazyStringList operation_
```
    - id_
```
java.lang.Object id_
```
    - notes_
```
java.lang.Object notes_
```
    - language_
```
java.lang.Object language_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SsurgeonResponse extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - result_
```
java.util.List<E> result_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.SsurgeonResponse.SsurgeonResult extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - graph_
```
CoreNLPProtos.DependencyGraph graph_
```
    - changed_
```
boolean changed_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Timex extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - value_
```
java.lang.Object value_
```
    - altValue_
```
java.lang.Object altValue_
```
    - text_
```
java.lang.Object text_
```
    - type_
```
java.lang.Object type_
```
    - tid_
```
java.lang.Object tid_
```
    - beginPoint_
```
int beginPoint_
```
    - endPoint_
```
int endPoint_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.Token extends com.google.protobuf.GeneratedMessageV3.ExtendableMessage<CoreNLPProtos.Token> implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - bitField1_
```
int bitField1_
```
    - word_
```
java.lang.Object word_
```
    - pos_
```
java.lang.Object pos_
```
    - value_
```
java.lang.Object value_
```
    - category_
```
java.lang.Object category_
```
    - before_
```
java.lang.Object before_
```
    - after_
```
java.lang.Object after_
```
    - originalText_
```
java.lang.Object originalText_
```
    - ner_
```
java.lang.Object ner_
```
    - coarseNER_
```
java.lang.Object coarseNER_
```
    - fineGrainedNER_
```
java.lang.Object fineGrainedNER_
```
    - nerLabelProbs_
```
com.google.protobuf.LazyStringList nerLabelProbs_
```
    - normalizedNER_
```
java.lang.Object normalizedNER_
```
    - lemma_
```
java.lang.Object lemma_
```
    - beginChar_
```
int beginChar_
```
    - endChar_
```
int endChar_
```
    - utterance_
```
int utterance_
```
    - speaker_
```
java.lang.Object speaker_
```
    - speakerType_
```
java.lang.Object speakerType_
```
    - beginIndex_
```
int beginIndex_
```
    - endIndex_
```
int endIndex_
```
    - tokenBeginIndex_
```
int tokenBeginIndex_
```
    - tokenEndIndex_
```
int tokenEndIndex_
```
    - timexValue_
```
CoreNLPProtos.Timex timexValue_
```
    - hasXmlContext_
```
boolean hasXmlContext_
```
    - xmlContext_
```
com.google.protobuf.LazyStringList xmlContext_
```
    - corefClusterID_
```
int corefClusterID_
```
    - answer_
```
java.lang.Object answer_
```
    - headWordIndex_
```
int headWordIndex_
```
    - operator_
```
CoreNLPProtos.Operator operator_
```
    - polarity_
```
CoreNLPProtos.Polarity polarity_
```
    - polarityDir_
```
java.lang.Object polarityDir_
```
    - span_
```
CoreNLPProtos.Span span_
```
    - sentiment_
```
java.lang.Object sentiment_
```
    - quotationIndex_
```
int quotationIndex_
```
    - conllUFeatures_
```
CoreNLPProtos.MapStringString conllUFeatures_
```
    - coarseTag_
```
java.lang.Object coarseTag_
```
    - conllUTokenSpan_
```
CoreNLPProtos.Span conllUTokenSpan_
```
    - conllUMisc_
```
java.lang.Object conllUMisc_
```
    - conllUSecondaryDeps_
```
CoreNLPProtos.MapStringString conllUSecondaryDeps_
```
    - wikipediaEntity_
```
java.lang.Object wikipediaEntity_
```
    - isNewline_
```
boolean isNewline_
```
    - gender_
```
java.lang.Object gender_
```
    - trueCase_
```
java.lang.Object trueCase_
```
    - trueCaseText_
```
java.lang.Object trueCaseText_
```
    - chineseChar_
```
java.lang.Object chineseChar_
```
    - chineseSeg_
```
java.lang.Object chineseSeg_
```
    - chineseXMLChar_
```
java.lang.Object chineseXMLChar_
```
    - arabicSeg_
```
java.lang.Object arabicSeg_
```
    - sectionName_
```
java.lang.Object sectionName_
```
    - sectionAuthor_
```
java.lang.Object sectionAuthor_
```
    - sectionDate_
```
java.lang.Object sectionDate_
```
    - sectionEndLabel_
```
java.lang.Object sectionEndLabel_
```
    - parent_
```
java.lang.Object parent_
```
    - corefMentionIndex_
```
com.google.protobuf.Internal.IntList corefMentionIndex_
```
    - entityMentionIndex_
```
int entityMentionIndex_
```
    - isMWT_
```
boolean isMWT_
```
    - isFirstMWT_
```
boolean isFirstMWT_
```
    - mwtText_
```
java.lang.Object mwtText_
```
    - mwtMisc_
```
java.lang.Object mwtMisc_
```
    - numericValue_
```
long numericValue_
```
    - numericType_
```
java.lang.Object numericType_
```
    - numericCompositeValue_
```
long numericCompositeValue_
```
    - numericCompositeType_
```
java.lang.Object numericCompositeType_
```
    - codepointOffsetBegin_
```
int codepointOffsetBegin_
```
    - codepointOffsetEnd_
```
int codepointOffsetEnd_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.TokenLocation extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - sentenceIndex_
```
int sentenceIndex_
```
    - tokenIndex_
```
int tokenIndex_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.TokensRegexRequest extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - doc_
```
CoreNLPProtos.Document doc_
```
    - pattern_
```
com.google.protobuf.LazyStringList pattern_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.TokensRegexResponse extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - match_
```
java.util.List<E> match_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.TokensRegexResponse.Match extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - sentence_
```
int sentence_
```
    - match_
```
CoreNLPProtos.TokensRegexResponse.MatchLocation match_
```
    - group_
```
java.util.List<E> group_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.TokensRegexResponse.MatchLocation extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - text_
```
java.lang.Object text_
```
    - begin_
```
int begin_
```
    - end_
```
int end_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.TokensRegexResponse.PatternMatch extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - match_
```
java.util.List<E> match_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.TsurgeonRequest extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - operations_
```
java.util.List<E> operations_
```
    - trees_
```
java.util.List<E> trees_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.TsurgeonRequest.Operation extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - bitField0_
```
int bitField0_
```
    - tregex_
```
java.lang.Object tregex_
```
    - tsurgeon_
```
com.google.protobuf.LazyStringList tsurgeon_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.CoreNLPProtos.TsurgeonResponse extends com.google.protobuf.GeneratedMessageV3 implements Serializable
  
  serialVersionUID:
  
  0L
  - Serialized Fields
    - trees_
```
java.util.List<E> trees_
```
    - memoizedIsInitialized
```
byte memoizedIsInitialized
```
- Class edu.stanford.nlp.pipeline.ProtobufAnnotationSerializer.LossySerializationException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  741506383659886245L
- Class edu.stanford.nlp.pipeline.WebServiceAnnotator.PermanentlyFailedException extends java.lang.Exception implements Serializable
  
  serialVersionUID:
  
  6812811056236924923L
- Class edu.stanford.nlp.pipeline.WebServiceAnnotator.ShouldRetryException extends java.lang.Exception implements Serializable
  
  serialVersionUID:
  
  -4292922700733296864L
Package edu.stanford.nlp.pipeline.webapp
- Class edu.stanford.nlp.pipeline.webapp.CoreNLPServlet extends javax.servlet.http.HttpServlet implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - pipeline
```
StanfordCoreNLP pipeline
```
    - corenlpTransformer
```
nu.xom.xslt.XSLTransform corenlpTransformer
```
    - defaultFormat
```
java.lang.String defaultFormat
```
Package edu.stanford.nlp.process
- Class edu.stanford.nlp.process.AmericanizeFunction extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.process.ChineseDocumentToSentenceProcessor extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4054964767812217460L
  - Serialized Fields
    - normalizationTable
```
java.util.List<E> normalizationTable
```
- Class edu.stanford.nlp.process.CoreLabelTokenFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4L
  - Serialized Fields
    - addIndices
```
boolean addIndices
```
- Class edu.stanford.nlp.process.DistSimClassifier extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3L
  - Serialized Fields
    - lexicon
```
java.util.Map<K,V> lexicon
```
    - cased
```
boolean cased
```
    - numberEquivalence
```
boolean numberEquivalence
```
    - unknownWordClass
```
java.lang.String unknownWordClass
```
- Class edu.stanford.nlp.process.LowercaseAndAmericanizeFunction extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.process.LowercaseFunction extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.process.PTBTokenizer.PTBTokenizerFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -8859638719818931606L
  - Serialized Fields
    - factory
```
LexedTokenFactory<T> factory
```
    - options
```
java.lang.String options
```
- Class edu.stanford.nlp.process.WhitespaceTokenizer.WhitespaceTokenizerFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -5438594683910349897L
  - Serialized Fields
    - tokenizeNLs
```
boolean tokenizeNLs
```
    - factory
```
LexedTokenFactory<T> factory
```
Package edu.stanford.nlp.scenegraph.image
- Class edu.stanford.nlp.scenegraph.image.SceneGraphImage extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - id
```
int id
```
    - url
```
java.lang.String url
```
    - height
```
int height
```
    - width
```
int width
```
    - objects
```
java.util.List<E> objects
```
    - regions
```
java.util.List<E> regions
```
    - relationships
```
java.util.List<E> relationships
```
    - attributes
```
java.util.List<E> attributes
```
Package edu.stanford.nlp.semgraph
- Class edu.stanford.nlp.semgraph.SemanticGraph extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - roots
```
java.util.Set<E> roots
```
      The distinguished root vertices, if known.
    - graph
```
DirectedMultiGraph<V,E> graph
```
    - comments
```
java.util.LinkedList<E> comments
```
- Class edu.stanford.nlp.semgraph.SemanticGraphEdge extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - relation
```
GrammaticalRelation relation
```
    - weight
```
double weight
```
    - isExtra
```
boolean isExtra
```
    - source
```
IndexedWord source
```
    - target
```
IndexedWord target
```
- Class edu.stanford.nlp.semgraph.UnknownVertexException extends java.lang.IllegalArgumentException implements Serializable
  - Serialized Fields
    - vertex
```
IndexedWord vertex
```
    - graph
```
SemanticGraph graph
```
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
```
    - isRoot
```
boolean isRoot
```
      Represents whether this is the root coordination. If so, the children have a higher operation priority, as the : operator is the lowest precedence possible.
    - children
```
java.util.List<E> children
```
- Class edu.stanford.nlp.semgraph.semgrex.Env extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4168610545399833956L
  - Serialized Fields
    - variables
```
java.util.Map<K,V> variables
```
      Mapping of variable names to their values.
- 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
```
java.util.Map<K,V> attributes
```
      A hash map from a key to a pair (case_sensitive_pattern, case_insensitive_pattern) If the type of the entry is a String, then string comparison is safe. If the type is a Boolean, it will always either match or not match corresponding to the Boolean value. Otherwise, the type will be a Pattern, and you must use Pattern.matches().
    - isRoot
```
boolean isRoot
```
    - isLink
```
boolean isLink
```
    - isEmpty
```
boolean isEmpty
```
    - name
```
java.lang.String name
```
    - descString
```
java.lang.String descString
```
    - child
```
SemgrexPattern child
```
    - variableGroups
```
java.util.List<E> variableGroups
```
- Class edu.stanford.nlp.semgraph.semgrex.ParseException extends java.lang.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 following this token will (therefore) be the first error token.
    - expectedTokenSequences
```
int[][] expectedTokenSequences
```
      Each entry in this array is an array of integers. Each array of integers represents a sequence of tokens (by their ordinal values) that is expected at this point of the parse.
    - tokenImage
```
java.lang.String[] tokenImage
```
      This is a reference to the "tokenImage" array of the generated parser within which the parse error occurred. This array is defined in the generated ...Constants interface.
- Class edu.stanford.nlp.semgraph.semgrex.SemgrexParseException extends java.lang.RuntimeException implements Serializable
- Class edu.stanford.nlp.semgraph.semgrex.SemgrexPattern extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1722052832350596732L
  - Serialized Fields
    - neg
```
boolean neg
```
    - opt
```
boolean opt
```
    - patternString
```
java.lang.String patternString
```
    - env
```
Env env
```
Package edu.stanford.nlp.semgraph.semgrex.ssurgeon
- Class edu.stanford.nlp.semgraph.semgrex.ssurgeon.SsurgeonParseException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  -278683457698L
- Class edu.stanford.nlp.semgraph.semgrex.ssurgeon.SsurgeonRuntimeException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  -278683457698L
Package edu.stanford.nlp.semgraph.semgrex.ssurgeon.pred
- Class edu.stanford.nlp.semgraph.semgrex.ssurgeon.pred.SsurgAndPred extends java.util.ArrayList<SsurgPred> implements Serializable
  
  serialVersionUID:
  
  760573332472162149L
- Class edu.stanford.nlp.semgraph.semgrex.ssurgeon.pred.SsurgOrPred extends java.util.ArrayList<SsurgPred> implements Serializable
  
  serialVersionUID:
  
  4581463857927967518L
Package edu.stanford.nlp.sentiment
- Class edu.stanford.nlp.sentiment.ForwardPropagationException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  564523452761325243L
- Class edu.stanford.nlp.sentiment.RNNOptions extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream in)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
  - Serialized Fields
    - randomSeed
```
int randomSeed
```
      The random seed the random number generator is initialized with.
    - wordVectors
```
java.lang.String wordVectors
```
      Filename for the word vectors
    - unkWord
```
java.lang.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
```
java.lang.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
```
java.lang.String[] equivalenceClassNames
```
    - testOptions
```
RNNTestOptions testOptions
```
- Class edu.stanford.nlp.sentiment.RNNTestOptions extends java.lang.Object implements Serializable
  - Serialized Fields
    - ngramRecordSize
```
int ngramRecordSize
```
    - ngramRecordMaximumLength
```
int ngramRecordMaximumLength
```
    - printLengthAccuracies
```
boolean printLengthAccuracies
```
- Class edu.stanford.nlp.sentiment.RNNTrainOptions extends java.lang.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
    - shuffleMatrices
```
boolean shuffleMatrices
```
      Shuffle matrices when training. Usually should be true. Set to false to compare training across different implementations, such as with the original Matlab version
    - initialMatrixLogPath
```
java.lang.String initialMatrixLogPath
```
      If set, the initial matrices are logged to this location as a single file using SentimentModel.toString()
    - nThreads
```
int nThreads
```
- Class edu.stanford.nlp.sentiment.SentimentModel extends java.lang.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
```
java.util.Map<K,V> unaryClassification
```
      CxN+1, where N = size of word vectors, C is the number of classes
    - wordVectors
```
java.util.Map<K,V> wordVectors
```
      Map from vocabulary words to word vectors.
      
      See Also:
      
      SentimentModel.getWordVector(String)
    - 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
```
java.util.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 java.lang.Object implements Serializable

serialVersionUID:

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

serialVersionUID:

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

serialVersionUID:

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

serialVersionUID:

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

serialVersionUID:

7249250071983091694L
- Serialized Fields
  - flags
```
SeqClassifierFlags flags
```
Class edu.stanford.nlp.sequences.LibSVMReaderAndWriter extends java.lang.Object implements Serializable

serialVersionUID:

-7997837004847909059L
- Serialized Fields
  - flags
```
SeqClassifierFlags flags
```
  - factory
```
IteratorFromReaderFactory<T> factory
```
  - num
```
int num
```
Class edu.stanford.nlp.sequences.MalletFeatureFactory extends FeatureFactory<IN extends CoreLabel> implements Serializable

serialVersionUID:

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

serialVersionUID:

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

serialVersionUID:

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

serialVersionUID:

-3838331732026362075L
- Serialized Fields
  - flags
```
SeqClassifierFlags flags
```
  - wrapped
```
ObjectBank<E> wrapped
```
  - knownLCWords
```
java.util.Set<E> knownLCWords
```
Class edu.stanford.nlp.sequences.PlainTextDocumentReaderAndWriter extends java.lang.Object implements Serializable

serialVersionUID:

-2420535144980273136L
- Serialized Fields
  - wts
```
WordToSentenceProcessor<IN> wts
```
  - flags
```
SeqClassifierFlags flags
```
  - tokenizerFactory
```
TokenizerFactory<T> tokenizerFactory
```

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

serialVersionUID:: -7076671761070232567L

Serialized Fields

stringRep
```
java.lang.String stringRep
```
useNGrams
```
boolean useNGrams
```
conjoinShapeNGrams
```
boolean conjoinShapeNGrams
```
lowercaseNGrams
```
boolean lowercaseNGrams
```
dehyphenateNGrams
```
boolean dehyphenateNGrams
```
usePrev
```
boolean usePrev
```
useNext
```
boolean useNext
```
useTags
```
boolean useTags
```
useWordPairs
```
boolean useWordPairs
```
useGazettes
```
boolean useGazettes
```
useSequences
```
boolean useSequences
```
usePrevSequences
```
boolean usePrevSequences
```
useNextSequences
```
boolean useNextSequences
```
useLongSequences
```
boolean useLongSequences
```
useBoundarySequences
```
boolean useBoundarySequences
```
useTaggySequences
```
boolean useTaggySequences
```
useExtraTaggySequences
```
boolean useExtraTaggySequences
```
dontExtendTaggy
```
boolean dontExtendTaggy
```

useTaggySequencesShapeInteraction

boolean useTaggySequencesShapeInteraction

strictlyZeroethOrder
```
boolean strictlyZeroethOrder
```
strictlyFirstOrder
```
boolean strictlyFirstOrder
```
strictlySecondOrder
```
boolean strictlySecondOrder
```
strictlyThirdOrder
```
boolean strictlyThirdOrder
```

entitySubclassification

java.lang.String entitySubclassification

retainEntitySubclassification
```
boolean retainEntitySubclassification
```
useGazettePhrases
```
boolean useGazettePhrases
```
makeConsistent
```
boolean makeConsistent
```
useViterbi
```
boolean useViterbi
```
binnedLengths
```
int[] binnedLengths
```
verboseMode
```
boolean verboseMode
```
useSum
```
boolean useSum
```
tolerance
```
double tolerance
```
printFeatures
```
java.lang.String printFeatures
```
useSymTags
```
boolean useSymTags
```
useSymWordPairs
```
boolean useSymWordPairs
```
useSymWordPairs Has a small negative effect.
printClassifier
```
java.lang.String printClassifier
```
printClassifierParam
```
int printClassifierParam
```
intern
```
boolean intern
```
intern2
```
boolean intern2
```
selfTest
```
boolean selfTest
```
sloppyGazette
```
boolean sloppyGazette
```
cleanGazette
```
boolean cleanGazette
```
noMidNGrams
```
boolean noMidNGrams
```
maxNGramLeng
```
int maxNGramLeng
```
useReverse
```
boolean useReverse
```
greekifyNGrams
```
boolean greekifyNGrams
```
useParenMatching
```
boolean useParenMatching
```
useLemmas
```
boolean useLemmas
```
usePrevNextLemmas
```
boolean usePrevNextLemmas
```
normalizeTerms
```
boolean normalizeTerms
```
normalizeTimex
```
boolean normalizeTimex
```
useNB
```
boolean useNB
```
useQN
```
boolean useQN
```
useFloat
```
boolean useFloat
```
QNsize
```
int QNsize
```
QNsize2
```
int QNsize2
```
maxIterations
```
int maxIterations
```
wordShape
```
int wordShape
```
useShapeStrings
```
boolean useShapeStrings
```
Set useShapeStrings to be true to say that the model should use word shape features and they are provided in the tokens, but should not be calculated via a word shape function. This flag must be false if the word shape features will be calculated; word shape features are also added if there is a defined word shape function.
useTypeSeqs
```
boolean useTypeSeqs
```
useTypeSeqs2
```
boolean useTypeSeqs2
```
useTypeSeqs3
```
boolean useTypeSeqs3
```
useDisjunctive
```
boolean useDisjunctive
```
disjunctionWidth
```
int disjunctionWidth
```
useDisjunctiveShapeInteraction
```
boolean useDisjunctiveShapeInteraction
```
useDisjShape
```
boolean useDisjShape
```
useWord
```
boolean useWord
```
useClassFeature
```
boolean useClassFeature
```
useShapeConjunctions
```
boolean useShapeConjunctions
```
useWordTag
```
boolean useWordTag
```
useNPHead
```
boolean useNPHead
```
useNPGovernor
```
boolean useNPGovernor
```
useHeadGov
```
boolean useHeadGov
```
useLastRealWord
```
boolean useLastRealWord
```
useNextRealWord
```
boolean useNextRealWord
```
useOccurrencePatterns
```
boolean useOccurrencePatterns
```
useTypeySequences
```
boolean useTypeySequences
```
justify
```
boolean justify
```
normalize
```
boolean normalize
```
priorType
```
java.lang.String priorType
```
sigma
```
double sigma
```
epsilon
```
double epsilon
```
beamSize
```
int beamSize
```
maxLeft
```
int maxLeft
```
maxRight
```
int maxRight
```
usePosition
```
boolean usePosition
```
useBeginSent
```
boolean useBeginSent
```
useGazFeatures
```
boolean useGazFeatures
```
useMoreGazFeatures
```
boolean useMoreGazFeatures
```
useAbbr
```
boolean useAbbr
```
useMinimalAbbr
```
boolean useMinimalAbbr
```
useAbbr1
```
boolean useAbbr1
```
useMinimalAbbr1
```
boolean useMinimalAbbr1
```
useMoreAbbr
```
boolean useMoreAbbr
```
deleteBlankLines
```
boolean deleteBlankLines
```
useGENIA
```
boolean useGENIA
```
useTOK
```
boolean useTOK
```
useABSTR
```
boolean useABSTR
```
useABSTRFreqDict
```
boolean useABSTRFreqDict
```
useABSTRFreq
```
boolean useABSTRFreq
```
useFREQ
```
boolean useFREQ
```
useABGENE
```
boolean useABGENE
```
useWEB
```
boolean useWEB
```
useWEBFreqDict
```
boolean useWEBFreqDict
```
useIsURL
```
boolean useIsURL
```
useURLSequences
```
boolean useURLSequences
```
useIsDateRange
```
boolean useIsDateRange
```
useEntityTypes
```
boolean useEntityTypes
```
useEntityTypeSequences
```
boolean useEntityTypeSequences
```
useEntityRule
```
boolean useEntityRule
```
useOrdinal
```
boolean useOrdinal
```
useACR
```
boolean useACR
```
useANTE
```
boolean useANTE
```
useMoreTags
```
boolean useMoreTags
```
useChunks
```
boolean useChunks
```
useChunkySequences
```
boolean useChunkySequences
```
usePrevVB
```
boolean usePrevVB
```
useNextVB
```
boolean useNextVB
```
useVB
```
boolean useVB
```
subCWGaz
```
boolean subCWGaz
```
documentReader
```
java.lang.String documentReader
```
map
```
java.lang.String map
```
useWideDisjunctive
```
boolean useWideDisjunctive
```
wideDisjunctionWidth
```
int wideDisjunctionWidth
```
useRadical
```
boolean useRadical
```
useBigramInTwoClique
```
boolean useBigramInTwoClique
```
morphFeatureFile
```
java.lang.String morphFeatureFile
```
useReverseAffix
```
boolean useReverseAffix
```
charHalfWindow
```
int charHalfWindow
```
useWord1
```
boolean useWord1
```
useWord2
```
boolean useWord2
```
useWord3
```
boolean useWord3
```
useWord4
```
boolean useWord4
```
useRad1
```
boolean useRad1
```
useRad2
```
boolean useRad2
```
useWordn
```
boolean useWordn
```
useCTBPre1
```
boolean useCTBPre1
```
useCTBSuf1
```
boolean useCTBSuf1
```
useASBCPre1
```
boolean useASBCPre1
```
useASBCSuf1
```
boolean useASBCSuf1
```
usePKPre1
```
boolean usePKPre1
```
usePKSuf1
```
boolean usePKSuf1
```
useHKPre1
```
boolean useHKPre1
```
useHKSuf1
```
boolean useHKSuf1
```
useCTBChar2
```
boolean useCTBChar2
```
useASBCChar2
```
boolean useASBCChar2
```
useHKChar2
```
boolean useHKChar2
```
usePKChar2
```
boolean usePKChar2
```
useRule2
```
boolean useRule2
```
useDict2
```
boolean useDict2
```
useOutDict2
```
boolean useOutDict2
```
outDict2
```
java.lang.String outDict2
```
useDictleng
```
boolean useDictleng
```
useDictCTB2
```
boolean useDictCTB2
```
useDictASBC2
```
boolean useDictASBC2
```
useDictPK2
```
boolean useDictPK2
```
useDictHK2
```
boolean useDictHK2
```
useBig5
```
boolean useBig5
```
useNegDict2
```
boolean useNegDict2
```
useNegDict3
```
boolean useNegDict3
```
useNegDict4
```
boolean useNegDict4
```
useNegCTBDict2
```
boolean useNegCTBDict2
```
useNegCTBDict3
```
boolean useNegCTBDict3
```
useNegCTBDict4
```
boolean useNegCTBDict4
```
useNegASBCDict2
```
boolean useNegASBCDict2
```
useNegASBCDict3
```
boolean useNegASBCDict3
```
useNegASBCDict4
```
boolean useNegASBCDict4
```
useNegHKDict2
```
boolean useNegHKDict2
```
useNegHKDict3
```
boolean useNegHKDict3
```
useNegHKDict4
```
boolean useNegHKDict4
```
useNegPKDict2
```
boolean useNegPKDict2
```
useNegPKDict3
```
boolean useNegPKDict3
```
useNegPKDict4
```
boolean useNegPKDict4
```
usePre
```
boolean usePre
```
useSuf
```
boolean useSuf
```
useRule
```
boolean useRule
```
useHk
```
boolean useHk
```
useMsr
```
boolean useMsr
```
useMSRChar2
```
boolean useMSRChar2
```
usePk
```
boolean usePk
```
useAs
```
boolean useAs
```
useFilter
```
boolean useFilter
```
largeChSegFile
```
boolean largeChSegFile
```
useRad2b
```
boolean useRad2b
```
keepEnglishWhitespaces
```
boolean keepEnglishWhitespaces
```
Keep the whitespace between English words in testFile when printing out answers. Doesn't really change the content of the CoreLabels. (For Chinese segmentation.)
keepAllWhitespaces
```
boolean keepAllWhitespaces
```
Keep all the whitespace words in testFile when printing out answers. Doesn't really change the content of the CoreLabels. (For Chinese segmentation.)
sighanPostProcessing
```
boolean sighanPostProcessing
```
useChPos
```
boolean useChPos
```
use POS information (an "open" feature for Chinese segmentation)
normalizationTable
```
java.lang.String normalizationTable
```
dictionary
```
java.lang.String dictionary
```
serializedDictionary
```
java.lang.String serializedDictionary
```
dictionary2
```
java.lang.String dictionary2
```
normTableEncoding
```
java.lang.String normTableEncoding
```
sighanCorporaDict
```
java.lang.String sighanCorporaDict
```
for Sighan bakeoff 2005, the path to the dictionary of bigrams appeared in corpus
useWordShapeGaz
```
boolean useWordShapeGaz
```
wordShapeGaz
```
java.lang.String wordShapeGaz
```
splitDocuments
```
boolean splitDocuments
```
printXML
```
boolean printXML
```
useSeenFeaturesOnly
```
boolean useSeenFeaturesOnly
```
lastNameList
```
java.lang.String lastNameList
```
maleNameList
```
java.lang.String maleNameList
```
femaleNameList
```
java.lang.String femaleNameList
```
inputEncoding
```
java.lang.String inputEncoding
```
bioSubmitOutput
```
boolean bioSubmitOutput
```
numRuns
```
int numRuns
```
answerFile
```
java.lang.String answerFile
```
altAnswerFile
```
java.lang.String altAnswerFile
```
dropGaz
```
java.lang.String dropGaz
```
printGazFeatures
```
java.lang.String printGazFeatures
```
numStartLayers
```
int numStartLayers
```
dump
```
boolean dump
```
mergeTags
```
boolean mergeTags
```
splitOnHead
```
boolean splitOnHead
```
featureCountThreshold
```
int featureCountThreshold
```
featureWeightThreshold
```
double featureWeightThreshold
```
featureFactory
```
java.lang.String featureFactory
```
featureFactoryArgs
```
java.lang.Object[] featureFactoryArgs
```
backgroundSymbol
```
java.lang.String backgroundSymbol
```
useObservedSequencesOnly
```
boolean useObservedSequencesOnly
```
maxDocSize
```
int maxDocSize
```
printProbs
```
boolean printProbs
```
printFirstOrderProbs
```
boolean printFirstOrderProbs
```
saveFeatureIndexToDisk
```
boolean saveFeatureIndexToDisk
```

removeBackgroundSingletonFeatures

boolean removeBackgroundSingletonFeatures

doGibbs
```
boolean doGibbs
```
numSamples
```
int numSamples
```
useNERPrior
```
boolean useNERPrior
```
useAcqPrior
```
boolean useAcqPrior
```
useUniformPrior
```
boolean useUniformPrior
```
useMUCFeatures
```
boolean useMUCFeatures
```
annealingRate
```
double annealingRate
```
annealingType
```
java.lang.String annealingType
```
loadProcessedData
```
java.lang.String loadProcessedData
```
initViterbi
```
boolean initViterbi
```
useUnknown
```
boolean useUnknown
```
checkNameList
```
boolean checkNameList
```
useSemPrior
```
boolean useSemPrior
```
useFirstWord
```
boolean useFirstWord
```
useNumberFeature
```
boolean useNumberFeature
```
ocrFold
```
int ocrFold
```
classifierType
```
java.lang.String classifierType
```
svmModelFile
```
java.lang.String svmModelFile
```
inferenceType
```
java.lang.String inferenceType
```
useLemmaAsWord
```
boolean useLemmaAsWord
```
type
```
java.lang.String type
```
readerAndWriter
```
java.lang.String readerAndWriter
```
comboProps
```
java.util.List<E> comboProps
```
usePrediction
```
boolean usePrediction
```
useAltGazFeatures
```
boolean useAltGazFeatures
```
gazFilesFile
```
java.lang.String gazFilesFile
```
usePrediction2
```
boolean usePrediction2
```
baseTrainDir
```
java.lang.String baseTrainDir
```
baseTestDir
```
java.lang.String baseTestDir
```
trainFiles
```
java.lang.String trainFiles
```
A regex pattern for files, which will be evaluated within a particular directory. If non-null, used over trainFileList and trainFile.
trainFileList
```
java.lang.String trainFileList
```
testFiles
```
java.lang.String testFiles
```
trainDirs
```
java.lang.String trainDirs
```
testDirs
```
java.lang.String testDirs
```
useOnlySeenWeights
```
boolean useOnlySeenWeights
```
predProp
```
java.lang.String predProp
```
pad
```
CoreLabel pad
```
useObservedFeaturesOnly
```
boolean useObservedFeaturesOnly
```
distSimLexicon
```
java.lang.String distSimLexicon
```
useDistSim
```
boolean useDistSim
```
removeTopN
```
int removeTopN
```
numTimesRemoveTopN
```
int numTimesRemoveTopN
```
randomizedRatio
```
double randomizedRatio
```
removeTopNPercent
```
double removeTopNPercent
```
purgeFeatures
```
int purgeFeatures
```
booleanFeatures
```
boolean booleanFeatures
```
iobWrapper
```
boolean iobWrapper
```
iobTags
```
boolean iobTags
```
useSegmentation
```
boolean useSegmentation
```
Binary segmentation feature for character-based Chinese NER.
memoryThrift
```
boolean memoryThrift
```
timitDatum
```
boolean timitDatum
```
serializeDatasetsDir
```
java.lang.String serializeDatasetsDir
```
loadDatasetsDir
```
java.lang.String loadDatasetsDir
```
pushDir
```
java.lang.String pushDir
```
purgeDatasets
```
boolean purgeDatasets
```
keepOBInMemory
```
boolean keepOBInMemory
```
fakeDataset
```
boolean fakeDataset
```
restrictTransitionsTimit
```
boolean restrictTransitionsTimit
```
numDatasetsPerFile
```
int numDatasetsPerFile
```
useTitle
```
boolean useTitle
```
lowerNewgeneThreshold
```
boolean lowerNewgeneThreshold
```
useEitherSideWord
```
boolean useEitherSideWord
```
useEitherSideDisjunctive
```
boolean useEitherSideDisjunctive
```
twoStage
```
boolean twoStage
```
crfType
```
java.lang.String crfType
```
featureThreshold
```
int featureThreshold
```
featThreshFile
```
java.lang.String featThreshFile
```
featureDiffThresh
```
double featureDiffThresh
```
numTimesPruneFeatures
```
int numTimesPruneFeatures
```
newgeneThreshold
```
double newgeneThreshold
```
doAdaptation
```
boolean doAdaptation
```
useInternal
```
boolean useInternal
```
useExternal
```
boolean useExternal
```
selfTrainConfidenceThreshold
```
double selfTrainConfidenceThreshold
```
selfTrainIterations
```
int selfTrainIterations
```
selfTrainWindowSize
```
int selfTrainWindowSize
```
useHuber
```
boolean useHuber
```
useQuartic
```
boolean useQuartic
```
adaptSigma
```
double adaptSigma
```
numFolds
```
int numFolds
```
startFold
```
int startFold
```
endFold
```
int endFold
```
cacheNGrams
```
boolean cacheNGrams
```
outputFormat
```
java.lang.String outputFormat
```
useSMD
```
boolean useSMD
```
useSGDtoQN
```
boolean useSGDtoQN
```
useStochasticQN
```
boolean useStochasticQN
```
useScaledSGD
```
boolean useScaledSGD
```
scaledSGDMethod
```
int scaledSGDMethod
```
SGDPasses
```
int SGDPasses
```
QNPasses
```
int QNPasses
```
tuneSGD
```
boolean tuneSGD
```

stochasticMethod

StochasticCalculateMethods stochasticMethod

initialGain
```
double initialGain
```
stochasticBatchSize
```
int stochasticBatchSize
```
useSGD
```
boolean useSGD
```
gainSGD
```
double gainSGD
```
useHybrid
```
boolean useHybrid
```
hybridCutoffIteration
```
int hybridCutoffIteration
```
outputIterationsToFile
```
boolean outputIterationsToFile
```
testObjFunction
```
boolean testObjFunction
```
testVariance
```
boolean testVariance
```
SGD2QNhessSamples
```
int SGD2QNhessSamples
```
testHessSamples
```
boolean testHessSamples
```
CRForder
```
int CRForder
```
CRFwindow
```
int CRFwindow
```
estimateInitial
```
boolean estimateInitial
```
outputEncoding
```
java.lang.String outputEncoding
```
useKBest
```
boolean useKBest
```
searchGraphPrefix
```
java.lang.String searchGraphPrefix
```
searchGraphPrune
```
double searchGraphPrune
```
kBest
```
int kBest
```
useFeaturesC4gram
```
boolean useFeaturesC4gram
```
useFeaturesC5gram
```
boolean useFeaturesC5gram
```
useFeaturesC6gram
```
boolean useFeaturesC6gram
```
useFeaturesCpC4gram
```
boolean useFeaturesCpC4gram
```
useFeaturesCpC5gram
```
boolean useFeaturesCpC5gram
```
useFeaturesCpC6gram
```
boolean useFeaturesCpC6gram
```
useUnicodeType
```
boolean useUnicodeType
```
useUnicodeType4gram
```
boolean useUnicodeType4gram
```
useUnicodeType5gram
```
boolean useUnicodeType5gram
```
use4Clique
```
boolean use4Clique
```
useUnicodeBlock
```
boolean useUnicodeBlock
```
useShapeStrings1
```
boolean useShapeStrings1
```
useShapeStrings3
```
boolean useShapeStrings3
```
useShapeStrings4
```
boolean useShapeStrings4
```
useShapeStrings5
```
boolean useShapeStrings5
```
useGoodForNamesCpC
```
boolean useGoodForNamesCpC
```
useDictionaryConjunctions
```
boolean useDictionaryConjunctions
```
expandMidDot
```
boolean expandMidDot
```
printFeaturesUpto
```
int printFeaturesUpto
```
useDictionaryConjunctions3
```
boolean useDictionaryConjunctions3
```
useWordUTypeConjunctions2
```
boolean useWordUTypeConjunctions2
```
useWordUTypeConjunctions3
```
boolean useWordUTypeConjunctions3
```
useWordShapeConjunctions2
```
boolean useWordShapeConjunctions2
```
useWordShapeConjunctions3
```
boolean useWordShapeConjunctions3
```
useMidDotShape
```
boolean useMidDotShape
```
augmentedDateChars
```
boolean augmentedDateChars
```
suppressMidDotPostprocessing
```
boolean suppressMidDotPostprocessing
```
printNR
```
boolean printNR
```
classBias
```
java.lang.String classBias
```
printLabelValue
```
boolean printLabelValue
```
useRobustQN
```
boolean useRobustQN
```
combo
```
boolean combo
```
useGenericFeatures
```
boolean useGenericFeatures
```
verboseForTrueCasing
```
boolean verboseForTrueCasing
```
trainHierarchical
```
java.lang.String trainHierarchical
```
domain
```
java.lang.String domain
```
baseline
```
boolean baseline
```
transferSigmas
```
java.lang.String transferSigmas
```
doFE
```
boolean doFE
```
restrictLabels
```
boolean restrictLabels
```
announceObjectBankEntries
```
boolean announceObjectBankEntries
```
l1reg
```
double l1reg
```
mixedCaseMapFile
```
java.lang.String mixedCaseMapFile
```
auxTrueCaseModels
```
java.lang.String auxTrueCaseModels
```
use2W
```
boolean use2W
```
useLC
```
boolean useLC
```
useYetMoreCpCShapes
```
boolean useYetMoreCpCShapes
```
useIfInteger
```
boolean useIfInteger
```
exportFeatures
```
java.lang.String exportFeatures
```
useInPlaceSGD
```
boolean useInPlaceSGD
```
useTopics
```
boolean useTopics
```
evaluateIters
```
int evaluateIters
```
evalCmd
```
java.lang.String evalCmd
```
evaluateTrain
```
boolean evaluateTrain
```
tuneSampleSize
```
int tuneSampleSize
```
usePhraseFeatures
```
boolean usePhraseFeatures
```
usePhraseWords
```
boolean usePhraseWords
```
usePhraseWordTags
```
boolean usePhraseWordTags
```
usePhraseWordSpecialTags
```
boolean usePhraseWordSpecialTags
```
useCommonWordsFeature
```
boolean useCommonWordsFeature
```
useProtoFeatures
```
boolean useProtoFeatures
```
useWordnetFeatures
```
boolean useWordnetFeatures
```
tokenFactory
```
java.lang.String tokenFactory
```
tokenFactoryArgs
```
java.lang.Object[] tokenFactoryArgs
```

tokensAnnotationClassName

java.lang.String tokensAnnotationClassName

useCorefFeatures
```
boolean useCorefFeatures
```
wikiFeatureDbFile
```
java.lang.String wikiFeatureDbFile
```
useNoisyNonNoisyFeature
```
boolean useNoisyNonNoisyFeature
```
useYear
```
boolean useYear
```
useSentenceNumber
```
boolean useSentenceNumber
```
useLabelSource
```
boolean useLabelSource
```
casedDistSim
```
boolean casedDistSim
```
Whether to (not) lowercase tokens before looking them up in distsim lexicon. By default lowercasing was done, but now it doesn't have to be true :-).
distSimFileFormat
```
java.lang.String distSimFileFormat
```
The format of the distsim file. Known values are: alexClark = TSV file. word TAB clusterNumber [optional other content] terryKoo = TSV file. clusterBitString TAB word TAB frequency
distSimMaxBits
```
int distSimMaxBits
```
If this number is greater than 0, the distSim class is assume to be a bit string and is truncated at this many characters. Normal distSim features will then use this amount of resolution. Extra, special distsim features may work at a coarser level of resolution. Since the lexicon only stores this length of bit string, there is then no way to have finer-grained clusters.
numberEquivalenceDistSim
```
boolean numberEquivalenceDistSim
```
If this is set to true, all digit characters get mapped to '9' in a distsim lexicon and for lookup. This is a simple word shaping that can shrink distsim lexicons and improve their performance.
unknownWordDistSimClass
```
java.lang.String unknownWordDistSimClass
```
What class to assign to words not found in the dist sim lexicon. You might want to make it a known class, if one is the "default class.
useNeighborNGrams
```
boolean useNeighborNGrams
```
Use prefixes and suffixes from the previous and current word in edge clique.
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

java.lang.String plainTextDocumentReaderAndWriter

useBagOfWords
```
boolean useBagOfWords
```
Use a bag of all words as a feature. Perhaps this will find some words that indicate certain types of entities are present.
evaluateBackground
```
boolean evaluateBackground
```
When scoring, count the background symbol stats too. Useful for things where the background symbol is particularly meaningful, such as truecase.
numLopExpert
```
int numLopExpert
```
Number of experts to be used in Logarithmic Opinion Pool (product of experts) training default value is 1
includeFullCRFInLOP
```
boolean includeFullCRFInLOP
```
backpropLopTraining
```
boolean backpropLopTraining
```
randomLopWeights
```
boolean randomLopWeights
```
randomLopFeatureSplit
```
boolean randomLopFeatureSplit
```
nonLinearCRF
```
boolean nonLinearCRF
```
secondOrderNonLinear
```
boolean secondOrderNonLinear
```
numHiddenUnits
```
int numHiddenUnits
```
useOutputLayer
```
boolean useOutputLayer
```
useHiddenLayer
```
boolean useHiddenLayer
```
gradientDebug
```
boolean gradientDebug
```
checkGradient
```
boolean checkGradient
```
useSigmoid
```
boolean useSigmoid
```
skipOutputRegularization
```
boolean skipOutputRegularization
```
sparseOutputLayer
```
boolean sparseOutputLayer
```
tieOutputLayer
```
boolean tieOutputLayer
```
blockInitialize
```
boolean blockInitialize
```
softmaxOutputLayer
```
boolean softmaxOutputLayer
```
loadBisequenceClassifierEn
```
java.lang.String loadBisequenceClassifierEn
```
Bisequence CRF parameters

loadBisequenceClassifierCh

java.lang.String loadBisequenceClassifierCh

bisequenceClassifierPropEn

java.lang.String bisequenceClassifierPropEn

bisequenceClassifierPropCh

java.lang.String bisequenceClassifierPropCh

bisequenceTestFileEn
```
java.lang.String bisequenceTestFileEn
```
bisequenceTestFileCh
```
java.lang.String bisequenceTestFileCh
```
bisequenceTestOutputEn
```
java.lang.String bisequenceTestOutputEn
```
bisequenceTestOutputCh
```
java.lang.String bisequenceTestOutputCh
```

bisequenceTestAlignmentFile

java.lang.String bisequenceTestAlignmentFile

bisequenceAlignmentTestOutput

java.lang.String bisequenceAlignmentTestOutput

bisequencePriorType
```
int bisequencePriorType
```

bisequenceAlignmentPriorPenaltyCh

java.lang.String bisequenceAlignmentPriorPenaltyCh

bisequenceAlignmentPriorPenaltyEn

java.lang.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
```
java.lang.String entityMatrixCh
```
entityMatrixEn
```
java.lang.String entityMatrixEn
```
multiThreadGibbs
```
int multiThreadGibbs
```
matchNERIncentive
```
boolean matchNERIncentive
```
useEmbedding
```
boolean useEmbedding
```
prependEmbedding
```
boolean prependEmbedding
```
embeddingWords
```
java.lang.String embeddingWords
```
embeddingVectors
```
java.lang.String embeddingVectors
```
transitionEdgeOnly
```
boolean transitionEdgeOnly
```
priorLambda
```
double priorLambda
```
addCapitalFeatures
```
boolean addCapitalFeatures
```
arbitraryInputLayerSize
```
int arbitraryInputLayerSize
```
noEdgeFeature
```
boolean noEdgeFeature
```
terminateOnEvalImprovement
```
boolean terminateOnEvalImprovement
```

terminateOnEvalImprovementNumOfEpoch

int terminateOnEvalImprovementNumOfEpoch

useMemoryEvaluator
```
boolean useMemoryEvaluator
```
suppressTestDebug
```
boolean suppressTestDebug
```
useOWLQN
```
boolean useOWLQN
```
printWeights
```
boolean printWeights
```
totalDataSlice
```
int totalDataSlice
```
numOfSlices
```
int numOfSlices
```
regularizeSoftmaxTieParam
```
boolean regularizeSoftmaxTieParam
```
softmaxTieLambda
```
double softmaxTieLambda
```
totalFeatureSlice
```
int totalFeatureSlice
```
numOfFeatureSlices
```
int numOfFeatureSlices
```
addBiasToEmbedding
```
boolean addBiasToEmbedding
```
hardcodeSoftmaxOutputWeights
```
boolean hardcodeSoftmaxOutputWeights
```
useNERPriorBIO
```
boolean useNERPriorBIO
```
entityMatrix
```
java.lang.String entityMatrix
```
multiThreadClassifier
```
int multiThreadClassifier
```
useDualDecomp
```
boolean useDualDecomp
```
biAlignmentPriorIsPMI
```
boolean biAlignmentPriorIsPMI
```
dampDDStepSizeWithAlignmentProb
```
boolean dampDDStepSizeWithAlignmentProb
```
dualDecompAlignment
```
boolean dualDecompAlignment
```

dualDecompInitialStepSizeAlignment

double dualDecompInitialStepSizeAlignment

dualDecompNotBIO
```
boolean dualDecompNotBIO
```

berkeleyAlignerLoadPath

java.lang.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
```
java.lang.String splitWordRegex
```
groupByInput
```
boolean groupByInput
```
groupByHiddenUnit
```
boolean groupByHiddenUnit
```
unigramLM
```
java.lang.String unigramLM
```
bigramLM
```
java.lang.String bigramLM
```
wordSegBeamSize
```
int wordSegBeamSize
```
vocabFile
```
java.lang.String vocabFile
```
normalizedFile
```
java.lang.String normalizedFile
```
averagePerceptron
```
boolean averagePerceptron
```
loadCRFSegmenterPath
```
java.lang.String loadCRFSegmenterPath
```
loadPCTSegmenterPath
```
java.lang.String loadPCTSegmenterPath
```
crfSegmenterProp
```
java.lang.String crfSegmenterProp
```
pctSegmenterProp
```
java.lang.String pctSegmenterProp
```

intermediateSegmenterOut

java.lang.String intermediateSegmenterOut

intermediateSegmenterModel

java.lang.String intermediateSegmenterModel

dualDecompMaxItr
```
int dualDecompMaxItr
```
dualDecompInitialStepSize
```
double dualDecompInitialStepSize
```
dualDecompDebug
```
boolean dualDecompDebug
```
useCWSWordFeatures
```
boolean useCWSWordFeatures
```
useCWSWordFeaturesAll
```
boolean useCWSWordFeaturesAll
```
useCWSWordFeaturesBigram
```
boolean useCWSWordFeaturesBigram
```
pctSegmenterLenAdjust
```
boolean pctSegmenterLenAdjust
```
useTrainLexicon
```
boolean useTrainLexicon
```
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
```
java.lang.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
```
java.lang.String loadWeightsFromEN
```
loadWeightsFromCH
```
java.lang.String loadWeightsFromCH
```
serializeToEN
```
java.lang.String serializeToEN
```
serializeToCH
```
java.lang.String serializeToCH
```
testFileEN
```
java.lang.String testFileEN
```
testFileCH
```
java.lang.String testFileCH
```
unsupFileEN
```
java.lang.String unsupFileEN
```
unsupFileCH
```
java.lang.String unsupFileCH
```
unsupAlignFile
```
java.lang.String unsupAlignFile
```
supFileEN
```
java.lang.String supFileEN
```
supFileCH
```
java.lang.String supFileCH
```
loadFeatureIndexFromEN
```
java.lang.String loadFeatureIndexFromEN
```
loadFeatureIndexFromCH
```
java.lang.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
```
java.lang.String[] featureFactories
```
featureFactoriesArgs
```
java.util.List<E> featureFactoriesArgs
```
useNoisyLabel
```
boolean useNoisyLabel
```
errorMatrix
```
java.lang.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
```
java.lang.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.
useUndirectedDisjunctive
```
boolean useUndirectedDisjunctive
```
Put in undirected (left/right) bag of words features for local neighborhood. Seems much worse than regular useDisjunctive.
splitSlashHyphenWords
```
boolean splitSlashHyphenWords
```
maxAdditionalKnownLCWords
```
int maxAdditionalKnownLCWords
```
How many words it is okay to add to knownLCWords after initial training. If this number is negative, then add any number of further words during classifying/testing. If this number is non-negative (greater than or equal to 0), then add at most this many words to the knownLCWords. By default, this is now set to 0, so there is no transductive learning on the test set, since too many people complained about results changing over runs. However, traditionally we used a non-zero value, and this usually helps performance a bit (until 2014 it was -1, then it was set to 10_000, so that memory would not grow without bound if a SequenceClassifier is run for a long time.

slashHyphenTreatment

SeqClassifierFlags.SlashHyphenEnum slashHyphenTreatment

useTitle2
```
boolean useTitle2
```
showNCCInfo
```
boolean showNCCInfo
```
showCCInfo
```
boolean showCCInfo
```
crfToExamine
```
java.lang.String crfToExamine
```
useSUTime
```
boolean useSUTime
```
applyNumericClassifiers
```
boolean applyNumericClassifiers
```
combinationMode
```
java.lang.String combinationMode
```
nerModel
```
java.lang.String nerModel
```
useMoreNeighborNGrams
```
boolean useMoreNeighborNGrams
```
Use prefixes and suffixes from the previous and next word in node clique.
dict2name
```
java.lang.String dict2name
```
if using dict2 in a segmenter, load it with this filename

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

serialVersionUID:

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

Package edu.stanford.nlp.simple
- Class edu.stanford.nlp.simple.Token extends java.lang.Object implements Serializable
  - Serialized Fields
    - sentence
```
Sentence sentence
```
      The underlying sentence supplying the fields for this token.
    - index
```
int index
```
      The index of this token in the underlying sentence. This can be out of bounds; the sentence is assumed to be infinitely padded.
Package edu.stanford.nlp.stats
- Class edu.stanford.nlp.stats.ClassicCounter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - mapFactory
```
MapFactory<K,V> mapFactory
```
    - totalCount
```
double totalCount
```
    - defaultValue
```
double defaultValue
```
- Class edu.stanford.nlp.stats.Dirichlet extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - parameters
```
Counter<E> parameters
```
- Class edu.stanford.nlp.stats.DirichletProcess extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -8653536087199951278L
  - Serialized Fields
    - baseMeasure
```
ProbabilityDistribution<E> baseMeasure
```
    - alpha
```
double alpha
```
    - sampled
```
ClassicCounter<E> sampled
```
- Class edu.stanford.nlp.stats.Distribution extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  6707148234288637809L
  - Serialized Fields
    - numberOfKeys
```
int numberOfKeys
```
    - reservedMass
```
double reservedMass
```
    - counter
```
Counter<E> counter
```
- Class edu.stanford.nlp.stats.Gamma extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -2992079318379176178L
  - Serialized Fields
    - alpha
```
double alpha
```
- Class edu.stanford.nlp.stats.GeneralizedCounter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - depth
```
int depth
```
    - total
```
double total
```
- Class edu.stanford.nlp.stats.IntCounter extends AbstractCounter<E> implements Serializable
  
  serialVersionUID:
  
  4L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - mapFactory
```
MapFactory<K,V> mapFactory
```
    - totalCount
```
int totalCount
```
    - defaultValue
```
int defaultValue
```
- Class edu.stanford.nlp.stats.Multinomial extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -697457414113362926L
  - Serialized Fields
    - parameters
```
Counter<E> parameters
```
    - hashCode
```
int hashCode
```
- Class edu.stanford.nlp.stats.TwoDimensionalCounter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - total
```
double total
```
    - outerMF
```
MapFactory<K,V> outerMF
```
    - innerMF
```
MapFactory<K,V> innerMF
```
    - defaultValue
```
double defaultValue
```
- Class edu.stanford.nlp.stats.TwoDimensionalIntCounter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - total
```
int total
```
    - outerMF
```
MapFactory<K,V> outerMF
```
    - innerMF
```
MapFactory<K,V> innerMF
```
    - defaultValue
```
int defaultValue
```
Package edu.stanford.nlp.swing
- Class edu.stanford.nlp.swing.TooltipJList extends javax.swing.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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - lexicon
```
java.util.Map<K,V> lexicon
```
    - unk
```
java.lang.String unk
```
    - mapdigits
```
boolean mapdigits
```
    - casedDistSim
```
boolean casedDistSim
```
- Class edu.stanford.nlp.tagger.maxent.Extractor extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4694133872973560083L
  - Serialized Fields
    - position
```
int position
```
    - isTag
```
boolean isTag
```
- Class edu.stanford.nlp.tagger.maxent.ExtractorDistsim extends Extractor implements Serializable
  
  serialVersionUID:
  
  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
```
java.lang.String name
```
- Class edu.stanford.nlp.tagger.maxent.Extractors extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4777107742414749890L
  - Serialized Fields
    - v
```
Extractor[] v
```
- Class edu.stanford.nlp.tagger.maxent.ExtractorVerbalVBNZero extends DictionaryExtractor implements Serializable
  
  serialVersionUID:
  
  -5881204185400060636L
  - Serialized Fields
    - bound
```
int bound
```
- Class edu.stanford.nlp.tagger.maxent.MaxentTagger extends Tagger implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - dict
```
Dictionary dict
```
    - tags
```
TTags tags
```
    - prob
```
LambdaSolveTagger prob
```
    - fAssociations
```
java.util.List<E> fAssociations
```
    - extractors
```
Extractors extractors
```
    - extractorsRare
```
Extractors extractorsRare
```
    - ambClasses
```
AmbiguityClasses ambClasses
```
    - alltags
```
boolean alltags
```
    - tagTokens
```
java.util.Map<K,V> tagTokens
```
    - defaultScore
```
double defaultScore
```
    - defaultScores
```
double[] defaultScores
```
    - leftContext
```
int leftContext
```
    - rightContext
```
int rightContext
```
    - config
```
TaggerConfig config
```
    - rareWordThresh
```
int rareWordThresh
```
      Determines which words are considered rare. All words with count in the training data strictly less than this number (standardly, < 5) are considered rare.
    - minFeatureThresh
```
int minFeatureThresh
```
      Determines which features are included in the model. The model includes features that occurred strictly more times than this number (standardly, > 5) in the training data. Here I look only at the history (not the tag), so the history appearing this often is enough.
    - curWordMinFeatureThresh
```
int curWordMinFeatureThresh
```
      This is a special threshold for the current word feature. Only words that have occurred strictly > this number of times in total will generate word features with all of their occurring tags. The traditional default was 2.
    - rareWordMinFeatureThresh
```
int rareWordMinFeatureThresh
```
      Determines which rare word features are included in the model. The features for rare words have a strictly higher support than this number are included. Traditional default is 10.
    - veryCommonWordThresh
```
int veryCommonWordThresh
```
      If using tag equivalence classes on following words, words that occur strictly more than this number of times (in total with any tag) are sufficiently frequent to form an equivalence class by themselves. (Not used unless using equivalence classes.) There are places in the code (ExtractorAmbiguityClass.java, for one) that assume this value is constant over the life of a tagger.
    - xSize
```
int xSize
```
    - ySize
```
int ySize
```
    - occurringTagsOnly
```
boolean occurringTagsOnly
```
    - possibleTagsOnly
```
boolean possibleTagsOnly
```
    - initted
```
boolean initted
```
    - VERBOSE
```
boolean VERBOSE
```
    - wordFunction
```
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 javax.swing.JFrame implements Serializable
  
  serialVersionUID:
  
  -2574711492469740892L
  - Serialized Fields
    - inputBox
```
javax.swing.JTextArea inputBox
```
    - outputBox
```
javax.swing.JTextArea outputBox
```
    - tagButton
```
javax.swing.JButton tagButton
```
- Class edu.stanford.nlp.tagger.maxent.TaggerConfig extends java.util.Properties implements Serializable
  
  serialVersionUID:
  
  -4136407850147157497L
Package edu.stanford.nlp.time
- Class edu.stanford.nlp.time.JollyDayHolidays.JollyHoliday extends SUTime.Time implements Serializable
  
  serialVersionUID:
  
  -1479143694893729803L
  - Serialized Fields
    - holidayManager
```
de.jollyday.HolidayManager holidayManager
```
    - base
```
de.jollyday.config.Holiday base
```
    - label
```
java.lang.String label
```
- Class edu.stanford.nlp.time.SUTime.CompositePartialTime extends SUTime.PartialTime implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - tod
```
SUTime.Time tod
```
    - dow
```
SUTime.Time dow
```
    - poy
```
SUTime.Time poy
```
- Class edu.stanford.nlp.time.SUTime.Duration extends SUTime.Temporal implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.time.SUTime.DurationRange extends SUTime.Duration implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - minDuration
```
SUTime.Duration minDuration
```
    - maxDuration
```
SUTime.Duration maxDuration
```
- Class edu.stanford.nlp.time.SUTime.DurationWithFields extends SUTime.Duration implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - period
```
org.joda.time.ReadablePeriod period
```
- Class edu.stanford.nlp.time.SUTime.DurationWithMillis extends SUTime.Duration implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - base
```
org.joda.time.ReadableDuration base
```
- Class edu.stanford.nlp.time.SUTime.ExplicitTemporalSet extends SUTime.TemporalSet implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - temporals
```
java.util.Set<E> temporals
```
- Class edu.stanford.nlp.time.SUTime.GroundedTime extends SUTime.Time implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - base
```
org.joda.time.ReadableInstant base
```
- Class edu.stanford.nlp.time.SUTime.InexactDuration extends SUTime.DurationWithFields implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.time.SUTime.InexactTime extends SUTime.Time implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - base
```
SUTime.Time base
```
    - duration
```
SUTime.Duration duration
```
    - range
```
SUTime.Range range
```
- Class edu.stanford.nlp.time.SUTime.IsoDate extends SUTime.PartialTime implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - era
```
int era
```
      Era: BC is era 0, AD is era 1, Unknown is -1
    - year
```
int year
```
      Year of Era
    - month
```
int month
```
      Month of Year
    - day
```
int day
```
      Day of Month
- Class edu.stanford.nlp.time.SUTime.IsoDateTime extends SUTime.PartialTime implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - date
```
SUTime.IsoDate date
```
    - time
```
SUTime.IsoTime time
```
- Class edu.stanford.nlp.time.SUTime.IsoTime extends SUTime.PartialTime implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - hour
```
int hour
```
    - minute
```
int minute
```
    - second
```
int second
```
    - millis
```
int millis
```
    - halfday
```
int halfday
```
- Class edu.stanford.nlp.time.SUTime.OrdinalTime extends SUTime.Time implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - base
```
SUTime.Temporal base
```
    - n
```
int n
```
- Class edu.stanford.nlp.time.SUTime.PartialTime extends SUTime.Time implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - base
```
org.joda.time.Partial base
```
    - dateTimeZone
```
org.joda.time.DateTimeZone dateTimeZone
```
- Class edu.stanford.nlp.time.SUTime.PeriodicTemporalSet extends SUTime.TemporalSet implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - occursIn
```
SUTime.Range occursIn
```
      Start and end times for when this set of times is suppose to be happening (e.g. 2011-09-01 to 2011-12-30)
    - base
```
SUTime.Temporal base
```
      Temporal that re-occurs (e.g. Friday 2-3pm)
    - periodicity
```
SUTime.Duration periodicity
```
      The periodicity of re-occurrence (e.g. week)
    - quant
```
java.lang.String quant
```
      Quantifier - every, every other
    - freq
```
java.lang.String freq
```
      String representation of frequency (3 days = P3D, 3 times = P3X)
- Class edu.stanford.nlp.time.SUTime.Range extends SUTime.Temporal implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - begin
```
SUTime.Time begin
```
    - end
```
SUTime.Time end
```
    - duration
```
SUTime.Duration duration
```
- Class edu.stanford.nlp.time.SUTime.RefTime extends SUTime.Time implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - label
```
java.lang.String label
```
- Class edu.stanford.nlp.time.SUTime.RelativeTime extends SUTime.Time implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - base
```
SUTime.Time base
```
    - tempOp
```
SUTime.TemporalOp tempOp
```
    - tempArg
```
SUTime.Temporal tempArg
```
    - opFlags
```
int opFlags
```
- Class edu.stanford.nlp.time.SUTime.SimpleTime extends SUTime.Time implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - label
```
java.lang.String label
```
- Class edu.stanford.nlp.time.SUTime.Temporal extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - mod
```
java.lang.String mod
```
    - approx
```
boolean approx
```
    - standardTemporalType
```
SUTime.StandardTemporalType standardTemporalType
```
    - timeLabel
```
java.lang.String timeLabel
```
    - 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 java.lang.Exception implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - timeExpression
```
java.lang.String timeExpression
```
- Class edu.stanford.nlp.time.TimeExpressionExtractorFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7280996573587450170L
  - Serialized Fields
    - timeExpressionExtractorClass
```
java.lang.String timeExpressionExtractorClass
```
- Class edu.stanford.nlp.time.Timex extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  385847729549981302L
  - Serialized Fields
    - xml
```
java.lang.String xml
```
      XML representation of the TIMEX tag
    - val
```
java.lang.String val
```
      TIMEX3 value attribute - Time value (given in extended ISO 8601 format).
    - altVal
```
java.lang.String altVal
```
      Alternate representation for time value (not part of TIMEX3 standard). used when value of the time expression cannot be expressed as a standard TIMEX3 value.
    - text
```
java.lang.String text
```
      Actual text that make up the time expression
    - type
```
java.lang.String type
```
      TIMEX3 type attribute - Type of the time expression (DATE, TIME, DURATION, or SET)
    - tid
```
java.lang.String tid
```
      TIMEX3 tid attribute - TimeID. ID to identify this time expression. Should have the format of t<integer>
    - beginPoint
```
int beginPoint
```
      TIMEX3 beginPoint attribute - integer indicating the TimeID of the begin time that anchors this duration/range (-1 is not present).
    - endPoint
```
int endPoint
```
      TIMEX3 beginPoint attribute - integer indicating the TimeID of the end time that anchors this duration/range (-1 is not present).
    - range
```
Timex.Range range
```
      Range begin/end/duration (this is not part of the timex standard and is typically null, available if sutime.includeRange is true)
- Class edu.stanford.nlp.time.Timex.Range extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - begin
```
java.lang.String begin
```
    - end
```
java.lang.String end
```
    - duration
```
java.lang.String duration
```
Package edu.stanford.nlp.time.suservlet
- Class edu.stanford.nlp.time.suservlet.SUTimeServlet extends javax.servlet.http.HttpServlet implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - pipeline
```
SUTimePipeline pipeline
```
Package edu.stanford.nlp.trees
- Class edu.stanford.nlp.trees.AbstractCollinsHeadFinder extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -6540278059442931087L
  - Serialized Fields
    - tlp
```
TreebankLanguagePack tlp
```
    - nonTerminalInfo
```
java.util.Map<K,V> nonTerminalInfo
```
    - defaultRule
```
java.lang.String[] defaultRule
```
      Default direction if no rule is found for category (the head/parent). Subclasses can turn it on if they like. If they don't it is an error if no rule is defined for a category (null is returned).
    - defaultLeftRule
```
java.lang.String[] defaultLeftRule
```
      These are built automatically from categoriesToAvoid and used in a fairly different fashion from defaultRule (above). These are used for categories that do have defined rules but where none of them have matched. Rather than picking the rightmost or leftmost child, we will use these to pick the the rightmost or leftmost child which isn't in categoriesToAvoid.
    - defaultRightRule
```
java.lang.String[] defaultRightRule
```
- Class edu.stanford.nlp.trees.AbstractTreebankLanguagePack extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -6506749780512708352L
  - Serialized Fields
    - gfCharacter
```
char gfCharacter
```
      Default character for indicating that something is a grammatical fn; probably should be overridden by lang specific ones
    - generateOriginalDependencies
```
boolean generateOriginalDependencies
```
      For languages where a Universal Dependency converter exists this variable determines whether the original or the Universal converter will be used.
    - 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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.trees.BobChrisTreeNormalizer.EmptyFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  8914098359495987617L
- Class edu.stanford.nlp.trees.CollinsDependency extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4236496863919294754L
  - Serialized Fields
    - modifier
```
CoreLabel modifier
```
    - head
```
CoreLabel head
```
    - relation
```
CollinsRelation relation
```
- Class edu.stanford.nlp.trees.CollinsHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -8747319554557223437L
- Class edu.stanford.nlp.trees.Dependencies.DependentPuncTagRejectFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -7732189363171164852L
  - Serialized Fields
    - tagRejectFilter
```
java.util.function.Predicate<T> tagRejectFilter
```
- Class edu.stanford.nlp.trees.Dependencies.DependentPuncWordRejectFilter extends java.lang.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
```
java.lang.String root
```
    - tlp
```
TreebankLanguagePack tlp
```
- Class edu.stanford.nlp.trees.GrammaticalRelation extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  892618003417550128L
  - Serialization Methods
    - readResolve
```
protected java.lang.Object readResolve()
                                throws java.io.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:
      
      java.io.ObjectStreamException
  - Serialized Fields
    - language
```
Language language
```
    - shortName
```
java.lang.String shortName
```
    - longName
```
java.lang.String longName
```
    - parent
```
GrammaticalRelation parent
```
    - children
```
java.util.List<E> children
```
    - sourcePattern
```
java.util.regex.Pattern sourcePattern
```
    - targetPatterns
```
java.util.List<E> targetPatterns
```
    - specific
```
java.lang.String specific
```
- Class edu.stanford.nlp.trees.GrammaticalStructure extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2286294455343892678L
  - Serialized Fields
    - typedDependencies
```
java.util.List<E> typedDependencies
```
    - allTypedDependencies
```
java.util.List<E> allTypedDependencies
```
    - puncFilter
```
java.util.function.Predicate<T> puncFilter
```
    - tagFilter
```
java.util.function.Predicate<T> tagFilter
```
    - root
```
TreeGraphNode root
```
      The root Tree node for this GrammaticalStructure.
    - indexMap
```
java.util.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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  8453889846239508208L
- Class edu.stanford.nlp.trees.LengthTreeFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - length
```
int length
```
- Class edu.stanford.nlp.trees.ModCollinsHeadFinder extends CollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -5870387458902637256L
- Class edu.stanford.nlp.trees.NamedDependency extends UnnamedDependency implements Serializable
  
  serialVersionUID:
  
  -1635646451505721133L
  - Serialized Fields
    - name
```
java.lang.Object name
```
- Class edu.stanford.nlp.trees.NPTmpRetainingTreeNormalizer extends BobChrisTreeNormalizer implements Serializable
  
  serialVersionUID:
  
  7548777133196579107L
  - Serialized Fields
    - temporalAnnotation
```
int temporalAnnotation
```
    - doSGappedStuff
```
boolean doSGappedStuff
```
    - doGappingStuff
```
boolean doGappingStuff
```
    - leaveItAll
```
int leaveItAll
```
    - doAdverbialNP
```
boolean doAdverbialNP
```
    - headFinder
```
HeadFinder headFinder
```
- Class edu.stanford.nlp.trees.OrderedCombinationTreeNormalizer extends TreeNormalizer implements Serializable
  
  serialVersionUID:
  
  326L
  - Serialized Fields
    - tns
```
java.util.List<E> tns
```
- Class edu.stanford.nlp.trees.PennTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  9081305982861675328L
- Class edu.stanford.nlp.trees.RightHeadFinder extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  127638412457653L
- Class edu.stanford.nlp.trees.SemanticHeadFinder extends ModCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  5721799188009249808L
  - Serialized Fields
    - verbalAuxiliaries
```
java.util.Set<E> verbalAuxiliaries
```
    - copulars
```
java.util.Set<E> copulars
```
    - passiveAuxiliaries
```
java.util.Set<E> passiveAuxiliaries
```
    - verbalTags
```
java.util.Set<E> verbalTags
```
    - unambiguousAuxiliaryTags
```
java.util.Set<E> unambiguousAuxiliaryTags
```
    - 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 java.util.AbstractCollection<Tree> implements Serializable
  
  serialVersionUID:
  
  5441849457648722744L
- Class edu.stanford.nlp.trees.TreeFilters.HasMatchingChild extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - tlp
```
TreebankLanguagePack tlp
```
    - pattern
```
java.util.regex.Pattern pattern
```
- Class edu.stanford.nlp.trees.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.
    - headWordNode
```
TreeGraphNode headWordNode
```
      For internal nodes, the head word of this subtree.
- Class edu.stanford.nlp.trees.TreeNormalizer extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1540681875853883387L
- Class edu.stanford.nlp.trees.TreeTokenizerFactory extends java.lang.Object implements Serializable
  - Serialized Fields
    - trf
```
TreeReaderFactory trf
```
- Class edu.stanford.nlp.trees.TypedDependency extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -7690294213151279779L
  - Serialized Fields
    - reln
```
GrammaticalRelation reln
```
    - gov
```
IndexedWord gov
```
    - dep
```
IndexedWord dep
```
    - extra
```
boolean extra
```
- Class edu.stanford.nlp.trees.UniversalEnglishGrammaticalStructure extends GrammaticalStructure implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.trees.UniversalSemanticHeadFinder extends ModCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  5721799188009249808L
  - Serialized Fields
    - verbalAuxiliaries
```
java.util.Set<E> verbalAuxiliaries
```
    - copulars
```
java.util.Set<E> copulars
```
    - passiveAuxiliaries
```
java.util.Set<E> passiveAuxiliaries
```
    - verbalTags
```
java.util.Set<E> verbalTags
```
    - unambiguousAuxiliaryTags
```
java.util.Set<E> unambiguousAuxiliaryTags
```
    - makeCopulaHead
```
boolean makeCopulaHead
```
- Class edu.stanford.nlp.trees.UnnamedConcreteDependency extends UnnamedDependency implements Serializable
  
  serialVersionUID:
  
  -8836949694741145222L
  - Serialized Fields
    - headIndex
```
int headIndex
```
    - depIndex
```
int depIndex
```
- Class edu.stanford.nlp.trees.UnnamedDependency extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -3768440215342256085L
  - Serialized Fields
    - regentText
```
java.lang.String regentText
```
    - dependentText
```
java.lang.String dependentText
```
    - regent
```
Label regent
```
    - dependent
```
Label dependent
```
Package edu.stanford.nlp.trees.international.arabic
- Class edu.stanford.nlp.trees.international.arabic.ArabicHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  6203368998430280740L
  - Serialized Fields
    - tagSet
```
ArabicHeadFinder.TagSet tagSet
```
    - predPattern
```
java.util.regex.Pattern predPattern
```
- Class edu.stanford.nlp.trees.international.arabic.ArabicTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  9081305982861675328L
  - Serialized Fields
    - tf
```
TokenizerFactory<T> tf
```
      TODO: there is no way to change this using options.
- Class edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer extends BobChrisTreeNormalizer implements Serializable
  
  serialVersionUID:
  
  -1592231121068698494L
  - Serialized Fields
    - retainNPTmp
```
boolean retainNPTmp
```
    - retainNPSbj
```
boolean retainNPSbj
```
    - markPRDverb
```
boolean markPRDverb
```
    - changeNoLabels
```
boolean changeNoLabels
```
    - retainPPClr
```
boolean retainPPClr
```
    - prdPattern
```
java.util.regex.Pattern prdPattern
```
    - prdVerbPattern
```
TregexPattern prdVerbPattern
```
    - npSbjPattern
```
TregexPattern npSbjPattern
```
    - rootLabel
```
java.lang.String rootLabel
```
    - lexMapper
```
Mapper lexMapper
```
- Class edu.stanford.nlp.trees.international.arabic.ArabicTreeNormalizer.ArabicEmptyFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7417844982953945964L
- Class edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1973767605277873017L
  - Serialized Fields
    - retainNPTmp
```
boolean retainNPTmp
```
    - retainNPSbj
```
boolean retainNPSbj
```
    - retainPRD
```
boolean retainPRD
```
    - retainPPClr
```
boolean retainPPClr
```
    - changeNoLabels
```
boolean changeNoLabels
```
    - filterX
```
boolean filterX
```
    - noNormalization
```
boolean noNormalization
```
- Class edu.stanford.nlp.trees.international.arabic.ArabicTreeReaderFactory.ArabicRawTreeReaderFactory extends ArabicTreeReaderFactory implements Serializable
  
  serialVersionUID:
  
  -5693371540982097793L
Package edu.stanford.nlp.trees.international.french
- Class edu.stanford.nlp.trees.international.french.AbishekFrenchHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -7195627297254128427L
- Class edu.stanford.nlp.trees.international.french.DybroFrenchHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  8798606577201646967L
- Class edu.stanford.nlp.trees.international.french.FrenchHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  8747319554557223422L
- Class edu.stanford.nlp.trees.international.french.FrenchTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  -7338244949063822519L
- Class edu.stanford.nlp.trees.international.french.FrenchTreeNormalizer extends BobChrisTreeNormalizer implements Serializable
  
  serialVersionUID:
  
  7868735300308066991L
  - Serialized Fields
    - rootLabel
```
java.lang.String rootLabel
```
    - morpho
```
MorphoFeatureSpecification morpho
```
    - ccTagset
```
boolean ccTagset
```
- Class edu.stanford.nlp.trees.international.french.FrenchTreeNormalizer.FrenchAOverAFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  793800623099852951L
- Class edu.stanford.nlp.trees.international.french.FrenchTreeReaderFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  8943534517L
- Class edu.stanford.nlp.trees.international.french.FrenchXMLTreeReaderFactory extends java.lang.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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -7256461296718287280L
- Class edu.stanford.nlp.trees.international.hebrew.HebrewTreeReaderFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  818065349424602548L
Package edu.stanford.nlp.trees.international.hungarian
- Class edu.stanford.nlp.trees.international.hungarian.HungarianTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  -7982635612452142L
Package edu.stanford.nlp.trees.international.italian
- Class edu.stanford.nlp.trees.international.italian.ItalianTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  -235378253615245L
Package edu.stanford.nlp.trees.international.negra
- Class edu.stanford.nlp.trees.international.negra.NegraHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -7253035927065152766L
  - Serialized Fields
    - coordSwitch
```
boolean coordSwitch
```
    - left
```
java.lang.String left
```
    - right
```
java.lang.String right
```
- Class edu.stanford.nlp.trees.international.negra.NegraLabel extends StringLabel implements Serializable
  
  serialVersionUID:
  
  2847331882765391095L
  - Serialized Fields
    - edge
```
java.lang.String edge
```
    - features
```
java.util.Map<K,V> features
```
- Class edu.stanford.nlp.trees.international.negra.NegraPennLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  9081305982861675328L
  - Serialized Fields
    - leaveGF
```
boolean leaveGF
```
      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
```
java.util.Set<E> prepositionTags
```
    - postpositionTags
```
java.util.Set<E> postpositionTags
```
- Class edu.stanford.nlp.trees.international.negra.NegraPennTreeReaderFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  5731352106152470304L
  - Serialized Fields
    - nodeCleanup
```
int nodeCleanup
```
    - tlp
```
TreebankLanguagePack tlp
```
    - treeNormalizerInsertNPinPP
```
boolean treeNormalizerInsertNPinPP
```
Package edu.stanford.nlp.trees.international.pennchinese
- Class edu.stanford.nlp.trees.international.pennchinese.BikelChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -5445795668059315082L
- Class edu.stanford.nlp.trees.international.pennchinese.CharacterLevelTagExtender extends BobChrisTreeNormalizer implements Serializable
  
  serialVersionUID:
  
  7893996593626523700L
- Class edu.stanford.nlp.trees.international.pennchinese.ChineseEnglishWordMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7655332268578049993L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - normalized
```
boolean normalized
```
- Class edu.stanford.nlp.trees.international.pennchinese.ChineseGrammaticalStructure extends GrammaticalStructure implements Serializable
  
  serialVersionUID:
  
  8877651855167458256L
- Class edu.stanford.nlp.trees.international.pennchinese.ChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  6143632784691159283L
- Class edu.stanford.nlp.trees.international.pennchinese.ChineseSemanticHeadFinder extends ChineseHeadFinder implements Serializable
  
  serialVersionUID:
  
  2L
- Class edu.stanford.nlp.trees.international.pennchinese.ChineseTreebankLanguagePack extends AbstractTreebankLanguagePack implements Serializable
  
  serialVersionUID:
  
  5757403475523638802L
  - Serialized Fields
    - tf
```
TokenizerFactory<T> tf
```
- Class edu.stanford.nlp.trees.international.pennchinese.CTBErrorCorrectingTreeNormalizer extends BobChrisTreeNormalizer implements Serializable
  
  serialVersionUID:
  
  -8203853817025401845L
  - Serialized Fields
    - tagExtender
```
TreeTransformer tagExtender
```
    - splitNPTMP
```
boolean splitNPTMP
```
    - splitPPTMP
```
boolean splitPPTMP
```
    - splitXPTMP
```
boolean splitXPTMP
```
    - chineseEmptyFilter
```
java.util.function.Predicate<T> chineseEmptyFilter
```
- Class edu.stanford.nlp.trees.international.pennchinese.FragmentTreeFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.trees.international.pennchinese.SunJurafskyChineseHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  -7942375587642755210L
- Class edu.stanford.nlp.trees.international.pennchinese.UniversalChineseGrammaticalStructure extends GrammaticalStructure implements Serializable
  
  serialVersionUID:
  
  8877651855167458256L
- Class edu.stanford.nlp.trees.international.pennchinese.UniversalChineseSemanticHeadFinder extends ChineseHeadFinder implements Serializable
  
  serialVersionUID:
  
  2L
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
  
  serialVersionUID:
  
  -3237606914912983720L
- 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
  
  serialVersionUID:
  
  7810182997777764277L
  - Serialized Fields
    - simplifiedTagset
```
boolean simplifiedTagset
```
    - aggressiveNormalization
```
boolean aggressiveNormalization
```
    - retainNER
```
boolean retainNER
```
- Class edu.stanford.nlp.trees.international.spanish.SpanishTreeReaderFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  8L
- Class edu.stanford.nlp.trees.international.spanish.SpanishXMLTreeReaderFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2019486878175311263L
  - Serialized Fields
    - simplifiedTagset
```
boolean simplifiedTagset
```
    - aggressiveNormalization
```
boolean aggressiveNormalization
```
    - retainNER
```
boolean retainNER
```
    - detailedAnnotations
```
boolean detailedAnnotations
```
    - expandElisions
```
boolean expandElisions
```
    - expandConmigo
```
boolean expandConmigo
```
Package edu.stanford.nlp.trees.international.tuebadz
- Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZHeadFinder extends AbstractCollinsHeadFinder implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - left
```
java.lang.String left
```
    - right
```
java.lang.String right
```
    - coordSwitch
```
boolean coordSwitch
```
    - headMarkedPattern
```
java.util.regex.Pattern headMarkedPattern
```
    - headMarkedPattern2
```
java.util.regex.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
```
java.lang.String root
```
    - tlp
```
TreebankLanguagePack tlp
```
    - tns
```
java.util.List<E> tns
```
- Class edu.stanford.nlp.trees.international.tuebadz.TueBaDZTreeReaderFactory extends java.lang.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.DescriptionPattern extends TregexPattern implements Serializable
  
  serialVersionUID:
  
  1179819056757295757L
  - Serialized Fields
    - rel
```
edu.stanford.nlp.trees.tregex.Relation rel
```
    - negDesc
```
boolean negDesc
```
    - descriptionMode
```
edu.stanford.nlp.trees.tregex.DescriptionPattern.DescriptionMode descriptionMode
```
    - exactMatch
```
java.lang.String exactMatch
```
    - descPattern
```
java.util.regex.Pattern descPattern
```
    - stringFilter
```
java.util.function.Predicate<T> stringFilter
```
    - stringDesc
```
java.lang.String stringDesc
```
    - name
```
java.lang.String name
```
      The name to give the matched node
    - linkedName
```
java.lang.String linkedName
```
      If this pattern is a link, this is the node linked to
    - isLink
```
boolean isLink
```
    - child
```
TregexPattern child
```
    - variableGroups
```
java.util.List<E> variableGroups
```
    - basicCatFunction
```
java.util.function.Function<T,R> basicCatFunction
```
- Class edu.stanford.nlp.trees.tregex.ParseException extends java.lang.Exception implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - currentToken
```
edu.stanford.nlp.trees.tregex.Token currentToken
```
      This is the last token that has been consumed successfully. If this object has been created due to a parse error, the token following this token will (therefore) be the first error token.
    - expectedTokenSequences
```
int[][] expectedTokenSequences
```
      Each entry in this array is an array of integers. Each array of integers represents a sequence of tokens (by their ordinal values) that is expected at this point of the parse.
    - tokenImage
```
java.lang.String[] tokenImage
```
      This is a reference to the "tokenImage" array of the generated parser within which the parse error occurred. This array is defined in the generated ...Constants interface.
- Class edu.stanford.nlp.trees.tregex.TregexParseException extends java.lang.RuntimeException implements Serializable
- Class edu.stanford.nlp.trees.tregex.TregexPattern extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  5060298043763944913L
  - Serialized Fields
    - neg
```
boolean neg
```
    - opt
```
boolean opt
```
    - patternString
```
java.lang.String patternString
```

Package edu.stanford.nlp.trees.tregex.gui

Class edu.stanford.nlp.trees.tregex.gui.DisplayMatchesPanel extends javax.swing.JPanel implements Serializable

Serialized Fields

scroller
```
javax.swing.JScrollPane scroller
```

firstMouseEvent

java.awt.event.MouseEvent firstMouseEvent

fontName
```
java.lang.String fontName
```
fontSize
```
int fontSize
```
defaultColor
```
java.awt.Color defaultColor
```
matchedColor
```
java.awt.Color matchedColor
```
tjp
```
ScrollableTreeJPanel tjp
```

matchedPartCoordinates

java.util.List<E> matchedPartCoordinates

matchedPartCoordinateIdx
```
int matchedPartCoordinateIdx
```

Class edu.stanford.nlp.trees.tregex.gui.FilePanel extends javax.swing.JPanel implements Serializable

serialVersionUID:

-2229250395240163264L
- Serialized Fields
  - tree
```
javax.swing.JTree tree
```
  - treeModel
```
FileTreeModel treeModel
```
Class edu.stanford.nlp.trees.tregex.gui.FileTreeModel extends javax.swing.tree.DefaultTreeModel implements Serializable
- Serialized Fields
  - listeners
```
java.util.List<E> listeners
```
  - root
```
FileTreeNode root
```
  - treeStructure
```
java.util.Map<K,V> treeStructure
```
Class edu.stanford.nlp.trees.tregex.gui.FileTreeNode extends javax.swing.tree.DefaultMutableTreeNode implements Serializable
- Serialized Fields
  - file
```
java.io.File file
```
  - check
```
javax.swing.JCheckBox check
```
  - label
```
javax.swing.JLabel label
```
  - t
```
Treebank t
```
  - listeners
```
java.util.ArrayList<E> listeners
```

Class edu.stanford.nlp.trees.tregex.gui.InputPanel extends javax.swing.JPanel implements Serializable

serialVersionUID:: -8219840036914495876L

Serialized Fields

foundStats
```
javax.swing.JLabel foundStats
```
findMatches
```
javax.swing.JButton findMatches
```
cancel
```
javax.swing.JButton cancel
```
help
```
javax.swing.JButton help
```
tregexPattern
```
javax.swing.JTextArea tregexPattern
```

recentTregexPatterns

javax.swing.JComboBox<E> recentTregexPatterns

recentTregexPatternsModel

javax.swing.DefaultComboBoxModel<E> recentTregexPatternsModel

numRecentPatterns
```
int numRecentPatterns
```
tsurgeonScript
```
javax.swing.JTextArea tsurgeonScript
```
compiler
```
TregexPatternCompiler compiler
```
historyList
```
java.util.List<E> historyList
```
historyFrame
```
javax.swing.JFrame historyFrame
```
scriptLabel
```
javax.swing.JLabel scriptLabel
```
tsurgeonEnabled
```
boolean tsurgeonEnabled
```
tsurgeonHelp
```
javax.swing.JButton tsurgeonHelp
```
cancelTsurgeon
```
javax.swing.JButton cancelTsurgeon
```
searchThread
```
java.lang.Thread searchThread
```
historyButton
```
javax.swing.JButton historyButton
```
progressBar
```
javax.swing.JProgressBar progressBar
```
browseButton
```
javax.swing.JButton browseButton
```
helpFrame
```
javax.swing.JFrame helpFrame
```
tsurgeonHelpFrame
```
javax.swing.JFrame tsurgeonHelpFrame
```
runScript
```
javax.swing.JButton runScript
```

Class edu.stanford.nlp.trees.tregex.gui.MatchesPanel extends javax.swing.JPanel implements Serializable

Serialized Fields

list
```
javax.swing.JList<E> list
```
matchedParts
```
java.util.Map<K,V> matchedParts
```
listeners
```
java.util.List<E> listeners
```
highlightColor
```
java.awt.Color highlightColor
```
showOnlyMatchedPortion
```
boolean showOnlyMatchedPortion
```
lastSelected
```
javax.swing.JTextField lastSelected
```

firstMouseEvent

java.awt.event.MouseEvent firstMouseEvent

maxMatches
```
int maxMatches
```

Class edu.stanford.nlp.trees.tregex.gui.PreferencesPanel extends javax.swing.JDialog implements Serializable
- Serialized Fields
  - gui
```
TregexGUI gui
```
  - highlightButton
```
javax.swing.JButton highlightButton
```
  - setEncoding
```
javax.swing.JTextField setEncoding
```

Class edu.stanford.nlp.trees.tregex.gui.ScrollableTreeJPanel extends TreeJPanel implements Serializable

Serialized Fields

fontSize
```
int fontSize
```
defaultColor
```
java.awt.Color defaultColor
```
matchedColor
```
java.awt.Color matchedColor
```
tdiffColor
```
java.awt.Color tdiffColor
```
fontName
```
java.lang.String fontName
```
style
```
int style
```
preferredSize
```
java.awt.Dimension preferredSize
```
matchedParts
```
java.util.List<E> matchedParts
```

matchedPartCoordinates

java.util.List<E> matchedPartCoordinates

leafCtr
```
int leafCtr
```
yieldHeight
```
double yieldHeight
```
yieldOffsets
```
float[] yieldOffsets
```
diffConstituents
```
java.util.Set<E> diffConstituents
```

Class edu.stanford.nlp.trees.tregex.gui.TregexGUI extends javax.swing.JFrame implements Serializable

Serialized Fields

preferences
```
javax.swing.JMenuItem preferences
```
loadFiles
```
javax.swing.JMenuItem loadFiles
```
saveMatches
```
javax.swing.JMenuItem saveMatches
```
saveSentences
```
javax.swing.JMenuItem saveSentences
```
saveHistory
```
javax.swing.JMenuItem saveHistory
```
loadTsurgeon
```
javax.swing.JMenuItem loadTsurgeon
```
tDiff
```
javax.swing.JMenuItem tDiff
```
quit
```
javax.swing.JMenuItem quit
```
copy
```
javax.swing.JMenuItem copy
```
searchMenuItem
```
javax.swing.JMenuItem searchMenuItem
```
prevMatch
```
javax.swing.JMenuItem prevMatch
```
nextMatch
```
javax.swing.JMenuItem nextMatch
```
prevTreeMatch
```
javax.swing.JMenuItem prevTreeMatch
```
nextTreeMatch
```
javax.swing.JMenuItem nextTreeMatch
```
clearFileList
```
javax.swing.JMenuItem clearFileList
```
chooser
```
javax.swing.JFileChooser chooser
```
transformer
```
TreeTransformer transformer
```
preferenceDialog
```
PreferencesPanel preferenceDialog
```
aboutBox
```
javax.swing.JDialog aboutBox
```
doTdiff
```
boolean doTdiff
```

Package edu.stanford.nlp.trees.tregex.tsurgeon
- Class edu.stanford.nlp.trees.tregex.tsurgeon.ParseException extends java.lang.Exception implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - currentToken
```
edu.stanford.nlp.trees.tregex.tsurgeon.Token currentToken
```
      This is the last token that has been consumed successfully. If this object has been created due to a parse error, the token following this token will (therefore) be the first error token.
    - expectedTokenSequences
```
int[][] expectedTokenSequences
```
      Each entry in this array is an array of integers. Each array of integers represents a sequence of tokens (by their ordinal values) that is expected at this point of the parse.
    - tokenImage
```
java.lang.String[] tokenImage
```
      This is a reference to the "tokenImage" array of the generated parser within which the parse error occurred. This array is defined in the generated ...Constants interface.
- Class edu.stanford.nlp.trees.tregex.tsurgeon.TsurgeonParseException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  -4417368416943652737L
- Class edu.stanford.nlp.trees.tregex.tsurgeon.TsurgeonRuntimeException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  1L
Package edu.stanford.nlp.trees.ud
- Class edu.stanford.nlp.trees.ud.CoNLLUDocumentReader extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -7340310509954331983L
  - Serialized Fields
    - ifrf
```
IteratorFromReaderFactory<T> ifrf
```
- Class edu.stanford.nlp.trees.ud.UniversalGrammaticalStructure extends GrammaticalStructure implements Serializable
Package edu.stanford.nlp.util
- Class edu.stanford.nlp.util.ArrayCoreMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - writeObject
```
private void writeObject(java.io.ObjectOutputStream out)
                  throws java.io.IOException
```
      Overridden serialization method: compacts our map before writing.
      
      Throws:
      
      java.io.IOException - If IO error
  - Serialized Fields
    - keys
```
java.lang.Class<T>[] keys
```
      Array of keys
    - values
```
java.lang.Object[] values
```
      Array of values
    - size
```
int size
```
      Total number of elements actually in keys,values
- Class edu.stanford.nlp.util.ArrayMap extends java.util.AbstractMap<K,V> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - entryArray
```
edu.stanford.nlp.util.ArrayMap.Entry<K,V>[] entryArray
```
    - capacity
```
int capacity
```
    - size
```
int size
```
    - hashCodeCache
```
int hashCodeCache
```
- Class edu.stanford.nlp.util.ArraySet extends java.util.AbstractSet<E> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - backer
```
java.util.List<E> backer
```
- Class edu.stanford.nlp.util.ArrayStringFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - words
```
java.lang.String[] words
```
    - length
```
int length
```
    - mode
```
ArrayStringFilter.Mode mode
```
- Class edu.stanford.nlp.util.BoundedPriorityQueue extends java.util.TreeSet<E> implements Serializable
  - Serialized Fields
    - remainingCapacity
```
int remainingCapacity
```
    - initialCapacity
```
int initialCapacity
```
- Class edu.stanford.nlp.util.CacheMap extends java.util.LinkedHashMap<K,V> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - backingFile
```
java.lang.String backingFile
```
    - CACHE_ENTRIES
```
int CACHE_ENTRIES
```
    - entriesSinceLastWritten
```
int entriesSinceLastWritten
```
    - frequencyToWrite
```
int frequencyToWrite
```
    - hits
```
int hits
```
    - misses
```
int misses
```
    - puts
```
int puts
```
- Class edu.stanford.nlp.util.CollectionFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3711321773145894069L
- Class edu.stanford.nlp.util.CollectionFactory.ArrayListFactory extends CollectionFactory<T> implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.CollectionFactory.HashSetFactory extends CollectionFactory<T> implements Serializable
  
  serialVersionUID:
  
  -6268401669449458602L
- Class edu.stanford.nlp.util.CollectionFactory.LinkedListFactory extends CollectionFactory<T> implements Serializable
  
  serialVersionUID:
  
  -4236184979948498000L
- Class edu.stanford.nlp.util.CollectionFactory.SizedArrayListFactory extends CollectionFactory<T> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - defaultSize
```
int defaultSize
```
- Class edu.stanford.nlp.util.CollectionFactory.TreeSetFactory extends CollectionFactory<T> implements Serializable
  
  serialVersionUID:
  
  -3451920268219478134L
- Class edu.stanford.nlp.util.CollectionValuedMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -9064664153962599076L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - cf
```
CollectionFactory<T> cf
```
    - treatCollectionsAsImmutable
```
boolean treatCollectionsAsImmutable
```
    - mf
```
MapFactory<K,V> mf
```
    - emptyValue
```
java.util.Collection<E> emptyValue
```
      The empty collection to be returned when a get doesn't find the key. The collection returned should be empty, such as Collections.emptySet, for example.
- Class edu.stanford.nlp.util.ConfusionMatrix.ConfusionGrid.Grid extends javax.swing.JPanel implements Serializable
  - Serialized Fields
    - columnCount
```
int columnCount
```
    - rowCount
```
int rowCount
```
    - cells
```
java.util.List<E> cells
```
    - selectedCell
```
java.awt.Point selectedCell
```
- Class edu.stanford.nlp.util.DeltaCollectionValuedMap extends CollectionValuedMap<K,V> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - originalMap
```
CollectionValuedMap<K,V> originalMap
```
    - deltaMap
```
java.util.Map<K,V> deltaMap
```
- Class edu.stanford.nlp.util.DeltaIndex extends java.util.AbstractCollection<E> implements Serializable
  
  serialVersionUID:
  
  -1459230891686013411L
  - Serialized Fields
    - backingIndex
```
Index<E> backingIndex
```
    - spilloverIndex
```
Index<E> spilloverIndex
```
    - backingIndexSize
```
int backingIndexSize
```
    - locked
```
boolean locked
```
- Class edu.stanford.nlp.util.Filters.ConjFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - filters
```
java.util.List<E> filters
```
- Class edu.stanford.nlp.util.Filters.DisjFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - filters
```
java.util.List<E> filters
```
- Class edu.stanford.nlp.util.Filters.RandomFilter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4885773582960355425L
  - Serialized Fields
    - random
```
java.util.Random random
```
    - fraction
```
double fraction
```
- Class edu.stanford.nlp.util.FiveDimensionalMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
- Class edu.stanford.nlp.util.FixedPrioritiesPriorityQueue extends java.util.AbstractSet<E> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - size
```
int size
```
    - capacity
```
int capacity
```
    - elements
```
java.util.List<E> elements
```
    - priorities
```
double[] priorities
```
- Class edu.stanford.nlp.util.FourDimensionalMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  5635664746940978837L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
- Class edu.stanford.nlp.util.FuzzyInterval extends Interval<E extends FuzzyInterval.FuzzyComparable<E>> implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.HashableCoreMap extends ArrayCoreMap implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - immutableKeys
```
java.util.Set<E> immutableKeys
```
      Set of immutable keys
    - hashcode
```
int hashcode
```
      Pre-computed hashcode
- Class edu.stanford.nlp.util.HashableCoreMap.HashableCoreMapException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.HashIndex extends java.util.AbstractCollection<E> implements Serializable
  
  serialVersionUID:
  
  5398562825928375260L
  - Serialized Fields
    - objects
```
java.util.List<E> objects
```
    - indexes
```
java.util.Map<K,V> indexes
```
    - locked
```
boolean locked
```
    - semaphore
```
java.util.concurrent.Semaphore semaphore
```
- Class edu.stanford.nlp.util.IdentityHashSet extends java.util.AbstractSet<E> implements Serializable
  
  serialVersionUID:
  
  -5024744406713321676L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Deserialize this Object in a manner which is binary-compatible with the JDK.
      
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
    - writeObject
```
private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException
```
      Serialize this Object in a manner which is binary-compatible with the JDK.
      
      Throws:
      
      java.io.IOException
- Class edu.stanford.nlp.util.Interval extends Pair<E extends java.lang.Comparable<E>,E extends java.lang.Comparable<E>> implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - flags
```
int flags
```
- Class edu.stanford.nlp.util.IntPair extends IntTuple implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.IntQuadruple extends IntTuple implements Serializable
  
  serialVersionUID:
  
  7154973101012473479L
- Class edu.stanford.nlp.util.IntTriple extends IntTuple implements Serializable
  
  serialVersionUID:
  
  -3744404627253652799L
- Class edu.stanford.nlp.util.IntTuple extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  7266305463893511982L
  - Serialized Fields
    - elements
```
int[] elements
```
- Class edu.stanford.nlp.util.IntUni extends IntTuple implements Serializable
  
  serialVersionUID:
  
  -7182556672628741200L
- Class edu.stanford.nlp.util.MapFactory extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  4529666940763477360L
- Class edu.stanford.nlp.util.MaxSizeConcurrentHashSet extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream stream)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Throws:
      
      java.io.IOException
      
      java.lang.ClassNotFoundException
  - Serialized Fields
    - m
```
java.util.concurrent.ConcurrentMap<K,V> m
```
    - maxSize
```
int maxSize
```
- Class edu.stanford.nlp.util.MetaClass.ClassCreationException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  -5980065992461870357L
- Class edu.stanford.nlp.util.MetaClass.ConstructorNotFoundException extends MetaClass.ClassCreationException implements Serializable
  
  serialVersionUID:
  
  -5980065992461870357L
- Class edu.stanford.nlp.util.MutableDouble extends java.lang.Number implements Serializable
  
  serialVersionUID:
  
  624465615824626762L
  - Serialized Fields
    - d
```
double d
```
- Class edu.stanford.nlp.util.MutableInteger extends java.lang.Number implements Serializable
  
  serialVersionUID:
  
  624465615824626762L
  - Serialized Fields
    - i
```
int i
```
- Class edu.stanford.nlp.util.MutableLong extends java.lang.Number implements Serializable
  
  serialVersionUID:
  
  624465615824626762L
  - Serialized Fields
    - i
```
long i
```
- Class edu.stanford.nlp.util.OneToOneMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - m_leftAsKey
```
java.util.Map<K,V> m_leftAsKey
```
    - m_rightAsKey
```
java.util.Map<K,V> m_rightAsKey
```
- Class edu.stanford.nlp.util.OneToOneMap.OneToOneMapException extends java.lang.Exception implements Serializable
  
  serialVersionUID:
  
  7743164489912070054L
- Class edu.stanford.nlp.util.PaddedList extends java.util.AbstractList<E> implements Serializable
  
  serialVersionUID:
  
  2064775966439971729L
  - Serialized Fields
    - l
```
java.util.List<E> l
```
    - padding
```
java.lang.Object padding
```
- Class edu.stanford.nlp.util.Pair extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1360822168806852921L
  - Serialized Fields
    - first
```
java.lang.Object first
```
      Direct access is deprecated. Use first().
    - second
```
java.lang.Object second
```
      Direct access is deprecated. Use second().
- Class edu.stanford.nlp.util.Pointer extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - impl
```
java.lang.Object impl
```
      The value the pointer is set to, if it is set.
- Class edu.stanford.nlp.util.Quadruple extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  6295043666955910662L
  - Serialized Fields
    - first
```
java.lang.Object first
```
    - second
```
java.lang.Object second
```
    - third
```
java.lang.Object third
```
    - fourth
```
java.lang.Object fourth
```
- Class edu.stanford.nlp.util.Quintuple extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  6295043666955910662L
  - Serialized Fields
    - first
```
java.lang.Object first
```
    - second
```
java.lang.Object second
```
    - third
```
java.lang.Object third
```
    - fourth
```
java.lang.Object fourth
```
    - fifth
```
java.lang.Object fifth
```
- Class edu.stanford.nlp.util.ReflectionLoading.ReflectionLoadingException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  -3324911744277952585L
- Class edu.stanford.nlp.util.RegexStringFilter extends java.lang.Object implements Serializable
  - Serialized Fields
    - pattern
```
java.util.regex.Pattern pattern
```
- Class edu.stanford.nlp.util.RuntimeClassNotFoundException extends java.lang.RuntimeException implements Serializable
- Class edu.stanford.nlp.util.RuntimeInterruptedException extends java.lang.RuntimeException implements Serializable
- Class edu.stanford.nlp.util.ScoredComparator extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - ascending
```
boolean ascending
```
- Class edu.stanford.nlp.util.ScoredObject extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - score
```
double score
```
    - object
```
java.lang.Object object
```
- Class edu.stanford.nlp.util.StringParsingTask.ParserException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.SystemUtils.ProcessException extends java.lang.RuntimeException implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.ThreeDimensionalCollectionValuedMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
- Class edu.stanford.nlp.util.ThreeDimensionalMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
- Class edu.stanford.nlp.util.Trilean extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  42L
  - Serialized Fields
    - value
```
byte value
```
      0 = false 1 = true 2 = unknown
- Class edu.stanford.nlp.util.Triple extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -4182871682751645440L
  - Serialized Fields
    - first
```
java.lang.Object first
```
    - second
```
java.lang.Object second
```
    - third
```
java.lang.Object third
```
- Class edu.stanford.nlp.util.TwoDimensionalCollectionValuedMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
  - Serialized Fields
    - map
```
java.util.Map<K,V> map
```
    - mf
```
MapFactory<K,V> mf
```
    - cf
```
CollectionFactory<T> cf
```
    - treatCollectionsAsImmutable
```
boolean treatCollectionsAsImmutable
```
- Class edu.stanford.nlp.util.TwoDimensionalMap extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - mf1
```
MapFactory<K,V> mf1
```
    - mf2
```
MapFactory<K,V> mf2
```
    - map
```
java.util.Map<K,V> map
```
- Class edu.stanford.nlp.util.TwoDimensionalSet extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  2L
  - Serialized Fields
    - backingMap
```
TwoDimensionalMap<K1,K2,V> backingMap
```
- Class edu.stanford.nlp.util.UnorderedPair extends Pair<T1,T2> implements Serializable
  
  serialVersionUID:
  
  1L
- Class edu.stanford.nlp.util.UTF8EquivalenceFunction extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  1L
Package edu.stanford.nlp.util.concurrent
- Class edu.stanford.nlp.util.concurrent.AtomicDouble extends java.lang.Number implements Serializable
  
  serialVersionUID:
  
  -8405198993435143622L
  - Serialization Methods
    - readObject
```
private void readObject(java.io.ObjectInputStream s)
                 throws java.io.IOException,
                        java.lang.ClassNotFoundException
```
      Reconstitutes the instance from a stream (that is, deserializes it).
      
      Throws:
      
      java.lang.ClassNotFoundException - if the class of a serialized object could not be found
      
      java.io.IOException - if an I/O error occurs
    - writeObject
```
private void writeObject(java.io.ObjectOutputStream s)
                  throws java.io.IOException
```
      Saves the state to a stream (that is, serializes it).
      
      Serial Data:
      
      The current value is emitted (a double).
      
      Throws:
      
      java.io.IOException - if an I/O error occurs
- Class edu.stanford.nlp.util.concurrent.ConcurrentHashCounter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  -8077192206562696111L
  - Serialized Fields
    - map
```
java.util.concurrent.ConcurrentMap<K,V> map
```
    - totalCount
```
AtomicDouble totalCount
```
    - defaultReturnValue
```
double defaultReturnValue
```
- Class edu.stanford.nlp.util.concurrent.ConcurrentHashIndex extends java.util.AbstractCollection<E> implements Serializable
  
  serialVersionUID:
  
  6465313844985269109L
  - Serialized Fields
    - item2Index
```
java.util.concurrent.ConcurrentHashMap<K,V> item2Index
```
    - indexSize
```
int indexSize
```
    - lock
```
java.util.concurrent.locks.ReentrantLock lock
```
    - index2Item
```
java.util.concurrent.atomic.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 java.lang.Object implements Serializable
  
  serialVersionUID:
  
  8263734344886904724L
  - Serialized Fields
    - words
```
java.util.Set<E> words
```
    - len
```
int len
```
    - edgesNb
```
int edgesNb
```
    - states
```
java.util.List<E> states
```
    - lattice
```
DFSA<T,S> lattice
```
- Class edu.stanford.nlp.wordseg.Sighan2005DocumentReaderAndWriter extends java.lang.Object implements Serializable
  
  serialVersionUID:
  
  3260295150250263237L
  - Serialized Fields
    - separatingPuncChars
```
java.util.regex.Pattern separatingPuncChars
```
    - ambiguousPuncChars
```
java.util.regex.Pattern ambiguousPuncChars
```
    - midDotPattern
```
java.util.regex.Pattern midDotPattern
```
    - cdtos
```
ChineseDocumentToSentenceProcessor cdtos
```
    - cdict
```
ChineseDictionary cdict
```
    - cdict2
```
ChineseDictionary cdict2
```
    - flags
```
SeqClassifierFlags flags
```
    - factory
```
IteratorFromReaderFactory<T> factory
```
    - outputFormat
```
edu.stanford.nlp.wordseg.Sighan2005DocumentReaderAndWriter.OutputFormat outputFormat
```

Serialized Form

Package edu.stanford.nlp.classify

Class edu.stanford.nlp.classify.AbstractLinearClassifierFactory extends java.lang.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 java.lang.Object implements Serializable

Serialized Fields

labelIndex

featureIndex

labels

data

size

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

Serialized Fields

weightedVotes

instances

classLookup

l2Normalize

k

Class edu.stanford.nlp.classify.LinearClassifier extends java.lang.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 java.lang.Object implements Serializable

Serialized Fields

weights

featureIndex

classes

prior

biased

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

Serialized Fields

weights

featureIndex

classes

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

Serialized Fields

means

otherPrior

type

sigmaSqM

sigmaQuM

sigmaSq

sigmaQu

epsilon

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

Serialized Fields

weights

featureIndex

labelIndex

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

Serialized Fields

weights

priors

features

addZeroValued

priorZero

labels

zero