AI Prompt Engineering · Leçon

Résumé hiérarchique

Compressez progressivement le contenu : chapitres → sections → résumé du document.

Leçon 3 sur 413 étapes

Résumé hiérarchique est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 4 leçons au total.

Qu’est-ce que la synthèse hiérarchique ?

La synthèse hiérarchique reprend la structure du document lui-même. Plutôt que de traiter tous les segments de la même façon, elle compresse le contenu niveau par niveau :

Pages → synthèses de sections
Sections → synthèses de chapitres
Chapitres → synthèse du document

Chaque niveau est une représentation compressée du niveau inférieur. C’est ainsi que les êtres humains résument les livres : ils lisent les chapitres, forment des synthèses mentales, puis les intègrent.

Quand utiliser la synthèse hiérarchique

La synthèse hiérarchique est le bon choix pour :

Les livres : plus de 200 pages avec une structure claire en chapitres
Les articles de recherche : résumé, introduction, méthodes, résultats, discussion
Les contrats juridiques : sections avec des titres définis (définitions, obligations, résiliation)
Les rapports techniques : résumé exécutif → résultats → annexes

Elle est excessive pour les articles courts. Elle est particulièrement efficace lorsque le document possède une structure arborescente naturelle.

Structure arborescente du document

Représentez le document sous forme d’arbre :

Racine : synthèse finale
Nœuds de niveau 1 : synthèses de chapitres
Nœuds de niveau 2 : synthèses de sections
Feuilles : texte brut d’une page ou d’un segment

La synthèse progresse de bas en haut : feuilles → niveau 2 → niveau 1 → racine. La synthèse de chaque nœud est dérivée uniquement des synthèses de ses enfants.

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

Synthèse de bas en haut

Parcourez l’arbre de bas en haut. Les nœuds feuilles sont synthétisés à partir de leur contenu brut. Les nœuds internes sont synthétisés à partir des synthèses de leurs enfants.

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

Compression progressive

La compression progressive signifie que chaque niveau réduit la densité de l’information. Voici une règle générale utile :

Page (2 000 jetons) → synthèse de section (200 jetons) — compression d’un facteur 10
Synthèse de section (200 jetons) → synthèse de chapitre (100 jetons) — compression d’un facteur 2
Synthèses de chapitres (5 × 100 jetons) → document (150 jetons) — compression d’un facteur 3

Au total, un document de 10 000 jetons est compressé en environ 150 jetons tout en conservant l’argument principal. Demandez à chaque niveau de maintenir le taux de compression.

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

Maintenir la cohérence entre les niveaux

La synthèse hiérarchique présente un risque : les synthèses d’un même niveau peuvent se contredire ou se répéter, et ces erreurs se propagent en s’amplifiant vers les niveaux supérieurs. Stratégies pour maintenir la cohérence :

Incluez le titre de la section parente dans la consigne afin que le modèle connaisse le contexte
Demandez au modèle d’éviter de répéter les faits déjà énoncés dans les synthèses des sections précédentes
À l’étape finale de réduction, demandez explicitement au modèle de résoudre toute contradiction

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

Hiérarchie d’un article de recherche

Les articles de recherche possèdent une hiérarchie naturelle : Résumé → Introduction → Méthodes → Résultats → Discussion → Conclusion. Chaque section joue un rôle distinct ; utilisez donc des consignes propres à chaque section :

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

Hiérarchie d’un contrat juridique

Les contrats juridiques suivent une hiérarchie de clauses : définitions → obligations → voies de recours → résiliation → droit applicable. La synthèse hiérarchique doit préserver :

Les chiffres exacts (montants des paiements, échéances)
Les noms des parties (client, fournisseur, concédant)
Les formulations conditionnelles (à moins que, sauf lorsque, à condition que)

Demandez au modèle de signaler toute clause comportant un montant numérique ou une condition qu’il synthétise, afin qu’elle ne soit pas supprimée accidentellement.

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

Stocker les synthèses hiérarchiques

Stockez l’arbre de synthèse complet, et pas seulement la synthèse de la racine. Cela permet :

L’exploration détaillée — afficher la synthèse du chapitre, puis celle de la section à la demande
La récupération — comparer la requête d’un utilisateur aux synthèses de sections, et pas seulement à l’intégralité du document
La mise à jour — lorsqu’une section change, resynthétiser uniquement cette branche de l’arbre

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

Mises à jour incrémentielles

Lorsqu’un document est mis à jour, sa structure hiérarchique permet une resynthèse incrémentielle. Resynthétisez uniquement le nœud modifié et ses ancêtres ; toutes les branches sœurs restent valides.

Pour un livre de 10 chapitres dont le chapitre 3 est révisé : resynthétisez les sections du chapitre 3, puis le chapitre 3, puis le livre. Recalculez 3 nœuds au lieu de tous les nœuds.

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

Comparaison entre synthèse à plat et synthèse hiérarchique

Mappage-réduction à plat contre synthèse hiérarchique :

À plat : plus simple, ignore la structure du document, mieux adaptée aux documents uniformes (articles d’actualité)
Hiérarchique : respecte la structure, permet l’exploration détaillée, offre une meilleure cohérence pour les documents structurés

En pratique, combinez les deux approches : utilisez le mappage-réduction à plat dans chaque chapitre (composé de nombreuses pages), puis appliquez la synthèse hiérarchique entre les chapitres. Il s’agit de l’approche la plus robuste pour les documents du monde réel.

Vérification des connaissances

Dans la synthèse hiérarchique, dans quelle direction le processus de synthèse progresse-t-il dans l’arbre du document ?

Réponds-y dans la leçon interactive

Récapitulatif : synthèse hiérarchique

La synthèse hiérarchique reprend la structure du document pour obtenir de meilleurs résultats :

Représentez le document sous forme d’un arbre : pages → sections → chapitres → document
Synthétisez de bas en haut : les feuilles d’abord, la racine en dernier
Chaque niveau applique une compression progressive pour maintenir la cohérence
Cette approche convient particulièrement aux livres, aux articles de recherche et aux contrats juridiques dotés d’une structure hiérarchique claire
Stockez l’arbre complet pour permettre la récupération par exploration détaillée et les mises à jour incrémentielles

Prochaine leçon : maintenir le contexte entre les segments grâce au chevauchement et aux synthèses glissantes.

Gratuit pour commencer

Apprends AI Prompt Engineering avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 53
Leçons: 199

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Résumé hiérarchique » est-elle gratuite ?

Oui — le texte complet de « Résumé hiérarchique » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Résumé hiérarchique » ?

Compressez progressivement le contenu : chapitres → sections → résumé du document. Tu pratiques AI Prompt Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Prompt Engineering ?

Aucune expérience préalable n'est requise. AI Prompt Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Résumé hiérarchique » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Prompt Engineering ?

Oui. Chaque leçon AI Prompt Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Stratégies de segmentation des textes longs
Modèle de résumé Map-Reduce
Résumé hiérarchique
Maintenir le contexte entre les segments

← Retour à AI Prompt Engineering