Optimize RelationClassifier by adding the option to filter long sentences and truncate context #3593
Conversation
| max_allowed_tokens_between_entities: int = 20, | ||
| max_surrounding_context_length: int = 10, |
There was a problem hiding this comment.
Maybe if would make sense to also allow for None values to disable the measures. ̀This could then also be used as default value for _init_model_with_state_dict to not change the behaviour of existing models.
| max_allowed_tokens_between_entities=state.get("max_allowed_tokens_between_entities", 25), | ||
| max_surrounding_context_length=state.get("max_surrounding_context_length", 50), |
There was a problem hiding this comment.
The default parameters for backwards compatibility are different to the ones in the ̀ init` method. Are these a better fit?
There was a problem hiding this comment.
backwards compatibility is tricky, since older models will have no limitations on max allowed tokens or surrounding context. It's probably best to set really high numbers here (e.g., even higher).
| head_idx = -10000 | ||
| tail_idx = 10000 |
There was a problem hiding this comment.
For safety and as a sanity check, we could also initialize these values as None and have an assertion after the for token in original_sentence loop that these variables should not be None.
There was a problem hiding this comment.
I had that before, but that gave me mypy errors. But I agree that this is better.
…ax operations instead of if-statements
…urrounding_context_length` filter for backwards compatibility
…rounding_context_length` parameters
|
I've incorporated the suggestions and also added a test case for the new parameters. |
The
RelationClassifierseparately considers each pair of entities in aSentencefor relation classification. If a sentence is long and contains many entities, this leads to a very large number of forward passes.This PR introduces two new parameters to RelationClassifier to optimize this behavior:
max_allowed_tokens_between_entitiesallows users to specify the maximum allowed distance between two entities in order to be considered a relation candidate. The idea is that entities that lie far apart in a text are unlikely to be in relation. All entity pairs with too many tokens in between are filtered.max_surrounding_context_lengthallows users to specify how much additional context (text around the two entities) is used to make the relation classification. Setting this to a low value makes classification more computationally efficient, since smaller encoded sentences are used in the forward pass.Further, the PR introduces a new sanity check to ensure that one entity in a pair does not contain the other.
To enable this, the
_encode_sentencefunction is changed to possibly return None if one of the criteria is not met. The_encode_sentence_for_inferenceand_encode_sentence_for_trainingmethods are accordingly changed to check for None values before the yield.