com.johnsnowlabs.nlp.annotators.spell.context
ContextSpellCheckerModel
Companion object ContextSpellCheckerModel
class ContextSpellCheckerModel extends AnnotatorModel[ContextSpellCheckerModel] with HasSimpleAnnotate[ContextSpellCheckerModel] with WeightedLevenshtein with WriteTensorflowModel with ParamsAndFeaturesWritable with HasTransducerFeatures with HasEngine
Implements a deep-learning based Noisy Channel Model Spell Algorithm. Correction candidates are extracted combining context information and word information.
Spell Checking is a sequence to sequence mapping problem. Given an input sequence, potentially
containing a certain number of errors, ContextSpellChecker will rank correction sequences
according to three things:
- Different correction candidates for each word — word level.
- The surrounding text of each word, i.e. it’s context — sentence level.
- The relative cost of different correction candidates according to the edit operations at the character level it requires — subword level.
For an in-depth explanation of the module see the article Applying Context Aware Spell Checking in Spark NLP.
This is the instantiated model of the ContextSpellCheckerApproach. For training your own model, please see the documentation of that class.
Pretrained models can be loaded with pretrained of the companion object:
val spellChecker = ContextSpellCheckerModel.pretrained() .setInputCols("token") .setOutputCol("checked")
The default model is "spellcheck_dl", if no name is provided. For available pretrained
models please see the Models Hub.
For extended examples of usage, see the Examples and the ContextSpellCheckerTestSpec.
Example
import spark.implicits._ import com.johnsnowlabs.nlp.DocumentAssembler import com.johnsnowlabs.nlp.annotators.Tokenizer import com.johnsnowlabs.nlp.annotators.spell.context.ContextSpellCheckerModel import org.apache.spark.ml.Pipeline val documentAssembler = new DocumentAssembler() .setInputCol("text") .setOutputCol("doc") val tokenizer = new Tokenizer() .setInputCols(Array("doc")) .setOutputCol("token") val spellChecker = ContextSpellCheckerModel .pretrained() .setTradeOff(12.0f) .setInputCols("token") .setOutputCol("checked") val pipeline = new Pipeline().setStages(Array( documentAssembler, tokenizer, spellChecker )) val data = Seq("It was a cold , dreary day and the country was white with smow .").toDF("text") val result = pipeline.fit(data).transform(data) result.select("checked.result").show(false) +--------------------------------------------------------------------------------+ |result | +--------------------------------------------------------------------------------+ |[It, was, a, cold, ,, dreary, day, and, the, country, was, white, with, snow, .]| +--------------------------------------------------------------------------------+
- See also
NorvigSweetingModel and SymmetricDeleteModel for alternative approaches to spell checking
- Grouped
- Alphabetic
- By Inheritance
- ContextSpellCheckerModel
- HasEngine
- HasTransducerFeatures
- WriteTensorflowModel
- WeightedLevenshtein
- HasSimpleAnnotate
- AnnotatorModel
- CanBeLazy
- RawAnnotator
- HasOutputAnnotationCol
- HasInputAnnotationCols
- HasOutputAnnotatorType
- ParamsAndFeaturesWritable
- HasFeatures
- DefaultParamsWritable
- MLWritable
- Model
- Transformer
- PipelineStage
- Logging
- Params
- Serializable
- Identifiable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
Type Members
- type AnnotationContent = Seq[Row]
internal types to show Rows as a relevant StructType Should be deleted once Spark releases UserDefinedTypes to @developerAPI
internal types to show Rows as a relevant StructType Should be deleted once Spark releases UserDefinedTypes to @developerAPI
- Attributes
- protected
- Definition Classes
- AnnotatorModel
- type AnnotatorType = String
- Definition Classes
- HasOutputAnnotatorType
- implicit class StringTools extends AnyRef
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def $[T](param: Param[T]): T
- Attributes
- protected
- Definition Classes
- Params
- def $$(feature: TransducerSeqFeature): Seq[SpecialClassParser]
- Attributes
- protected
- Definition Classes
- HasTransducerFeatures
- def $$(feature: TransducerFeature): VocabParser
- Attributes
- protected
- Definition Classes
- HasTransducerFeatures
- def $$[T](feature: StructFeature[T]): T
- Attributes
- protected
- Definition Classes
- HasFeatures
- def $$[K, V](feature: MapFeature[K, V]): Map[K, V]
- Attributes
- protected
- Definition Classes
- HasFeatures
- def $$[T](feature: SetFeature[T]): Set[T]
- Attributes
- protected
- Definition Classes
- HasFeatures
- def $$[T](feature: ArrayFeature[T]): Array[T]
- Attributes
- protected
- Definition Classes
- HasFeatures
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def _transform(dataset: Dataset[_], recursivePipeline: Option[PipelineModel]): DataFrame
- Attributes
- protected
- Definition Classes
- AnnotatorModel
- def afterAnnotate(dataset: DataFrame): DataFrame
- Attributes
- protected
- Definition Classes
- AnnotatorModel
- def annotate(annotations: Seq[Annotation]): Seq[Annotation]
takes a document and annotations and produces new annotations of this annotator's annotation type
takes a document and annotations and produces new annotations of this annotator's annotation type
- annotations
Annotations that correspond to inputAnnotationCols generated by previous annotators if any
- returns
any number of annotations processed for every input annotation. Not necessary one to one relationship
- Definition Classes
- ContextSpellCheckerModel → HasSimpleAnnotate
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def backTrack(dist: Array[Array[Float]], s2: String, s1: String, j: Int, i: Int, acc: Seq[(String, String)]): Seq[(String, String)]
- Definition Classes
- WeightedLevenshtein
- def beforeAnnotate(dataset: Dataset[_]): Dataset[_]
- Definition Classes
- ContextSpellCheckerModel → AnnotatorModel
- val caseStrategy: IntParam
What case combinations to try when generating candidates (Default:
CandidateStrategy.ALL). - final def checkSchema(schema: StructType, inputAnnotatorType: String): Boolean
- Attributes
- protected
- Definition Classes
- HasInputAnnotationCols
- val classes: MapFeature[Int, (Int, Int)]
Classes the spell checker recognizes
- final def clear(param: Param[_]): ContextSpellCheckerModel.this.type
- Definition Classes
- Params
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @HotSpotIntrinsicCandidate() @native()
- val compareLowcase: BooleanParam
If true will compare tokens in low case with vocabulary (Default:
false) - def computeMask(annotations: Seq[Annotation]): Array[Boolean]
- def computeTrellis(annotations: Seq[Annotation], mask: Seq[Boolean]): Array[Array[(String, Double, String)]]
- val configProtoBytes: IntArrayParam
ConfigProto from tensorflow, serialized into byte array.
ConfigProto from tensorflow, serialized into byte array. Get with config_proto.SerializeToString()
- def copy(extra: ParamMap): ContextSpellCheckerModel
requirement for annotators copies
requirement for annotators copies
- Definition Classes
- RawAnnotator → Model → Transformer → PipelineStage → Params
- def copyValues[T <: Params](to: T, extra: ParamMap): T
- Attributes
- protected
- Definition Classes
- Params
- val correctSymbols: BooleanParam
Whether to correct special symbols or skip spell checking for them
- def decodeViterbi(trellis: Array[Array[(String, Double, String)]]): (Array[String], Double)
- final def defaultCopy[T <: Params](extra: ParamMap): T
- Attributes
- protected
- Definition Classes
- Params
- def dfAnnotate: UserDefinedFunction
Wraps annotate to happen inside SparkSQL user defined functions in order to act with org.apache.spark.sql.Column
Wraps annotate to happen inside SparkSQL user defined functions in order to act with org.apache.spark.sql.Column
- returns
udf function to be applied to inputCols using this annotator's annotate function as part of ML transformation
- Definition Classes
- HasSimpleAnnotate
- val engine: Param[String]
This param is set internally once via loadSavedModel.
This param is set internally once via loadSavedModel. That's why there is no setter
- Definition Classes
- HasEngine
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- val errorThreshold: FloatParam
Threshold perplexity for a word to be considered as an error.
- def explainParam(param: Param[_]): String
- Definition Classes
- Params
- def explainParams(): String
- Definition Classes
- Params
- def extraValidate(structType: StructType): Boolean
- Attributes
- protected
- Definition Classes
- RawAnnotator
- def extraValidateMsg: String
Override for additional custom schema checks
Override for additional custom schema checks
- Attributes
- protected
- Definition Classes
- RawAnnotator
- final def extractParamMap(): ParamMap
- Definition Classes
- Params
- final def extractParamMap(extra: ParamMap): ParamMap
- Definition Classes
- Params
- val features: ArrayBuffer[Feature[_, _, _]]
- Definition Classes
- HasFeatures
- val gamma: FloatParam
Controls the influence of individual word frequency in the decision (Default:
120.0f). - def get(feature: TransducerSeqFeature): Option[Seq[SpecialClassParser]]
- Attributes
- protected
- Definition Classes
- HasTransducerFeatures
- def get(feature: TransducerFeature): Option[VocabParser]
- Attributes
- protected
- Definition Classes
- HasTransducerFeatures
- def get[T](feature: StructFeature[T]): Option[T]
- Attributes
- protected
- Definition Classes
- HasFeatures
- def get[K, V](feature: MapFeature[K, V]): Option[Map[K, V]]
- Attributes
- protected
- Definition Classes
- HasFeatures
- def get[T](feature: SetFeature[T]): Option[Set[T]]
- Attributes
- protected
- Definition Classes
- HasFeatures
- def get[T](feature: ArrayFeature[T]): Option[Array[T]]
- Attributes
- protected
- Definition Classes
- HasFeatures
- final def get[T](param: Param[T]): Option[T]
- Definition Classes
- Params
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- def getClassCandidates(transducer: ITransducer[Candidate], token: String, label: String, maxDist: Int, limit: Int = 2): Seq[(String, String, Float)]
- def getConfigProtoBytes: Option[Array[Byte]]
- final def getDefault[T](param: Param[T]): Option[T]
- Definition Classes
- Params
- def getEngine: String
- Definition Classes
- HasEngine
- def getInputCols: Array[String]
- returns
input annotations columns currently used
- Definition Classes
- HasInputAnnotationCols
- def getLazyAnnotator: Boolean
- Definition Classes
- CanBeLazy
- def getModelIfNotSet: TensorflowSpell
- final def getOrDefault[T](param: Param[T]): T
- Definition Classes
- Params
- final def getOutputCol: String
Gets annotation column name going to generate
Gets annotation column name going to generate
- Definition Classes
- HasOutputAnnotationCol
- def getParam(paramName: String): Param[Any]
- Definition Classes
- Params
- def getVocabCandidates(token: String, maxDist: Int): List[(String, String, Float)]
- def getWordClasses: Seq[(String, AnnotatorType)]
- final def hasDefault[T](param: Param[T]): Boolean
- Definition Classes
- Params
- def hasParam(paramName: String): Boolean
- Definition Classes
- Params
- def hasParent: Boolean
- Definition Classes
- Model
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- val idsVocab: MapFeature[Int, String]
Mapping of ids to vocabulary
- def initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean
- Attributes
- protected
- Definition Classes
- Logging
- def initializeLogIfNecessary(isInterpreter: Boolean): Unit
- Attributes
- protected
- Definition Classes
- Logging
- val inputAnnotatorTypes: Array[String]
Input Annotator Types: TOKEN
Input Annotator Types: TOKEN
- Definition Classes
- ContextSpellCheckerModel → HasInputAnnotationCols
- final val inputCols: StringArrayParam
columns that contain annotations necessary to run this annotator AnnotatorType is used both as input and output columns if not specified
columns that contain annotations necessary to run this annotator AnnotatorType is used both as input and output columns if not specified
- Attributes
- protected
- Definition Classes
- HasInputAnnotationCols
- final def isDefined(param: Param[_]): Boolean
- Definition Classes
- Params
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- final def isSet(param: Param[_]): Boolean
- Definition Classes
- Params
- def isTraceEnabled(): Boolean
- Attributes
- protected
- Definition Classes
- Logging
- val lazyAnnotator: BooleanParam
- Definition Classes
- CanBeLazy
- def learnDist(s1: String, s2: String): Seq[(String, String)]
- Definition Classes
- WeightedLevenshtein
- def levenshteinDist(s11: String, s22: String)(cost: (String, String) => Float): Float
- Definition Classes
- WeightedLevenshtein
- def loadWeights(filename: String): Map[String, Map[String, Float]]
- Definition Classes
- WeightedLevenshtein
- def log: Logger
- Attributes
- protected
- Definition Classes
- Logging
- def logDebug(msg: => String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logDebug(msg: => String): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logError(msg: => String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logError(msg: => String): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logInfo(msg: => String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logInfo(msg: => String): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logName: String
- Attributes
- protected
- Definition Classes
- Logging
- def logTrace(msg: => String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logTrace(msg: => String): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logWarning(msg: => String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
- def logWarning(msg: => String): Unit
- Attributes
- protected
- Definition Classes
- Logging
- val maxCandidates: IntParam
Maximum number of candidates for every word (Default:
6). - val maxWindowLen: IntParam
Maximum size for the window used to remember history prior to every correction (Default:
5). - def msgHelper(schema: StructType): String
- Attributes
- protected
- Definition Classes
- HasInputAnnotationCols
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- def onWrite(path: String, spark: SparkSession): Unit
- Definition Classes
- ContextSpellCheckerModel → ParamsAndFeaturesWritable
- val optionalInputAnnotatorTypes: Array[String]
- Definition Classes
- HasInputAnnotationCols
- val outputAnnotatorType: AnnotatorType
Output Annotator Types: TOKEN
Output Annotator Types: TOKEN
- Definition Classes
- ContextSpellCheckerModel → HasOutputAnnotatorType
- final val outputCol: Param[String]
- Attributes
- protected
- Definition Classes
- HasOutputAnnotationCol
- lazy val params: Array[Param[_]]
- Definition Classes
- Params
- var parent: Estimator[ContextSpellCheckerModel]
- Definition Classes
- Model
- def save(path: String): Unit
- Definition Classes
- MLWritable
- Annotations
- @throws("If the input path already exists but overwrite is not enabled.") @Since("1.6.0")
- def set(feature: TransducerSeqFeature, value: Seq[SpecialClassParser]): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- HasTransducerFeatures
- def set(feature: TransducerFeature, value: VocabParser): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- HasTransducerFeatures
- def set[T](feature: StructFeature[T], value: T): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
- def set[K, V](feature: MapFeature[K, V], value: Map[K, V]): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
- def set[T](feature: SetFeature[T], value: Set[T]): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
- def set[T](feature: ArrayFeature[T], value: Array[T]): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
- final def set(paramPair: ParamPair[_]): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- Params
- final def set(param: String, value: Any): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- Params
- final def set[T](param: Param[T], value: T): ContextSpellCheckerModel.this.type
- Definition Classes
- Params
- def setCaseStrategy(k: Int): ContextSpellCheckerModel.this.type
- def setClasses(c: Map[Int, (Int, Int)]): ContextSpellCheckerModel.this.type
- def setCompareLowcase(value: Boolean): ContextSpellCheckerModel.this.type
- def setConfigProtoBytes(bytes: Array[Int]): ContextSpellCheckerModel.this.type
- def setCorrectSymbols(value: Boolean): ContextSpellCheckerModel.this.type
- def setDefault(feature: TransducerSeqFeature, value: () => Seq[SpecialClassParser]): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- HasTransducerFeatures
- def setDefault(feature: TransducerFeature, value: () => VocabParser): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- HasTransducerFeatures
- def setDefault[T](feature: StructFeature[T], value: () => T): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
- def setDefault[K, V](feature: MapFeature[K, V], value: () => Map[K, V]): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
- def setDefault[T](feature: SetFeature[T], value: () => Set[T]): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
- def setDefault[T](feature: ArrayFeature[T], value: () => Array[T]): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- HasFeatures
- final def setDefault(paramPairs: ParamPair[_]*): ContextSpellCheckerModel.this.type
- Attributes
- protected
- Definition Classes
- Params
- final def setDefault[T](param: Param[T], value: T): ContextSpellCheckerModel.this.type
- Attributes
- protected[org.apache.spark.ml]
- Definition Classes
- Params
- def setErrorThreshold(t: Float): ContextSpellCheckerModel.this.type
- def setGamma(g: Float): ContextSpellCheckerModel.this.type
- final def setInputCols(value: String*): ContextSpellCheckerModel.this.type
- Definition Classes
- HasInputAnnotationCols
- def setInputCols(value: Array[String]): ContextSpellCheckerModel.this.type
Overrides required annotators column if different than default
Overrides required annotators column if different than default
- Definition Classes
- HasInputAnnotationCols
- def setLazyAnnotator(value: Boolean): ContextSpellCheckerModel.this.type
- Definition Classes
- CanBeLazy
- def setMaxCandidates(k: Int): ContextSpellCheckerModel.this.type
- def setMaxWindowLen(w: Int): ContextSpellCheckerModel.this.type
- def setModelIfNotSet(spark: SparkSession, tensorflow: TensorflowWrapper): ContextSpellCheckerModel.this.type
- final def setOutputCol(value: String): ContextSpellCheckerModel.this.type
Overrides annotation column name when transforming
Overrides annotation column name when transforming
- Definition Classes
- HasOutputAnnotationCol
- def setParent(parent: Estimator[ContextSpellCheckerModel]): ContextSpellCheckerModel
- Definition Classes
- Model
- def setSpecialClassesTransducers(transducers: Seq[SpecialClassParser]): ContextSpellCheckerModel.this.type
- def setTradeOff(lambda: Float): ContextSpellCheckerModel.this.type
- def setUseNewLines(useIt: Boolean): ContextSpellCheckerModel.this.type
- def setVocabFreq(v: Map[String, Double]): ContextSpellCheckerModel.this.type
- def setVocabIds(v: Map[String, Int]): ContextSpellCheckerModel.this.type
- def setVocabTransducer(trans: ITransducer[Candidate]): ContextSpellCheckerModel.this.type
- def setWeights(w: HashMap[String, HashMap[String, Double]]): ContextSpellCheckerModel.this.type
- def setWeights(w: Map[String, Map[String, Float]]): ContextSpellCheckerModel.this.type
- def setWordMaxDistance(k: Int): ContextSpellCheckerModel.this.type
- val specialTransducers: TransducerSeqFeature
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toOption(boolean: Boolean): Option[Boolean]
- def toString(): String
- Definition Classes
- Identifiable → AnyRef → Any
- val tradeoff: FloatParam
Tradeoff between the cost of a word and a transition in the language model (Default:
18.0f). - val transducer: TransducerFeature
- final def transform(dataset: Dataset[_]): DataFrame
Given requirements are met, this applies ML transformation within a Pipeline or stand-alone Output annotation will be generated as a new column, previous annotations are still available separately metadata is built at schema level to record annotations structural information outside its content
Given requirements are met, this applies ML transformation within a Pipeline or stand-alone Output annotation will be generated as a new column, previous annotations are still available separately metadata is built at schema level to record annotations structural information outside its content
- dataset
Dataset[Row]
- Definition Classes
- AnnotatorModel → Transformer
- def transform(dataset: Dataset[_], paramMap: ParamMap): DataFrame
- Definition Classes
- Transformer
- Annotations
- @Since("2.0.0")
- def transform(dataset: Dataset[_], firstParamPair: ParamPair[_], otherParamPairs: ParamPair[_]*): DataFrame
- Definition Classes
- Transformer
- Annotations
- @varargs() @Since("2.0.0")
- final def transformSchema(schema: StructType): StructType
requirement for pipeline transformation validation.
requirement for pipeline transformation validation. It is called on fit()
- Definition Classes
- RawAnnotator → PipelineStage
- def transformSchema(schema: StructType, logging: Boolean): StructType
- Attributes
- protected
- Definition Classes
- PipelineStage
- Annotations
- @DeveloperApi()
- val uid: String
- Definition Classes
- ContextSpellCheckerModel → Identifiable
- def updateRegexClass(label: String, regex: String): ContextSpellCheckerModel
- def updateVocabClass(label: String, vocabList: ArrayList[String], append: Boolean = true): ContextSpellCheckerModel
- val useNewLines: BooleanParam
When set to true new lines will be treated as any other character (Default:
false).When set to true new lines will be treated as any other character (Default:
false). When set to false correction is applied on paragraphs as defined by newline characters. - def validate(schema: StructType): Boolean
takes a Dataset and checks to see if all the required annotation types are present.
takes a Dataset and checks to see if all the required annotation types are present.
- schema
to be validated
- returns
True if all the required types are present, else false
- Attributes
- protected
- Definition Classes
- RawAnnotator
- val vocabFreq: MapFeature[String, Double]
Frequency words from the vocabulary
- val vocabIds: MapFeature[String, Int]
Mapping of vocabulary to ids
- def wLevenshteinDist(s1: String, s2: String, weights: Map[String, Map[String, Float]]): Float
- Definition Classes
- WeightedLevenshtein
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- val weights: MapFeature[String, Map[String, Float]]
- val wordMaxDistance: IntParam
Maximum distance for the generated candidates for every word, minimum 1.
- def wrapColumnMetadata(col: Column): Column
- Attributes
- protected
- Definition Classes
- RawAnnotator
- def write: MLWriter
- Definition Classes
- ParamsAndFeaturesWritable → DefaultParamsWritable → MLWritable
- def writeTensorflowHub(path: String, tfPath: String, spark: SparkSession, suffix: String = "_use"): Unit
- Definition Classes
- WriteTensorflowModel
- def writeTensorflowModel(path: String, spark: SparkSession, tensorflow: TensorflowWrapper, suffix: String, filename: String, configProtoBytes: Option[Array[Byte]] = None): Unit
- Definition Classes
- WriteTensorflowModel
- def writeTensorflowModelV2(path: String, spark: SparkSession, tensorflow: TensorflowWrapper, suffix: String, filename: String, configProtoBytes: Option[Array[Byte]] = None, savedSignatures: Option[Map[String, String]] = None): Unit
- Definition Classes
- WriteTensorflowModel
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated
(Since version 9)
Inherited from HasEngine
Inherited from HasTransducerFeatures
Inherited from WriteTensorflowModel
Inherited from WeightedLevenshtein
Inherited from HasSimpleAnnotate[ContextSpellCheckerModel]
Inherited from AnnotatorModel[ContextSpellCheckerModel]
Inherited from CanBeLazy
Inherited from RawAnnotator[ContextSpellCheckerModel]
Inherited from HasOutputAnnotationCol
Inherited from HasInputAnnotationCols
Inherited from HasOutputAnnotatorType
Inherited from ParamsAndFeaturesWritable
Inherited from HasFeatures
Inherited from DefaultParamsWritable
Inherited from MLWritable
Inherited from Model[ContextSpellCheckerModel]
Inherited from Transformer
Inherited from PipelineStage
Inherited from Logging
Inherited from Params
Inherited from Serializable
Inherited from Identifiable
Inherited from AnyRef
Inherited from Any
Parameters
A list of (hyper-)parameter keys this annotator can take. Users can set and get the parameter values through setters and getters, respectively.
Annotator types
Required input and expected output annotator types