AI Prompt Engineering · Pelajaran

Perangkuman Hierarkis

Lakukan kompresi bertahap: bab → bagian → ringkasan dokumen.

Pelajaran 3 dari 413 langkah

Perangkuman Hierarkis adalah pelajaran AI Prompt Engineering gratis di CoddyKit. Ini adalah pelajaran 3 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.

Apa Itu Peringkasan Hierarkis

Peringkasan hierarkis mencerminkan struktur dokumen itu sendiri. Alih-alih memperlakukan semua potongan secara sama, metode ini memampatkan isi tingkat demi tingkat:

Halaman → ringkasan bagian
Bagian → ringkasan bab
Bab → ringkasan dokumen

Setiap tingkat merupakan representasi terkompresi dari tingkat di bawahnya. Begitulah manusia meringkas buku — membaca bab, membentuk ringkasan dalam pikiran, lalu menggabungkannya.

Kapan Menggunakan Peringkasan Hierarkis

Peringkasan hierarkis merupakan pilihan yang tepat untuk:

Buku: lebih dari 200 halaman dengan struktur bab yang jelas
Makalah penelitian: abstrak, pendahuluan, metode, hasil, pembahasan
Kontrak hukum: bagian-bagian dengan judul yang ditentukan (definisi, kewajiban, pengakhiran)
Laporan teknis: ringkasan eksekutif → temuan → lampiran

Metode ini berlebihan untuk artikel pendek. Keunggulannya terlihat ketika dokumen memiliki struktur pohon alami.

Struktur Pohon Dokumen

Modelkan dokumen sebagai pohon:

Akar: ringkasan akhir
Simpul tingkat 1: ringkasan bab
Simpul tingkat 2: ringkasan bagian
Daun: teks halaman atau potongan mentah

Peringkasan berlangsung dari bawah ke atas: daun → tingkat 2 → tingkat 1 → akar. Ringkasan setiap simpul hanya diturunkan dari ringkasan anak-anaknya.

from dataclasses import dataclass, field
from typing import List, Optional

@dataclass
class DocNode:
    title: str
    content: str = ''
    summary: str = ''
    children: List['DocNode'] = field(default_factory=list)

# Example: book with 3 chapters, each with 3 sections
book = DocNode(
    title='My Book',
    children=[
        DocNode('Chapter 1', children=[
            DocNode('Section 1.1', content='...raw text...'),
            DocNode('Section 1.2', content='...raw text...'),
        ]),
        DocNode('Chapter 2', children=[
            DocNode('Section 2.1', content='...raw text...'),
        ])
    ]
)

Peringkasan dari Bawah ke Atas

Telusuri pohon dari bawah ke atas. Simpul daun diringkas berdasarkan isi mentahnya. Simpul internal diringkas berdasarkan ringkasan anak-anaknya.

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

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

def summarize_tree(node, depth=0):
    role = ['document', 'chapter', 'section', 'page'][min(depth, 3)]
    if not node.children:
        node.summary = summarize_text(node.content, role)
    else:
        for child in node.children:
            summarize_tree(child, depth + 1)
        combined = '\n\n'.join(
            f'{c.title}:\n{c.summary}' for c in node.children
        )
        node.summary = summarize_text(combined, role)
    return node.summary

Kompresi Progresif

Kompresi progresif berarti setiap tingkat mengurangi kepadatan informasi. Pedoman praktisnya:

Halaman (2000 token) → ringkasan bagian (200 token) — kompresi 10 kali
Ringkasan bagian (200 token) → ringkasan bab (100 token) — kompresi 2 kali
Ringkasan bab (5 × 100 token) → dokumen (150 token) — kompresi 3 kali

Total: dokumen 10.000 token dikompresi menjadi ~150 token dengan tetap mempertahankan argumen utama. Perintahkan setiap tingkat untuk mempertahankan rasio kompresi.

PAGE_PROMPT = 'Summarize this page in 2-3 sentences (under 80 words).'
SECTION_PROMPT = 'Given these page summaries, write a section summary in 3-4 sentences (under 120 words).'
CHAPTER_PROMPT = 'Given these section summaries, write a chapter summary in 4-5 sentences (under 150 words).'
DOC_PROMPT = 'Given these chapter summaries, write an executive summary of the entire document (under 200 words).'

Mempertahankan Koherensi Antar-Tingkat

Salah satu risiko peringkasan hierarkis adalah ringkasan pada satu tingkat dapat saling bertentangan atau berulang, dan kesalahan ini terakumulasi ke tingkat yang lebih tinggi. Strategi untuk mempertahankan koherensi:

Sertakan judul bagian induk dalam perintah agar model mengetahui konteksnya
Minta model menghindari pengulangan fakta yang sudah disebutkan dalam ringkasan bagian sebelumnya
Pada langkah reduce terakhir, minta model secara eksplisit menyelesaikan pertentangan apa pun

def summarize_sections_for_chapter(chapter_title, section_summaries):
    content = '\n\n'.join(
        f'Section: {s["title"]}\n{s["summary"]}'
        for s in section_summaries
    )
    prompt = (
        f'Chapter: {chapter_title}\n\n'
        'Below are summaries of each section. '
        'Write a unified chapter summary without repeating '
        'the same facts from multiple sections.\n\n' + content
    )
    resp = client.chat.completions.create(
        model='gpt-4o',
        messages=[{'role': 'user', 'content': prompt}]
    )
    return resp.choices[0].message.content

Hierarki Makalah Penelitian

Makalah penelitian memiliki hierarki alami: Abstrak → Pendahuluan → Metode → Hasil → Pembahasan → Kesimpulan. Setiap bagian memiliki peran yang berbeda, jadi gunakan perintah khusus untuk setiap bagian:

