spark-nlp 2.6.3rc1__py2.py3-none-any.whl → 6.2.1__py2.py3-none-any.whl

sparknlp/annotator/matcher/text_matcher.py

@@ -0,0 +1,290 @@
+#  Copyright 2017-2022 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains classes for the TextMatcher."""
+
+
+from sparknlp.common import *
+
+
+class TextMatcher(AnnotatorApproach):
+    """Annotator to match exact phrases (by token) provided in a file against a
+    Document.
+
+    A text file of predefined phrases must be provided with
+    :meth:`.setEntities`.
+
+    For extended examples of usage, see the `Examples
+    <https://github.com/JohnSnowLabs/spark-nlp/blob/master/examples/python/annotation/text/english/text-matcher-pipeline/extractor.ipynb>`__.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``DOCUMENT, TOKEN``    ``CHUNK``
+    ====================== ======================
+
+    Parameters
+    ----------
+    entities
+        ExternalResource for entities
+    caseSensitive
+        Whether to match regardless of case, by default True
+    mergeOverlapping
+        Whether to merge overlapping matched chunks, by default False
+    entityValue
+        Value for the entity metadata field
+    buildFromTokens
+        Whether the TextMatcher should take the CHUNK from TOKEN or not
+
+    Examples
+    --------
+    In this example, the entities file is of the form::
+
+        ...
+        dolore magna aliqua
+        lorem ipsum dolor. sit
+        laborum
+        ...
+
+    where each line represents an entity phrase to be extracted.
+
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> documentAssembler = DocumentAssembler() \\
+    ...     .setInputCol("text") \\
+    ...     .setOutputCol("document")
+    >>> tokenizer = Tokenizer() \\
+    ...     .setInputCols(["document"]) \\
+    ...     .setOutputCol("token")
+    >>> data = spark.createDataFrame([["Hello dolore magna aliqua. Lorem ipsum dolor. sit in laborum"]]).toDF("text")
+    >>> entityExtractor = TextMatcher() \\
+    ...     .setInputCols(["document", "token"]) \\
+    ...     .setEntities("src/test/resources/entity-extractor/test-phrases.txt", ReadAs.TEXT) \\
+    ...     .setOutputCol("entity") \\
+    ...     .setCaseSensitive(False)
+    >>> pipeline = Pipeline().setStages([documentAssembler, tokenizer, entityExtractor])
+    >>> results = pipeline.fit(data).transform(data)
+    >>> results.selectExpr("explode(entity) as result").show(truncate=False)
+    +------------------------------------------------------------------------------------------+
+    |result                                                                                    |
+    +------------------------------------------------------------------------------------------+
+    |[chunk, 6, 24, dolore magna aliqua, [entity -> entity, sentence -> 0, chunk -> 0], []]    |
+    |[chunk, 27, 48, Lorem ipsum dolor. sit, [entity -> entity, sentence -> 0, chunk -> 1], []]|
+    |[chunk, 53, 59, laborum, [entity -> entity, sentence -> 0, chunk -> 2], []]               |
+    +------------------------------------------------------------------------------------------+
+
+    See Also
+    --------
+    BigTextMatcher : to match large amounts of text
+    """
+
+    inputAnnotatorTypes = [AnnotatorType.DOCUMENT, AnnotatorType.TOKEN]
+
+    outputAnnotatorType = AnnotatorType.CHUNK
+
+    entities = Param(Params._dummy(),
+                     "entities",
+                     "ExternalResource for entities",
+                     typeConverter=TypeConverters.identity)
+
+    caseSensitive = Param(Params._dummy(),
+                          "caseSensitive",
+                          "whether to match regardless of case. Defaults true",
+                          typeConverter=TypeConverters.toBoolean)
+
+    mergeOverlapping = Param(Params._dummy(),
+                             "mergeOverlapping",
+                             "whether to merge overlapping matched chunks. Defaults false",
+                             typeConverter=TypeConverters.toBoolean)
+
+    entityValue = Param(Params._dummy(),
+                        "entityValue",
+                        "value for the entity metadata field",
+                        typeConverter=TypeConverters.toString)
+
+    buildFromTokens = Param(Params._dummy(),
+                            "buildFromTokens",
+                            "whether the TextMatcher should take the CHUNK from TOKEN or not",
+                            typeConverter=TypeConverters.toBoolean)
+
+    @keyword_only
+    def __init__(self):
+        super(TextMatcher, self).__init__(classname="com.johnsnowlabs.nlp.annotators.TextMatcher")
+        self._setDefault(inputCols=[AnnotatorType.DOCUMENT, AnnotatorType.TOKEN])
+        self._setDefault(caseSensitive=True)
+        self._setDefault(mergeOverlapping=False)
+
+    def _create_model(self, java_model):
+        return TextMatcherModel(java_model=java_model)
+
+    def setEntities(self, path, read_as=ReadAs.TEXT, options={"format": "text"}):
+        """Sets the external resource for the entities.
+
+        Parameters
+        ----------
+        path : str
+            Path to the external resource
+        read_as : str, optional
+            How to read the resource, by default ReadAs.TEXT
+        options : dict, optional
+            Options for reading the resource, by default {"format": "text"}
+        """
+        return self._set(entities=ExternalResource(path, read_as, options.copy()))
+
+    def setCaseSensitive(self, b):
+        """Sets whether to match regardless of case, by default True.
+
+        Parameters
+        ----------
+        b : bool
+            Whether to match regardless of case
+        """
+        return self._set(caseSensitive=b)
+
+    def setMergeOverlapping(self, b):
+        """Sets whether to merge overlapping matched chunks, by default False.
+
+        Parameters
+        ----------
+        b : bool
+            Whether to merge overlapping matched chunks
+        """
+        return self._set(mergeOverlapping=b)
+
+    def setEntityValue(self, b):
+        """Sets value for the entity metadata field.
+
+        Parameters
+        ----------
+        b : str
+            Value for the entity metadata field
+        """
+        return self._set(entityValue=b)
+
+    def setBuildFromTokens(self, b):
+        """Sets whether the TextMatcher should take the CHUNK from TOKEN or not.
+
+        Parameters
+        ----------
+        b : bool
+            Whether the TextMatcher should take the CHUNK from TOKEN or not
+        """
+        return self._set(buildFromTokens=b)
+
+
+class TextMatcherModel(AnnotatorModel):
+    """Instantiated model of the TextMatcher.
+
+    This is the instantiated model of the :class:`.TextMatcher`. For training
+    your own model, please see the documentation of that class.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``DOCUMENT, TOKEN``    ``CHUNK``
+    ====================== ======================
+
+    Parameters
+    ----------
+    mergeOverlapping
+        Whether to merge overlapping matched chunks, by default False
+    entityValue
+        Value for the entity metadata field
+    buildFromTokens
+        Whether the TextMatcher should take the CHUNK from TOKEN or not
+    """
+    name = "TextMatcherModel"
+
+    inputAnnotatorTypes = [AnnotatorType.DOCUMENT, AnnotatorType.TOKEN]
+
+    outputAnnotatorType = AnnotatorType.CHUNK
+
+    mergeOverlapping = Param(Params._dummy(),
+                             "mergeOverlapping",
+                             "whether to merge overlapping matched chunks. Defaults false",
+                             typeConverter=TypeConverters.toBoolean)
+
+    searchTrie = Param(Params._dummy(),
+                       "searchTrie",
+                       "searchTrie",
+                       typeConverter=TypeConverters.identity)
+
+    entityValue = Param(Params._dummy(),
+                        "entityValue",
+                        "value for the entity metadata field",
+                        typeConverter=TypeConverters.toString)
+
+    buildFromTokens = Param(Params._dummy(),
+                            "buildFromTokens",
+                            "whether the TextMatcher should take the CHUNK from TOKEN or not",
+                            typeConverter=TypeConverters.toBoolean)
+
+    def __init__(self, classname="com.johnsnowlabs.nlp.annotators.TextMatcherModel", java_model=None):
+        super(TextMatcherModel, self).__init__(
+            classname=classname,
+            java_model=java_model
+        )
+
+    def setMergeOverlapping(self, b):
+        """Sets whether to merge overlapping matched chunks, by default False.
+
+        Parameters
+        ----------
+        b : bool
+            Whether to merge overlapping matched chunks
+        """
+        return self._set(mergeOverlapping=b)
+
+    def setEntityValue(self, b):
+        """Sets value for the entity metadata field.
+
+        Parameters
+        ----------
+        b : str
+            Value for the entity metadata field
+        """
+        return self._set(entityValue=b)
+
+    def setBuildFromTokens(self, b):
+        """Sets whether the TextMatcher should take the CHUNK from TOKEN or not.
+
+        Parameters
+        ----------
+        b : bool
+            Whether the TextMatcher should take the CHUNK from TOKEN or not
+        """
+        return self._set(buildFromTokens=b)
+
+    @staticmethod
+    def pretrained(name, lang="en", remote_loc=None):
+        """Downloads and loads a pretrained model.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the pretrained model
+        lang : str, optional
+            Language of the pretrained model, by default "en"
+        remote_loc : str, optional
+            Optional remote address of the resource, by default None. Will use
+            Spark NLPs repositories otherwise.
+
+        Returns
+        -------
+        TextMatcherModel
+            The restored model
+        """
+        from sparknlp.pretrained import ResourceDownloader
+        return ResourceDownloader.downloadModel(TextMatcherModel, name, lang, remote_loc)

