0Pricing
AI Prompt Engineering · Aula

Padrão de sumarização Map-Reduce

Resuma cada parte de forma independente e depois sintetize os resumos.

Padrão de sumarização Map-Reduce é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

O padrão de mapeamento e redução

Quando um documento excede a janela de contexto do LLM, não é possível enviá-lo inteiro de uma só vez. O padrão de mapeamento e redução resolve esse problema:

  • Mapeamento: resumir cada fragmento de forma independente
  • Redução: sintetizar todos os resumos dos fragmentos em um único resumo final

Isso reproduz o MapReduce clássico dos sistemas distribuídos — a mesma lógica de dividir para conquistar aplicada a tarefas de linguagem.

Etapa 1: a fase de mapeamento

Na fase de mapeamento, cada fragmento é enviado ao LLM com uma instrução de sumarização. O modelo retorna um resumo curto somente daquele fragmento. Esses resumos são reunidos em uma lista.

Cada resumo deve ser muito mais curto que o fragmento original — normalmente, ter de 10% a 20% do tamanho original. É essa compressão que torna a etapa de redução viável.

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]

Etapa 2: a fase de redução

Na fase de redução, todos os resumos dos fragmentos são concatenados e enviados ao LLM com uma instrução de síntese. O modelo produz um único resumo final coerente.

Se os resumos dos fragmentos ainda forem longos demais para caber em uma única janela de contexto, aplique a redução recursivamente — resuma primeiro grupos de resumos e depois sintetize esses resultados.

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

Integração: API bruta

Aqui está o fluxo completo de mapeamento e redução usando chamadas diretas à API da OpenAI — sem necessidade de uma estrutura. Isso oferece controle total sobre as instruções e os parâmetros em cada 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)

MapReduceDocumentsChain do LangChain

O LangChain oferece uma MapReduceDocumentsChain pronta que lida com a fragmentação, as chamadas paralelas da fase de mapeamento e a etapa de redução. Ela é conveniente, mas menos flexível que as chamadas diretas à 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'])

Paralelização da fase de mapeamento

O resumo de cada fragmento é independente, portanto a fase de mapeamento pode ser paralelizada. Usando o ThreadPoolExecutor do Python, todas as chamadas à API para os fragmentos são enviadas simultaneamente, reduzindo drasticamente o tempo de execução real.

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

Redução recursiva

Quando um documento é muito longo, os próprios resumos dos fragmentos podem exceder a janela de contexto. Aplique a redução de forma recursiva: agrupe os resumos em lotes, reduza cada lote e depois reduza os resumos dos lotes.

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]

Preservação dos detalhes importantes

Uma falha comum do mapeamento e redução ingênuos é a perda de detalhes importantes durante a compressão. Algumas formas de mitigá-la:

  • Instrua a etapa de mapeamento a preservar nomes, números e datas
  • Solicite à etapa de redução que verifique se há contradições entre as seções
  • Use um tamanho de fragmento maior para que o contexto do mapeamento seja mais rico
  • Execute uma etapa de verificação: pergunte ao modelo se as entidades importantes do original aparecem no resumo final
MAP_PROMPT = '''Summarize the following section in 5 sentences.
Preserve all key names, numbers, dates, and conclusions.

Section:
{chunk}'''

Cadeia de refinamento: um padrão alternativo

A cadeia de refinamento é uma alternativa ao mapeamento e redução. Ela processa os fragmentos sequencialmente: o resumo do fragmento N é passado junto com o fragmento N+1, e o modelo atualiza o resumo acumulado. Isso produz uma saída mais coerente, mas não pode ser paralelizado e é mais lento.

Use o refinamento quando a coerência narrativa for importante (por exemplo, em contratos jurídicos). Use o mapeamento e redução quando a velocidade for importante (por exemplo, em lotes de artigos de notícias).

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

Gerenciamento de custos e tokens

O mapeamento e redução realiza muitas chamadas à API. Para um documento com 100 fragmentos usando gpt-4o a $5/1 milhão de tokens de entrada:

  • Mapeamento: 100 fragmentos × 1000 tokens = 100 mil tokens de entrada ≈ $0,50
  • Redução: aproximadamente 10 mil tokens (resumos) ≈ $0,05
  • Total: aproximadamente $0,55 por documento

Para reduzir o custo, use gpt-4o-mini na fase de mapeamento ($0,15/1 milhão) e gpt-4o somente na redução. Essa abordagem híbrida reduz os custos em 70%, com perda mínima de qualidade.

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 usar o mapeamento e redução

A sumarização por mapeamento e redução é mais adequada para:

  • Documentos mais longos que a janela de contexto do modelo
  • Sumarização em lote de muitos documentos (paralelize também no nível do documento)
  • Situações em que é necessário controlar a instrução em cada etapa

Ela é menos adequada para extrair um fato específico (use recuperação em vez disso) ou quando o documento é curto o suficiente para caber no contexto (basta resumi-lo diretamente).

Verificação de conhecimentos

No padrão de sumarização por mapeamento e redução, o que acontece durante a fase de redução?

Recapitulação: sumarização por mapeamento e redução

O padrão de mapeamento e redução lida com documentos longos demais para uma única chamada ao LLM:

  • Mapeamento: resumir cada fragmento de forma independente — pode ser paralelizado
  • Redução: sintetizar os resumos dos fragmentos em um único resumo final
  • Redução recursiva: aplicar quando os próprios resumos forem longos demais
  • Dica de custo: usar um modelo barato no mapeamento e um modelo de qualidade na redução

O MapReduceDocumentsChain do LangChain oferece uma implementação pronta. A próxima lição aborda a sumarização hierárquica de livros e artigos de pesquisa.

Perguntas Frequentes

A aula “Padrão de sumarização Map-Reduce” é grátis?

Sim — o texto completo de “Padrão de sumarização Map-Reduce” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Padrão de sumarização Map-Reduce”?

Resuma cada parte de forma independente e depois sintetize os resumos. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Padrão de sumarização Map-Reduce”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Estratégias de divisão para textos longos
  2. Padrão de sumarização Map-Reduce
  3. Sumarização hierárquica
  4. Mantendo o contexto entre partes
← Voltar para AI Prompt Engineering