Help with trying to remove a custom pipeline factory

[dbragdon1]

Hello, I recently updated spacy to 3.0.3 (Windows 10, Python 3.7) and I am trying to build and debug a custom factory. As I find issues and errors in the factory, I would like to overwrite and re-add the factory to my Language.

Here is the code I'm working with:

@language.factory('my_factory')
def custom_factory(nlp: Language, name: str):
   return None

The issue is that, after adding the factory for the first time using the @Language.factory decorator, I am running into an E004 error:

[E004] Can't set up pipeline component: a factory for 'my_factory' already exists. Existing factory: <function custom_factory at ...>. New factory: <function custom_factory at>

I understand that this is because I am trying to create two functions of the same name, but I can not figure out a way to delete a custom factory once it has been added to my Language. Can someone help me figure out how to simply remove this custom factory so that I can debug it and re-add it to my list? Thanks.

[jkafrouni]

+1, did you ever find a solution?

[polm]

Sorry for the late response to this.

It sounds like you want to change the code for your component and re-add it in the same process. The components are not really designed to be used that way - even if you are debugging, the expectation is that you'll stop the process and start a new process as you redefine the component. This is why there is no registry.remove function.

Under the hood the registry is just using a dictionary with some extra state management on top, so if you want to dig into the internals there's probably a way to unset a key, but I really wouldn't recommend it.

If you have a compelling use case for this we could think about adding it as a feature, but if you're just developing interactively I would encourage you to rethink your approach.

[Guillermogsjc]

Hi @polm, how would you generate several factory components with different configs inside the same process?

[Guillermogsjc]

Finally I found a way, a very dirty way to perform this ... to create names with uuid ... It would be very nice if the api allows to remove component, as the "one component by process", at least for ourr spacy-based applications, does not make sense at all.

   __init__...
      self.NAME = f"custom_entity_ruler_{uuid.uuid4().hex}"
      
    def get_custom_entity_ruler(self):

        @Language.component(self.NAME)
        def custom_entity_ruler(doc):
            for key in self.entity_ruler_dict:
                entity_ruler = self.entity_ruler_dict.get(key)
                doc_ents = entity_ruler(doc).ents
                doc._.ents_dict_update({key: doc_ents})
                doc.ents = []

            doc.ents = doc._.ents_dict['00']

            return doc

        return custom_entity_ruler

Take in mind that previous to the @Language.component naming API in v3, you could add and remove any object to the spacy pipe, and this API is breaking hardly any code that performs this.

[polm]

It's not clear to me why you're making a lot of copies of that component - I think you omitted the custom parameters? - but making many different copies of a single component doesn't have to be complicated, and you definitely don't have to call the decorator in a function like that.

Here's an example from the docs:

import spacy
from spacy.language import Language

@Language.factory("my_component", default_config={"some_setting": True})
def my_component(nlp, name, some_setting: bool):
    return MyComponent(some_setting=some_setting)

nlp = spacy.blank("en")
nlp.add_pipe("my_component", config={"some_setting": False})

Language.component is for stateless components, where every copy of the component is the same. For components that have state, like slightly different configuration, you should use Language.factory to make a stateful component. Then when you add things to the pipeline you just specify the name of the type of component, as well as the name of the specific instance in your pipeline. Here's an example:

nlp.add_pipe("my_component", name="my_component2", config={"foo": "bar"})

Here my_component is the name you give the @Language.factory decorator, and my_component2 is the name used for the instance of the component in the pipeline. That allows you to make as many differently configured instances of a component as you want. With the default components you can use this to add multiple EntityRulers, for example, so that a second one can depend on the results of the first one.

I'm not sure I completely understand what you're asking, so if that doesn't answer your question let me know.

[Guillermogsjc]

Thank you @polm for the quick response.

The config arguments in the decorator raises JSON seriallization errors for input as config, so it is very limiting, this is why I avoided the use of that.

I will try again anyway with the clues given, thanks again

[polm]

The config arguments in the decorator raises JSON seriallization errors for input as config, so it is very limiting, this is why I avoided the use of that.

OK, thanks for clarifying that. I recently worked on a project where I ran into that, and I understand it can feel arbitrary and frustrating, but it's there to make serialization easier.

What I ended up doing was giving the component class a method to set parameters that weren't JSON-serializable. So something like:

@Language.factory("something")
def make_something(nlp, name, ...):
    return Something(nlp, name, ...)

class Something:
    def __init__(self, nlp, name, ...):
        ...

    def set_stuff(self, foo, bar, ...):
        self.foo = foo
        self.bar = bar

