SeqClassifierFlags (Stanford CoreNLP API)

java.lang.Object
- edu.stanford.nlp.sequences.SeqClassifierFlags

All Implemented Interfaces:: Serializable

public class SeqClassifierFlags
extends Object
implements Serializable

Flags for sequence classifiers. Documentation for general flags and flags for NER can be found in the Javadoc of NERFeatureFactory. Documentation for the flags for Chinese word segmentation can be found in the Javadoc of ChineseSegmenterFeatureFactory.
IMPORTANT NOTE IF CHANGING THIS FILE: MAKE SURE TO ONLY ADD NEW VARIABLES AT THE END OF THE LIST OF VARIABLES (and not to change existing variables)! Otherwise you usually break all currently serialized classifiers!!! Search for "ADD VARIABLES ABOVE HERE" below.
Some general flags are described here StringString

Property Name	Type	Default Value	Description
useQN	boolean	true	Use Quasi-Newton (L-BFGS) optimization to find minimum. NOTE: Need to set this to false if using other minimizers such as SGD.
QNsize	int	25	Number of previous iterations of Quasi-Newton to store (this increases memory use, but speeds convergence by letting the Quasi-Newton optimization more effectively approximate the second derivative).
QNsize2	int	25	Number of previous iterations of Quasi-Newton to store (used when pruning features, after the first iteration - the first iteration is with QNSize).
useInPlaceSGD	boolean	false	Use SGD (tweaking weights in place) to find minimum (more efficient than the old SGD, faster to converge than Quasi-Newton if there are very large of samples). Implemented for CRFClassifier. NOTE: Remember to set useQN to false
tuneSampleSize	int	-1	If this number is greater than 0, specifies the number of samples to use for tuning (default is 1000).
SGDPasses	int	-1	If this number is greater than 0, specifies the number of SGD passes over entire training set) to do before giving up (default is 50). Can be smaller if sample size is very large.
useSGD	boolean	false	Use SGD to find minimum (can be slow). NOTE: Remember to set useQN to false
useSGDtoQN	boolean	false	Use SGD (SGD version selected by useInPlaceSGD or useSGD) for a certain number of passes (SGDPasses) and then switches to QN. Gives the quick initial convergence of SGD, with the desired convergence criterion of QN (there is some rampup time for QN). NOTE: Remember to set useQN to false
evaluateIters	int	0	If this number is greater than 0, evaluates on the test set every so often while minimizing. Implemented for CRFClassifier.
evalCmd	String		If specified (and evaluateIters is set), runs the specified cmdline command during evaluation (instead of default CONLL-like NER evaluation)
evaluateTrain	boolean	false	If specified (and evaluateIters is set), also evaluate on training set (can be expensive)
tokenizerOptions	(null)	Extra options to supply to the tokenizer when creating it.
tokenizerFactory	(null)	A different tokenizer factory to use if the ReaderAndWriter in question uses tokenizers.