sparknlp/annotator/n_gram_generator.py

@@ -0,0 +1,141 @@
+#  Copyright 2017-2022 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains classes for the NGramGenerator."""
+from sparknlp.common import *
+
+
+class NGramGenerator(AnnotatorModel):
+    """A feature transformer that converts the input array of strings
+    (annotatorType ``TOKEN``) into an array of n-grams (annotatorType
+    ``CHUNK``).
+
+    Null values in the input array are ignored. It returns an array of n-grams
+    where each n-gram is represented by a space-separated string of words.
+
+    When the input is empty, an empty array is returned. When the input array
+    length is less than n (number of elements per n-gram), no n-grams are
+    returned.
+
+    For more extended examples see the `Examples <https://github.com/JohnSnowLabs/spark-nlp/blob/master/examples/python/annotation/text/english/chunking/NgramGenerator.ipynb>`__.
+
+    ====================== ======================
+    Input Annotation types Output Annotation type
+    ====================== ======================
+    ``TOKEN``              ``CHUNK``
+    ====================== ======================
+
+    Parameters
+    ----------
+    n
+        Number elements per n-gram (>=1), by default 2
+    enableCumulative
+        Whether to calculate just the actual n-grams, by default False
+    delimiter
+        Character to use to join the tokens, by default " "
+
+    Examples
+    --------
+    >>> import sparknlp
+    >>> from sparknlp.base import *
+    >>> from sparknlp.annotator import *
+    >>> from pyspark.ml import Pipeline
+    >>> documentAssembler = DocumentAssembler() \\
+    ...     .setInputCol("text") \\
+    ...     .setOutputCol("document")
+    >>> sentence = SentenceDetector() \\
+    ...     .setInputCols(["document"]) \\
+    ...     .setOutputCol("sentence")
+    >>> tokenizer = Tokenizer() \\
+    ...     .setInputCols(["sentence"]) \\
+    ...     .setOutputCol("token")
+    >>> nGrams = NGramGenerator() \\
+    ...     .setInputCols(["token"]) \\
+    ...     .setOutputCol("ngrams") \\
+    ...     .setN(2)
+    >>> pipeline = Pipeline().setStages([
+    ...       documentAssembler,
+    ...       sentence,
+    ...       tokenizer,
+    ...       nGrams
+    ...     ])
+    >>> data = spark.createDataFrame([["This is my sentence."]]).toDF("text")
+    >>> results = pipeline.fit(data).transform(data)
+    >>> results.selectExpr("explode(ngrams) as result").show(truncate=False)
+    +------------------------------------------------------------+
+    |result                                                      |
+    +------------------------------------------------------------+
+    |[chunk, 0, 6, This is, [sentence -> 0, chunk -> 0], []]     |
+    |[chunk, 5, 9, is my, [sentence -> 0, chunk -> 1], []]       |
+    |[chunk, 8, 18, my sentence, [sentence -> 0, chunk -> 2], []]|
+    |[chunk, 11, 19, sentence ., [sentence -> 0, chunk -> 3], []]|
+    +------------------------------------------------------------+
+    """
+
+    name = "NGramGenerator"
+
+    inputAnnotatorTypes = [AnnotatorType.TOKEN]
+
+    outputAnnotatorType = AnnotatorType.CHUNK
+
+    @keyword_only
+    def __init__(self):
+        super(NGramGenerator, self).__init__(classname="com.johnsnowlabs.nlp.annotators.NGramGenerator")
+        self._setDefault(
+            n=2,
+            enableCumulative=False
+        )
+
+    n = Param(Params._dummy(), "n", "number elements per n-gram (>=1)", typeConverter=TypeConverters.toInt)
+    enableCumulative = Param(Params._dummy(), "enableCumulative", "whether to calculate just the actual n-grams " +
+                             "or all n-grams from 1 through n", typeConverter=TypeConverters.toBoolean)
+
+    delimiter = Param(Params._dummy(), "delimiter", "String to use to join the tokens ",
+                      typeConverter=TypeConverters.toString)
+
+    def setN(self, value):
+        """Sets number elements per n-gram (>=1), by default 2.
+
+        Parameters
+        ----------
+        value : int
+            Number elements per n-gram (>=1), by default 2
+        """
+        return self._set(n=value)
+
+    def setEnableCumulative(self, value):
+        """Sets whether to calculate just the actual n-grams, by default False.
+
+        Parameters
+        ----------
+        value : bool
+            Whether to calculate just the actual n-grams
+        """
+        return self._set(enableCumulative=value)
+
+    def setDelimiter(self, value):
+        """Sets character to use to join the tokens
+
+        Parameters
+        ----------
+        value : str
+            character to use to join the tokens
+
+        Raises
+        ------
+        Exception
+            Delimiter should have length == 1
+        """
+        if len(value) > 1:
+            raise Exception("Delimiter should have length == 1")
+        return self._set(delimiter=value)

