0Pricing
AI Prompt Engineering · Lekcja

Podsumowywanie hierarchiczne

Stopniowa kompresja: rozdziały → sekcje → podsumowanie dokumentu.

Podsumowywanie hierarchiczne to bezpłatna lekcja AI Prompt Engineering na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Prompt Engineering, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.

Czym jest hierarchiczne podsumowywanie

Hierarchiczne podsumowywanie odzwierciedla strukturę samego dokumentu. Zamiast traktować wszystkie fragmenty jednakowo, kompresuje treść poziom po poziomie:

  • Strony → podsumowania sekcji
  • Sekcje → podsumowania rozdziałów
  • Rozdziały → podsumowanie dokumentu

Każdy poziom jest skompresowaną reprezentacją poziomu poniżej. Tak właśnie ludzie podsumowują książki — czytają rozdziały, tworzą podsumowania w myślach, a następnie je integrują.

Kiedy stosować hierarchiczne podsumowywanie

Hierarchiczne podsumowywanie jest właściwym wyborem w przypadku:

  • książek: co najmniej 200 stron, z wyraźną strukturą rozdziałów
  • artykułów naukowych: abstrakt, wprowadzenie, metody, wyniki, dyskusja
  • umów prawnych: sekcje z określonymi nagłówkami (definicje, zobowiązania, rozwiązanie umowy)
  • raportów technicznych: streszczenie zarządcze → ustalenia → załączniki

W przypadku krótkich artykułów jest to rozwiązanie przesadne. Metoda ta sprawdza się szczególnie wtedy, gdy dokument ma naturalną strukturę drzewa.

Struktura drzewa dokumentu

Dokument należy modelować jako drzewo:

  • Korzeń: podsumowanie końcowe
  • Węzły poziomu 1: podsumowania rozdziałów
  • Węzły poziomu 2: podsumowania sekcji
  • Liście: surowy tekst strony lub fragmentu

Podsumowywanie przebiega od dołu do góry: liście → poziom 2 → poziom 1 → korzeń. Podsumowanie każdego węzła wynika wyłącznie z podsumowań jego węzłów potomnych.

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

Podsumowywanie od dołu do góry

Drzewo należy przechodzić od dołu do góry. Węzły liści są podsumowywane na podstawie surowej treści. Węzły wewnętrzne są podsumowywane na podstawie podsumowań węzłów potomnych.

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

Stopniowa kompresja

Stopniowa kompresja oznacza, że każdy poziom zmniejsza gęstość informacji. Przydatna reguła orientacyjna:

  • Strona (2000 tokenów) → podsumowanie sekcji (200 tokenów) — kompresja 10x
  • Podsumowanie sekcji (200 tokenów) → podsumowanie rozdziału (100 tokenów) — kompresja 2x
  • Podsumowania rozdziałów (5 × 100 tokenów) → dokument (150 tokenów) — kompresja 3x

Łącznie dokument o długości 10 000 tokenów zostaje skompresowany do około 150 tokenów przy zachowaniu głównego argumentu. W promptach dla każdego poziomu należy zachować współczynnik kompresji.

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

Zachowywanie spójności między poziomami

Ryzyko związane z hierarchicznym podsumowywaniem polega na tym, że podsumowania na jednym poziomie mogą sobie przeczyć lub wzajemnie się powtarzać, a te błędy kumulują się na wyższych poziomach. Strategie zachowywania spójności:

  • Uwzględnić w prompcie nagłówek sekcji nadrzędnej, aby model znał kontekst
  • Poprosić model o unikanie powtarzania faktów podanych już we wcześniejszych podsumowaniach sekcji
  • W końcowym kroku redukcji wyraźnie poprosić model o rozwiązanie wszelkich sprzeczności
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

Hierarchia artykułu naukowego

Artykuły naukowe mają naturalną hierarchię: Abstrakt → Wprowadzenie → Metody → Wyniki → Dyskusja → Wnioski. Każda sekcja pełni odrębną funkcję, dlatego należy używać promptów dostosowanych do sekcji:

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

Hierarchia umowy prawnej