Author:: Jenny Finkel
See Also:: Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`double`	`adaDeltaRho`
`double`	`adaGradEps`
`String`	`adaptFile` NER adaptation (Gaussian prior) parameters.
`double`	`adaptSigma`
`boolean`	`addBiasToEmbedding`
`boolean`	`addCapitalFeatures`
`double`	`alignDDAlpha`
`double`	`alignmentDecodeThreshold`
`double`	`alignmentPruneThreshold`
`String`	`altAnswerFile`
`boolean`	`alternateTraining`
`double`	`annealingRate`
`String`	`annealingType`
`boolean`	`announceObjectBankEntries`
`String`	`answerFile`
`boolean`	`appendLC`
`boolean`	`applyNERPenalty`
`int`	`arbitraryInputLayerSize`
`boolean`	`augmentedDateChars`
`String`	`auxTrueCaseModels`
`boolean`	`averagePerceptron`
`String`	`backgroundSymbol`
`boolean`	`backpropLopTraining`
`boolean`	`baseline`
`String`	`baseTestDir`
`String`	`baseTrainDir`
`int`	`beamSize`
`String`	`berkeleyAlignerLoadPath`
`boolean`	`biAlignmentPriorIsPMI`
`String`	`biasedTrainFile`
`String`	`bigramLM`
`int[]`	`binnedLengths`
`boolean`	`bioSubmitOutput`
`String`	`bisequenceAlignmentPriorPenaltyCh`
`String`	`bisequenceAlignmentPriorPenaltyEn`
`String`	`bisequenceAlignmentTestOutput`
`String`	`bisequenceClassifierPropCh`
`String`	`bisequenceClassifierPropEn`
`int`	`bisequencePriorType`
`String`	`bisequenceTestAlignmentFile`
`String`	`bisequenceTestFileCh`
`String`	`bisequenceTestFileEn`
`String`	`bisequenceTestOutputCh`
`String`	`bisequenceTestOutputEn`
`boolean`	`blockInitialize`
`boolean`	`booleanFeatures`
`boolean`	`cacheNGrams`
`boolean`	`casedDistSim` Whether to (not) lowercase tokens before looking them up in distsim lexicon.
`int`	`charHalfWindow`
`boolean`	`checkGradient`
`boolean`	`checkNameList`
`String`	`classBias`
`String`	`classifierType`
`boolean`	`cleanGazette`
`boolean`	`combo`
`List<String>`	`comboProps`
`String`	`confusionMatrix`
`boolean`	`conjoinShapeNGrams`
`int`	`CRForder`
`String`	`crfSegmenterProp`
`String`	`crfType`
`int`	`CRFwindow`
`boolean`	`dampDDStepSizeWithAlignmentProb`
`static String`	`DEFAULT_BACKGROUND_SYMBOL`
`static String`	`DEFAULT_PLAIN_TEXT_READER`
`boolean`	`dehyphenateNGrams`
`boolean`	`deleteBlankLines`
`String`	`devFile`
`String`	`dictionary`
`String`	`dictionary2`
`int`	`disjunctionWidth`
`String`	`distSimFileFormat` The format of the distsim file.
`String`	`distSimLexicon`
`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.
`boolean`	`doAdaptation`
`String`	`documentReader`
`boolean`	`doFE`
`boolean`	`doFeatureDiscovery`
`boolean`	`doGibbs`
`String`	`domain`
`boolean`	`dontExtendTaggy`
`String`	`dropGaz`
`boolean`	`dropoutApprox`
`double`	`dropoutRate`
`double`	`dropoutScale`
`boolean`	`dualDecompAlignment`
`boolean`	`dualDecompDebug`
`double`	`dualDecompInitialStepSize`
`double`	`dualDecompInitialStepSizeAlignment`
`int`	`dualDecompMaxItr`
`boolean`	`dualDecompNotBIO`
`boolean`	`dump`
`String`	`embeddingVectors`
`String`	`embeddingWords`
`int`	`endFold`
`String`	`entityMatrix`
`String`	`entityMatrixCh`
`String`	`entityMatrixEn`
`String`	`entitySubclassification`
`double`	`epsilon`
`String`	`errorMatrix`
`boolean`	`estimateInitial`
`String`	`evalCmd`
`boolean`	`evaluateBackground` When scoring, count the background symbol stats too.
`int`	`evaluateIters`
`boolean`	`evaluateTrain`
`boolean`	`expandMidDot`
`String`	`exportFeatures`
`boolean`	`factorInAlignmentProb`
`boolean`	`factorInBiEdgePotential`
`boolean`	`fakeDataset`
`String`	`featThreshFile`
`int`	`featureCountThresh`
`int`	`featureCountThreshold`
`double`	`featureDiffThresh`
`String[]`	`featureFactories`
`List<Object[]>`	`featureFactoriesArgs`
`String`	`featureFactory`
`Object[]`	`featureFactoryArgs`
`int`	`featureThreshold`
`double`	`featureWeightThreshold`
`String`	`femaleNameList`
`double`	`gainSGD`
`List<String>`	`gazettes`
`String`	`gazFilesFile`
`boolean`	`geDebug`
`boolean`	`gradientDebug`
`boolean`	`greekifyNGrams`
`boolean`	`groupByFeatureTemplate`
`boolean`	`groupByHiddenUnit`
`boolean`	`groupByInput`
`boolean`	`groupByOutputClass`
`boolean`	`hardcodeSoftmaxOutputWeights`
`int`	`hybridCutoffIteration`
`boolean`	`includeC2EViterbi`
`boolean`	`includeFullCRFInLOP`
`String`	`inferenceType`
`double`	`initialGain`
`String`	`initialLopScales`
`String`	`initialLopWeights`
`String`	`initialWeights`
`double`	`initRate`
`boolean`	`initViterbi`
`boolean`	`initWithNERPosterior`
`boolean`	`initWithPosterior`
`String`	`inputEncoding`
`int`	`interimOutputFreq`
`String`	`intermediateSegmenterModel`
`String`	`intermediateSegmenterOut`
`boolean`	`intern`
`boolean`	`intern2`
`boolean`	`iobTags`
`boolean`	`iobWrapper`
`boolean`	`justify`
`int`	`kBest`
`boolean`	`keepAllWhitespaces` Keep all the whitespace words in testFile when printing out answers.
`boolean`	`keepEmptySentences` Whether or not to keep blank sentences when processing.
`boolean`	`keepEnglishWhitespaces` Keep the whitespace between English words in testFile when printing out answers.
`boolean`	`keepOBInMemory`
`double`	`l1reg`
`int`	`labelDictionaryCutoff`
`double`	`lambdaCH`
`double`	`lambdaEN`
`boolean`	`largeChSegFile`
`String`	`lastNameList`
`boolean`	`lazyUpdate`
`boolean`	`learnCHBasedOnEN`
`boolean`	`learnENBasedOnCH`
`String`	`loadAuxClassifier`
`String`	`loadBisequenceClassifierCh`
`String`	`loadBisequenceClassifierEn` Bisequence CRF parameters
`String`	`loadClassifier`
`String`	`loadClassIndexFrom`
`String`	`loadCRFSegmenterPath`
`String`	`loadDatasetsDir`
`String`	`loadFeatureIndexFromCH`
`String`	`loadFeatureIndexFromEN`
`String`	`loadJarClassifier`
`String`	`loadPCTSegmenterPath`
`String`	`loadProcessedData`
`String`	`loadTextClassifier`
`String`	`loadWeightsFrom`
`String`	`loadWeightsFromCH`
`String`	`loadWeightsFromEN`
`boolean`	`lowercaseNGrams`
`boolean`	`lowerNewgeneThreshold`
`boolean`	`makeConsistent`
`String`	`maleNameList`
`String`	`map`
`boolean`	`matchNERIncentive`
`int`	`maxAllowedChromaticSize`
`int`	`maxDocSize`
`int`	`maxIterations`
`int`	`maxLeft`
`int`	`maxNGramLeng`
`int`	`maxQNItr`
`int`	`maxRight`
`boolean`	`memoryThrift`
`boolean`	`mergeTags`
`String`	`mixedCaseMapFile`
`String`	`morphFeatureFile`
`int`	`multiThreadClassifier`
`int`	`multiThreadGibbs`
`int`	`multiThreadGrad`
`int`	`multiThreadPerceptron`
`int`	`nerSkipFirstK`
`int`	`nerSlowerTimes`
`double`	`newgeneThreshold`
`boolean`	`noEdgeFeature`
`boolean`	`noMidNGrams`
`boolean`	`noNeighborConstraints`
`boolean`	`nonLinearCRF`
`String`	`normalizationTable`
`boolean`	`normalize`
`String`	`normalizedFile`
`boolean`	`normalizeTerms`
`boolean`	`normalizeTimex`
`String`	`normTableEncoding`
`boolean`	`numberEquivalenceDistSim` If this is set to true, all digit characters get mapped to '9' in a distsim lexicon and for lookup.
`int`	`numDatasetsPerFile`
`int`	`numFolds`
`int`	`numHiddenUnits`
`int`	`numLopExpert` Number of experts to be used in Logarithmic Opinion Pool (product of experts) training default value is 1
`int`	`numOfFeatureSlices`
`int`	`numOfSlices`
`int`	`numRuns`
`int`	`numSamples`
`int`	`numStartLayers`
`int`	`numTimesPruneFeatures`
`int`	`numTimesRemoveTopN`
`int`	`ocrFold`
`boolean`	`ocrTrain`
`String`	`outDict2`
`String`	`outputEncoding`
`String`	`outputFile`
`String`	`outputFormat`
`boolean`	`outputIterationsToFile`
`CoreLabel`	`pad`
`boolean`	`pctSegmenterLenAdjust`
`String`	`pctSegmenterProp`
`double`	`pctSegmenterScale`
`boolean`	`pctSegmenterScaleByCRF`
`boolean`	`perceptronDebug`
`List<String>`	`phraseGazettes`
`String`	`plainTextDocumentReaderAndWriter`
`boolean`	`powerAlignProb`
`boolean`	`powerAlignProbAsAddition`
`String`	`predProp`
`boolean`	`prependEmbedding`
`String`	`printClassifier`
`int`	`printClassifierParam`
`boolean`	`printFactorTable`
`String`	`printFeatures`
`int`	`printFeaturesUpto`
`boolean`	`printFirstOrderProbs`
`String`	`printGazFeatures`
`boolean`	`printLabelValue`
`boolean`	`printNR`
`boolean`	`printProbs`
`boolean`	`printTrainLabels`
`boolean`	`printWeights`
`boolean`	`printXML`
`double`	`priorAlpha`
`double`	`priorLambda`
`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.
`String`	`priorType`
`Properties`	`props`
`boolean`	`purgeDatasets`
`int`	`purgeFeatures`
`String`	`pushDir`
`int`	`QNPasses`
`int`	`QNsize`
`int`	`QNsize2`
`double`	`randomizedRatio`
`boolean`	`randomLopFeatureSplit`
`boolean`	`randomLopWeights`
`String`	`readerAndWriter`
`boolean`	`readStdin`
`boolean`	`regularizeSoftmaxTieParam`
`boolean`	`removeBackgroundSingletonFeatures`
`boolean`	`removeStrictGoodCoNLLDuplicates`
`int`	`removeTopN`
`double`	`removeTopNPercent`
`boolean`	`restrictLabels`
`boolean`	`restrictTransitionsTimit`
`boolean`	`retainEntitySubclassification`
`int`	`samplingSpeedUpThreshold`
`boolean`	`saveFeatureIndexToDisk`
`int`	`scaledSGDMethod`
`String`	`searchGraphPrefix`
`double`	`searchGraphPrune`
`boolean`	`secondOrderNonLinear`
`boolean`	`selfTest`
`double`	`selfTrainConfidenceThreshold`
`String`	`selfTrainFile`
`int`	`selfTrainIterations`
`int`	`selfTrainWindowSize`
`boolean`	`separateASCIIandRange`
`String`	`serializeClassIndexTo`
`String`	`serializeDatasetsDir`
`String`	`serializedDictionary`
`String`	`serializeFeatureIndexTo`
`String`	`serializeTo`
`String`	`serializeToCH`
`String`	`serializeToEN`
`String`	`serializeToText`
`String`	`serializeWeightsTo`
`int`	`SGD2QNhessSamples`
`int`	`SGDPasses`
`String`	`sighanCorporaDict` for Sighan bakeoff 2005, the path to the dictionary of bigrams appeared in corpus
`boolean`	`sighanPostProcessing`
`double`	`sigma`
`boolean`	`skipOutputRegularization`
`boolean`	`sloppyGazette`
`boolean`	`softmaxOutputLayer`
`double`	`softmaxTieLambda`
`boolean`	`sparseOutputLayer`
`boolean`	`splitDocuments`
`boolean`	`splitOnHead`
`String`	`splitWordRegex`
`int`	`startEvaluateIters`
`int`	`startFold`
`int`	`stochasticBatchSize`
`StochasticCalculateMethods`	`stochasticMethod`
`boolean`	`strictGoodCoNLL`
`boolean`	`strictlyFirstOrder`
`boolean`	`strictlySecondOrder`
`boolean`	`strictlyThirdOrder`
`boolean`	`strictlyZeroethOrder`
`boolean`	`subCWGaz`
`String`	`supFileCH`
`String`	`supFileEN`
`boolean`	`suppressMidDotPostprocessing`
`boolean`	`suppressTestDebug`
`String`	`svmModelFile`
`boolean`	`terminateOnAvgImprovement`
`boolean`	`terminateOnEvalImprovement`
`int`	`terminateOnEvalImprovementNumOfEpoch`
`String`	`testDirs`
`String`	`testFile`
`String`	`testFileCH`
`String`	`testFileEN`
`String`	`testFiles`
`boolean`	`testHessSamples`
`boolean`	`testObjFunction`
`boolean`	`testVariance`
`String`	`textFile`
`String`	`textFiles`
`boolean`	`tieOutputLayer`
`boolean`	`timitDatum`
`String`	`tokenFactory`
`Object[]`	`tokenFactoryArgs`
`String`	`tokenizerFactory`
`String`	`tokenizerOptions`
`String`	`tokensAnnotationClassName`
`double`	`tolerance`
`int`	`totalDataSlice`
`int`	`totalFeatureSlice`
`String`	`trainDirs`
`String`	`trainFile`
`String`	`trainFileList`
`String`	`trainFiles`
`String`	`trainHierarchical`
`String`	`transferSigmas`
`boolean`	`transitionEdgeOnly`
`int`	`tuneSampleSize`
`boolean`	`tuneSGD`
`boolean`	`twoStage`
`String`	`type`
`String`	`unigramLM`
`String`	`unknownWordDistSimClass` What class to assign to words not found in the dist sim lexicon.
`String`	`unsupAlignFile`
`String`	`unsupDropoutFile`
`double`	`unsupDropoutScale`
`String`	`unsupFileCH`
`String`	`unsupFileEN`
`boolean`	`use2W`
`boolean`	`use4Clique`
`boolean`	`useAbbr`
`boolean`	`useAbbr1`
`boolean`	`useABGENE`
`boolean`	`useABSTR`
`boolean`	`useABSTRFreq`
`boolean`	`useABSTRFreqDict`
`boolean`	`useAcqPrior`
`boolean`	`useACR`
`boolean`	`useAdaDelta`
`boolean`	`useAdaDiff`
`boolean`	`useAdaGradFOBOS`
`boolean`	`useAltGazFeatures`
`boolean`	`useANTE`
`boolean`	`useAs`
`boolean`	`useASBCChar2`
`boolean`	`useASBCPre1`
`boolean`	`useASBCSuf1`
`boolean`	`useBagOfWords` Use a bag of all words as a feature.
`boolean`	`useBeginSent`
`boolean`	`useBerkeleyAlignerForViterbi`
`boolean`	`useBerkeleyCompetitivePosterior`
`boolean`	`useBig5`
`boolean`	`useBigramInTwoClique`
`boolean`	`useBilingualNERPrior`
`boolean`	`useBoundarySequences`
`boolean`	`useChPos` use POS information (an "open" feature for Chinese segmentation)
`boolean`	`useChromaticSampling`
`boolean`	`useChunks`
`boolean`	`useChunkySequences`
`boolean`	`useClassFeature`
`boolean`	`useCommonWordsFeature`
`boolean`	`useCorefFeatures`
`boolean`	`useCRFforUnsup`
`boolean`	`useCTBChar2`
`boolean`	`useCTBPre1`
`boolean`	`useCTBSuf1`
`boolean`	`useCWSFeatures`
`boolean`	`useCWSWordFeatures`
`boolean`	`useCWSWordFeaturesAll`
`boolean`	`useCWSWordFeaturesBigram`
`boolean`	`useDenero`
`boolean`	`useDict2`
`boolean`	`useDictASBC2`
`boolean`	`useDictCTB2`
`boolean`	`useDictHK2`
`boolean`	`useDictionaryConjunctions`
`boolean`	`useDictionaryConjunctions3`
`boolean`	`useDictleng`
`boolean`	`useDictPK2`
`boolean`	`useDisjShape`
`boolean`	`useDisjunctive`
`boolean`	`useDisjunctiveShapeInteraction`
`boolean`	`useDistSim`
`boolean`	`useDualDecomp`
`boolean`	`useEitherSideDisjunctive`
`boolean`	`useEitherSideWord`
`boolean`	`useEmbedding`
`boolean`	`useEntityRule`
`boolean`	`useEntityTypes`
`boolean`	`useEntityTypeSequences`
`boolean`	`useExternal`
`boolean`	`useExtraTaggySequences`
`boolean`	`useFeaturesC4gram`
`boolean`	`useFeaturesC5gram`
`boolean`	`useFeaturesC6gram`
`boolean`	`useFeaturesCpC4gram`
`boolean`	`useFeaturesCpC5gram`
`boolean`	`useFeaturesCpC6gram`
`boolean`	`useFilter`
`boolean`	`useFirstWord`
`boolean`	`useFloat`
`boolean`	`useFREQ`
`boolean`	`useGazettePhrases`
`boolean`	`useGazettes`
`boolean`	`useGazFeatures`
`boolean`	`useGEforSup`
`boolean`	`useGenericFeatures`
`boolean`	`useGENIA`
`boolean`	`useGoodForNamesCpC`
`boolean`	`useHardGE`
`boolean`	`useHeadGov`
`boolean`	`useHiddenLayer`
`boolean`	`useHk`
`boolean`	`useHKChar2`
`boolean`	`useHKPre1`
`boolean`	`useHKSuf1`
`boolean`	`useHuber`
`boolean`	`useHybrid`
`boolean`	`useIfInteger`
`boolean`	`useInPlaceSGD`
`boolean`	`useInternal`
`boolean`	`useIsDateRange`
`boolean`	`useIsURL`
`boolean`	`useKBest`
`boolean`	`useKL`
`boolean`	`useKnownLCWords`
`boolean`	`useLabelSource`
`boolean`	`useLastRealWord`
`boolean`	`useLC`
`boolean`	`useLemmaAsWord`
`boolean`	`useLemmas`
`boolean`	`useLongSequences`
`boolean`	`useMemoryEvaluator`
`boolean`	`useMidDotShape`
`boolean`	`useMinimalAbbr`
`boolean`	`useMinimalAbbr1`
`boolean`	`useMoreAbbr`
`boolean`	`useMoreGazFeatures`
`boolean`	`useMoreTags`
`boolean`	`useMsr`
`boolean`	`useMSRChar2`
`boolean`	`useMUCFeatures`
`boolean`	`useNB`
`boolean`	`useNegASBCDict2`
`boolean`	`useNegASBCDict3`
`boolean`	`useNegASBCDict4`
`boolean`	`useNegCTBDict2`
`boolean`	`useNegCTBDict3`
`boolean`	`useNegCTBDict4`
`boolean`	`useNegDict2`
`boolean`	`useNegDict3`
`boolean`	`useNegDict4`
`boolean`	`useNegHKDict2`
`boolean`	`useNegHKDict3`
`boolean`	`useNegHKDict4`
`boolean`	`useNegPKDict2`
`boolean`	`useNegPKDict3`
`boolean`	`useNegPKDict4`
`boolean`	`useNeighborNGrams` Use prefixes and suffixes from the previous and next word.
`boolean`	`useNERPrior`
`boolean`	`useNERPriorBIO`
`boolean`	`useNext`
`boolean`	`useNextRealWord`
`boolean`	`useNextSequences`
`boolean`	`useNextVB`
`boolean`	`useNGrams`
`boolean`	`useNoisyLabel`
`boolean`	`useNoisyNonNoisyFeature`
`boolean`	`useNPGovernor`
`boolean`	`useNPHead`
`boolean`	`useNumberFeature`
`boolean`	`useObservedFeaturesOnly`
`boolean`	`useObservedSequencesOnly`
`boolean`	`useOccurrencePatterns`
`boolean`	`useOnlySeenWeights`
`boolean`	`useOrdinal`
`boolean`	`useOutDict2`
`boolean`	`useOutputLayer`
`boolean`	`useOWLQN`
`boolean`	`useParenMatching`
`boolean`	`usePhraseFeatures`
`boolean`	`usePhraseWords`
`boolean`	`usePhraseWordSpecialTags`
`boolean`	`usePhraseWordTags`
`boolean`	`usePk`
`boolean`	`usePKChar2`
`boolean`	`usePKPre1`
`boolean`	`usePKSuf1`
`boolean`	`usePosition`
`boolean`	`usePre`
`boolean`	`usePrediction`
`boolean`	`usePrediction2`
`boolean`	`usePrev`
`boolean`	`usePrevNextLemmas`
`boolean`	`usePrevSequences`
`boolean`	`usePrevVB`
`boolean`	`useProtoFeatures`
`boolean`	`useQN`
`boolean`	`useQuartic`
`boolean`	`useRad1`
`boolean`	`useRad2`
`boolean`	`useRad2b`
`boolean`	`useRadical`
`boolean`	`useRandomSeed`
`boolean`	`useReverse`
`boolean`	`useReverseAffix`
`boolean`	`useRobustQN`
`boolean`	`useRule`
`boolean`	`useRule2`
`boolean`	`useScaledSGD`
`boolean`	`useSeenFeaturesOnly`
`boolean`	`useSegmentation`
`boolean`	`useSemPrior`
`boolean`	`useSentenceNumber`
`boolean`	`useSequences`
`boolean`	`useSequentialScanSampling`
`boolean`	`useSGD`
`boolean`	`useSGDtoQN`
`boolean`	`useShapeConjunctions`
`boolean`	`useShapeStrings`
`boolean`	`useShapeStrings1`
`boolean`	`useShapeStrings3`
`boolean`	`useShapeStrings4`
`boolean`	`useShapeStrings5`
`boolean`	`useSigmoid`
`boolean`	`useSMD`
`boolean`	`useStochasticQN`
`boolean`	`useSuf`
`boolean`	`useSum`
`boolean`	`useSymTags`
`boolean`	`useSymWordPairs` useSymWordPairs Has a small negative effect.
`boolean`	`useTaggySequences`
`boolean`	`useTaggySequencesShapeInteraction`
`boolean`	`useTags`
`boolean`	`useTitle`
`boolean`	`useTOK`
`boolean`	`useTopics`
`boolean`	`useTrainLexicon`
`boolean`	`useTypeSeqs`
`boolean`	`useTypeSeqs2`
`boolean`	`useTypeSeqs3`
`boolean`	`useTypeySequences`
`boolean`	`useUnicodeBlock`
`boolean`	`useUnicodeType`
`boolean`	`useUnicodeType4gram`
`boolean`	`useUnicodeType5gram`
`boolean`	`useUniformPrior`
`boolean`	`useUnknown`
`boolean`	`useURLSequences`
`boolean`	`useVB`
`boolean`	`useViterbi`
`boolean`	`useWEB`
`boolean`	`useWEBFreqDict`
`boolean`	`useWideDisjunctive`
`boolean`	`useWord`
`boolean`	`useWord1`
`boolean`	`useWord2`
`boolean`	`useWord3`
`boolean`	`useWord4`
`boolean`	`useWordn`
`boolean`	`useWordnetFeatures`
`boolean`	`useWordPairs`
`boolean`	`useWordShapeConjunctions2`
`boolean`	`useWordShapeConjunctions3`
`boolean`	`useWordShapeGaz`
`boolean`	`useWordTag`
`boolean`	`useWordUTypeConjunctions2`
`boolean`	`useWordUTypeConjunctions3`
`boolean`	`useYear`
`boolean`	`useYetMoreCpCShapes`
`boolean`	`verboseForTrueCasing`
`boolean`	`verboseMode`
`String`	`vocabFile`
`boolean`	`weightByEntropy`
`int`	`wideDisjunctionWidth`
`String`	`wikiFeatureDbFile`
`Function<String,String>`	`wordFunction` This function maps words in the training or test data to new words.
`int`	`wordSegBeamSize`
`int`	`wordShape`
`String`	`wordShapeGaz`

