DependencyMatcher RIGHT_ATTRS allow for only one sort of filtering

[JakubOrlinskiUPM]

The DependencyMatcher documentation states:
The token attributes to match for the right-hand node in the same format as patterns provided to the regular token-based Matcher. This is not true though, as the RIGHT_ATTRS expects a dictionary not a list. This is a problem when trying to filter on a node.

For example, I want to get a verb that is not in an infinitive form (to be should be excluded). So trying this code doesn't work as the OP gets applied to both POS and MORPH tags.

        {
            "RIGHT_ID": "anchor_verb",
            "RIGHT_ATTRS": {
                "POS": "VERB",
                "MORPH": "VerbForm=Inf"
                "OP": "!"
            }
        },

Which page or section is this issue related to?

DependencyMatcher: https://spacy.io/api/dependencymatcher

[adrianeboyd]

Hi, sorry that explanation is indeed a bit unclear. The dependency matcher matches exactly one token in each RIGHT_ATTRS and the format is the same as the dict for exactly one token in a Matcher pattern. The Matcher pattern is a list of token dicts.

For this kind of pattern, you can use NOT_IN as in "MORPH": {"NOT_IN": ["VerbForm=Inf"]} (or possibly use the subset/superset/intersects operators if it's not the full morph tag that you want to match). Even with a Matcher pattern, you wouldn't be able to apply OP to an individual feature. It always applies to the whole token pattern.

[JakubOrlinskiUPM]

Oh nice, thank you for the response! And that should solve the issue :)

But also, isn't it possible to do this with Matcher? Here the OP applies only to the dictionary it's in, whereas in DM as you said the OP applies to the whole query.

[
  {"LOWER": "i"},
  {"LEMMA": {"IN": ["like", "love"], "OP": "?"}},
  {"POS": "NOUN", "OP": "+"}
]

I guess it amounts to the same functionality mostly because you can use the operations IN and so on but I think there are cases that are not covered by the current DependencyMatcher that are present in Matcher.

[adrianeboyd]

No, this isn't a valid pattern:

pattern = [{"LEMMA": {"IN": ["like", "love"], "OP": "?"}}]

You'd get an error when you try to add it to a Matcher.

Each token dict (each line in your example) can only have one OP and the RIGHT_ATTRS pattern corresponds to only one token dict.

The DependencyMatcher is actually using a standard Matcher internally to match the tokens. There shouldn't be any difference in terms of the patterns that are supported, except that the DependencyMatcher doesn't allow any OP values that could result in 0 matches or 2+ matches. You need the node patterns to match exactly one token in the dependency tree for the dependency patterns to work because the dependency relations are always between exactly two tokens.

[Ptark]

Hi, I have a related usecase where I want to match a pattern with the DependencyMatcher unless a certain child token appears. I have tried the following:

pattern = [
    {
        "RIGHT_ID": "anchor",
        "RIGHT_ATTRS": {"LEMMA": "werden"}
    },
    {
        "LEFT_ID": "anchor",
        "REL_OP": ">",
        "RIGHT_ID": "infinitive",
        "RIGHT_ATTRS": {
            "TAG": {"NOT_IN": ["VVINF", "VMINF"]}
            "OP": "*"
]

Essentially I want to match patterns which are 1 or 2 tokens while disallowing certain tags on the second token. I haven't found a way to match those patterns except matching only the first token and then manually filtering the matches. I would appreciate any suggestions.
Thank you very much for your time and effort.

[polm]

This seems to be the same question as #11614. Please do not double post, we'll reply in that thread.