Role frames: decoding constraints and evidence revisions

Last updated: 6 Oct 20265 min read

tutorial

Independent span scores can form an impossible event. Decode a consistent frame and keep its supporting text revision.

Decode under simple constraints

A candidate frame needs one predicate span, role spans inside the source sentence and a polarity value. Reject spans outside the sentence and roles assigned to the same characters when policy forbids overlap. One sentence can contain multiple predicates; do not force all arguments onto the first verb. Link a pronoun to a prior mention only when the coreference decision is reviewed or sufficiently supported. Coreference chains are a separate hypothesis.

Keep provenance granular

Store source document, revision, sentence offsets, predicate span and argument spans. If a model emits an inferred actor absent from the sentence, mark it as inferred rather than extractive. A downstream relation should reference the exact frame version, not just its text. Relation provenance prevents an edge from surviving after its support disappears.

Resolve competing frames

Two decoders may disagree about whether “before rollback” modifies deployment or alarm. Keep alternative proposals and a reason for review; a high average score does not make the ambiguity vanish. Review contradictions with the event timeline, including negated actions and speculative plans. Do not automatically merge two frames merely because they share an actor and verb; targets and time can differ.

Measure useful correctness

Report exact full-frame accuracy, polarity errors, omitted predicates and wrong arguments by source channel. Compare a parser baseline with a trained decoder on the same incident-grouped audit. Include passive voice, conjunction, quotation and multi-event sentences. The applied project uses a conservative release gate for operational action frames.

Implementation

def validate_role_spans(sentence, predicate_span, role_spans):
    length = len(sentence)
    spans = {"predicate": predicate_span, **role_spans}
    for role, (start, end) in spans.items():
        if not 0 <= start < end <= length:
            raise ValueError(f"{role} span outside sentence")
    return {role: sentence[start:end]
            for role, (start, end) in spans.items()}

line = "Gateway retried charge ZX-47."
roles = validate_role_spans(line, (8, 15),
                            {"actor": (0, 7), "target": (16, 28)})
assert roles["predicate"] == "retried" and roles["actor"] == "Gateway"

Performance and operating cost

Checking r span coordinates takes O(r) time, while extracting text copies O(total span length) characters. Decoding all candidate combinations can grow quickly when each role has many spans, so prune by sentence and predicate before scoring. Track full-frame error and reviewer time, rather than optimizing token-level accuracy alone.

Common Mistakes

Assembling the highest-scoring role spans without validating their relation.
Losing the source revision after a frame is stored.
Treating an inferred actor as verbatim text.
Evaluating only role tokens and missing a wrong complete event.