Constructor Summary

Constructors
Constructor and Description
`SeqClassifierFlags()`
`SeqClassifierFlags(Properties props)` Create a new SeqClassifierFlags object and initialize it using values in the Properties object.

Method Summary

Methods
Modifier and Type	Method and Description
`String`	`getNotNullTrueStringRep()` note that this does not return string representation of arrays, lists and enums
`void`	`setProperties(Properties props)` Initialize this object using values in Properties object.
`void`	`setProperties(Properties props, boolean printProps)` Initialize using values in Properties file.
`String`	`toString()` Print the properties specified by this object.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

DEFAULT_BACKGROUND_SYMBOL

public static final String DEFAULT_BACKGROUND_SYMBOL

See Also:: Constant Field Values

useNGrams
```
public boolean useNGrams
```

conjoinShapeNGrams
```
public boolean conjoinShapeNGrams
```

lowercaseNGrams
```
public boolean lowercaseNGrams
```

dehyphenateNGrams
```
public boolean dehyphenateNGrams
```

usePrev
```
public boolean usePrev
```

useNext
```
public boolean useNext
```

useTags
```
public boolean useTags
```

useWordPairs
```
public boolean useWordPairs
```

useGazettes
```
public boolean useGazettes
```

useSequences
```
public boolean useSequences
```

