AI Prompt Engineering · Pelajaran

Eksplorasi Tree-of-Thought

Membuat cabang dan mengevaluasi pemikiran.

Eksplorasi Tree-of-Thought 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.

Dari Rantai Menjadi Pohon

Pohon Pemikiran (ToT, Yao dkk., 2023) menggeneralisasi rantai pemikiran dari satu jalur linear menjadi pohon pencarian solusi parsial. Setiap simpul merupakan pemikiran antara yang koheren; cabang menjelajahi kelanjutan alternatif.

Hal ini memungkinkan model untuk menimbang: menghasilkan beberapa langkah berikutnya, mengevaluasinya, mempertahankan yang menjanjikan, dan kembali dari jalan buntu, sehingga meniru pemecahan masalah yang sistematis alih-alih berkomitmen pada ide pertama.

class ThoughtNode:
    def __init__(self, state, parent=None):
        self.state = state      # partial solution / reasoning so far
        self.parent = parent
        self.children = []
        self.value = None       # evaluator score

Empat Komponen ToT

Sistem ToT memiliki empat pilihan desain: dekomposisi pemikiran (apa yang dimaksud satu langkah), pembangkit pemikiran (cara mengusulkan langkah berikutnya), evaluator keadaan (cara memberi skor pada solusi parsial), dan algoritme pencarian (BFS, DFS, atau best-first).

Masing-masing merupakan perintah atau kebijakan terpisah. Mendesain ToT berarti menentukan keempatnya untuk tugas Anda.

tot = {
    'decompose': step_definition,   # e.g. one equation, one move
    'generate':  propose_thoughts,  # sampling or proposal prompt
    'evaluate':  score_state,        # value/vote prompt
    'search':    bfs_with_beam,      # BFS | DFS | best-first
}

Menghasilkan Pemikiran Kandidat

Ada dua strategi pembangkitan: ambil sampel dari beberapa pemikiran independen pada suhu sedang (baik ketika ruang solusinya kaya), atau ajukan sekumpulan langkah berikutnya yang berbeda dalam satu perintah (baik ketika Anda menginginkan opsi yang secara eksplisit berbeda).

Buat faktor percabangan yang kecil (sering kali 3 hingga 5); terlalu banyak kandidat akan memperbesar pencarian dan biaya secara drastis.

def propose_thoughts(state, k=4):
    prompt = (
        'Given the partial solution below, propose ' + str(k) +
        ' DISTINCT possible next steps.\n' + state
    )
    return parse_list(llm(prompt, temperature=0.7))

Mengevaluasi Keadaan

Evaluator keadaan membuat ToT lebih dari sekadar pengambilan sampel acak. Evaluator ini menilai seberapa menjanjikan suatu solusi parsial, baik melalui perintah nilai (beri nilai keadaan ini dari 1 hingga 10 berdasarkan kemajuannya dalam menyelesaikan masalah) maupun melalui perintah pemungutan suara (keadaan mana yang paling menjanjikan).

Pemungutan suara di antara kandidat sering kali lebih tangguh daripada pemberian skor absolut karena penilaian relatif lebih mudah bagi model.

def score_state(state):
    prompt = (
        'Rate how likely this partial solution leads to a correct '
        'final answer. Reply sure / likely / impossible.\n' + state
    )
    label = llm(prompt, temperature=0).strip().lower()
    return {'sure': 1.0, 'likely': 0.5, 'impossible': 0.0}.get(label, 0.3)

BFS dengan Pencarian Beam

ToT breadth-first memperluas semua simpul terdepan satu tingkat setiap kali, lalu hanya mempertahankan simpul dengan skor evaluator tertinggi sebanyak b (sebuah beam). Cara ini membatasi ledakan pencarian sekaligus menjelajahi beberapa jalur secara paralel.

Lebar beam b menukar keluasan eksplorasi dengan biaya; lebar 5 dengan kedalaman 3 merupakan titik awal yang umum untuk teka-teki terstruktur.

def bfs_with_beam(root, depth, branch, beam):
    frontier = [root]
    for _ in range(depth):
        nxt = []
        for node in frontier:
            for t in propose_thoughts(node.state, branch):
                child = ThoughtNode(node.state + '\n' + t, node)
                child.value = score_state(child.state)
                nxt.append(child)
        frontier = sorted(nxt, key=lambda n: -n.value)[:beam]
    return max(frontier, key=lambda n: n.value)

DFS dengan Penelusuran Mundur

ToT depth-first menelusuri cabang yang paling menjanjikan hingga dalam dan melakukan penelusuran mundur ketika evaluator menganggap suatu keadaan tidak memiliki harapan. Metode ini cocok untuk masalah dengan gagasan yang jelas tentang keadaan parsial yang tidak layak, seperti teka-teki berkendala.

Pemangkasan cabang yang mustahil sejak awal merupakan keuntungan efisiensi utama karena mencegah perluasan pohon bagian yang sudah pasti gagal.

def dfs(node, depth, branch, prune=0.2):
    if depth == 0 or is_solution(node.state):
        return node
    for t in propose_thoughts(node.state, branch):
        child = ThoughtNode(node.state + '\n' + t, node)
        child.value = score_state(child.state)
        if child.value < prune:
            continue                      # backtrack: prune dead end
        res = dfs(child, depth - 1, branch, prune)
        if res and is_solution(res.state):
            return res
    return None

ToT vs Konsistensi Mandiri

