0Pricing
AI Prompt Engineering · Lektion

Hierarchische Zusammenfassung

Progressive Komprimierung: Kapitel → Abschnitte → Dokumentzusammenfassung

Hierarchische Zusammenfassung ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Prompt Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Was sind hierarchische Zusammenfassungen?

Hierarchische Zusammenfassungen spiegeln die Struktur des Dokuments selbst wider. Statt alle Chunks gleich zu behandeln, wird der Inhalt Ebene für Ebene komprimiert:

  • Seiten → Abschnittszusammenfassungen
  • Abschnitte → Kapitelzusammenfassungen
  • Kapitel → Dokumentzusammenfassung

Jede Ebene ist eine komprimierte Darstellung der darunterliegenden Ebene. So fassen Menschen Bücher zusammen: Sie lesen Kapitel, bilden mentale Zusammenfassungen und führen diese anschließend zusammen.

Wann Sie hierarchische Zusammenfassungen verwenden sollten

Hierarchische Zusammenfassungen eignen sich für:

  • Bücher: mehr als 200 Seiten mit klarer Kapitelstruktur
  • Wissenschaftliche Arbeiten: Abstract, Einleitung, Methoden, Ergebnisse, Diskussion
  • Rechtsverträge: Abschnitte mit festgelegten Überschriften (Definitionen, Pflichten, Beendigung)
  • Technische Berichte: Zusammenfassung für die Führungsebene → Ergebnisse → Anhänge

Für kurze Artikel wäre das überdimensioniert. Ihre Stärke zeigt sich bei Dokumenten mit einer natürlichen Baumstruktur.

Dokumentbaumstruktur

Modellieren Sie das Dokument als Baum:

  • Wurzel: abschließende Zusammenfassung
  • Knoten der Ebene 1: Kapitelzusammenfassungen
  • Knoten der Ebene 2: Abschnittszusammenfassungen
  • Blätter: roher Seiten- oder Chunk-Text

Die Zusammenfassung erfolgt von unten nach oben: Blätter → Ebene 2 → Ebene 1 → Wurzel. Die Zusammenfassung jedes Knotens wird ausschließlich aus den Zusammenfassungen seiner Kindknoten abgeleitet.

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

Zusammenfassung von unten nach oben

Durchlaufen Sie den Baum von unten nach oben. Blattknoten werden aus ihrem Rohinhalt zusammengefasst. Interne Knoten werden aus den Zusammenfassungen ihrer Kindknoten zusammengefasst.

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

Progressive Komprimierung

Progressive Komprimierung bedeutet, dass jede Ebene die Informationsdichte reduziert. Als Faustregel gilt:

  • Seite (2000 Tokens) → Abschnittszusammenfassung (200 Tokens) — 10-fache Komprimierung
  • Abschnittszusammenfassung (200 Tokens) → Kapitelzusammenfassung (100 Tokens) — 2-fache Komprimierung
  • Kapitelzusammenfassungen (5 × 100 Tokens) → Dokument (150 Tokens) — 3-fache Komprimierung

Insgesamt wird ein Dokument mit 10.000 Tokens auf ungefähr 150 Tokens komprimiert, wobei die Hauptaussage erhalten bleibt. Formulieren Sie für jede Ebene einen Prompt, der das Komprimierungsverhältnis beibehält.

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

Kohärenz über Ebenen hinweg bewahren

Ein Risiko hierarchischer Zusammenfassungen besteht darin, dass sich Zusammenfassungen auf einer Ebene widersprechen oder wiederholen können und sich diese Fehler nach oben fortpflanzen. Strategien zur Wahrung der Kohärenz:

  • Nehmen Sie die Überschrift des übergeordneten Abschnitts in den Prompt auf, damit das Modell den Kontext kennt
  • Bitten Sie das Modell, Fakten nicht zu wiederholen, die bereits in vorherigen Abschnittszusammenfassungen genannt wurden
  • Bitten Sie das Modell im abschließenden Reduce-Schritt ausdrücklich darum, Widersprüche aufzulösen
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

Hierarchie wissenschaftlicher Arbeiten

Wissenschaftliche Arbeiten haben eine natürliche Hierarchie: Abstract → Einleitung → Methoden → Ergebnisse → Diskussion → Schlussfolgerung. Jeder Abschnitt hat eine eigene Funktion. Verwenden Sie daher abschnittsspezifische Prompts:

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

Hierarchie von Rechtsverträgen