usePrevSequences
```
public boolean usePrevSequences
```

useNextSequences
```
public boolean useNextSequences
```

useLongSequences
```
public boolean useLongSequences
```

useBoundarySequences
```
public boolean useBoundarySequences
```

useTaggySequences
```
public boolean useTaggySequences
```

useExtraTaggySequences
```
public boolean useExtraTaggySequences
```

dontExtendTaggy
```
public boolean dontExtendTaggy
```

useTaggySequencesShapeInteraction

public boolean useTaggySequencesShapeInteraction

strictlyZeroethOrder
```
public boolean strictlyZeroethOrder
```

strictlyFirstOrder
```
public boolean strictlyFirstOrder
```

strictlySecondOrder
```
public boolean strictlySecondOrder
```

strictlyThirdOrder
```
public boolean strictlyThirdOrder
```

entitySubclassification
```
public String entitySubclassification
```

retainEntitySubclassification

public boolean retainEntitySubclassification

useGazettePhrases
```
public boolean useGazettePhrases
```

makeConsistent
```
public boolean makeConsistent
```

useViterbi
```
public boolean useViterbi
```

binnedLengths
```
public int[] binnedLengths
```

verboseMode
```
public boolean verboseMode
```

useSum
```
public boolean useSum
```

tolerance
```
public double tolerance
```

printFeatures
```
public String printFeatures
```

useSymTags
```
public boolean useSymTags
```

useSymWordPairs
```
public boolean useSymWordPairs
```
useSymWordPairs Has a small negative effect.

printClassifier
```
public String printClassifier
```

printClassifierParam
```
public int printClassifierParam
```

intern
```
public boolean intern
```

intern2
```
public boolean intern2
```

selfTest
```
public boolean selfTest
```

sloppyGazette
```
public boolean sloppyGazette
```

cleanGazette
```
public boolean cleanGazette
```

noMidNGrams
```
public boolean noMidNGrams
```

maxNGramLeng
```
public int maxNGramLeng
```

useReverse
```
public boolean useReverse
```

greekifyNGrams
```
public boolean greekifyNGrams
```

useParenMatching
```
public boolean useParenMatching
```

useLemmas
```
public boolean useLemmas
```

usePrevNextLemmas
```
public boolean usePrevNextLemmas
```

normalizeTerms
```
public boolean normalizeTerms
```

normalizeTimex
```
public boolean normalizeTimex
```

useNB
```
public boolean useNB
```

useQN
```
public boolean useQN
```

useFloat
```
public boolean useFloat
```

QNsize
```
public int QNsize
```

QNsize2
```
public int QNsize2
```

maxIterations
```
public int maxIterations
```

wordShape
```
public int wordShape
```

useShapeStrings
```
public boolean useShapeStrings
```

useTypeSeqs
```
public boolean useTypeSeqs
```

useTypeSeqs2
```
public boolean useTypeSeqs2
```

useTypeSeqs3
```
public boolean useTypeSeqs3
```

useDisjunctive
```
public boolean useDisjunctive
```

disjunctionWidth
```
public int disjunctionWidth
```

useDisjunctiveShapeInteraction

public boolean useDisjunctiveShapeInteraction

useDisjShape
```
public boolean useDisjShape
```

useWord
```
public boolean useWord
```

useClassFeature
```
public boolean useClassFeature
```

useShapeConjunctions
```
public boolean useShapeConjunctions
```

useWordTag
```
public boolean useWordTag
```

useNPHead
```
public boolean useNPHead
```

useNPGovernor
```
public boolean useNPGovernor
```

useHeadGov
```
public boolean useHeadGov
```

useLastRealWord
```
public boolean useLastRealWord
```

useNextRealWord
```
public boolean useNextRealWord
```

useOccurrencePatterns
```
public boolean useOccurrencePatterns
```

useTypeySequences
```
public boolean useTypeySequences
```

justify
```
public boolean justify
```

normalize
```
public boolean normalize
```

priorType
```
public String priorType
```

sigma
```
public double sigma
```

epsilon
```
public double epsilon
```

beamSize
```
public int beamSize
```

maxLeft
```
public int maxLeft
```

maxRight
```
public int maxRight
```

usePosition
```
public boolean usePosition
```

useBeginSent
```
public boolean useBeginSent
```

useGazFeatures
```
public boolean useGazFeatures
```

useMoreGazFeatures
```
public boolean useMoreGazFeatures
```

useAbbr
```
public boolean useAbbr
```

useMinimalAbbr
```
public boolean useMinimalAbbr
```

useAbbr1
```
public boolean useAbbr1
```

useMinimalAbbr1
```
public boolean useMinimalAbbr1
```

useMoreAbbr
```
public boolean useMoreAbbr
```

deleteBlankLines
```
public boolean deleteBlankLines
```

useGENIA
```
public boolean useGENIA
```

