Phase 05 - Lesson 26

Extracción de Relaciones y Construcción de Grafos de Conocimiento

El NER encontró las entidades. La vinculación de entidades las ancló. La extracción de relaciones encuentra las aristas entre ellas. Un grafo de conocimiento es la suma de nodos, aristas y su procedencia.

Tipo: Build Lenguajes: Python Requisitos previos: Fase 5 · 06 (NER), Fase 5 · 25 (Vinculación de Entidades) Tiempo: ~60 minutos

El Problema

Un analista lee: "Tim Cook se convirtió en CEO de Apple en 2011." Cuatro hechos:

• (Tim Cook, role, CEO)
• (Tim Cook, employer, Apple)
• (Tim Cook, start_date, 2011)
• (Apple, type, Organization)

La Extracción de Relaciones (RE) convierte texto libre en triples estructurados (subject, relation, object). Agrega a lo largo de un corpus y tienes un grafo de conocimiento. Agrega y consulta y tienes un sustrato de razonamiento para RAG, analítica o auditorías de cumplimiento.

El problema de 2026: los LLM extraen relaciones con entusiasmo. Demasiado entusiasmo. Alucinan triples que el texto fuente no respalda. Sin procedencia, no puedes distinguir triples reales de ficción plausible. La respuesta de 2026 son los pipelines de anclar-y-verificar al estilo AEVS.

El Concepto

Forma de triple. (subject_entity, relation_type, object_entity). Las relaciones provienen de una ontología cerrada (propiedades de Wikidata, FIBO, UMLS) o de un conjunto abierto (estilo OpenIE, todo vale).

Tres enfoques de extracción.

1. Basado en reglas / patrones. Patrones de Hearst: "X such as Y" → (Y, isA, X). Más expresiones regulares hechas a mano. Frágil, preciso, explicable.
2. Clasificador supervisado. Dadas dos menciones de entidades en una oración, predice la relación a partir de un conjunto fijo. Entrenado en TACRED, ACE, KBP. Estándar de 2015–2022.
3. LLM generativo. Da un prompt al modelo para que emita triples. Funciona de inmediato. Necesita procedencia, o alucina basura de apariencia plausible.

AEVS (Anchor-Extraction-Verification-Supplement, 2026). El framework actual de mitigación de alucinaciones:

• Anchor (Anclar). Identifica cada span de entidad y cada span de frase-relación con posiciones exactas.
• Extract (Extraer). Genera triples vinculados a los spans-ancla.
• Verify (Verificar). Coteja cada elemento del triple con el texto fuente; rechaza cualquier cosa no respaldada.
• Supplement (Complementar). Una pasada de cobertura garantiza que no se descarte ningún span anclado.

Las alucinaciones caen drásticamente. Exige más cómputo, pero es auditable.

La disyuntiva abierto-versus-cerrado.

• Ontología cerrada. Lista fija de propiedades (por ejemplo, las más de 11.000 propiedades de Wikidata). Predecible. Consultable. Difícil de inventar.
• IE abierta. Cualquier frase verbal se convierte en una relación. Alta exhaustividad. Baja precisión. Desordenada de consultar.

Los KG de producción suelen mezclar: IE abierta para descubrimiento, luego canonicalizan las relaciones sobre una ontología cerrada antes de fusionarlas en el grafo principal.

Constrúyelo

Paso 1: extracción basada en patrones

PATTERNS = [
    (r"(?P<s>[A-Z]\w+) (?:is|was) (?:a|an|the) (?P<o>[A-Z]?\w+)", "isA"),
    (r"(?P<s>[A-Z]\w+) (?:is|was) born in (?P<o>\w+)", "bornIn"),
    (r"(?P<s>[A-Z]\w+) works? (?:at|for) (?P<o>[A-Z]\w+)", "worksAt"),
    (r"(?P<s>[A-Z]\w+) founded (?P<o>[A-Z]\w+)", "founded"),
]

Consulta code/main.py para el extractor de juguete completo. Los patrones de Hearst todavía se incluyen en pipelines específicos de dominio porque son depurables.

Paso 2: clasificación supervisada de relaciones

from transformers import AutoTokenizer, AutoModelForSequenceClassification

tok = AutoTokenizer.from_pretrained("Babelscape/rebel-large")
model = AutoModelForSequenceClassification.from_pretrained("Babelscape/rebel-large")

text = "Tim Cook was born in Alabama. He later became CEO of Apple."
encoded = tok(text, return_tensors="pt", truncation=True)
output = model.generate(**encoded, max_length=200)
triples = tok.batch_decode(output, skip_special_tokens=False)

REBEL es un extractor de relaciones seq2seq: texto a la entrada, triples a la salida, ya en ids de propiedad de Wikidata. Afinado con datos de supervisión distante. Baseline estándar de pesos abiertos.

Paso 3: extracción mediante prompt de LLM con anclaje

prompt = f"""Extract (subject, relation, object) triples from the text.
For each triple, include the exact character span in the source text.

Text: {text}

Output JSON:
[{{"subject": {{"text": "...", "span": [start, end]}},
   "relation": "...",
   "object": {{"text": "...", "span": [start, end]}}}}, ...]

Only include triples fully supported by the text. No inference beyond what is stated.
"""

