How to transfer custom extension attributes from source entities to merged tokens when using "merge_entities" component?

[koernel2]

Hi, I'm planning to use the Matcher for rule-based relationship extraction between entities. The entities (Spans) carry custom information in extension attributes (ent._.custom_data). Since the Matcher is working on Tokens (and not Spans) I have been meaning to first apply a pipeline ( setup in a away that it includes the component for merging, i.e. nlp_merge_tokens.add_pipe("merge_entities") ). All of this works fine, I have each entity now represented as a single token, even the ones that span over multiple words, and also the original values in ent.entity_type_ are automatically and correctly transferred and available via token.ent_type_ .
Now to my problem: How do I transfer the custom extension attributes (e.g. 'custom_data' ) stored in entity X over to a token derived from entity X ? I have already registered the extension attributes for the Tokens (Token.set_extension("custom_data", default=-1.0, force=True) ), but of course, they all carry the init value -1 after just merging the tokens according to entities.
I would like to use the values of my custom extension from the entites in my pattern definitions for matching, so I would need them stored in the newly defined tokens. Is there a way to refer back to the source entity from a token that has been created from merge_entities? I have tried to find exactly this but got stuck in my search. Or is there another option I have missed
Many thanks in advance!

[svlandeg]

Hi!

To back up slightly, I'm trying to understand why you need the "merge token" functionality at all. It's true that the Matcher works on Tokens, as you say. But in my view, that doesn't mean that you need to merge all tokens of one entity into one artificial "token". Would the following setup work instead?

• Define your entities and their custom data
• Loop over each entity, and for each token within the entity, set the token attribute according to the entity attribute
• Apply the matcher, matching on the token attribute
• Retrieve the hits from the matcher, and for each token that hits, expand to the original entity by finding the entity whose start and end matches the token index

If this works, I think it might be a better approach overall, as you don't need these artificially merged "tokens" that could mess up parser/NER/tagger performance if you'd need that in your pipeline...

[koernel2]

Hi Sofie,
Thank you for your quick and helpful reply. This is a good suggestio and I will try this first. I was thinking to use the offset (position) of the merged tokens to identify the corresponding pairs of merged tokens and entities, but yours is more elegant as it skipps the need for the merging step alltogether.
On thing: when you say

"...for each token that hits, expand to the original entity by finding the entity whose start and end matches the token index"

I think it will have to be

"...for each token that hits, expand to the original entity by finding the entity whose start and end position encloses (positional identity included) the start- and end-position of the matching token".

For example, lets assume we have the (obviously made up) sentence

"Paracetamol cures type II diabetes mellitus."

and the entities are "Paracetamol" and "type II diabetes mellitus" , and the matched tokens that identify the relation 'cures' are " "Paracetamol" and "diabetes", I will have to find the entity "type II diabetes mellitus", which is the matched token plus some surrounding tokens in both directions in this case. Other cases will need expansion in only one or the other direction.
Would you agree, or am I missing something?

[svlandeg]

Exactly - that's what I meant even though I wrote it somewhat too succinctly.

In code, it would look something like this:

matches = self.matcher(doc)
for match in matches:
    match_id, token_ids = match
    for i in range(len(token_ids)):
        token_id = token_ids[i]

        # identify the entity belonging to this token
        for ent in ents:
            if ent.start <= token_index < ent.end:
                # this is the correct ent for the given token

[koernel2]

For sake of completeness and as a reference for anyone who may find this helpful when looking into a related topic, here is how I ended up transfering the extension attributes from entities to covered tokens (on which I then apply the Matcher/DependencyMatcher without applying the "merge_entities" component on the document:

for ent in doc.ents:

  # add some custom data from entity to all its related tokens:
  for tok_ind in range(ent.start, ent.end):
      doc[tok_ind]._.prob = ent._.prob
      doc[tok_ind]._.ontology_ids = ent._.ontology_ids
      doc[tok_ind].ent_type_ = ent.label_

Afterwards, the matches returned by Matcher/DependencyMatcher can be related back to the entities by applying this function using Sofie's code from above

def get_entity_from_token(token_index, doc):
    ret_ent = None

    for ent in doc.ents:
        if ent.start <= token_index < ent.end:
            ret_ent = ent
            break

    return ret_ent

[svlandeg]

Thanks for sharing, that's super useful for others! 🙏