useTOK
```
public boolean useTOK
```

useABSTR
```
public boolean useABSTR
```

useABSTRFreqDict
```
public boolean useABSTRFreqDict
```

useABSTRFreq
```
public boolean useABSTRFreq
```

useFREQ
```
public boolean useFREQ
```

useABGENE
```
public boolean useABGENE
```

useWEB
```
public boolean useWEB
```

useWEBFreqDict
```
public boolean useWEBFreqDict
```

useIsURL
```
public boolean useIsURL
```

useURLSequences
```
public boolean useURLSequences
```

useIsDateRange
```
public boolean useIsDateRange
```

useEntityTypes
```
public boolean useEntityTypes
```

useEntityTypeSequences
```
public boolean useEntityTypeSequences
```

useEntityRule
```
public boolean useEntityRule
```

useOrdinal
```
public boolean useOrdinal
```

useACR
```
public boolean useACR
```

useANTE
```
public boolean useANTE
```

useMoreTags
```
public boolean useMoreTags
```

useChunks
```
public boolean useChunks
```

useChunkySequences
```
public boolean useChunkySequences
```

usePrevVB
```
public boolean usePrevVB
```

useNextVB
```
public boolean useNextVB
```

useVB
```
public boolean useVB
```

subCWGaz
```
public boolean subCWGaz
```

documentReader
```
public String documentReader
```

map
```
public String map
```

useWideDisjunctive
```
public boolean useWideDisjunctive
```

wideDisjunctionWidth
```
public int wideDisjunctionWidth
```

useRadical
```
public boolean useRadical
```

useBigramInTwoClique
```
public boolean useBigramInTwoClique
```

morphFeatureFile
```
public String morphFeatureFile
```

useReverseAffix
```
public boolean useReverseAffix
```

charHalfWindow
```
public int charHalfWindow
```

useWord1
```
public boolean useWord1
```

useWord2
```
public boolean useWord2
```

useWord3
```
public boolean useWord3
```

useWord4
```
public boolean useWord4
```

useRad1
```
public boolean useRad1
```

useRad2
```
public boolean useRad2
```

useWordn
```
public boolean useWordn
```

useCTBPre1
```
public boolean useCTBPre1
```

useCTBSuf1
```
public boolean useCTBSuf1
```

useASBCPre1
```
public boolean useASBCPre1
```

useASBCSuf1
```
public boolean useASBCSuf1
```

usePKPre1
```
public boolean usePKPre1
```

usePKSuf1
```
public boolean usePKSuf1
```

useHKPre1
```
public boolean useHKPre1
```

useHKSuf1
```
public boolean useHKSuf1
```

useCTBChar2
```
public boolean useCTBChar2
```

useASBCChar2
```
public boolean useASBCChar2
```

useHKChar2
```
public boolean useHKChar2
```

usePKChar2
```
public boolean usePKChar2
```

useRule2
```
public boolean useRule2
```

useDict2
```
public boolean useDict2
```

useOutDict2
```
public boolean useOutDict2
```

outDict2
```
public String outDict2
```

useDictleng
```
public boolean useDictleng
```

useDictCTB2
```
public boolean useDictCTB2
```

useDictASBC2
```
public boolean useDictASBC2
```

useDictPK2
```
public boolean useDictPK2
```

useDictHK2
```
public boolean useDictHK2
```

useBig5
```
public boolean useBig5
```

useNegDict2
```
public boolean useNegDict2
```

useNegDict3
```
public boolean useNegDict3
```

useNegDict4
```
public boolean useNegDict4
```

useNegCTBDict2
```
public boolean useNegCTBDict2
```

useNegCTBDict3
```
public boolean useNegCTBDict3
```

useNegCTBDict4
```
public boolean useNegCTBDict4
```

useNegASBCDict2
```
public boolean useNegASBCDict2
```

useNegASBCDict3
```
public boolean useNegASBCDict3
```

useNegASBCDict4
```
public boolean useNegASBCDict4
```

useNegHKDict2
```
public boolean useNegHKDict2
```

useNegHKDict3
```
public boolean useNegHKDict3
```

useNegHKDict4
```
public boolean useNegHKDict4
```

useNegPKDict2
```
public boolean useNegPKDict2
```

useNegPKDict3
```
public boolean useNegPKDict3
```

useNegPKDict4
```
public boolean useNegPKDict4
```

usePre
```
public boolean usePre
```

useSuf
```
public boolean useSuf
```

useRule
```
public boolean useRule
```

useHk
```
public boolean useHk
```

useMsr
```
public boolean useMsr
```

useMSRChar2
```
public boolean useMSRChar2
```

usePk
```
public boolean usePk
```

useAs
```
public boolean useAs
```

useFilter
```
public boolean useFilter
```

largeChSegFile
```
public boolean largeChSegFile
```

useRad2b
```
public boolean useRad2b
```

keepEnglishWhitespaces
```
public 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
```
public 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
```
public boolean sighanPostProcessing
```

useChPos
```
public boolean useChPos
```
use POS information (an "open" feature for Chinese segmentation)

normalizationTable
```
public String normalizationTable
```

dictionary
```
public String dictionary
```

serializedDictionary
```
public String serializedDictionary
```

dictionary2
```
public String dictionary2
```

normTableEncoding
```
public String normTableEncoding
```

sighanCorporaDict
```
public String sighanCorporaDict
```
for Sighan bakeoff 2005, the path to the dictionary of bigrams appeared in corpus

useWordShapeGaz
```
public boolean useWordShapeGaz
```

wordShapeGaz
```
public String wordShapeGaz
```

splitDocuments
```
public boolean splitDocuments
```

printXML
```
public boolean printXML
```

useSeenFeaturesOnly
```
public boolean useSeenFeaturesOnly
```

lastNameList
```
public String lastNameList
```

maleNameList
```
public String maleNameList
```

femaleNameList
```
public String femaleNameList
```

trainFile
```
public transient String trainFile
```

adaptFile
```
public transient String adaptFile
```
NER adaptation (Gaussian prior) parameters.

devFile
```
public transient String devFile
```

testFile
```
public transient String testFile
```

textFile
```
public transient String textFile
```

textFiles
```
public transient String textFiles
```

readStdin
```
public transient boolean readStdin
```

outputFile
```
public transient String outputFile
```

loadClassifier
```
public transient String loadClassifier
```

loadTextClassifier

public transient String loadTextClassifier

loadJarClassifier

public transient String loadJarClassifier

loadAuxClassifier

public transient String loadAuxClassifier

serializeTo
```
public transient String serializeTo
```

serializeToText

public transient String serializeToText

interimOutputFreq
```
public transient int interimOutputFreq
```

initialWeights
```
public transient String initialWeights
```

gazettes
```
public transient List<String> gazettes
```

selfTrainFile
```
public transient String selfTrainFile
```

inputEncoding
```
public String inputEncoding
```

bioSubmitOutput
```
public boolean bioSubmitOutput
```

numRuns
```
public int numRuns
```

answerFile
```
public String answerFile
```

altAnswerFile
```
public String altAnswerFile
```

dropGaz
```
public String dropGaz
```

printGazFeatures
```
public String printGazFeatures
```

numStartLayers
```
public int numStartLayers
```

dump
```
public boolean dump
```

mergeTags
```
public boolean mergeTags
```

splitOnHead
```
public boolean splitOnHead
```

featureCountThreshold
```
public int featureCountThreshold
```

featureWeightThreshold
```
public double featureWeightThreshold
```

featureFactory
```
public String featureFactory
```

featureFactoryArgs
```
public Object[] featureFactoryArgs
```

backgroundSymbol
```
public String backgroundSymbol
```

useObservedSequencesOnly

public boolean useObservedSequencesOnly

maxDocSize
```
public int maxDocSize
```

printProbs
```
public boolean printProbs
```

printFirstOrderProbs
```
public boolean printFirstOrderProbs
```

saveFeatureIndexToDisk
```
public boolean saveFeatureIndexToDisk
```

removeBackgroundSingletonFeatures

public boolean removeBackgroundSingletonFeatures

doGibbs
```
public boolean doGibbs
```

numSamples
```
public int numSamples
```

useNERPrior
```
public boolean useNERPrior
```

useAcqPrior
```
public boolean useAcqPrior
```

useUniformPrior
```
public boolean useUniformPrior
```

useMUCFeatures
```
public boolean useMUCFeatures
```

annealingRate
```
public double annealingRate
```

annealingType
```
public String annealingType
```

loadProcessedData
```
public String loadProcessedData
```

initViterbi
```
public boolean initViterbi
```

