AI Prompt Engineering · Aula

Sumarização hierárquica

Compressão progressiva: capítulos → seções → resumo do documento.

Sumarização hierárquica é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que é sumarização hierárquica?

A sumarização hierárquica reproduz a estrutura do próprio documento. Em vez de tratar todos os fragmentos da mesma forma, ela comprime o conteúdo nível a nível:

Páginas → resumos de seções
Seções → resumos de capítulos
Capítulos → resumo do documento

Cada nível é uma representação comprimida do nível abaixo. É assim que as pessoas resumem livros: leem os capítulos, formam resumos mentais e depois os integram.

Quando usar a sumarização hierárquica

A sumarização hierárquica é a escolha certa para:

Livros: com mais de 200 páginas e uma estrutura clara de capítulos
Artigos de pesquisa: resumo, introdução, métodos, resultados e discussão
Contratos jurídicos: seções com títulos definidos (definições, obrigações e rescisão)
Relatórios técnicos: resumo executivo → conclusões → apêndices

Ela é exagerada para artigos curtos. Seu ponto forte aparece quando o documento tem uma estrutura natural em árvore.

Estrutura em árvore do documento

Modele o documento como uma árvore:

Raiz: resumo final
Nós do nível 1: resumos de capítulos
Nós do nível 2: resumos de seções
Folhas: texto bruto de páginas ou fragmentos

A sumarização prossegue de baixo para cima: folhas → nível 2 → nível 1 → raiz. O resumo de cada nó é derivado somente dos resumos de seus nós filhos.

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...'),
        ])
    ]
)

Sumarização de baixo para cima

Percorra a árvore de baixo para cima. Os nós folha são resumidos a partir de seu conteúdo bruto. Os nós internos são resumidos a partir dos resumos de seus nós filhos.

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

Compressão progressiva

Compressão progressiva significa que cada nível reduz a densidade das informações. Uma regra prática:

Página (2000 tokens) → resumo da seção (200 tokens) — compressão de 10 vezes
Resumo da seção (200 tokens) → resumo do capítulo (100 tokens) — compressão de 2 vezes
Resumos dos capítulos (5 × 100 tokens) → documento (150 tokens) — compressão de 3 vezes

Total: um documento de 10 mil tokens é comprimido para aproximadamente 150 tokens, preservando o argumento principal. Instrua cada nível a manter a proporção de compressão.

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).'

Manutenção da coerência entre níveis

Um risco da sumarização hierárquica é que os resumos de um nível podem se contradizer ou se repetir, e esses erros se acumulam nos níveis superiores. Estratégias para manter a coerência:

Inclua no comando o título da seção pai para que o modelo conheça o contexto
Solicite ao modelo que evite repetir fatos já apresentados nos resumos de seções anteriores
Na etapa final de redução, solicite explicitamente ao modelo que resolva todas as contradições

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

Hierarquia de um artigo de pesquisa

Os artigos de pesquisa têm uma hierarquia natural: Resumo → Introdução → Métodos → Resultados → Discussão → Conclusão. Cada seção tem uma função distinta, portanto use comandos específicos para cada seção:

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

Hierarquia de um contrato jurídico

Os contratos jurídicos seguem uma hierarquia de cláusulas: definições → obrigações → medidas de reparação → rescisão → lei aplicável. A sumarização hierárquica deve preservar:

Valores exatos (valores de pagamento e prazos)
Nomes das partes (cliente, fornecedor e licenciador)
Linguagem condicional (a menos que, exceto quando e desde que)

Instrua o modelo a sinalizar qualquer cláusula com um valor numérico ou uma condição que esteja sendo resumida, para que ela não seja omitida acidentalmente.

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

Armazenamento de resumos hierárquicos

Armazene toda a árvore de resumos, não apenas o resumo da raiz. Isso permite:

Aprofundamento — mostrar o resumo do capítulo e, sob demanda, o resumo da seção
Recuperação — comparar uma consulta do usuário com os resumos das seções, não apenas com o documento completo
Atualização — quando uma seção muda, refazer o resumo somente daquele ramo da árvore

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}')

Atualizações incrementais

Quando um documento é atualizado, a estrutura hierárquica permite uma resumarização incremental. Refazer o resumo somente do nó modificado e de seus ancestrais — todos os ramos irmãos continuam válidos.

Em um livro de 10 capítulos no qual o capítulo 3 foi revisado: refaça os resumos das seções do capítulo 3, depois do capítulo 3 e, por fim, do livro. Recalcule 3 nós em vez de todos os nós.

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

Comparação entre estruturas plana e hierárquica

Mapeamento e redução plano versus sumarização hierárquica:

Plano: mais simples, ignora a estrutura do documento e é melhor para documentos uniformes (artigos de notícias)
Hierárquico: respeita a estrutura, permite aprofundamento e oferece melhor coerência para documentos estruturados

Na prática, combine os dois: use o mapeamento e redução plano dentro de cada capítulo (muitas páginas) e depois aplique a sumarização hierárquica entre os capítulos. Essa é a abordagem mais robusta para documentos do mundo real.

Verificação de conhecimentos

Na sumarização hierárquica, em que direção o processo de sumarização percorre a árvore do documento?

Recapitulação: sumarização hierárquica

A sumarização hierárquica reproduz a estrutura do documento para obter resultados superiores:

Modele o documento como uma árvore: páginas → seções → capítulos → documento
Resuma de baixo para cima: primeiro as folhas e, por último, a raiz
Cada nível aplica compressão progressiva para manter a coerência
É ideal para livros, artigos de pesquisa e contratos jurídicos com uma estrutura hierárquica clara
Armazene a árvore completa para permitir recuperação por aprofundamento e atualizações incrementais

Próxima lição: manutenção do contexto entre fragmentos com sobreposição e resumos acumulados.

Perguntas Frequentes

A aula “Sumarização hierárquica” é grátis?

Sim — o texto completo de “Sumarização hierárquica” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Sumarização hierárquica”?

Compressão progressiva: capítulos → seções → resumo do documento. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Sumarização hierárquica”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Estratégias de divisão para textos longos
Padrão de sumarização Map-Reduce
Sumarização hierárquica
Mantendo o contexto entre partes

← Voltar para AI Prompt Engineering