0Pricing
AI Prompt Engineering · Leçon

Modèle de résumé Map-Reduce

Résumez chaque segment indépendamment, puis synthétisez les résumés.

Modèle de résumé Map-Reduce est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 2 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.

Le modèle de mappage-réduction

Lorsqu’un document dépasse la fenêtre de contexte du LLM, vous ne pouvez pas le transmettre en une seule fois. Le modèle de mappage-réduction résout ce problème :

  • Mappage : synthétiser chaque segment indépendamment
  • Réduction : réunir les synthèses de tous les segments en une synthèse finale unique

Ce modèle reprend le MapReduce classique des systèmes distribués — la même logique de division pour mieux régner, appliquée aux tâches liées au langage.

Étape 1 : la phase de mappage

Lors de la phase de mappage, chaque segment est envoyé au LLM avec une consigne de synthèse. Le modèle renvoie une courte synthèse de ce seul segment. Ces synthèses sont réunies dans une liste.

Chaque synthèse doit être beaucoup plus courte que le segment d’origine — généralement 10 à 20 % de sa longueur initiale. C’est cette compression qui rend l’étape de réduction réalisable.

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]

Étape 2 : la phase de réduction

Lors de la phase de réduction, toutes les synthèses de segments sont concaténées et envoyées au LLM avec une consigne de synthèse. Le modèle produit une seule synthèse finale cohérente.

Si les synthèses de segments sont encore trop longues pour tenir dans une seule fenêtre de contexte, appliquez la réduction de manière récursive : synthétisez d’abord des groupes de synthèses, puis réunissez ces résultats.

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

Mise en pratique : API brute

Voici le pipeline complet de mappage-réduction utilisant des appels directs à l’API OpenAI — aucune infrastructure n’est requise. Vous disposez ainsi d’un contrôle total sur les consignes et les paramètres de chaque phase.

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)

MapReduceDocumentsChain de LangChain

LangChain fournit une MapReduceDocumentsChain prête à l’emploi qui gère la segmentation, les appels de mappage parallèles et l’étape de réduction. Elle est pratique, mais moins flexible que les appels directs à l’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'])

Paralléliser la phase de mappage

Chaque synthèse de segment est indépendante ; la phase de mappage peut donc être parallélisée. Avec le ThreadPoolExecutor de Python, tous les appels d’API liés aux segments sont envoyés simultanément, ce qui réduit considérablement le temps réel écoulé.

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

Réduction récursive

Lorsqu’un document est très long, les synthèses des segments peuvent elles-mêmes dépasser la fenêtre de contexte. Appliquez la réduction de manière récursive : regroupez les synthèses par lots, réduisez chaque lot, puis réduisez les synthèses des lots.

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]

Préserver les détails importants

Une défaillance fréquente du mappage-réduction naïf est la perte de détails importants pendant la compression. Mesures d’atténuation :

  • Demandez à la phase de mappage de préserver les noms, nombres et dates
  • Demandez à la phase de réduction de rechercher les contradictions entre les sections
  • Utilisez une taille de segment plus grande afin que le contexte de mappage soit plus riche
  • Effectuez une passe de vérification : demandez au modèle si les entités importantes du document d’origine apparaissent dans la synthèse finale
MAP_PROMPT = '''Summarize the following section in 5 sentences.
Preserve all key names, numbers, dates, and conclusions.

Section:
{chunk}'''

Chaîne de raffinement : un autre modèle

La chaîne de raffinement constitue une autre approche que le mappage-réduction. Elle traite les segments séquentiellement : la synthèse du segment N est transmise avec le segment N+1, puis le modèle met à jour la synthèse en cours. Cette approche produit un résultat plus cohérent, mais ne peut pas être parallélisée et est plus lente.

Utilisez le raffinement lorsque la cohérence narrative est importante (par exemple, pour des contrats juridiques). Utilisez le mappage-réduction lorsque la rapidité est importante (par exemple, pour des lots d’articles d’actualité).

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

Gestion des coûts et des jetons

Le mappage-réduction nécessite de nombreux appels d’API. Pour un document de 100 segments avec gpt-4o à 5 $ pour 1 million de jetons d’entrée :

  • Mappage : 100 segments × 1 000 jetons = 100 000 jetons d’entrée ≈ 0,50 $
  • Réduction : environ 10 000 jetons (synthèses) ≈ 0,05 $
  • Total : environ 0,55 $ par document

Pour réduire les coûts, utilisez gpt-4o-mini pour la phase de mappage (0,15 $ pour 1 million de jetons) et gpt-4o uniquement pour la réduction. Cette approche hybride réduit les coûts de 70 % avec une perte de qualité minimale.

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

Quand utiliser le mappage-réduction

La synthèse par mappage-réduction est particulièrement adaptée aux situations suivantes :

  • Documents plus longs que la fenêtre de contexte du modèle
  • Synthèse par lots de nombreux documents (parallélisez également au niveau des documents)
  • Situations dans lesquelles vous devez contrôler la consigne à chaque étape

Elle est moins adaptée à l’extraction d’un fait précis (utilisez plutôt la récupération) ou lorsque le document est suffisamment court pour tenir dans le contexte (synthétisez-le directement).

Vérification des connaissances

Dans le modèle de synthèse par mappage-réduction, que se passe-t-il pendant la phase de réduction ?

Récapitulatif : synthèse par mappage-réduction

Le modèle de mappage-réduction traite les documents trop longs pour un seul appel au LLM :

  • Mappage : synthétiser chaque segment indépendamment — peut être parallélisé
  • Réduction : réunir les synthèses des segments en une synthèse finale unique
  • Réduction récursive : à appliquer lorsque les synthèses elles-mêmes sont trop longues
  • Conseil pour réduire les coûts : utiliser un modèle économique pour le mappage et un modèle de qualité pour la réduction

Le MapReduceDocumentsChain de LangChain fournit une implémentation prête à l’emploi. La prochaine leçon porte sur la synthèse hiérarchique des livres et des articles de recherche.

Questions Fréquemment Posées

La leçon « Modèle de résumé Map-Reduce » est-elle gratuite ?

Oui — le texte complet de « Modèle de résumé Map-Reduce » 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 « Modèle de résumé Map-Reduce » ?

Résumez chaque segment indépendamment, puis synthétisez les résumés. 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 2 sur 4.

Combien de temps prend la leçon « Modèle de résumé Map-Reduce » ?

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

  1. Stratégies de segmentation des textes longs
  2. Modèle de résumé Map-Reduce
  3. Résumé hiérarchique
  4. Maintenir le contexte entre les segments
← Retour à AI Prompt Engineering