useUnknown
```
public boolean useUnknown
```

checkNameList
```
public boolean checkNameList
```

useSemPrior
```
public boolean useSemPrior
```

useFirstWord
```
public boolean useFirstWord
```

useNumberFeature
```
public boolean useNumberFeature
```

ocrFold
```
public int ocrFold
```

ocrTrain
```
public transient boolean ocrTrain
```

classifierType
```
public String classifierType
```

svmModelFile
```
public String svmModelFile
```

inferenceType
```
public String inferenceType
```

useLemmaAsWord
```
public boolean useLemmaAsWord
```

type
```
public String type
```

readerAndWriter
```
public String readerAndWriter
```

comboProps
```
public List<String> comboProps
```

usePrediction
```
public boolean usePrediction
```

useAltGazFeatures
```
public boolean useAltGazFeatures
```

gazFilesFile
```
public String gazFilesFile
```

usePrediction2
```
public boolean usePrediction2
```

baseTrainDir
```
public String baseTrainDir
```

baseTestDir
```
public String baseTestDir
```

trainFiles
```
public String trainFiles
```

trainFileList
```
public String trainFileList
```

testFiles
```
public String testFiles
```

trainDirs
```
public String trainDirs
```

testDirs
```
public String testDirs
```

useOnlySeenWeights
```
public boolean useOnlySeenWeights
```

predProp
```
public String predProp
```

pad
```
public CoreLabel pad
```

useObservedFeaturesOnly
```
public boolean useObservedFeaturesOnly
```

distSimLexicon
```
public String distSimLexicon
```

useDistSim
```
public boolean useDistSim
```

removeTopN
```
public int removeTopN
```

numTimesRemoveTopN
```
public int numTimesRemoveTopN
```

randomizedRatio
```
public double randomizedRatio
```

removeTopNPercent
```
public double removeTopNPercent
```

purgeFeatures
```
public int purgeFeatures
```

booleanFeatures
```
public boolean booleanFeatures
```

iobWrapper
```
public boolean iobWrapper
```

iobTags
```
public boolean iobTags
```

useSegmentation
```
public boolean useSegmentation
```

memoryThrift
```
public boolean memoryThrift
```

timitDatum
```
public boolean timitDatum
```

serializeDatasetsDir
```
public String serializeDatasetsDir
```

loadDatasetsDir
```
public String loadDatasetsDir
```

pushDir
```
public String pushDir
```

purgeDatasets
```
public boolean purgeDatasets
```

keepOBInMemory
```
public boolean keepOBInMemory
```

fakeDataset
```
public boolean fakeDataset
```

restrictTransitionsTimit

public boolean restrictTransitionsTimit

numDatasetsPerFile
```
public int numDatasetsPerFile
```

useTitle
```
public boolean useTitle
```

lowerNewgeneThreshold
```
public boolean lowerNewgeneThreshold
```

useEitherSideWord
```
public boolean useEitherSideWord
```

useEitherSideDisjunctive

public boolean useEitherSideDisjunctive

twoStage
```
public boolean twoStage
```

crfType
```
public String crfType
```

featureThreshold
```
public int featureThreshold
```

featThreshFile
```
public String featThreshFile
```

featureDiffThresh
```
public double featureDiffThresh
```

numTimesPruneFeatures
```
public int numTimesPruneFeatures
```

newgeneThreshold
```
public double newgeneThreshold
```

doAdaptation
```
public boolean doAdaptation
```

useInternal
```
public boolean useInternal
```

useExternal
```
public boolean useExternal
```

selfTrainConfidenceThreshold

public double selfTrainConfidenceThreshold

selfTrainIterations
```
public int selfTrainIterations
```

selfTrainWindowSize
```
public int selfTrainWindowSize
```

useHuber
```
public boolean useHuber
```

useQuartic
```
public boolean useQuartic
```

adaptSigma
```
public double adaptSigma
```

numFolds
```
public int numFolds
```

startFold
```
public int startFold
```

endFold
```
public int endFold
```

cacheNGrams
```
public boolean cacheNGrams
```

outputFormat
```
public String outputFormat
```

useSMD
```
public boolean useSMD
```

useSGDtoQN
```
public boolean useSGDtoQN
```

useStochasticQN
```
public boolean useStochasticQN
```

useScaledSGD
```
public boolean useScaledSGD
```

scaledSGDMethod
```
public int scaledSGDMethod
```

SGDPasses
```
public int SGDPasses
```

QNPasses
```
public int QNPasses
```

tuneSGD
```
public boolean tuneSGD
```

stochasticMethod

public StochasticCalculateMethods stochasticMethod

initialGain
```
public double initialGain
```

stochasticBatchSize
```
public int stochasticBatchSize
```

useSGD
```
public boolean useSGD
```

gainSGD
```
public double gainSGD
```

useHybrid
```
public boolean useHybrid
```

hybridCutoffIteration
```
public int hybridCutoffIteration
```

outputIterationsToFile
```
public boolean outputIterationsToFile
```

testObjFunction
```
public boolean testObjFunction
```

testVariance
```
public boolean testVariance
```

SGD2QNhessSamples
```
public int SGD2QNhessSamples
```

testHessSamples
```
public boolean testHessSamples
```

CRForder
```
public int CRForder
```

CRFwindow
```
public int CRFwindow
```

estimateInitial
```
public boolean estimateInitial
```

biasedTrainFile

public transient String biasedTrainFile

confusionMatrix

public transient String confusionMatrix

outputEncoding
```
public String outputEncoding
```

useKBest
```
public boolean useKBest
```

searchGraphPrefix
```
public String searchGraphPrefix
```

searchGraphPrune
```
public double searchGraphPrune
```

kBest
```
public int kBest
```

useFeaturesC4gram
```
public boolean useFeaturesC4gram
```

useFeaturesC5gram
```
public boolean useFeaturesC5gram
```

useFeaturesC6gram
```
public boolean useFeaturesC6gram
```

useFeaturesCpC4gram
```
public boolean useFeaturesCpC4gram
```

useFeaturesCpC5gram
```
public boolean useFeaturesCpC5gram
```

useFeaturesCpC6gram
```
public boolean useFeaturesCpC6gram
```

useUnicodeType
```
public boolean useUnicodeType
```

useUnicodeType4gram
```
public boolean useUnicodeType4gram
```

useUnicodeType5gram
```
public boolean useUnicodeType5gram
```

use4Clique
```
public boolean use4Clique
```

useUnicodeBlock
```
public boolean useUnicodeBlock
```

useShapeStrings1
```
public boolean useShapeStrings1
```

useShapeStrings3
```
public boolean useShapeStrings3
```

useShapeStrings4
```
public boolean useShapeStrings4
```

useShapeStrings5
```
public boolean useShapeStrings5
```

useGoodForNamesCpC
```
public boolean useGoodForNamesCpC
```

useDictionaryConjunctions

public boolean useDictionaryConjunctions

expandMidDot
```
public boolean expandMidDot
```

printFeaturesUpto
```
public int printFeaturesUpto
```

useDictionaryConjunctions3

public boolean useDictionaryConjunctions3

useWordUTypeConjunctions2

public boolean useWordUTypeConjunctions2

useWordUTypeConjunctions3

public boolean useWordUTypeConjunctions3

useWordShapeConjunctions2

public boolean useWordShapeConjunctions2

useWordShapeConjunctions3

public boolean useWordShapeConjunctions3

useMidDotShape
```
public boolean useMidDotShape
```

augmentedDateChars
```
public boolean augmentedDateChars
```

suppressMidDotPostprocessing

public boolean suppressMidDotPostprocessing

printNR
```
public boolean printNR
```

classBias
```
public String classBias
```

printLabelValue
```
public boolean printLabelValue
```

useRobustQN
```
public boolean useRobustQN
```

combo
```
public boolean combo
```

useGenericFeatures
```
public boolean useGenericFeatures
```

verboseForTrueCasing
```
public boolean verboseForTrueCasing
```

trainHierarchical
```
public String trainHierarchical
```

domain
```
public String domain
```

baseline
```
public boolean baseline
```

transferSigmas
```
public String transferSigmas
```

doFE
```
public boolean doFE
```

restrictLabels
```
public boolean restrictLabels
```

announceObjectBankEntries

public boolean announceObjectBankEntries

l1reg
```
public double l1reg
```

mixedCaseMapFile
```
public String mixedCaseMapFile
```

auxTrueCaseModels
```
public String auxTrueCaseModels
```

use2W
```
public boolean use2W
```

useLC
```
public boolean useLC
```

