AI Prompt Engineering · Lección

Resumen jerárquico

Compresión progresiva: capítulos → secciones → resumen del documento.

Resumen jerárquico es una lección gratuita de AI Prompt Engineering en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Prompt Engineering, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Prompt Engineering incluye 4 lecciones en total.

¿Qué es el resumido jerárquico?

El resumido jerárquico refleja la propia estructura del documento. En lugar de tratar todos los fragmentos por igual, comprime el contenido nivel por nivel:

Páginas → resúmenes de secciones
Secciones → resúmenes de capítulos
Capítulos → resumen del documento

Cada nivel es una representación comprimida del nivel inferior. Así es como las personas resumen libros: leen los capítulos, forman resúmenes mentales y luego los integran.

Cuándo utilizar el resumido jerárquico

El resumido jerárquico es la opción adecuada para:

Libros: más de 200 páginas con una estructura clara de capítulos
Artículos de investigación: resumen, introducción, métodos, resultados y discusión
Contratos legales: secciones con encabezados definidos (definiciones, obligaciones y terminación)
Informes técnicos: resumen ejecutivo → conclusiones → apéndices

Es excesivo para artículos breves. Resulta especialmente útil cuando el documento tiene una estructura de árbol natural.

Estructura arbórea del documento

Modele el documento como un árbol:

Raíz: resumen final
Nodos de nivel 1: resúmenes de capítulos
Nodos de nivel 2: resúmenes de secciones
Hojas: texto sin procesar de páginas o fragmentos

El resumido avanza de abajo arriba: hojas → nivel 2 → nivel 1 → raíz. El resumen de cada nodo se deriva únicamente de los resúmenes de sus hijos.

from dataclasses import dataclass, field
from typing import List, Optional

@dataclass
class DocNode:
    title: str
    content: str = ''
    summary: str = ''
    children: List['DocNode'] = field(default_factory=list)

# Example: book with 3 chapters, each with 3 sections
book = DocNode(
    title='My Book',
    children=[
        DocNode('Chapter 1', children=[
            DocNode('Section 1.1', content='...raw text...'),
            DocNode('Section 1.2', content='...raw text...'),
        ]),
        DocNode('Chapter 2', children=[
            DocNode('Section 2.1', content='...raw text...'),
        ])
    ]
)

Resumido de abajo arriba

Recorra el árbol de abajo arriba. Los nodos hoja se resumen a partir de su contenido sin procesar. Los nodos internos se resumen a partir de los resúmenes de sus hijos.

import openai
client = openai.OpenAI(api_key='sk-...')

def summarize_text(text, role='section'):
    resp = client.chat.completions.create(
        model='gpt-4o',
        messages=[
            {'role': 'system',
             'content': f'Summarize this {role} in 3-5 sentences.'},
            {'role': 'user', 'content': text}
        ]
    )
    return resp.choices[0].message.content

def summarize_tree(node, depth=0):
    role = ['document', 'chapter', 'section', 'page'][min(depth, 3)]
    if not node.children:
        node.summary = summarize_text(node.content, role)
    else:
        for child in node.children:
            summarize_tree(child, depth + 1)
        combined = '\n\n'.join(
            f'{c.title}:\n{c.summary}' for c in node.children
        )
        node.summary = summarize_text(combined, role)
    return node.summary

Compresión progresiva

La compresión progresiva significa que cada nivel reduce la densidad de información. Una regla práctica:

Página (2000 tokens) → resumen de sección (200 tokens): compresión de 10 veces
Resumen de sección (200 tokens) → resumen de capítulo (100 tokens): compresión de 2 veces
Resúmenes de capítulos (5 × 100 tokens) → documento (150 tokens): compresión de 3 veces

En total, un documento de 10.000 tokens se comprime a aproximadamente 150 tokens, conservando el argumento principal. Indique en el prompt de cada nivel que mantenga la proporción de compresión.

PAGE_PROMPT = 'Summarize this page in 2-3 sentences (under 80 words).'
SECTION_PROMPT = 'Given these page summaries, write a section summary in 3-4 sentences (under 120 words).'
CHAPTER_PROMPT = 'Given these section summaries, write a chapter summary in 4-5 sentences (under 150 words).'
DOC_PROMPT = 'Given these chapter summaries, write an executive summary of the entire document (under 200 words).'

Mantenimiento de la coherencia entre niveles

Un riesgo del resumido jerárquico es que los resúmenes de un mismo nivel se contradigan o repitan entre sí, y estos errores se acumulen hacia arriba. Estrategias para mantener la coherencia:

Incluya en el prompt el encabezado de la sección principal para que el modelo conozca el contexto
Pida al modelo que evite repetir datos ya indicados en resúmenes de secciones anteriores
En el paso reduce final, pida explícitamente al modelo que resuelva cualquier contradicción

def summarize_sections_for_chapter(chapter_title, section_summaries):
    content = '\n\n'.join(
        f'Section: {s["title"]}\n{s["summary"]}'
        for s in section_summaries
    )
    prompt = (
        f'Chapter: {chapter_title}\n\n'
        'Below are summaries of each section. '
        'Write a unified chapter summary without repeating '
        'the same facts from multiple sections.\n\n' + content
    )
    resp = client.chat.completions.create(
        model='gpt-4o',
        messages=[{'role': 'user', 'content': prompt}]
    )
    return resp.choices[0].message.content

Jerarquía de un artículo de investigación

Los artículos de investigación tienen una jerarquía natural: resumen → introducción → métodos → resultados → discusión → conclusión. Cada sección tiene una función distinta, por lo que debe utilizar prompts específicos para cada sección:

