0Pricing
AI Prompt Engineering · Lektion

Map-Reduce-Muster zur Zusammenfassung

Fassen Sie jeden Chunk unabhängig zusammen und führen Sie die Zusammenfassungen anschließend zusammen

Map-Reduce-Muster zur Zusammenfassung ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Das Map-Reduce-Muster

Wenn ein Dokument das LLM-Kontextfenster überschreitet, können Sie es nicht auf einmal übergeben. Das Map-Reduce-Muster löst dieses Problem:

  • Map: jeden Chunk unabhängig zusammenfassen
  • Reduce: alle Chunk-Zusammenfassungen zu einer abschließenden Zusammenfassung zusammenführen

Dies entspricht dem klassischen MapReduce aus verteilten Systemen — dieselbe Teile-und-herrsche-Logik, angewandt auf Sprachaufgaben.

Schritt 1: Die Map-Phase

In der Map-Phase wird jeder Chunk zusammen mit einem Prompt zur Zusammenfassung an das LLM gesendet. Das Modell gibt eine kurze Zusammenfassung ausschließlich dieses Chunks zurück. Diese Zusammenfassungen werden in einer Liste gesammelt.

Jede Zusammenfassung sollte deutlich kürzer als der ursprüngliche Chunk sein — typischerweise 10–20 % der ursprünglichen Länge. Diese Komprimierung macht den Reduce-Schritt überhaupt erst praktikabel.

import openai

client = openai.OpenAI(api_key='sk-...')

def summarize_chunk(chunk, model='gpt-4o'):
    resp = client.chat.completions.create(
        model=model,
        messages=[
            {'role': 'system', 'content': 'Summarize the following text concisely in 3-5 sentences.'},
            {'role': 'user', 'content': chunk}
        ]
    )
    return resp.choices[0].message.content

def map_phase(chunks):
    return [summarize_chunk(c) for c in chunks]

Schritt 2: Die Reduce-Phase

In der Reduce-Phase werden alle Chunk-Zusammenfassungen verkettet und mit einem Prompt zur Zusammenführung an das LLM gesendet. Das Modell erzeugt eine einzige kohärente abschließende Zusammenfassung.

Wenn die Chunk-Zusammenfassungen immer noch zu lang für ein einziges Kontextfenster sind, wenden Sie Reduce rekursiv an — fassen Sie zunächst Gruppen von Zusammenfassungen zusammen und führen Sie diese anschließend zusammen.

def reduce_phase(chunk_summaries, model='gpt-4o'):
    combined = '\n\n'.join(
        f'Section {i+1}:\n{s}'
        for i, s in enumerate(chunk_summaries)
    )
    resp = client.chat.completions.create(
        model=model,
        messages=[
            {'role': 'system', 'content': 'You are given summaries of consecutive sections of a document. Write a single coherent summary of the entire document.'},
            {'role': 'user', 'content': combined}
        ]
    )
    return resp.choices[0].message.content

Zusammensetzen: Raw API

Hier sehen Sie die vollständige Map-Reduce-Pipeline mit direkten Aufrufen der OpenAI API — ohne Framework. Dadurch haben Sie in jeder Phase vollständige Kontrolle über Prompts und Parameter.

def map_reduce_summarize(document, chunk_size=1000):
    chunks = fixed_chunk(document, max_tokens=chunk_size)
    print(f'Chunks: {len(chunks)}')

    chunk_summaries = map_phase(chunks)
    print(f'Map phase complete. Summaries: {len(chunk_summaries)}')

    final_summary = reduce_phase(chunk_summaries)
    return final_summary

with open('long_report.txt') as f:
    doc = f.read()

result = map_reduce_summarize(doc)
print(result)

LangChain MapReduceDocumentsChain

LangChain stellt eine fertige MapReduceDocumentsChain bereit, die das Chunking, parallele Map-Aufrufe und den Reduce-Schritt übernimmt. Das ist praktisch, aber weniger flexibel als direkte API-Aufrufe.

from langchain_openai import ChatOpenAI
from langchain.chains.summarize import load_summarize_chain
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.docstore.document import Document

llm = ChatOpenAI(model='gpt-4o', openai_api_key='sk-...')
splitter = RecursiveCharacterTextSplitter(chunk_size=3000, chunk_overlap=200)

with open('long_report.txt') as f:
    text = f.read()

docs = splitter.create_documents([text])
chain = load_summarize_chain(llm, chain_type='map_reduce')
result = chain.invoke(docs)
print(result['output_text'])

Die Map-Phase parallelisieren

Jede Chunk-Zusammenfassung ist unabhängig, daher kann die Map-Phase parallelisiert werden. Mit Pythons ThreadPoolExecutor werden alle API-Aufrufe für die Chunks gleichzeitig gesendet, wodurch sich die tatsächliche Laufzeit deutlich verkürzt.

from concurrent.futures import ThreadPoolExecutor, as_completed

def map_phase_parallel(chunks, max_workers=10):
    summaries = [None] * len(chunks)
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = {
            executor.submit(summarize_chunk, chunk): i
            for i, chunk in enumerate(chunks)
        }
        for future in as_completed(futures):
            idx = futures[future]
            summaries[idx] = future.result()
    return summaries

Rekursives Reduce

Bei sehr langen Dokumenten können die Chunk-Zusammenfassungen selbst das Kontextfenster überschreiten. Wenden Sie Reduce rekursiv an: Gruppieren Sie die Zusammenfassungen in Batches, reduzieren Sie jeden Batch und reduzieren Sie anschließend die Batch-Zusammenfassungen.

