Do multiple patterns need an if/else situation in dependency matcher? Plus: wildcard issue

[ricardojosehlima]

Hi,
As Dependency Matcher doesn't work with optionality, I'm facing a situation that is being difficult to solve - my temporary solution is use if/else logic.

This is what I intend:

• match subjects with some dependencies ("Good children want good things", "Paul's son left yesterday");
• match subjects without any dependency ("Children want good things", "Paul left yesterday").
  separately, ie, each must form an independent group.

In order to match the first case, I have:
(i)

{
                "RIGHT_ID": "verb",
                "RIGHT_ATTRS": {"POS": "VERB"}
                },
                
                {
                "LEFT_ID": "verb",
                "REL_OP": ">",
                "RIGHT_ID": subject",
                "RIGHT_ATTRS": {"DEP": "nsubj"}
                },
                
               {
                "LEFT_ID": "subject",
                "REL_OP": ">>",
                "RIGHT_ID": "part_of_subject",
                "RIGHT_ATTRS": {"DEP": {"NOT_IN": ["ROOT"]}}
                }

Note that I wanted to use "DEP": {}, the wildcard available in the Matcher, but then an error message occurred, so I used not in ROOT as (almost) always never a ROOT will be dependent of a subject,

Apart from it, the code above matches "Good children...", "Paul's son..." but not "Children...", "Paul..." because I can't make the last dictionary (part_of_subject) optional.

So, to match "Children...", "Paul..." it would either be:

(a) this code:
(ii)

{
                "RIGHT_ID": "verb",
                "RIGHT_ATTRS": {"POS": "VERB"}
                },
                
                {
                "LEFT_ID": "verb",
                "REL_OP": ">",
                "RIGHT_ID": "subject",
                "RIGHT_ATTRS": {"DEP": "nsubj"}
                },

that would appear as:

if (i): # the sentence is like "Good children"
     do stuff
else: #the sentence is like "Children"
    (ii)

OR

(b) run (ii), that would match all four examples. Run (i), that would match "Good children" and "Paul's son", and get these outputs and remove from the list of the results of the second code ran above.

(i) = ["Good children", "Paul's son", "Children", "Paul"]
(ii) = ["Good children", "Paul's son"]
and a list comprehension would split them.

If either of these ways is the way, ok, but could there be a simpler way? This situation in just an example, there may be more.
And better if some other solution takes place inside the Dependency Matcher.

[polm]

I think your current method is OK, but the way I would handle this is to just use your second rule and then directly check the matched nodes in code to see if they have dependents or not using Token.children.

[ricardojosehlima]

Hi, thanks for the answer!
I am currently trying the dependency parsing feature subtree for the nsubj. For this case, it automatically matches both "Good children" and "Children", then if len is 1, it is "Children", else "Good Children", "The children", etc.