useYetMoreCpCShapes
```
public boolean useYetMoreCpCShapes
```

useIfInteger
```
public boolean useIfInteger
```

exportFeatures
```
public String exportFeatures
```

useInPlaceSGD
```
public boolean useInPlaceSGD
```

useTopics
```
public boolean useTopics
```

evaluateIters
```
public int evaluateIters
```

evalCmd
```
public String evalCmd
```

evaluateTrain
```
public boolean evaluateTrain
```

tuneSampleSize
```
public int tuneSampleSize
```

usePhraseFeatures
```
public boolean usePhraseFeatures
```

usePhraseWords
```
public boolean usePhraseWords
```

usePhraseWordTags
```
public boolean usePhraseWordTags
```

usePhraseWordSpecialTags

public boolean usePhraseWordSpecialTags

useCommonWordsFeature
```
public boolean useCommonWordsFeature
```

useProtoFeatures
```
public boolean useProtoFeatures
```

useWordnetFeatures
```
public boolean useWordnetFeatures
```

tokenFactory
```
public String tokenFactory
```

tokenFactoryArgs
```
public Object[] tokenFactoryArgs
```

tokensAnnotationClassName

public String tokensAnnotationClassName

tokenizerOptions

public transient String tokenizerOptions

tokenizerFactory

public transient String tokenizerFactory

useCorefFeatures
```
public boolean useCorefFeatures
```

wikiFeatureDbFile
```
public String wikiFeatureDbFile
```

useNoisyNonNoisyFeature
```
public boolean useNoisyNonNoisyFeature
```

useYear
```
public boolean useYear
```

useSentenceNumber
```
public boolean useSentenceNumber
```

useLabelSource
```
public boolean useLabelSource
```

casedDistSim
```
public 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
```
public 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
```
public 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
```
public 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
```
public 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
```
public boolean useNeighborNGrams
```
Use prefixes and suffixes from the previous and next word.

wordFunction
```
public Function<String,String> 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.

DEFAULT_PLAIN_TEXT_READER

public static final String DEFAULT_PLAIN_TEXT_READER

See Also:: Constant Field Values

plainTextDocumentReaderAndWriter

public String plainTextDocumentReaderAndWriter

useBagOfWords
```
public 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
```
public boolean evaluateBackground
```
When scoring, count the background symbol stats too. Useful for things where the background symbol is particularly meaningful, such as truecase.

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

initialLopScales

public transient String initialLopScales

initialLopWeights

public transient String initialLopWeights

includeFullCRFInLOP
```
public boolean includeFullCRFInLOP
```

backpropLopTraining
```
public boolean backpropLopTraining
```

randomLopWeights
```
public boolean randomLopWeights
```

randomLopFeatureSplit
```
public boolean randomLopFeatureSplit
```

nonLinearCRF
```
public boolean nonLinearCRF
```

secondOrderNonLinear
```
public boolean secondOrderNonLinear
```

numHiddenUnits
```
public int numHiddenUnits
```

useOutputLayer
```
public boolean useOutputLayer
```

useHiddenLayer
```
public boolean useHiddenLayer
```

gradientDebug
```
public boolean gradientDebug
```

checkGradient
```
public boolean checkGradient
```

useSigmoid
```
public boolean useSigmoid
```

skipOutputRegularization

public boolean skipOutputRegularization

sparseOutputLayer
```
public boolean sparseOutputLayer
```

tieOutputLayer
```
public boolean tieOutputLayer
```

blockInitialize
```
public boolean blockInitialize
```

softmaxOutputLayer
```
public boolean softmaxOutputLayer
```

loadBisequenceClassifierEn
```
public String loadBisequenceClassifierEn
```
Bisequence CRF parameters

loadBisequenceClassifierCh

public String loadBisequenceClassifierCh

bisequenceClassifierPropEn

public String bisequenceClassifierPropEn

bisequenceClassifierPropCh

public String bisequenceClassifierPropCh

bisequenceTestFileEn
```
public String bisequenceTestFileEn
```

bisequenceTestFileCh
```
public String bisequenceTestFileCh
```

bisequenceTestOutputEn
```
public String bisequenceTestOutputEn
```

bisequenceTestOutputCh
```
public String bisequenceTestOutputCh
```

bisequenceTestAlignmentFile

public String bisequenceTestAlignmentFile

bisequenceAlignmentTestOutput

public String bisequenceAlignmentTestOutput

bisequencePriorType
```
public int bisequencePriorType
```

bisequenceAlignmentPriorPenaltyCh

public String bisequenceAlignmentPriorPenaltyCh

bisequenceAlignmentPriorPenaltyEn

public String bisequenceAlignmentPriorPenaltyEn

alignmentPruneThreshold
```
public double alignmentPruneThreshold
```

alignmentDecodeThreshold
```
public double alignmentDecodeThreshold
```

factorInAlignmentProb
```
public boolean factorInAlignmentProb
```

useChromaticSampling
```
public boolean useChromaticSampling
```

useSequentialScanSampling

public boolean useSequentialScanSampling

maxAllowedChromaticSize
```
public int maxAllowedChromaticSize
```

keepEmptySentences
```
public 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
```
public boolean useBilingualNERPrior
```

samplingSpeedUpThreshold
```
public int samplingSpeedUpThreshold
```

entityMatrixCh
```
public String entityMatrixCh
```

entityMatrixEn
```
public String entityMatrixEn
```

multiThreadGibbs
```
public int multiThreadGibbs
```

matchNERIncentive
```
public boolean matchNERIncentive
```

useEmbedding
```
public boolean useEmbedding
```

prependEmbedding
```
public boolean prependEmbedding
```

embeddingWords
```
public String embeddingWords
```

embeddingVectors
```
public String embeddingVectors
```

transitionEdgeOnly
```
public boolean transitionEdgeOnly
```

priorLambda
```
public double priorLambda
```

addCapitalFeatures
```
public boolean addCapitalFeatures
```

arbitraryInputLayerSize
```
public int arbitraryInputLayerSize
```

noEdgeFeature
```
public boolean noEdgeFeature
```

terminateOnEvalImprovement

public boolean terminateOnEvalImprovement

terminateOnEvalImprovementNumOfEpoch

public int terminateOnEvalImprovementNumOfEpoch

useMemoryEvaluator
```
public boolean useMemoryEvaluator
```

suppressTestDebug
```
public boolean suppressTestDebug
```

useOWLQN
```
public boolean useOWLQN
```

printWeights
```
public boolean printWeights
```

totalDataSlice
```
public int totalDataSlice
```

numOfSlices
```
public int numOfSlices
```

regularizeSoftmaxTieParam

public boolean regularizeSoftmaxTieParam

softmaxTieLambda
```
public double softmaxTieLambda
```

totalFeatureSlice
```
public int totalFeatureSlice
```

numOfFeatureSlices
```
public int numOfFeatureSlices
```

addBiasToEmbedding
```
public boolean addBiasToEmbedding
```

hardcodeSoftmaxOutputWeights

public boolean hardcodeSoftmaxOutputWeights

useNERPriorBIO
```
public boolean useNERPriorBIO
```

entityMatrix
```
public String entityMatrix
```

multiThreadClassifier
```
public int multiThreadClassifier
```

useDualDecomp
```
public boolean useDualDecomp
```

biAlignmentPriorIsPMI
```
public boolean biAlignmentPriorIsPMI
```

dampDDStepSizeWithAlignmentProb

public boolean dampDDStepSizeWithAlignmentProb

dualDecompAlignment
```
public boolean dualDecompAlignment
```

dualDecompInitialStepSizeAlignment

public double dualDecompInitialStepSizeAlignment

dualDecompNotBIO
```
public boolean dualDecompNotBIO
```

berkeleyAlignerLoadPath
```
public String berkeleyAlignerLoadPath
```

useBerkeleyAlignerForViterbi

public boolean useBerkeleyAlignerForViterbi

useBerkeleyCompetitivePosterior

public boolean useBerkeleyCompetitivePosterior

useDenero
```
public boolean useDenero
```

alignDDAlpha
```
public double alignDDAlpha
```

factorInBiEdgePotential
```
public boolean factorInBiEdgePotential
```

noNeighborConstraints
```
public boolean noNeighborConstraints
```

includeC2EViterbi
```
public boolean includeC2EViterbi
```

initWithPosterior
```
public boolean initWithPosterior
```

nerSkipFirstK
```
public int nerSkipFirstK
```

nerSlowerTimes
```
public int nerSlowerTimes
```

powerAlignProb
```
public boolean powerAlignProb
```

powerAlignProbAsAddition

public boolean powerAlignProbAsAddition