Rechtsverträge folgen einer Klausel-Hierarchie: Definitionen → Pflichten → Rechtsbehelfe → Beendigung → geltendes Recht. Hierarchische Zusammenfassungen müssen Folgendes bewahren:

  • Genaue Zahlenangaben (Zahlungsbeträge, Fristen)
  • Namen der Vertragsparteien (Kunde, Anbieter, Lizenzgeber)
  • Konditionale Formulierungen (es sei denn, außer wenn, vorausgesetzt, dass)

Fordern Sie das Modell auf, beim Zusammenfassen jede Klausel mit einem Zahlenwert oder einer Bedingung zu kennzeichnen, damit sie nicht versehentlich verloren geht.

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

Hierarchische Zusammenfassungen speichern

Speichern Sie den gesamten Zusammenfassungsbaum und nicht nur die Wurzelzusammenfassung. Dadurch wird Folgendes ermöglicht:

  • Drill-down — Kapitelzusammenfassung und anschließend bei Bedarf Abschnittszusammenfassung anzeigen
  • Retrieval — eine Nutzerabfrage mit Abschnittszusammenfassungen statt nur mit dem gesamten Dokument abgleichen
  • Aktualisierung — wenn sich ein Abschnitt ändert, nur diesen Zweig des Baums neu zusammenfassen
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}')

Inkrementelle Aktualisierungen

Wenn ein Dokument aktualisiert wird, ermöglicht die hierarchische Struktur eine inkrementelle Neuzusammenfassung. Fassen Sie nur den geänderten Knoten und seine Vorfahren neu zusammen — alle Geschwisterzweige bleiben gültig.

Bei einem Buch mit 10 Kapiteln, in dem Kapitel 3 überarbeitet wird, fassen Sie die Abschnitte von Kapitel 3, anschließend Kapitel 3 und dann das Buch neu zusammen. Dadurch werden 3 Knoten statt aller Knoten neu berechnet.

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

Flach vs. hierarchisch vergleichen

Flaches Map-Reduce im Vergleich zu hierarchischen Zusammenfassungen:

  • Flach: einfacher, ignoriert die Dokumentstruktur, besser für gleichförmige Dokumente (Nachrichtenartikel)
  • Hierarchisch: berücksichtigt die Struktur, ermöglicht Drill-down und sorgt bei strukturierten Dokumenten für bessere Kohärenz

In der Praxis sollten Sie beides kombinieren: Verwenden Sie flaches Map-Reduce innerhalb jedes Kapitels (bei vielen Seiten) und anschließend eine hierarchische Verarbeitung über die Kapitel hinweg. Das ist der robusteste Ansatz für Dokumente aus der Praxis.

Wissenscheck

In welche Richtung verläuft der Zusammenfassungsprozess bei hierarchischen Zusammenfassungen durch den Dokumentbaum?

Rückblick: Hierarchische Zusammenfassungen

Hierarchische Zusammenfassungen spiegeln die Dokumentstruktur wider und liefern dadurch bessere Ergebnisse:

  • Modellieren Sie das Dokument als Baum: Seiten → Abschnitte → Kapitel → Dokument
  • Fassen Sie von unten nach oben zusammen: zuerst die Blätter, zuletzt die Wurzel
  • Jede Ebene wendet progressive Komprimierung an, um die Kohärenz zu bewahren
  • Am besten geeignet für Bücher, wissenschaftliche Arbeiten und Rechtsverträge mit klarer hierarchischer Struktur
  • Speichern Sie den vollständigen Baum, um Drill-down-Retrieval und inkrementelle Aktualisierungen zu ermöglichen

In der nächsten Lektion geht es darum, mit Überlappungen und fortlaufenden Zusammenfassungen den Kontext über Chunks hinweg zu bewahren.

Häufig gestellte Fragen

Ist die Lektion „Hierarchische Zusammenfassung“ kostenlos?

Ja — der vollständige Text von „Hierarchische Zusammenfassung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Prompt Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Hierarchische Zusammenfassung“?

Progressive Komprimierung: Kapitel → Abschnitte → Dokumentzusammenfassung Du übst AI Prompt Engineering mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Prompt Engineering zu starten?

Keine Vorkenntnisse erforderlich. AI Prompt Engineering auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Hierarchische Zusammenfassung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Prompt Engineering-Lektion Code schreiben und ausführen?

Ja. Jede AI Prompt Engineering-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Chunking-Strategien für lange Texte
  2. Map-Reduce-Muster zur Zusammenfassung
  3. Hierarchische Zusammenfassung
  4. Kontext über Chunks hinweg bewahren
← Zurück zu AI Prompt Engineering