Verifica cada span devuelto contra la fuente. Rechaza cualquier cosa donde text[start:end] != triple_entity. Este es el paso "verify" de AEVS en su forma mínima.

Paso 4: canonicaliza sobre una ontología cerrada

RELATION_MAP = {
    "is the CEO of": "P169",       # "chief executive officer"
    "was born in":   "P19",         # "place of birth"
    "founded":        "P112",       # "founded by" (inverted subject/object)
    "works at":       "P108",       # "employer"
}


def canonicalize(relation):
    rel_low = relation.lower().strip()
    if rel_low in RELATION_MAP:
        return RELATION_MAP[rel_low]
    return None   # drop unmapped open relations or route to manual review

La canonicalización suele ser el 60-80% del trabajo de ingeniería. Presupuéstala.

Paso 5: construye un grafo pequeño y consúltalo

triples = extract(text)
graph = {}
for s, r, o in triples:
    graph.setdefault(s, []).append((r, o))


def neighbors(node, relation=None):
    return [(r, o) for r, o in graph.get(node, []) if relation is None or r == relation]


print(neighbors("Tim Cook", relation="P108"))    # -> [(P108, Apple)]

Este es el átomo de todo sistema de RAG-sobre-KG. Escálalo con triple stores RDF (Blazegraph, Virtuoso), grafos de propiedades (Neo4j) o stores de grafo aumentados por vectores.

Errores Comunes

• Correferencia antes de la RE. "He founded Apple" — la RE necesita saber quién es "he". Ejecuta la correferencia primero (lección 24).
• Canonicalización de entidades. "Apple Inc" y "Apple" deben resolverse al mismo nodo. Vinculación de entidades primero (lección 25).
• Triples alucinados. Los LLM emiten triples que el texto no respalda. Aplica la verificación de spans.
• Deriva en la canonicalización de relaciones. Las relaciones de IE abierta son inconsistentes ("was born in", "came from", "is a native of"). Reduce a ids canónicos o el grafo queda no consultable.
• Errores temporales. "Tim Cook is CEO of Apple" — cierto ahora, falso en 2005. Muchas relaciones están acotadas en el tiempo. Usa calificadores (P580 tiempo de inicio, P582 tiempo de fin en Wikidata).
• Desajuste de dominio. REBEL se entrenó en Wikipedia. Los textos jurídicos, médicos y científicos a menudo necesitan modelos de RE afinados al dominio.

Úsalo

El stack de 2026:

El patrón de integración: NER → correferencia → vinculación de entidades → extracción de relaciones → mapeo de ontología → carga en el grafo. Cada etapa es una posible compuerta de calidad.

Entrégalo

Guarda como outputs/skill-re-designer.md:

---
name: re-designer
description: Design a relation extraction pipeline with provenance and canonicalization.
version: 1.0.0
phase: 5
lesson: 26
tags: [nlp, relation-extraction, knowledge-graph]
---

Given a corpus (domain, language, volume) and downstream use (KG-RAG, analytics, compliance), output:

1. Extractor. Pattern-based / supervised / LLM / AEVS hybrid. Reason tied to precision vs recall target.
2. Ontology. Closed property list (Wikidata / domain) or open IE with canonicalization pass.
3. Provenance. Every triple carries source char-span + doc id. Non-negotiable for audit.
4. Merge strategy. Canonical entity id + relation id + temporal qualifiers; dedup policy.
5. Evaluation. Precision / recall on 200 hand-labelled triples + hallucination-rate on LLM-extracted sample.

Refuse any LLM-based RE pipeline without span verification (source provenance). Refuse open-IE output flowing into a production graph without canonicalization. Flag pipelines with no temporal qualifier on time-bounded relations (employer, spouse, position).

Ejercicios

1. Fácil. Ejecuta el extractor de patrones en code/main.py sobre 5 oraciones de artículos de noticias. Verifica la precisión a mano.
2. Medio. Usa REBEL (o un LLM pequeño) sobre las mismas oraciones. Compara los triples. ¿Qué extractor tiene mayor precisión? ¿Mayor exhaustividad?
3. Difícil. Construye el pipeline AEVS: extrae con LLM + verifica los spans contra la fuente. Mide la tasa de alucinación antes versus después del paso de verificación en 50 oraciones al estilo de Wikipedia.

Términos Clave

Lecturas Adicionales

• Mintz et al. (2009). Distant supervision for relation extraction without labeled data — el artículo de supervisión distante.
• Huguet Cabot, Navigli (2021). REBEL: Relation Extraction By End-to-end Language generation — el caballo de batalla seq2seq de RE.
• Wadden et al. (2019). Entity, Relation, and Event Extraction with Contextualized Span Representations (DyGIE++) — IE conjunta.
• AEVS — Anchor-Extraction-Verification-Supplement framework — diseño de mitigación de alucinaciones de 2026.
• Wikidata SPARQL tutorial — consultas canónicas a grafos.