SECTION_PROMPTS = {
    'abstract': 'Summarize the paper abstract: what problem, method, and result?',
    'introduction': 'Summarize the introduction: what gap does the paper address?',
    'methods': 'Summarize the methods: what approach was used?',
    'results': 'Summarize the results: what were the key findings and metrics?',
    'discussion': 'Summarize the discussion: what do the results mean?',
    'conclusion': 'Summarize the conclusion and future work.'
}

def summarize_paper(sections_dict):
    section_summaries = {}
    for section, text in sections_dict.items():
        prompt = SECTION_PROMPTS.get(section, 'Summarize this section.')
        section_summaries[section] = call_llm(prompt, text)
    return section_summaries

Hierarki Kontrak Hukum

Kontrak hukum mengikuti hierarki klausul: definisi → kewajiban → upaya hukum → pengakhiran → hukum yang berlaku. Peringkasan hierarkis harus mempertahankan:

Angka yang persis (jumlah pembayaran, tenggat waktu)
Nama para pihak (klien, vendor, pemberi lisensi)
Bahasa bersyarat (kecuali, kecuali ketika, dengan ketentuan bahwa)

Perintahkan model untuk menandai setiap klausul yang memiliki jumlah numerik atau ketentuan bersyarat yang sedang diringkas, agar tidak terhapus secara tidak sengaja.

LEGAL_PROMPT = '''Summarize this contract clause in plain English.
Preserve: all monetary amounts, dates, party names, and conditionals.
Flag any obligation with [OBLIGATION] and any amount with [AMOUNT].'''

def summarize_clause(clause_text):
    resp = client.chat.completions.create(
        model='gpt-4o',
        messages=[
            {'role': 'system', 'content': LEGAL_PROMPT},
            {'role': 'user', 'content': clause_text}
        ]
    )
    return resp.choices[0].message.content

Menyimpan Ringkasan Hierarkis

Simpan seluruh pohon ringkasan, bukan hanya ringkasan akar. Hal ini memungkinkan:

Penelusuran mendalam — tampilkan ringkasan bab, lalu ringkasan bagian sesuai permintaan
Pengambilan — cocokkan kueri pengguna dengan ringkasan bagian, bukan hanya seluruh dokumen
Pembaruan — ketika satu bagian berubah, ringkas ulang hanya cabang pohon tersebut

import json

def tree_to_dict(node):
    return {
        'title': node.title,
        'summary': node.summary,
        'children': [tree_to_dict(c) for c in node.children]
    }

def save_tree(node, path):
    with open(path, 'w') as f:
        json.dump(tree_to_dict(node), f, indent=2)
    print(f'Saved summary tree to {path}')

Pembaruan Bertahap

Ketika dokumen diperbarui, struktur hierarkis memungkinkan peringkasan ulang bertahap. Ringkas ulang hanya simpul yang diubah dan leluhurnya — semua cabang saudara tetap valid.

Untuk buku dengan 10 bab ketika bab 3 direvisi: ringkas ulang bagian-bagian dalam bab 3, lalu bab 3, kemudian buku tersebut. Hitung ulang 3 simpul, bukan semua simpul.

def update_node(node, updated_child_title):
    # Re-summarize the changed child
    for child in node.children:
        if child.title == updated_child_title:
            summarize_tree(child)  # re-summarize from leaves
            break
    # Re-summarize current node from updated children
    combined = '\n\n'.join(
        f'{c.title}:\n{c.summary}' for c in node.children
    )
    node.summary = summarize_text(combined)
    return node.summary

Perbandingan Datar dan Hierarkis

Map-reduce datar dibandingkan dengan peringkasan hierarkis:

Datar: lebih sederhana, mengabaikan struktur dokumen, lebih baik untuk dokumen seragam (artikel berita)
Hierarkis: menghormati struktur, memungkinkan penelusuran mendalam, menghasilkan koherensi yang lebih baik untuk dokumen terstruktur

Dalam praktiknya, gabungkan keduanya: gunakan map-reduce datar di dalam setiap bab (banyak halaman), lalu gunakan pendekatan hierarkis antar-bab. Ini merupakan pendekatan paling tangguh untuk dokumen dunia nyata.

Uji Pengetahuan

Dalam peringkasan hierarkis, ke arah mana proses peringkasan berlangsung melalui pohon dokumen?

Jawab di pelajaran interaktif

Rekap: Peringkasan Hierarkis

Peringkasan hierarkis mencerminkan struktur dokumen untuk menghasilkan hasil yang lebih baik:

Modelkan dokumen sebagai pohon: halaman → bagian → bab → dokumen
Ringkas dari bawah ke atas: daun terlebih dahulu, akar terakhir
Setiap tingkat menerapkan kompresi progresif untuk mempertahankan koherensi
Paling sesuai untuk buku, makalah penelitian, dan kontrak hukum dengan struktur hierarkis yang jelas
Simpan seluruh pohon untuk memungkinkan pengambilan melalui penelusuran mendalam dan pembaruan bertahap

Pelajaran berikutnya: mempertahankan konteks antar-potongan dengan tumpang tindih dan ringkasan bergulir.

Gratis untuk memulai

Belajar AI Prompt Engineering dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 53
Pelajaran: 199

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Perangkuman Hierarkis” gratis?

Ya — teks lengkap “Perangkuman Hierarkis” 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 “Perangkuman Hierarkis”?

Lakukan kompresi bertahap: bab → bagian → ringkasan dokumen. 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 3 dari 4.

Berapa lama pelajaran “Perangkuman Hierarkis” 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

← Kembali ke AI Prompt Engineering