0Pricing
AI Prompt Engineering · Lezione

Riepilogo gerarchico

Compressione progressiva: capitoli → sezioni → riepilogo del documento

Riepilogo gerarchico è una lezione AI Prompt Engineering gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Prompt Engineering, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Prompt Engineering include 4 lezioni in totale.

Che cos'è il riepilogo gerarchico

Il riepilogo gerarchico rispecchia la struttura del documento stesso. Invece di trattare tutti i chunk allo stesso modo, comprime il contenuto livello per livello:

  • Pagine → riepiloghi delle sezioni
  • Sezioni → riepiloghi dei capitoli
  • Capitoli → riepilogo del documento

Ogni livello è una rappresentazione compressa del livello sottostante. È così che le persone riepilogano i libri: leggono i capitoli, ne elaborano riepiloghi mentali e poi li integrano.

Quando usare il riepilogo gerarchico

Il riepilogo gerarchico è la scelta giusta per:

  • Libri: oltre 200 pagine con una struttura chiara in capitoli
  • Articoli di ricerca: abstract, introduzione, metodi, risultati, discussione
  • Contratti legali: sezioni con titoli definiti (definizioni, obblighi, risoluzione)
  • Report tecnici: sintesi esecutiva → risultati → appendici

È eccessivo per gli articoli brevi. Offre i risultati migliori quando il documento presenta una struttura ad albero naturale.

Struttura ad albero del documento

Rappresenti il documento come un albero:

  • Radice: riepilogo finale
  • Nodi di livello 1: riepiloghi dei capitoli
  • Nodi di livello 2: riepiloghi delle sezioni
  • Foglie: testo grezzo delle pagine o dei chunk

Il riepilogo procede dal basso verso l'alto: foglie → livello 2 → livello 1 → radice. Il riepilogo di ogni nodo deriva esclusivamente dai riepiloghi dei suoi figli.

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

Riepilogo dal basso verso l'alto

Attraversi l'albero dal basso verso l'alto. I nodi foglia vengono riepilogati a partire dal loro contenuto grezzo. I nodi interni vengono riepilogati a partire dai riepiloghi dei loro figli.

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

Compressione progressiva

La compressione progressiva consiste nel ridurre la densità delle informazioni a ogni livello. Una buona regola pratica:

  • Pagina (2000 token) → riepilogo della sezione (200 token) — compressione 10x
  • Riepilogo della sezione (200 token) → riepilogo del capitolo (100 token) — compressione 2x
  • Riepiloghi dei capitoli (5 × 100 token) → documento (150 token) — compressione 3x

Totale: un documento di 10.000 token viene compresso in ~150 token, preservando l'argomentazione principale. Chieda al modello di mantenere il rapporto di compressione a ogni livello.

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

Mantenere la coerenza tra i livelli

Un rischio del riepilogo gerarchico è che i riepiloghi di uno stesso livello possano contraddirsi o ripetersi, e che questi errori si amplifichino salendo nell'albero. Strategie per mantenere la coerenza:

  • Includa nel prompt il titolo della sezione padre, così il modello conoscerà il contesto
  • Chieda al modello di evitare di ripetere fatti già indicati nei riepiloghi delle sezioni precedenti
  • Nella fase reduce finale, chieda esplicitamente al modello di risolvere eventuali contraddizioni
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

Gerarchia di un articolo di ricerca

Gli articoli di ricerca presentano una gerarchia naturale: Abstract → Introduzione → Metodi → Risultati → Discussione → Conclusione. Ogni sezione ha un ruolo distinto, quindi utilizzi prompt specifici per sezione:

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

Gerarchia di un contratto legale

I contratti legali seguono una gerarchia di clausole: definizioni → obblighi → rimedi → risoluzione → legge applicabile. Il riepilogo gerarchico deve preservare:

  • Valori esatti (importi dei pagamenti, scadenze)
  • Nomi delle parti (cliente, fornitore, licenziante)
  • Formulazioni condizionali (a meno che, salvo quando, a condizione che)

Chieda al modello di segnalare ogni clausola con un importo numerico o una condizione che sta riepilogando, affinché non venga eliminata 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

Memorizzare i riepiloghi gerarchici

Memorizzi l'intero albero dei riepiloghi, non solo quello della radice. Questo consente di:

  • Esplorare i dettagli — mostrare il riepilogo del capitolo e poi, su richiesta, quello della sezione
  • Eseguire il retrieval — confrontare la query dell'utente con i riepiloghi delle sezioni, non solo con l'intero documento
  • Aggiornare — quando cambia una sezione, riepilogare nuovamente solo quel ramo dell'albero
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}')

Aggiornamenti incrementali

Quando un documento viene aggiornato, la struttura gerarchica consente il nuovo riepilogo incrementale. Riepiloghi nuovamente solo il nodo modificato e i suoi antenati: tutti i rami fratelli rimangono validi.

Per un libro di 10 capitoli in cui viene rivisto il capitolo 3: riepiloghi nuovamente le sezioni del capitolo 3, poi il capitolo 3 e infine il libro. Ricalcoli 3 nodi invece di tutti i nodi.

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

Confronto tra riepilogo piatto e gerarchico

Map-reduce piatto e riepilogo gerarchico a confronto:

  • Piatto: più semplice, ignora la struttura del documento, migliore per documenti uniformi (articoli di notizie)
  • Gerarchico: rispetta la struttura, consente di esplorare i dettagli, offre una coerenza migliore per i documenti strutturati

Nella pratica, combini entrambi: utilizzi map-reduce piatto all'interno di ogni capitolo (composto da molte pagine), quindi applichi il riepilogo gerarchico tra i capitoli. Questo è l'approccio più solido per i documenti del mondo reale.

Verifica delle conoscenze

Nel riepilogo gerarchico, in quale direzione procede il processo di riepilogo attraverso l'albero del documento?

Riepilogo: riepilogo gerarchico

Il riepilogo gerarchico rispecchia la struttura del documento per ottenere risultati migliori:

  • Rappresenti il documento come un albero: pagine → sezioni → capitoli → documento
  • Riepiloghi dal basso verso l'alto: prima le foglie, per ultima la radice
  • Ogni livello applica una compressione progressiva per mantenere la coerenza
  • È ideale per libri, articoli di ricerca e contratti legali con una struttura gerarchica chiara
  • Memorizzi l'intero albero per abilitare il retrieval con esplorazione dei dettagli e gli aggiornamenti incrementali

La lezione successiva illustra come mantenere il contesto tra i chunk tramite sovrapposizioni e riepiloghi progressivi.

Domande Frequenti

La lezione «Riepilogo gerarchico» è gratuita?

Sì — il testo completo di «Riepilogo gerarchico» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Prompt Engineering, passa a CoddyKit PRO. Il corso AI Prompt Engineering include 4 lezioni in totale.

Cosa imparerò in «Riepilogo gerarchico»?

Compressione progressiva: capitoli → sezioni → riepilogo del documento Eserciti AI Prompt Engineering con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare AI Prompt Engineering?

Non è richiesta alcuna esperienza precedente. AI Prompt Engineering su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Riepilogo gerarchico»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione AI Prompt Engineering?

Sì. Ogni lezione AI Prompt Engineering include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Strategie di chunking per testi lunghi
  2. Schema di riepilogo Map-Reduce
  3. Riepilogo gerarchico
  4. Mantenere il contesto tra i segmenti
← Torna a AI Prompt Engineering