Umowy prawne mają hierarchię klauzul: definicje → zobowiązania → środki ochrony prawnej → rozwiązanie umowy → prawo właściwe. Hierarchiczne podsumowywanie musi zachować:

  • Dokładne wartości (kwoty płatności, terminy)
  • Nazwy stron (klient, dostawca, licencjodawca)
  • Sformułowania warunkowe (chyba że, z wyjątkiem gdy, pod warunkiem że)

Należy poinstruować model, aby oznaczał każdą podsumowywaną klauzulę zawierającą wartość liczbową lub warunek, tak aby nie została przypadkowo pominięta.

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

Przechowywanie hierarchicznych podsumowań

Należy przechowywać całe drzewo podsumowań, a nie tylko podsumowanie korzenia. Umożliwia to:

  • Przechodzenie do szczegółów — wyświetlenie podsumowania rozdziału, a następnie na żądanie podsumowania sekcji
  • Wyszukiwanie — dopasowanie zapytania użytkownika do podsumowań sekcji, a nie tylko do całego dokumentu
  • Aktualizację — gdy zmieni się jedna sekcja, ponowne podsumowanie tylko tej gałęzi drzewa
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}')

Przyrostowe aktualizacje

Gdy dokument zostaje zaktualizowany, struktura hierarchiczna umożliwia przyrostowe ponowne podsumowywanie. Należy ponownie podsumować tylko zmodyfikowany węzeł i jego przodków — wszystkie pozostałe gałęzie pozostają aktualne.

W przypadku książki składającej się z 10 rozdziałów, w której zmieniono rozdział 3, należy ponownie podsumować sekcje rozdziału 3, następnie rozdział 3, a na końcu książkę. Wymaga to ponownego obliczenia 3 węzłów zamiast wszystkich.

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

Porównanie podejścia płaskiego i hierarchicznego

Płaskie map-reduce a hierarchiczne podsumowywanie:

  • Płaskie: prostsze, ignoruje strukturę dokumentu, lepsze w przypadku jednorodnych dokumentów (artykułów informacyjnych)
  • Hierarchiczne: uwzględnia strukturę, umożliwia przechodzenie do szczegółów, zapewnia lepszą spójność w przypadku dokumentów o uporządkowanej strukturze

W praktyce warto połączyć oba podejścia: użyć płaskiego map-reduce w obrębie każdego rozdziału (obejmującego wiele stron), a następnie zastosować hierarchię między rozdziałami. Jest to najbardziej niezawodne podejście w przypadku dokumentów spotykanych w praktyce.

Sprawdzenie wiedzy

W jakim kierunku przebiega proces podsumowywania w drzewie dokumentu podczas hierarchicznego podsumowywania?

Podsumowanie: hierarchiczne podsumowywanie

Hierarchiczne podsumowywanie odzwierciedla strukturę dokumentu, zapewniając lepsze wyniki:

  • Modeluj dokument jako drzewo: strony → sekcje → rozdziały → dokument
  • Podsumowuj od dołu do góry: najpierw liście, na końcu korzeń
  • Na każdym poziomie stosuj stopniową kompresję, aby zachować spójność
  • Metoda najlepiej sprawdza się w przypadku książek, artykułów naukowych i umów prawnych o wyraźnej strukturze hierarchicznej
  • Przechowuj całe drzewo, aby umożliwić wyszukiwanie z przechodzeniem do szczegółów i przyrostowe aktualizacje

Następna lekcja: zachowywanie kontekstu między fragmentami za pomocą nakładania i podsumowań kroczących.

Często zadawane pytania

Czy lekcja „Podsumowywanie hierarchiczne” jest bezpłatna?

Tak — pełny tekst „Podsumowywanie hierarchiczne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Prompt Engineering, przejdź na CoddyKit PRO. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.

Co nauczysz się w „Podsumowywanie hierarchiczne”?

Stopniowa kompresja: rozdziały → sekcje → podsumowanie dokumentu. Ćwiczysz AI Prompt Engineering z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Prompt Engineering?

Nie wymagamy żadnego doświadczenia. AI Prompt Engineering w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Podsumowywanie hierarchiczne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Prompt Engineering?

Tak. Każda lekcja AI Prompt Engineering zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Strategie dzielenia długich tekstów na fragmenty
  2. Wzorzec podsumowywania Map-Reduce
  3. Podsumowywanie hierarchiczne
  4. Zachowywanie kontekstu między fragmentami
← Powrót do AI Prompt Engineering