Relation Extraction (RE)

The fundamental output of RE is a semantic triple in the form (Subject, Predicate, Object). This transforms raw text into machine-readable knowledge graph edges.

• Subject & Object: The named entities identified in the text (e.g., 'Elon Musk', 'SpaceX').
• Predicate: The classified relationship type (e.g., 'founded_by', 'CEO_of').
• Directionality: Relations are directed; 'acquired' is distinct from 'acquired_by'.

This structured output directly populates enterprise knowledge graphs and enables downstream reasoning tasks.

Traditional RE is framed as a multi-class classification problem over entity pairs. A model receives a sentence with two tagged entities and assigns a relation label from a predefined schema.

• Input: A sentence with marked entity spans (e.g., [E1]Apple[/E1] was founded by [E2]Steve Jobs[/E2]).
• Output: A probability distribution over relation classes (e.g., founded_by: 0.97, employee_of: 0.01).
• Negative Class: A special 'no_relation' label is critical, as most entity pairs in a corpus are unrelated.

This paradigm requires high-quality, manually annotated datasets like TACRED and SemEval for training.

Before deep learning, the shortest dependency path between two entities in a parse tree was the dominant feature for RE. It captures the syntactic backbone connecting the entities while filtering noise.

• Mechanism: The path is extracted from a dependency parse tree, connecting the head words of the two entity mentions.
• Example: In 'The CEO of Acme Corp announced a merger', the path between 'CEO' and 'Acme Corp' is CEO <-nsubj- announced -nmod:of-> Corp.
• Kernel Methods: Early systems used tree kernels to compute similarity between these paths for classification.

While neural methods now dominate, dependency paths remain a powerful feature for few-shot relation extraction.

Manually labeling relation data is expensive. Distant supervision automatically generates training data by heuristically aligning a knowledge base with a text corpus.

• Assumption: If a knowledge base contains a fact (e.g., founded_by(Apple, Steve_Jobs)), any sentence mentioning both entities expresses that relation.
• Challenge: This assumption introduces noisy labels. A sentence mentioning 'Apple' and 'Steve Jobs' might discuss his resignation, not the founding.
• Mitigation: Multi-instance learning and attention mechanisms are used to de-emphasize noisy sentences during training.

This technique enables the creation of massive, weakly-labeled datasets like the NYT-FB corpus.

Pipeline models suffer from error propagation, where entity recognition mistakes cascade into relation classification. Joint models solve both tasks simultaneously.

• Single-Pass Architecture: A shared encoder identifies entity spans and classifies relations between them in one forward pass.
• Parameter Sharing: The model learns representations useful for both entity typing and relation prediction, improving generalization.
• Span-Based Methods: Modern approaches enumerate all possible text spans, classify them as entity types, and then score all pairs for relations.

Joint extraction eliminates the hard boundary between Named Entity Recognition and RE, leading to state-of-the-art performance on benchmarks.

Many relationships cannot be inferred from a single sentence. Document-level RE requires reasoning across multiple sentences to connect entities.

• Coreference Resolution: The model must link pronouns ('he', 'the company') to their antecedents to build a coherent entity narrative.
• Logical Inference: Some relations require synthesizing facts across sentences (e.g., 'A is the father of B' and 'B is the father of C' implies 'A is the grandfather of C').
• Graph Construction: Entities are often modeled as nodes in a document graph, with edges representing co-occurrence or coreference, processed by Graph Neural Networks.

The DocRED benchmark is the standard evaluation for this challenging setting.