class RegexMatcher extends AnnotatorApproach[RegexMatcherModel]
Uses rules to match a set of regular expressions and associate them with a provided identifier.
A rule consists of a regex pattern and an identifier, delimited by a character of choice. An
example could be \d{4}\/\d\d\/\d\d,date which will match strings like "1970/01/01" to the
identifier "date".
Rules must be provided by either setRules (followed by setDelimiter) or an external file.
To use an external file, a dictionary of predefined regular expressions must be provided with
setExternalRules. The dictionary can be set in either in the form of a delimited text file
or directly as an ExternalResource.
Pretrained pipelines are available for this module, see Pipelines.
For extended examples of usage, see the Examples and the RegexMatcherTestSpec.
Example
In this example, the rules.txt has the form of
the\s\w+, followed by 'the'
ceremonies, ceremonywhere each regex is separated by the identifier by ","
import ResourceHelper.spark.implicits._ import com.johnsnowlabs.nlp.base.DocumentAssembler import com.johnsnowlabs.nlp.annotator.SentenceDetector import com.johnsnowlabs.nlp.annotators.RegexMatcher import org.apache.spark.ml.Pipeline val documentAssembler = new DocumentAssembler().setInputCol("text").setOutputCol("document") val sentence = new SentenceDetector().setInputCols("document").setOutputCol("sentence") val regexMatcher = new RegexMatcher() .setExternalRules("src/test/resources/regex-matcher/rules.txt", ",") .setInputCols(Array("sentence")) .setOutputCol("regex") .setStrategy("MATCH_ALL") val pipeline = new Pipeline().setStages(Array(documentAssembler, sentence, regexMatcher)) val data = Seq( "My first sentence with the first rule. This is my second sentence with ceremonies rule." ).toDF("text") val results = pipeline.fit(data).transform(data) results.selectExpr("explode(regex) as result").show(false) +--------------------------------------------------------------------------------------------+ |result | +--------------------------------------------------------------------------------------------+ |[chunk, 23, 31, the first, [identifier -> followed by 'the', sentence -> 0, chunk -> 0], []]| |[chunk, 71, 80, ceremonies, [identifier -> ceremony, sentence -> 1, chunk -> 0], []] | +--------------------------------------------------------------------------------------------+
- Grouped
- Alphabetic
- By Inheritance
- RegexMatcher
- AnnotatorApproach
- CanBeLazy
- DefaultParamsWritable
- MLWritable
- HasOutputAnnotatorType
- HasOutputAnnotationCol
- HasInputAnnotationCols
- Estimator
- PipelineStage
- Logging
- Params
- Serializable
- Identifiable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
Type Members
- type AnnotatorType = String
- Definition Classes
- HasOutputAnnotatorType
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
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def _fit(dataset: Dataset[_], recursiveStages: Option[PipelineModel]): RegexMatcherModel
- Attributes
- protected
- Definition Classes
- AnnotatorApproach
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def beforeTraining(spark: SparkSession): Unit
- Definition Classes
- AnnotatorApproach
- final def checkSchema(schema: StructType, inputAnnotatorType: String): Boolean
- Attributes
- protected
- Definition Classes
- HasInputAnnotationCols
- final def clear(param: Param[_]): RegexMatcher.this.type
- Definition Classes
- Params
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @HotSpotIntrinsicCandidate() @native()
- final def copy(extra: ParamMap): Estimator[RegexMatcherModel]
- Definition Classes
- AnnotatorApproach → Estimator → PipelineStage → Params
- def copyValues[T <: Params](to: T, extra: ParamMap): T
- Attributes
- protected
- Definition Classes
- Params
- final def defaultCopy[T <: Params](extra: ParamMap): T
- Attributes
- protected
- Definition Classes
- Params
- val delimiter: Param[String]
Delimiter for rules provided with setRules
- val description: String
Matches described regex rules that come in tuples in a text file
Matches described regex rules that come in tuples in a text file
- Definition Classes
- RegexMatcher → AnnotatorApproach
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def explainParam(param: Param[_]): String
- Definition Classes
- Params
- def explainParams(): String
- Definition Classes
- Params
- val externalRules: ExternalResourceParam
External resource to rules, needs 'delimiter' in options
- final def extractParamMap(): ParamMap
- Definition Classes
- Params
- final def extractParamMap(extra: ParamMap): ParamMap
- Definition Classes
- Params
- final def fit(dataset: Dataset[_]): RegexMatcherModel
- Definition Classes
- AnnotatorApproach → Estimator
- def fit(dataset: Dataset[_], paramMaps: Seq[ParamMap]): Seq[RegexMatcherModel]
- Definition Classes
- Estimator
- Annotations
- @Since("2.0.0")
- def fit(dataset: Dataset[_], paramMap: ParamMap): RegexMatcherModel
- Definition Classes
- Estimator
- Annotations
- @Since("2.0.0")
- def fit(dataset: Dataset[_], firstParamPair: ParamPair[_], otherParamPairs: ParamPair[_]*): RegexMatcherModel
- Definition Classes
- Estimator
- Annotations
- @varargs() @Since("2.0.0")
- final def get[T](param: Param[T]): Option[T]
- Definition Classes
- Params
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- final def getDefault[T](param: Param[T]): Option[T]
- Definition Classes
- Params
- def getInputCols: Array[String]
- returns
input annotations columns currently used
- Definition Classes
- HasInputAnnotationCols
- def getLazyAnnotator: Boolean
- Definition Classes
- CanBeLazy
- 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 getStrategy: String
Strategy for which to match the expressions (Default:
"MATCH_ALL") - final def hasDefault[T](param: Param[T]): Boolean
- Definition Classes
- Params
- def hasParam(paramName: String): Boolean
- Definition Classes
- Params
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @HotSpotIntrinsicCandidate() @native()
- 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[AnnotatorType]
Input annotator type: DOCUMENT
Input annotator type: DOCUMENT
- Definition Classes
- RegexMatcher → 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 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
- 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 onTrained(model: RegexMatcherModel, spark: SparkSession): Unit
- Definition Classes
- AnnotatorApproach
- val optionalInputAnnotatorTypes: Array[String]
- Definition Classes
- HasInputAnnotationCols
- val outputAnnotatorType: AnnotatorType
Input annotator type: CHUNK
Input annotator type: CHUNK
- Definition Classes
- RegexMatcher → HasOutputAnnotatorType
- final val outputCol: Param[String]
- Attributes
- protected
- Definition Classes
- HasOutputAnnotationCol
- lazy val params: Array[Param[_]]
- Definition Classes
- Params
- val rules: StringArrayParam
Rules with regex pattern and identifiers for matching
- 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")
- final def set(paramPair: ParamPair[_]): RegexMatcher.this.type
- Attributes
- protected
- Definition Classes
- Params
- final def set(param: String, value: Any): RegexMatcher.this.type
- Attributes
- protected
- Definition Classes
- Params
- final def set[T](param: Param[T], value: T): RegexMatcher.this.type
- Definition Classes
- Params
- final def setDefault(paramPairs: ParamPair[_]*): RegexMatcher.this.type
- Attributes
- protected
- Definition Classes
- Params
- final def setDefault[T](param: Param[T], value: T): RegexMatcher.this.type
- Attributes
- protected[org.apache.spark.ml]
- Definition Classes
- Params
- def setDelimiter(value: String): RegexMatcher.this.type
Sets the regex rules to match the identifier with.
Sets the regex rules to match the identifier with.
Note that only either externalRules or rules can be set at once.
- value
Array of rules and identifiers as tuples
- def setExternalRules(path: String, delimiter: String, readAs: Format = ReadAs.TEXT, options: Map[String, String] = Map("format" -> "text")): RegexMatcher.this.type
External dictionary to be used by the lemmatizer, which needs
delimiterset for parsing the resource.External dictionary to be used by the lemmatizer, which needs
delimiterset for parsing the resource.Note that only either externalRules or rules can be set at once.
- def setExternalRules(value: ExternalResource): RegexMatcher.this.type
External dictionary already in the form of ExternalResource, for which the Map member
optionshas"delimiter"defined.External dictionary already in the form of ExternalResource, for which the Map member
optionshas"delimiter"defined.Note that only either externalRules or rules can be set at once.
Example
val regexMatcher = new RegexMatcher() .setExternalRules(ExternalResource( "src/test/resources/regex-matcher/rules.txt", ReadAs.TEXT, Map("delimiter" -> ",") )) .setInputCols("sentence") .setOutputCol("regex") .setStrategy(strategy)
- final def setInputCols(value: String*): RegexMatcher.this.type
- Definition Classes
- HasInputAnnotationCols
- def setInputCols(value: Array[String]): RegexMatcher.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): RegexMatcher.this.type
- Definition Classes
- CanBeLazy
- final def setOutputCol(value: String): RegexMatcher.this.type
Overrides annotation column name when transforming
Overrides annotation column name when transforming
- Definition Classes
- HasOutputAnnotationCol
- def setRules(value: Array[String]): RegexMatcher.this.type
Sets the regex rules to match the identifier with.
Sets the regex rules to match the identifier with.
The rules must consist of a regex pattern and an identifier for that pattern. The regex pattern and the identifier must be delimited by a character that will also have to set with
setDelimiter.Only one of either parameter
rulesorexternalRulesmust be set.Example
val regexMatcher = new RegexMatcher() .setRules(Array("\d{4}\/\d\d\/\d\d,date", "\d{2}\/\d\d\/\d\d,date_short") .setDelimiter(",") .setInputCols("sentence") .setOutputCol("regex") .setStrategy("MATCH_ALL")
- value
Array of rules
- def setStrategy(value: String): RegexMatcher.this.type
Strategy for which to match the expressions (Default:
"MATCH_ALL") - val strategy: Param[String]
Strategy for which to match the expressions (Default:
"MATCH_ALL").Strategy for which to match the expressions (Default:
"MATCH_ALL"). Possible values are:- MATCH_ALL brings one-to-many results
- MATCH_FIRST catches only first match
- MATCH_COMPLETE returns only if match is entire target.
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- Identifiable → AnyRef → Any
- def train(dataset: Dataset[_], recursivePipeline: Option[PipelineModel]): RegexMatcherModel
- Definition Classes
- RegexMatcher → AnnotatorApproach
- final def transformSchema(schema: StructType): StructType
requirement for pipeline transformation validation.
requirement for pipeline transformation validation. It is called on fit()
- Definition Classes
- AnnotatorApproach → PipelineStage
- def transformSchema(schema: StructType, logging: Boolean): StructType
- Attributes
- protected
- Definition Classes
- PipelineStage
- Annotations
- @DeveloperApi()
- val uid: String
- Definition Classes
- RegexMatcher → Identifiable
- 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
- AnnotatorApproach
- 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])
- def write: MLWriter
- Definition Classes
- DefaultParamsWritable → MLWritable
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 AnnotatorApproach[RegexMatcherModel]
Inherited from CanBeLazy
Inherited from DefaultParamsWritable
Inherited from MLWritable
Inherited from HasOutputAnnotatorType
Inherited from HasOutputAnnotationCol
Inherited from HasInputAnnotationCols
Inherited from Estimator[RegexMatcherModel]
Inherited from PipelineStage
Inherited from Logging
Inherited from Params
Inherited from Serializable
Inherited from Identifiable
Inherited from AnyRef
Inherited from Any
Annotator types
Required input and expected output annotator types
Parameters
A list of (hyper-)parameter keys this annotator can take. Users can set and get the parameter values through setters and getters, respectively.