initWithNERPosterior
```
public boolean initWithNERPosterior
```

applyNERPenalty
```
public boolean applyNERPenalty
```

printFactorTable
```
public boolean printFactorTable
```

useAdaGradFOBOS
```
public boolean useAdaGradFOBOS
```

initRate
```
public double initRate
```

groupByFeatureTemplate
```
public boolean groupByFeatureTemplate
```

groupByOutputClass
```
public boolean groupByOutputClass
```

priorAlpha
```
public double priorAlpha
```

splitWordRegex
```
public String splitWordRegex
```

groupByInput
```
public boolean groupByInput
```

groupByHiddenUnit
```
public boolean groupByHiddenUnit
```

unigramLM
```
public String unigramLM
```

bigramLM
```
public String bigramLM
```

wordSegBeamSize
```
public int wordSegBeamSize
```

vocabFile
```
public String vocabFile
```

normalizedFile
```
public String normalizedFile
```

averagePerceptron
```
public boolean averagePerceptron
```

loadCRFSegmenterPath
```
public String loadCRFSegmenterPath
```

loadPCTSegmenterPath
```
public String loadPCTSegmenterPath
```

crfSegmenterProp
```
public String crfSegmenterProp
```

pctSegmenterProp
```
public String pctSegmenterProp
```

intermediateSegmenterOut
```
public String intermediateSegmenterOut
```

intermediateSegmenterModel

public String intermediateSegmenterModel

dualDecompMaxItr
```
public int dualDecompMaxItr
```

dualDecompInitialStepSize

public double dualDecompInitialStepSize

dualDecompDebug
```
public boolean dualDecompDebug
```

useCWSWordFeatures
```
public boolean useCWSWordFeatures
```

useCWSWordFeaturesAll
```
public boolean useCWSWordFeaturesAll
```

useCWSWordFeaturesBigram

public boolean useCWSWordFeaturesBigram

pctSegmenterLenAdjust
```
public boolean pctSegmenterLenAdjust
```

useTrainLexicon
```
public boolean useTrainLexicon
```

useCWSFeatures
```
public boolean useCWSFeatures
```

appendLC
```
public boolean appendLC
```

perceptronDebug
```
public boolean perceptronDebug
```

pctSegmenterScaleByCRF
```
public boolean pctSegmenterScaleByCRF
```

pctSegmenterScale
```
public double pctSegmenterScale
```

separateASCIIandRange
```
public boolean separateASCIIandRange
```

dropoutRate
```
public double dropoutRate
```

dropoutScale
```
public double dropoutScale
```

multiThreadGrad
```
public int multiThreadGrad
```

maxQNItr
```
public int maxQNItr
```

dropoutApprox
```
public boolean dropoutApprox
```

unsupDropoutFile
```
public String unsupDropoutFile
```

unsupDropoutScale
```
public double unsupDropoutScale
```

startEvaluateIters
```
public int startEvaluateIters
```

multiThreadPerceptron
```
public int multiThreadPerceptron
```

lazyUpdate
```
public boolean lazyUpdate
```

featureCountThresh
```
public int featureCountThresh
```

serializeWeightsTo

public transient String serializeWeightsTo

geDebug
```
public boolean geDebug
```

doFeatureDiscovery
```
public boolean doFeatureDiscovery
```

loadWeightsFrom

public transient String loadWeightsFrom

loadClassIndexFrom

public transient String loadClassIndexFrom

serializeClassIndexTo

public transient String serializeClassIndexTo

learnCHBasedOnEN
```
public boolean learnCHBasedOnEN
```

learnENBasedOnCH
```
public boolean learnENBasedOnCH
```

loadWeightsFromEN
```
public String loadWeightsFromEN
```

loadWeightsFromCH
```
public String loadWeightsFromCH
```

serializeToEN
```
public String serializeToEN
```

serializeToCH
```
public String serializeToCH
```

testFileEN
```
public String testFileEN
```

testFileCH
```
public String testFileCH
```

unsupFileEN
```
public String unsupFileEN
```

unsupFileCH
```
public String unsupFileCH
```

unsupAlignFile
```
public String unsupAlignFile
```

supFileEN
```
public String supFileEN
```

supFileCH
```
public String supFileCH
```

serializeFeatureIndexTo

public transient String serializeFeatureIndexTo

loadFeatureIndexFromEN
```
public String loadFeatureIndexFromEN
```

loadFeatureIndexFromCH
```
public String loadFeatureIndexFromCH
```

lambdaEN
```
public double lambdaEN
```

lambdaCH
```
public double lambdaCH
```

alternateTraining
```
public boolean alternateTraining
```

weightByEntropy
```
public boolean weightByEntropy
```

useKL
```
public boolean useKL
```

useHardGE
```
public boolean useHardGE
```

useCRFforUnsup
```
public boolean useCRFforUnsup
```

useGEforSup
```
public boolean useGEforSup
```

useKnownLCWords
```
public boolean useKnownLCWords
```

featureFactories
```
public String[] featureFactories
```

featureFactoriesArgs

public List<Object[]> featureFactoriesArgs

useNoisyLabel
```
public boolean useNoisyLabel
```

errorMatrix
```
public String errorMatrix
```

printTrainLabels
```
public boolean printTrainLabels
```

labelDictionaryCutoff
```
public int labelDictionaryCutoff
```

useAdaDelta
```
public boolean useAdaDelta
```

useAdaDiff
```
public boolean useAdaDiff
```

adaGradEps
```
public double adaGradEps
```

adaDeltaRho
```
public double adaDeltaRho
```

useRandomSeed
```
public boolean useRandomSeed
```

terminateOnAvgImprovement

public boolean terminateOnAvgImprovement

strictGoodCoNLL
```
public boolean strictGoodCoNLL
```

removeStrictGoodCoNLLDuplicates

public boolean removeStrictGoodCoNLLDuplicates

priorModelFactory
```
public 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.

phraseGazettes

public transient List<String> phraseGazettes

props
```
public transient Properties props
```

Constructor Detail
- SeqClassifierFlags
```
public SeqClassifierFlags()
```
- SeqClassifierFlags
```
public SeqClassifierFlags(Properties props)
```
  Create a new SeqClassifierFlags object and initialize it using values in the Properties object. The properties are printed to stderr as it works.
  
  Parameters:
  props - The properties object used for initialization

Method Detail
- setProperties
```
public final void setProperties(Properties props)
```
  Initialize this object using values in Properties object. The properties are printed to stderr as it works.
  
  Parameters:
  props - The properties object used for initialization
- setProperties
```
public void setProperties(Properties props,
                 boolean printProps)
```
  Initialize using values in Properties file.
  
  Parameters:
  props - The properties object used for initialization
  printProps - Whether to print the properties to stderr as it works.
- toString
```
public String toString()
```
  Print the properties specified by this object.
  
  Overrides:
  
  toString in class Object
  
  Returns:
  A String describing the properties specified by this object.
- getNotNullTrueStringRep
```
public String getNotNullTrueStringRep()
```
  note that this does *not* return string representation of arrays, lists and enums
  
  Throws:
  
  IllegalAccessException
  
  IllegalArgumentException

Class SeqClassifierFlags

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_BACKGROUND_SYMBOL

useNGrams

conjoinShapeNGrams

lowercaseNGrams

dehyphenateNGrams

usePrev

useNext

useTags

useWordPairs

useGazettes

useSequences

usePrevSequences

useNextSequences

useLongSequences

useBoundarySequences

useTaggySequences

useExtraTaggySequences

dontExtendTaggy

useTaggySequencesShapeInteraction

strictlyZeroethOrder

strictlyFirstOrder

strictlySecondOrder

strictlyThirdOrder

entitySubclassification

retainEntitySubclassification

useGazettePhrases

makeConsistent

useViterbi

binnedLengths

verboseMode

useSum

tolerance

printFeatures

useSymTags

useSymWordPairs

printClassifier

printClassifierParam

intern

intern2

selfTest

sloppyGazette

cleanGazette

noMidNGrams

maxNGramLeng

useReverse

greekifyNGrams

useParenMatching

useLemmas

usePrevNextLemmas

normalizeTerms

normalizeTimex

useNB

useQN

useFloat

QNsize

QNsize2

maxIterations

wordShape

useShapeStrings

useTypeSeqs

useTypeSeqs2

useTypeSeqs3

useDisjunctive

disjunctionWidth

useDisjunctiveShapeInteraction

useDisjShape

useWord

useClassFeature

useShapeConjunctions

useWordTag

useNPHead

useNPGovernor

useHeadGov

useLastRealWord