SECTION_PROMPTS = {
    'abstract': 'Summarize the paper abstract: what problem, method, and result?',
    'introduction': 'Summarize the introduction: what gap does the paper address?',
    'methods': 'Summarize the methods: what approach was used?',
    'results': 'Summarize the results: what were the key findings and metrics?',
    'discussion': 'Summarize the discussion: what do the results mean?',
    'conclusion': 'Summarize the conclusion and future work.'
}

def summarize_paper(sections_dict):
    section_summaries = {}
    for section, text in sections_dict.items():
        prompt = SECTION_PROMPTS.get(section, 'Summarize this section.')
        section_summaries[section] = call_llm(prompt, text)
    return section_summaries

Jerarquía de un contrato legal

Los contratos legales siguen una jerarquía de cláusulas: definiciones → obligaciones → recursos → terminación → ley aplicable. El resumido jerárquico debe conservar:

Importes exactos (cantidades de pago y plazos)
Nombres de las partes (cliente, proveedor y licenciante)
Lenguaje condicional (a menos que, excepto cuando, siempre que)

Indique en el prompt al modelo que marque cualquier cláusula con un importe numérico o una condición que esté resumiendo, para evitar que se omita accidentalmente.

LEGAL_PROMPT = '''Summarize this contract clause in plain English.
Preserve: all monetary amounts, dates, party names, and conditionals.
Flag any obligation with [OBLIGATION] and any amount with [AMOUNT].'''

def summarize_clause(clause_text):
    resp = client.chat.completions.create(
        model='gpt-4o',
        messages=[
            {'role': 'system', 'content': LEGAL_PROMPT},
            {'role': 'user', 'content': clause_text}
        ]
    )
    return resp.choices[0].message.content

Almacenamiento de resúmenes jerárquicos

Almacene el árbol de resúmenes completo, no solo el resumen de la raíz. Esto permite:

Profundizar: mostrar el resumen del capítulo y, a continuación, el resumen de la sección cuando se solicite
Recuperar información: comparar la consulta del usuario con los resúmenes de las secciones, no solo con el documento completo
Actualizar: cuando cambia una sección, volver a resumir únicamente esa rama del árbol

import json

def tree_to_dict(node):
    return {
        'title': node.title,
        'summary': node.summary,
        'children': [tree_to_dict(c) for c in node.children]
    }

def save_tree(node, path):
    with open(path, 'w') as f:
        json.dump(tree_to_dict(node), f, indent=2)
    print(f'Saved summary tree to {path}')

Actualizaciones incrementales

Cuando se actualiza un documento, la estructura jerárquica permite realizar un resumido incremental. Solo debe volver a resumir el nodo modificado y sus antecesores; todas las ramas hermanas siguen siendo válidas.

En un libro de 10 capítulos en el que se revisa el capítulo 3, vuelva a resumir las secciones del capítulo 3, después el capítulo 3 y, por último, el libro. Vuelva a calcular 3 nodos en lugar de todos.

def update_node(node, updated_child_title):
    # Re-summarize the changed child
    for child in node.children:
        if child.title == updated_child_title:
            summarize_tree(child)  # re-summarize from leaves
            break
    # Re-summarize current node from updated children
    combined = '\n\n'.join(
        f'{c.title}:\n{c.summary}' for c in node.children
    )
    node.summary = summarize_text(combined)
    return node.summary

Comparación entre resumido plano y jerárquico

Map-reduce plano frente a resumido jerárquico:

Plano: más sencillo, ignora la estructura del documento y es mejor para documentos uniformes (artículos de noticias)
Jerárquico: respeta la estructura, permite profundizar y ofrece mayor coherencia en documentos estructurados

En la práctica, combine ambos: utilice map-reduce plano dentro de cada capítulo (cuando tenga muchas páginas) y, después, un enfoque jerárquico entre capítulos. Este es el enfoque más sólido para documentos del mundo real.

Comprobación de conocimientos

En el resumido jerárquico, ¿en qué dirección avanza el proceso de resumido por el árbol del documento?

Recapitulación: resumido jerárquico

El resumido jerárquico refleja la estructura del documento para obtener mejores resultados:

Modele el documento como un árbol: páginas → secciones → capítulos → documento
Resuma de abajo arriba: primero las hojas y, al final, la raíz
Cada nivel aplica una compresión progresiva para mantener la coherencia
Es ideal para libros, artículos de investigación y contratos legales con una estructura jerárquica clara
Almacene el árbol completo para permitir la recuperación con navegación en profundidad y las actualizaciones incrementales

Próxima lección: mantenimiento del contexto entre fragmentos mediante solapamiento y resúmenes acumulados.

Preguntas frecuentes

¿La lección «Resumen jerárquico» es gratis?

Sí — el texto completo de «Resumen jerárquico» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Prompt Engineering, actualiza a CoddyKit PRO. El curso de AI Prompt Engineering incluye 4 lecciones en total.

¿Qué aprenderé en «Resumen jerárquico»?

Compresión progresiva: capítulos → secciones → resumen del documento. Practicas AI Prompt Engineering con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar AI Prompt Engineering?

No se requiere experiencia previa. AI Prompt Engineering en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Resumen jerárquico»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de AI Prompt Engineering?

Sí. Cada lección de AI Prompt Engineering incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Estrategias de división para textos largos
Patrón de resumen Map-Reduce
Resumen jerárquico
Mantener el contexto entre fragmentos

← Volver a AI Prompt Engineering