def recursive_reduce(summaries, batch_size=10):
    while len(summaries) > 1:
        batches = [
            summaries[i:i + batch_size]
            for i in range(0, len(summaries), batch_size)
        ]
        summaries = [reduce_phase(batch) for batch in batches]
        print(f'Reduced to {len(summaries)} summaries')
    return summaries[0]

Wichtige Details bewahren

Ein häufiger Fehler des naiven Map-Reduce-Verfahrens besteht darin, dass wichtige Details bei der Komprimierung verloren gehen. Gegenmaßnahmen:

  • Fordern Sie im Map-Schritt dazu auf, Namen, Zahlen und Datumsangaben zu bewahren
  • Bitten Sie den Reduce-Schritt, auf Widersprüche zwischen Abschnitten zu prüfen
  • Verwenden Sie eine größere Chunk-Größe, damit der Kontext der Map-Phase umfangreicher ist
  • Führen Sie einen Verifizierungsschritt durch: Fragen Sie das Modell, ob wichtige Entitäten aus dem Original in der abschließenden Zusammenfassung vorkommen
MAP_PROMPT = '''Summarize the following section in 5 sentences.
Preserve all key names, numbers, dates, and conclusions.

Section:
{chunk}'''

Refine-Chain: Ein alternatives Muster

Die Refine-Chain ist eine Alternative zu Map-Reduce. Sie verarbeitet Chunks sequenziell: Die Zusammenfassung von Chunk N wird zusammen mit Chunk N+1 übergeben, und das Modell aktualisiert die fortlaufende Zusammenfassung. Dadurch entstehen kohärentere Ausgaben, aber die Verarbeitung kann nicht parallelisiert werden und ist langsamer.

Verwenden Sie Refine, wenn die narrative Kohärenz wichtig ist (z. B. bei Rechtsverträgen). Verwenden Sie Map-Reduce, wenn die Geschwindigkeit entscheidend ist (z. B. bei Stapeln von Nachrichtenartikeln).

def refine_summarize(chunks):
    current_summary = summarize_chunk(chunks[0])
    for chunk in chunks[1:]:
        prompt = (
            f'Existing summary:\n{current_summary}\n\n'
            f'New section:\n{chunk}\n\n'
            'Update the summary to incorporate the new section.'
        )
        resp = client.chat.completions.create(
            model='gpt-4o',
            messages=[{'role': 'user', 'content': prompt}]
        )
        current_summary = resp.choices[0].message.content
    return current_summary

Kosten- und Tokenverwaltung

Map-Reduce erfordert viele API-Aufrufe. Für ein Dokument mit 100 Chunks und gpt-4o zu 5 $ pro 1 Mio. Eingabetokens:

  • Map: 100 Chunks × 1000 Tokens = 100.000 Eingabetokens ≈ 0,50 $
  • Reduce: ungefähr 10.000 Tokens (Zusammenfassungen) ≈ 0,05 $
  • Gesamt: ungefähr 0,55 $ pro Dokument

Um Kosten zu senken, verwenden Sie gpt-4o-mini für die Map-Phase (0,15 $ pro 1 Mio. Tokens) und gpt-4o nur für Reduce. Dieser hybride Ansatz senkt die Kosten bei minimalem Qualitätsverlust um 70 %.

def map_phase_cheap(chunks):
    # Use mini model for map — cheaper, sufficient for chunk summaries
    return [
        summarize_chunk(c, model='gpt-4o-mini')
        for c in chunks
    ]

def reduce_phase_quality(summaries):
    # Use full model for final synthesis
    return reduce_phase(summaries, model='gpt-4o')

Wann Sie Map-Reduce verwenden sollten

Die Zusammenfassung mit Map-Reduce eignet sich am besten für:

  • Dokumente, die länger als das Kontextfenster des Modells sind
  • Die stapelweise Zusammenfassung vieler Dokumente (parallelisieren Sie zusätzlich auf Dokumentebene)
  • Situationen, in denen Sie den Prompt für jeden Schritt kontrollieren müssen

Weniger geeignet ist es für: das Extrahieren einer bestimmten Tatsache (verwenden Sie stattdessen Retrieval) oder Dokumente, die kurz genug für das Kontextfenster sind (fassen Sie sie einfach direkt zusammen).

Wissenscheck

Was geschieht beim Map-Reduce-Muster für Zusammenfassungen während der Reduce-Phase?

Rückblick: Map-Reduce-Zusammenfassungen

Das Map-Reduce-Muster verarbeitet Dokumente, die zu lang für einen einzelnen LLM-Aufruf sind:

  • Map: jeden Chunk unabhängig zusammenfassen — kann parallelisiert werden
  • Reduce: die Chunk-Zusammenfassungen zu einer abschließenden Zusammenfassung zusammenführen
  • Rekursives Reduce: anwenden, wenn die Zusammenfassungen selbst zu lang sind
  • Kostentipp: ein günstiges Modell für Map und ein leistungsfähiges Modell für Reduce verwenden

LangChains MapReduceDocumentsChain bietet eine fertige Implementierung. In der nächsten Lektion geht es um hierarchische Zusammenfassungen von Büchern und wissenschaftlichen Arbeiten.

Häufig gestellte Fragen

Ist die Lektion „Map-Reduce-Muster zur Zusammenfassung“ kostenlos?

Ja — der vollständige Text von „Map-Reduce-Muster zur 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 „Map-Reduce-Muster zur Zusammenfassung“?

Fassen Sie jeden Chunk unabhängig zusammen und führen Sie die Zusammenfassungen anschließend zusammen 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 2 von 4.

Wie lange dauert die Lektion „Map-Reduce-Muster zur 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