sparknlp/annotator/ner/__init__.py

@@ -0,0 +1,21 @@
+#  Copyright 2017-2023 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Module of annotators for named entity recognition."""
+from sparknlp.annotator.ner.ner_approach import *
+from sparknlp.annotator.ner.ner_converter import *
+from sparknlp.annotator.ner.ner_crf import *
+from sparknlp.annotator.ner.ner_dl import *
+from sparknlp.annotator.ner.ner_dl_graph_checker import *
+from sparknlp.annotator.ner.ner_overwriter import *
+from sparknlp.annotator.ner.zero_shot_ner_model import *

sparknlp/annotator/ner/ner_approach.py

@@ -0,0 +1,94 @@
+#  Copyright 2017-2022 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains base classes for NER Annotators."""
+
+from sparknlp.common import *
+
+
+class NerApproach(Params):
+    """Base class for Ner*Approach Annotators
+    """
+    labelColumn = Param(Params._dummy(),
+                        "labelColumn",
+                        "Column with label per each token",
+                        typeConverter=TypeConverters.toString)
+
+    entities = Param(Params._dummy(), "entities", "Entities to recognize", TypeConverters.toListString)
+
+    minEpochs = Param(Params._dummy(), "minEpochs", "Minimum number of epochs to train", TypeConverters.toInt)
+
+    maxEpochs = Param(Params._dummy(), "maxEpochs", "Maximum number of epochs to train", TypeConverters.toInt)
+
+    randomSeed = Param(Params._dummy(), "randomSeed", "Random seed", TypeConverters.toInt)
+
+    def setLabelColumn(self, value):
+        """Sets name of column for data labels.
+
+        Parameters
+        ----------
+        value : str
+            Column for data labels
+        """
+        return self._set(labelColumn=value)
+
+    def setEntities(self, tags):
+        """Sets entities to recognize.
+
+        Parameters
+        ----------
+        tags : List[str]
+            List of entities
+        """
+        return self._set(entities=tags)
+
+    def setMinEpochs(self, epochs):
+        """Sets minimum number of epochs to train.
+
+        Parameters
+        ----------
+        epochs : int
+            Minimum number of epochs to train
+        """
+        return self._set(minEpochs=epochs)
+
+    def setMaxEpochs(self, epochs):
+        """Sets maximum number of epochs to train.
+
+        Parameters
+        ----------
+        epochs : int
+            Maximum number of epochs to train
+        """
+        return self._set(maxEpochs=epochs)
+
+    def setRandomSeed(self, seed):
+        """Sets random seed for shuffling.
+
+        Parameters
+        ----------
+        seed : int
+            Random seed for shuffling
+        """
+        return self._set(randomSeed=seed)
+
+    def getLabelColumn(self):
+        """Gets column for label per each token.
+
+        Returns
+        -------
+        str
+            Column with label per each token
+        """
+        return self.getOrDefault(self.labelColumn)
+

