0Pricing
AI Prompt Engineering · Pelajaran

Pola Perangkuman Map-Reduce

Ringkas setiap potongan secara terpisah, lalu gabungkan semua ringkasan.

Pola Perangkuman Map-Reduce adalah pelajaran AI Prompt Engineering gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Prompt Engineering, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Prompt Engineering mencakup 4 pelajaran total.

Pola Map-Reduce

Ketika dokumen melebihi jendela konteks LLM, Anda tidak dapat mengirimkan seluruhnya sekaligus. Pola map-reduce mengatasi masalah ini:

  • Map: meringkas setiap potongan secara independen
  • Reduce: menyintesis semua ringkasan potongan menjadi satu ringkasan akhir

Ini menyerupai MapReduce klasik dalam sistem terdistribusi — logika bagi-dan-taklukkan yang sama, diterapkan pada tugas bahasa.

Langkah 1: Fase Map

Dalam fase map, setiap potongan dikirim ke LLM bersama perintah peringkasan. Model mengembalikan ringkasan singkat yang hanya mencakup potongan tersebut. Ringkasan ini dikumpulkan ke dalam sebuah daftar.

Setiap ringkasan harus jauh lebih pendek daripada potongan aslinya — biasanya 10–20% dari panjang asli. Kompresi inilah yang membuat langkah reduce dapat dilakukan.

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]

Langkah 2: Fase Reduce

Dalam fase reduce, semua ringkasan potongan digabungkan dan dikirim ke LLM bersama perintah sintesis. Model menghasilkan satu ringkasan akhir yang koheren.

Jika ringkasan potongan masih terlalu panjang untuk dimuat dalam satu jendela konteks, terapkan reduce secara rekursif — ringkas kelompok ringkasan terlebih dahulu, lalu sintesis hasilnya.

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

Menggabungkan Semuanya: API Mentah

Berikut pipeline map-reduce lengkap yang menggunakan panggilan API OpenAI mentah — tidak memerlukan kerangka kerja. Dengan cara ini, Anda memiliki kendali penuh atas perintah dan parameter pada setiap 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 LangChain

LangChain menyediakan MapReduceDocumentsChain siap pakai yang menangani pembagian potongan, panggilan map secara paralel, dan langkah reduce. Ini praktis, tetapi kurang fleksibel dibandingkan panggilan API mentah.

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

Memparalelkan Fase Map

Ringkasan setiap potongan bersifat independen, sehingga fase map dapat diparalelkan. Dengan menggunakan ThreadPoolExecutor Python, semua panggilan API untuk potongan dikirim secara bersamaan, sehingga waktu nyata yang diperlukan berkurang drastis.

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 Rekursif

Ketika dokumen sangat panjang, ringkasan potongannya sendiri mungkin melebihi jendela konteks. Terapkan reduce secara rekursif: kelompokkan ringkasan ke dalam beberapa kumpulan, lakukan reduce pada setiap kumpulan, lalu lakukan reduce pada ringkasan setiap kumpulan.

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]

Mempertahankan Detail Penting

Kegagalan umum map-reduce naif adalah hilangnya detail penting selama kompresi. Cara mengatasinya:

  • Perintahkan langkah map untuk mempertahankan nama, angka, tanggal
  • Minta langkah reduce memeriksa pertentangan antarbagian
  • Gunakan ukuran potongan yang lebih besar agar konteks map lebih kaya
  • Lakukan tahap verifikasi: tanyakan kepada model apakah entitas penting dari dokumen asli muncul dalam ringkasan akhir
MAP_PROMPT = '''Summarize the following section in 5 sentences.
Preserve all key names, numbers, dates, and conclusions.

Section:
{chunk}'''

Rantai Refine: Pola Alternatif

Rantai refine merupakan alternatif terhadap map-reduce. Rantai ini memproses potongan secara berurutan: ringkasan potongan N diteruskan bersama potongan N+1, lalu model memperbarui ringkasan yang sedang berjalan. Cara ini menghasilkan keluaran yang lebih koheren, tetapi tidak dapat diparalelkan dan lebih lambat.

Gunakan refine ketika koherensi narasi penting (misalnya, kontrak hukum). Gunakan map-reduce ketika kecepatan lebih penting (misalnya, kumpulan artikel berita).

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

Pengelolaan Biaya dan Token

Map-reduce melakukan banyak panggilan API. Untuk dokumen dengan 100 potongan menggunakan gpt-4o dengan biaya $5/1 juta token input:

  • Map: 100 potongan × 1000 token = 100 ribu token input ≈ $0,50
  • Reduce: ~10 ribu token (ringkasan) ≈ $0,05
  • Total: ~$0,55 per dokumen

Untuk mengurangi biaya: gunakan gpt-4o-mini untuk fase map ($0,15/1 juta) dan gpt-4o hanya untuk reduce. Pendekatan hibrida ini memangkas biaya sebesar 70% dengan penurunan kualitas yang minimal.

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

Kapan Menggunakan Map-Reduce

Peringkasan map-reduce paling sesuai untuk:

  • Dokumen yang lebih panjang daripada jendela konteks model
  • Peringkasan banyak dokumen secara berkelompok (paralelkan juga pada tingkat dokumen)
  • Situasi yang memerlukan kendali atas perintah pada setiap langkah

Pola ini kurang sesuai untuk: mengekstrak fakta tertentu (gunakan pengambilan sebagai gantinya), atau ketika dokumen cukup pendek untuk dimuat dalam konteks (langsung ringkas saja).

Uji Pengetahuan

Dalam pola peringkasan map-reduce, apa yang terjadi selama fase reduce?

Rekap: Peringkasan Map-Reduce

Pola map-reduce menangani dokumen yang terlalu panjang untuk satu panggilan LLM:

  • Map: meringkas setiap potongan secara independen — dapat diparalelkan
  • Reduce: menyintesis ringkasan potongan menjadi satu ringkasan akhir
  • Reduce rekursif: diterapkan ketika ringkasan itu sendiri terlalu panjang
  • Tips biaya: gunakan model murah untuk map dan model berkualitas untuk reduce

MapReduceDocumentsChain dari LangChain menyediakan implementasi siap pakai. Pelajaran berikutnya membahas peringkasan hierarkis untuk buku dan makalah penelitian.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pola Perangkuman Map-Reduce” gratis?

Ya — teks lengkap “Pola Perangkuman Map-Reduce” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Prompt Engineering, upgrade ke CoddyKit PRO. Kursus AI Prompt Engineering mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pola Perangkuman Map-Reduce”?

Ringkas setiap potongan secara terpisah, lalu gabungkan semua ringkasan. Kamu berlatih AI Prompt Engineering dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Prompt Engineering?

Tidak diperlukan pengalaman sebelumnya. AI Prompt Engineering di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Pola Perangkuman Map-Reduce” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Prompt Engineering ini?

Ya. Setiap pelajaran AI Prompt Engineering menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Strategi Pemotongan Teks Panjang
  2. Pola Perangkuman Map-Reduce
  3. Perangkuman Hierarkis
  4. Mempertahankan Konteks Antar-Potongan
← Kembali ke AI Prompt Engineering