Konsistensi mandiri mengambil sampel dari rantai lengkap yang independen lalu melakukan pemungutan suara. ToT secara aktif mengarahkan eksplorasi melalui evaluasi antara dan penelusuran mundur, dengan menginvestasikan komputasi pada bagian yang menjanjikan.

ToT unggul pada masalah yang memerlukan perencanaan, pencarian, atau ketika kesalahan awal berakibat fatal (Permainan 24, teka-teki silang, perencanaan). Untuk tugas dengan rantai beragam yang murah dan jawaban diskret, konsistensi mandiri lebih sederhana dan sering kali sudah memadai.

# Rule of thumb
# - reachable by diverse single passes  -> self-consistency
# - needs lookahead / pruning / backtrack -> tree-of-thought
# ToT cost ~ branch * depth * beam * (gen + eval) LLM calls

Ledakan Biaya dan Anggaran

ToT mahal: setiap simpul memicu pemanggilan pembangkitan dan evaluasi. Total biaya kira-kira meningkat sebanding dengan percabangan x kedalaman x beam, ditambah pemanggilan evaluator. Tanpa anggaran yang ketat, biayanya dapat membengkak.

Batasi jumlah pemanggilan LLM, gunakan pencarian best-first untuk membelanjakan anggaran pada bagian terdepan yang paling bernilai, dan gunakan solusi parsial terbaik sebagai cadangan jika anggaran habis.

import heapq

def best_first(root, max_calls):
    heap = [(-root.value, root)]
    best, calls = root, 0
    while heap and calls < max_calls:
        _, node = heapq.heappop(heap)
        for t in propose_thoughts(node.state, 3):
            calls += 1
            child = ThoughtNode(node.state + '\n' + t, node)
            child.value = score_state(child.state); calls += 1
            if child.value > best.value:
                best = child
            heapq.heappush(heap, (-child.value, child))
    return best

Keandalan Evaluator

ToT hanya sebaik evaluator-nya. Evaluator yang tidak terkalibrasi dapat memangkas cabang yang benar atau mengejar jalan buntu. Tingkatkan evaluator dengan pemungutan suara (beberapa evaluasi per keadaan), contoh keadaan baik dan buruk dengan beberapa contoh, atau verifikator eksternal (uji unit, pemecah masalah, atau pemeriksa).

Jika tersedia pemeriksaan objektif (apakah persamaan berlaku, apakah kode berhasil), utamakan pemeriksaan tersebut daripada penilaian LLM.

def robust_eval(state, votes=3):
    scores = [score_state(state) for _ in range(votes)]
    return sum(scores) / votes        # average to reduce judge noise
# Even better: replace with a deterministic verifier when available

Keterterapan Praktis

ToT bermanfaat pada kelas masalah yang sempit tetapi bernilai: perencanaan bertahap, teka-teki kombinatorial, dan tugas yang langkahnya lebih murah untuk diverifikasi daripada menyelesaikan keseluruhan tugas. Untuk sebagian besar pemberian perintah sehari-hari, ToT berlebihan.

Pada model yang secara bawaan unggul dalam penalaran dengan pencarian internal yang kuat, kerangka ToT eksplisit sering menambah biaya tanpa banyak manfaat; lakukan pembandingan sebelum mengadopsinya.

def choose_strategy(task):
    if task.requires_search and task.step_verifiable:
        return 'tree-of-thought'
    if task.discrete_answer:
        return 'self-consistency'
    return 'single chain-of-thought'

Pemecah ToT Minimal

Dari awal hingga akhir: tentukan satu langkah, ajukan cabang kecil pemikiran, evaluasi masing-masing (dengan pemungutan suara atau verifikator), lakukan pencarian melalui BFS-beam atau DFS-backtrack dengan anggaran pemanggilan, lalu kembalikan keadaan terminal terbaik.

Catat jumlah simpul dan skor evaluator agar Anda dapat menyesuaikan percabangan, kedalaman, dan beam secara empiris untuk setiap tugas.

def solve(problem, branch=4, depth=3, beam=5, budget=200):
    root = ThoughtNode(problem)
    root.value = score_state(root.state)
    node = bfs_with_beam(root, depth, branch, beam)
    return extract_solution(node.state)

Pemeriksaan Singkat

Pilih strategi penalaran yang tepat.

Rangkuman

Hal-hal penting:

ToT menggeneralisasi CoT menjadi pohon pencarian dengan pembangkitan pemikiran, evaluasi keadaan, dan algoritme pencarian.
Gunakan BFS dengan beam atau DFS dengan penelusuran mundur; pertahankan faktor percabangan tetap kecil untuk mengendalikan ledakan pencarian.
Evaluator keadaan merupakan inti metode ini; perkuat dengan pemungutan suara atau verifikator eksternal.
Biaya meningkat sebanding dengan percabangan x kedalaman x beam, jadi tetapkan anggaran pemanggilan, sering kali melalui pencarian best-first.
Simpan ToT untuk masalah perencanaan atau kombinatorial yang langkahnya dapat diverifikasi; ToT berlebihan untuk pemberian perintah sehari-hari.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Eksplorasi Tree-of-Thought” gratis?

Ya — teks lengkap “Eksplorasi Tree-of-Thought” 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 “Eksplorasi Tree-of-Thought”?

Membuat cabang dan mengevaluasi pemikiran. 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 “Eksplorasi Tree-of-Thought” 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