sparknlp/annotator/ner/ner_converter.py

@@ -0,0 +1,148 @@
+#  Copyright 2017-2022 John Snow Labs
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Contains classes for the NerConverter."""
+
+from sparknlp.common import *
+
+
+class NerConverter(AnnotatorModel):
+    """Converts a IOB or IOB2 representation of NER to a user-friendly one, by
+    associating the tokens of recognized entities and their label. Results in
+    ``CHUNK`` Annotation type.
+
+    NER chunks can then be filtered by setting a whitelist with
+    ``setWhiteList``. Chunks with no associated entity (tagged "O") are
+    filtered.
+
+    See also `Inside–outside–beginning (tagging)
+    <https://en.wikipedia.org/wiki/Inside%E2%80%93outside%E2%80%93beginning_(tagging)>`__
+    for more information.
+
+    ================================= ======================
+    Input Annotation types            Output Annotation type
+    ================================= ======================
+    ``DOCUMENT, TOKEN, NAMED_ENTITY`` ``CHUNK``
+    ================================= ======================
+
+    Parameters
+    ----------
+    whiteList
+        If defined, list of entities to process. The rest will be ignored. Do
+        not include IOB prefix on labels
+    preservePosition
+        Whether to preserve the original position of the tokens in the original document
+        or use the modified tokens, by default `True`
+
+    Examples
+    --------
+    This is a continuation of the example of the :class:`.NerDLModel`. See that
+    class on how to extract the entities. The output of the NerDLModel follows
+    the Annotator schema and can be converted like so:
+
+    >>> result.selectExpr("explode(ner)").show(truncate=False)
+    +----------------------------------------------------+
+    |col                                                 |
+    +----------------------------------------------------+
+    |[named_entity, 0, 2, B-ORG, [word -> U.N], []]      |
+    |[named_entity, 3, 3, O, [word -> .], []]            |
+    |[named_entity, 5, 12, O, [word -> official], []]    |
+    |[named_entity, 14, 18, B-PER, [word -> Ekeus], []]  |
+    |[named_entity, 20, 24, O, [word -> heads], []]      |
+    |[named_entity, 26, 28, O, [word -> for], []]        |
+    |[named_entity, 30, 36, B-LOC, [word -> Baghdad], []]|
+    |[named_entity, 37, 37, O, [word -> .], []]          |
+    +----------------------------------------------------+
+
+    After the converter is used:
+
+    >>> converter = NerConverter() \\
+    ...     .setInputCols(["sentence", "token", "ner"]) \\
+    ...     .setOutputCol("entities")
+    >>> converter.transform(result).selectExpr("explode(entities)").show(truncate=False)
+    +------------------------------------------------------------------------+
+    |col                                                                     |
+    +------------------------------------------------------------------------+
+    |[chunk, 0, 2, U.N, [entity -> ORG, sentence -> 0, chunk -> 0], []]      |
+    |[chunk, 14, 18, Ekeus, [entity -> PER, sentence -> 0, chunk -> 1], []]  |
+    |[chunk, 30, 36, Baghdad, [entity -> LOC, sentence -> 0, chunk -> 2], []]|
+    +------------------------------------------------------------------------+
+    """
+    name = 'NerConverter'
+
+    inputAnnotatorTypes = [AnnotatorType.DOCUMENT, AnnotatorType.TOKEN, AnnotatorType.NAMED_ENTITY]
+
+    outputAnnotatorType = AnnotatorType.CHUNK
+
+    whiteList = Param(
+        Params._dummy(),
+        "whiteList",
+        "If defined, list of entities to process. The rest will be ignored. Do not include IOB prefix on labels",
+        typeConverter=TypeConverters.toListString
+    )
+
+    preservePosition = Param(
+        Params._dummy(),
+        "preservePosition",
+        "Whether to preserve the original position of the tokens in the original document or use the modified tokens",
+        typeConverter=TypeConverters.toBoolean
+    )
+
+    nerHasNoSchema = Param(
+        Params._dummy(),
+        "nerHasNoSchema",
+        "set this to true if your NER tags coming from a model that does not have a IOB/IOB2 schema",
+        typeConverter=TypeConverters.toBoolean
+    )
+
+    def setWhiteList(self, entities):
+        """Sets list of entities to process. The rest will be ignored.
+
+        Does not include IOB prefix on labels.
+
+        Parameters
+        ----------
+        entities : List[str]
+            If defined, list of entities to process. The rest will be ignored.
+
+        """
+        return self._set(whiteList=entities)
+
+    def setPreservePosition(self, value):
+        """
+        Whether to preserve the original position of the tokens in the original document
+        or use the modified tokens, by default `True`.
+
+        Parameters
+        ----------
+        value : bool
+            Whether to preserve the original position of the tokens in the original
+            document or use the modified tokens
+        """
+        return self._set(preservePosition=value)
+
+    def setNerHasNoSchema(self, value):
+        """
+        set this to true if your NER tags coming from a model that does not have a IOB/IOB2 schema
+
+        Parameters
+        ----------
+        value : bool
+            set this to true if your NER tags coming from a model that does not have a IOB/IOB2 schema
+        """
+        return self._set(nerHasNoSchema=value)
+
+    @keyword_only
+    def __init__(self):
+        super(NerConverter, self).__init__(
+            classname="com.johnsnowlabs.nlp.annotators.ner.NerConverter")