# Use it like this
something = nlp.add_pipe("something", name="hoge", config=...)
something.set_stuff(alpha, beta, ...)

[cuiqui]

Hello, I think I have an use case for this. But perhaps anyone can point me to a better solution. So, long story short, we have several clients, and those clients have their own set of products. We need to recognize these products customer-wise. In order to do that, we:

1. Train an entity ruler specific to a client (its rules are relative to a list of products specific to that client).
2. Train a custom pipe that tries to detect versions of products, named expand_product_model.
3. Train a NER cross client.
4. Build a pipeline which is the result of the entity ruler (running first), then the pipe step expand_product_model, and then the NER (running third), in case it detects anything else.

So we would have many models consisting of an entity ruler + custom pipe that are client-specific; and then the same NER for all of them. Now, our setup is that we have a flask API of the type GET api/products/<client:str>?q=<text:str> that tries to extract products from a text for a given client. Inside that backend, we try to import all of the models, and that's when I get the error

ValueError: [E004] Can't set up pipeline component: a factory for 'expand_product_model' already exists. Existing factory: <function create_expand_product_model at 0x7f8829f98e50>. New factory: <function create_expand_product_model at 0x7f8829faaaf0>

I think this solution nlp.add_pipe("my_component", name="my_component2", config={"foo": "bar"}) doesn't work for me since the custom pipe is sticked into the pipeline through config definition.

[nlp]
lang = "en"
pipeline = ["tok2vec","entity_ruler","expand_product_model","ner"]

Does the above workflow make sense? If it does, I'd really like to be able to import several models this way. Thanks.

[cuiqui]

Hey, thanks for the reply. I'm using @Language.factory. Let me show you what my backend is doing:

from importlib import import_module

import spacy


class Models:
    models = {
        'client1': 'en_products_ner_client1',
        'client2': 'en_products_ner_client2'
    }
    _nlp = {}

    @classmethod
    def load(cls):
        for client, model in cls.models.items():
            import_module(model)
            cls._nlp[client] = spacy.load(model)

This fails as both en_products_ner_client1 and en_products_ner_client2 have a custom pipeline step:

@Language.factory('expand_product_model')
def create_expand_product_model(nlp: Language, name: str):
    return ExpandProductModel(nlp, name)`

This pipeline step tries different things for different clients. When trying to import the second model, it fails with:

ValueError: [E004] Can't set up pipeline component: a factory for 'expand_product_model' already exists. Existing factory: <function create_expand_product_model at 0x7f8829f98e50>. New factory: <function create_expand_product_model at 0x7f8829faaaf0>

[polm]

Ah OK, I see what happened.

It looks like you are using spacy package and the --code argument to create your pipelines, but the included code is creating custom components with the same name. There are a couple of ways you can work around that, but unregistering components with the same name is not one of them. (If I am not correct about spacy package, let me know.)

If the code for the custom component does not change, just don't provide the --code argument when packaging your models. Instead you import it in the code where you load the models, and for the client specific settings, you load them in like I suggested above. This is easier and I would recommend this approach.

However it sounds like you might have different code per client, so that ExpandProductModel actually has a different definition per client? If that's the case you should instead change the name of the factory to be like @Language.factory('expand_product_model_cisco'). This way you can include the code in the package as before and the names won't conflict. Note that the component name in the pipe can stay the same, it doesn't have to be the same as the name in the registry.

[cuiqui]

That's exactly correct. I'm using spacy package with --code.

The component initializes and is packaged with different data depending on the client.

    def initialize(self, get_examples=None, nlp=None, data=None):
        self.data = {...}

    def to_disk(self, path: Path, **kwargs):
        path.mkdir(exist_ok=True)
        srsly.write_json(path / 'data.json', self.data)

    def from_disk(self, path, **kwargs):
        self.data = srsly.read_json(path / 'data.json')
        return self

So I'll try changing the name of the factory as you suggest. I understand that this means that I have to change it in the config as well:

[components.expand_product_model]
factory = "expand_product_model_{client}"

There's no string interpolation available there in the config, right? I'll have to update the config manually every time. Thanks very much for the quick response.

[cuiqui]

Changing the name of the factory worked perfectly, thanks.

[polm]

Glad it worked!

Also note the config does have string interpolation, see ${paths.train} for example in the default quickstart configs. Docs about interpolation are here.

[Athena75]

I just changed the name of the new component : instead of "language_detector" I called it "language_detector_v2"

It worked for me

def get_lang_detector(nlp, name):
    return LanguageDetector()

Language.factory("language_detector_v2", func=get_lang_detector)
nlp.add_pipe('language_detector_v2', last=True)