AI Prompt Engineering · Lezione

Schema di riepilogo Map-Reduce

Riassuma ogni segmento indipendentemente, quindi sintetizzi i riepiloghi

Schema di riepilogo Map-Reduce è una lezione AI Prompt Engineering gratuita su CoddyKit. Questa è la lezione 2 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.

Il pattern map-reduce

Quando un documento supera la finestra di contesto dell'LLM, non può passarlo tutto in una volta. Il pattern map-reduce risolve questo problema:

Map: riepiloga ogni chunk in modo indipendente
Reduce: sintetizza tutti i riepiloghi dei chunk in un unico riepilogo finale

Questo rispecchia il MapReduce classico dei sistemi distribuiti: la stessa logica divide et impera applicata alle attività linguistiche.

Passaggio 1: la fase map

Nella fase map, ogni chunk viene inviato all'LLM insieme a un prompt di riepilogo. Il modello restituisce un breve riepilogo limitato a quel chunk. I riepiloghi vengono raccolti in un elenco.

Ogni riepilogo dovrebbe essere molto più breve del chunk originale, in genere il 10–20% della lunghezza originale. È questa compressione a rendere possibile la fase reduce.

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]

Passaggio 2: la fase reduce

Nella fase reduce, tutti i riepiloghi dei chunk vengono concatenati e inviati all'LLM insieme a un prompt di sintesi. Il modello produce un unico riepilogo finale coerente.

Se i riepiloghi dei chunk sono ancora troppo lunghi per entrare in un'unica finestra di contesto, applichi reduce ricorsivamente: riepiloghi prima gruppi di riepiloghi, quindi li sintetizzi.

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

Assemblaggio completo: API dirette

Ecco la pipeline map-reduce completa usando chiamate dirette all'API di OpenAI, senza alcun framework. In questo modo ha il pieno controllo sui prompt e sui parametri di ogni fase.

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 mette a disposizione una MapReduceDocumentsChain già pronta, che gestisce la suddivisione in chunk, le chiamate map parallele e la fase reduce. È comoda, ma meno flessibile delle chiamate dirette all'API.

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

Parallelizzare la fase map

Il riepilogo di ogni chunk è indipendente, quindi la fase map può essere parallelizzata. Usando ThreadPoolExecutor di Python, tutte le chiamate API per i chunk vengono inviate contemporaneamente, riducendo drasticamente il tempo effettivo di esecuzione.

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

Reduce ricorsivo

Quando un documento è molto lungo, gli stessi riepiloghi dei chunk potrebbero superare la finestra di contesto. Applichi reduce in modo ricorsivo: raggruppi i riepiloghi in batch, riduca ogni batch, quindi riduca i riepiloghi dei batch.

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]

Conservare i dettagli importanti

Un errore comune del map-reduce ingenuo è la perdita di dettagli importanti durante la compressione. Possibili rimedi:

Chieda al modello, nel passaggio map, di conservare nomi, numeri e date
Chieda al modello, nel passaggio reduce, di verificare la presenza di contraddizioni tra le sezioni
Utilizzi chunk più grandi, così il contesto della fase map sarà più ricco
Esegua un passaggio di verifica: chieda al modello se le entità principali dell'originale compaiono nel riepilogo finale

MAP_PROMPT = '''Summarize the following section in 5 sentences.
Preserve all key names, numbers, dates, and conclusions.

Section:
{chunk}'''

Refine chain: un pattern alternativo

La refine chain è un'alternativa a map-reduce. Elabora i chunk in sequenza: il riepilogo del chunk N viene passato insieme al chunk N+1 e il modello aggiorna il riepilogo progressivo. Il risultato è più coerente, ma il processo non può essere parallelizzato ed è più lento.

Utilizzi refine quando la coerenza narrativa è importante (ad esempio, nei contratti legali). Utilizzi map-reduce quando la velocità è importante (ad esempio, nei batch di articoli di notizie).

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

Gestione dei costi e dei token

Map-reduce comporta numerose chiamate API. Per un documento di 100 chunk con gpt-4o a 5 $ per 1M di token di input:

Map: 100 chunk × 1000 token = 100k token di input ≈ 0,50 $
Reduce: ~10k token (riepiloghi) ≈ 0,05 $
Totale: ~0,55 $ per documento

Per ridurre i costi: utilizzi gpt-4o-mini per la fase map (0,15 $ per 1M) e gpt-4o solo per reduce. Questo approccio ibrido riduce i costi del 70% con una perdita di qualità minima.

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

Quando usare map-reduce

Il riepilogo map-reduce è ideale per:

Documenti più lunghi della finestra di contesto del modello
Riepilogare molti documenti in batch (parallelizzando anche a livello di documento)
Situazioni in cui è necessario controllare il prompt a ogni passaggio

È meno adatto per estrarre un fatto specifico (utilizzi invece il retrieval) o quando il documento è abbastanza breve da entrare nel contesto (in tal caso lo riepiloghi direttamente).

Verifica delle conoscenze

Nel pattern di riepilogo map-reduce, che cosa accade durante la fase reduce?

Riepilogo: riepilogo map-reduce

Il pattern map-reduce gestisce documenti troppo lunghi per una singola chiamata all'LLM:

Map: riepiloga ogni chunk in modo indipendente — può essere parallelizzato
Reduce: sintetizza i riepiloghi dei chunk in un unico riepilogo finale
Reduce ricorsivo: si applica quando anche i riepiloghi sono troppo lunghi
Consiglio sui costi: utilizzi un modello economico per map e un modello di qualità per reduce

Il MapReduceDocumentsChain di LangChain offre un'implementazione già pronta. La lezione successiva illustra il riepilogo gerarchico per libri e articoli di ricerca.

Domande Frequenti

La lezione «Schema di riepilogo Map-Reduce» è gratuita?

Sì — il testo completo di «Schema di riepilogo Map-Reduce» è 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 «Schema di riepilogo Map-Reduce»?

Riassuma ogni segmento indipendentemente, quindi sintetizzi i riepiloghi 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 2 di 4.

Quanto tempo richiede la lezione «Schema di riepilogo Map-Reduce»?

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

← Torna a AI Prompt Engineering