Kejuruteraan Arahan AI · Pelajaran

Penerokaan Pokok Pemikiran

Membina cabang dan menilai pemikiran.

Pelajaran 3 daripada 413 langkah

Penerokaan Pokok Pemikiran ialah pelajaran Kejuruteraan Arahan AI percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kejuruteraan Arahan AI, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kejuruteraan Arahan AI merangkumi sejumlah 4 pelajaran.

Daripada Rantaian kepada Pepohon

Pokok Pemikiran (ToT, Yao et al., 2023) menggeneralisasikan rantaian pemikiran daripada satu laluan linear kepada pepohon carian penyelesaian separa. Setiap nod ialah pemikiran perantaraan yang koheren; cabang meneroka sambungan alternatif.

Ini membolehkan model membuat pertimbangan: menjana beberapa langkah seterusnya, menilainya, mengekalkan langkah yang menjanjikan dan berundur daripada jalan buntu, dengan meniru penyelesaian masalah yang sistematik dan bukannya terus berpegang pada idea 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 mempunyai empat pilihan reka bentuk: penguraian pemikiran (apakah yang dikira sebagai satu langkah), penjana pemikiran (cara mencadangkan langkah seterusnya), penilai keadaan (cara memberikan skor kepada penyelesaian separa), dan algoritma carian (BFS, DFS atau mendahulukan yang terbaik).

Setiap satunya ialah gesaan atau dasar yang berasingan. Mereka bentuk ToT bermaksud menetapkan keempat-empatnya untuk tugasan 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
}

Menjana Pemikiran Calon

Terdapat dua strategi penjanaan: ambil sampel beberapa pemikiran bebas pada suhu sederhana (baik apabila ruangnya luas), atau cadangkan sekumpulan langkah seterusnya yang berbeza dalam satu gesaan (baik apabila anda mahukan pilihan yang berbeza dengan jelas).

Jana faktor percabangan yang kecil (selalunya 3 hingga 5); terlalu banyak calon menyebabkan carian dan kos meledak.

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

Menilai Keadaan

Penilai keadaan ialah perkara yang menjadikan ToT lebih daripada pensampelan rawak. Ia memberikan skor tentang sejauh mana menjanjikannya sesuatu penyelesaian separa, sama ada melalui gesaan nilai (berikan penilaian 1 hingga 10 tentang kemajuan keadaan ini ke arah penyelesaian masalah) atau melalui gesaan undian (yang manakah antara keadaan ini paling menjanjikan).

Melakukan undian merentas calon selalunya lebih teguh daripada pemberian skor mutlak kerana pertimbangan 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 Carian Rasuk

ToT secara lebar dahulu mengembangkan semua nod sempadan pada satu aras pada satu-satu masa, kemudian mengekalkan hanya b teratas berdasarkan skor penilai (satu rasuk). Ini mengehadkan ledakan carian sambil meneroka beberapa laluan secara selari.

Lebar rasuk b menukar keluasan penerokaan dengan kos; lebar 5 dengan kedalaman 3 ialah titik permulaan yang biasa bagi teka-teki berstruktur.

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 Jejak Balik

ToT secara mendalam dahulu menyusuri cabang yang paling menjanjikan dan berundur semula apabila penilai menganggap sesuatu keadaan tiada harapan. Kaedah ini sesuai untuk masalah yang mempunyai takrif jelas tentang keadaan separa yang tidak boleh dilaksanakan, seperti teka-teki kekangan.

Memangkas cabang yang mustahil pada peringkat awal ialah keuntungan kecekapan utama kerana ia mengelakkan pengembangan subpepohon yang 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 berbanding Konsistensi Kendiri

Konsistensi kendiri mengambil sampel rantaian lengkap yang bebas dan melakukan undian. ToT mengarahkan penerokaan secara aktif melalui penilaian perantaraan dan jejak balik, lalu menumpukan pengiraan pada bahagian yang menjanjikan.

ToT cemerlang pada masalah yang memerlukan perancangan, carian, atau masalah yang kesilapan awalnya menyebabkan kegagalan (Permainan 24, teka silang kata, perancangan). Bagi tugasan yang mempunyai rantaian pelbagai yang murah dan jawapan diskret, konsistensi kendiri lebih mudah dan selalunya mencukupi.

# 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 Kos dan Belanjawan

ToT mahal: setiap nod mencetuskan panggilan penjanaan dan penilaian. Jumlah kos meningkat kira-kira mengikut cabang x kedalaman x rasuk, ditambah panggilan penilai. Tanpa belanjawan yang ketat, kosnya boleh melonjak.

Hadkan jumlah panggilan LLM, gunakan carian yang mendahulukan yang terbaik untuk membelanjakan belanjawan pada nod sempadan yang paling bernilai, dan gunakan penyelesaian separa terbaik sebagai sandaran jika belanjawan 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

Kebolehpercayaan Penilai

ToT hanya sebaik penilainya. Penilai yang tidak ditentukur dengan betul mungkin memangkas cabang yang betul atau mengejar jalan buntu. Tingkatkan penilai dengan undian (berbilang penilaian bagi setiap keadaan), contoh teladan beberapa keadaan baik dan buruk, atau pengesah luaran (ujian unit, penyelesai atau pemeriksa).

Apabila pemeriksaan objektif tersedia (sama ada persamaan dipenuhi atau kod lulus), utamakan pemeriksaan itu berbanding pertimbangan 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

Kebolehgunaan Praktikal

ToT berbaloi untuk kelompok masalah yang kecil tetapi bernilai: perancangan berbilang langkah, teka-teki kombinatorial dan tugasan yang pengesahan satu langkahnya lebih murah daripada penyelesaian keseluruhan. Bagi kebanyakan penggesaan harian, ToT berlebihan.

Pada model yang mempunyai penaakulan terbina dalam serta carian yang kukuh, rangka kerja ToT yang eksplisit sering menambah kos tanpa banyak peningkatan; lakukan penandaarasan sebelum menerimanya.

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'

Penyelesai ToT Minimum

Dari hujung ke hujung: takrifkan satu langkah, cadangkan percabangan kecil pemikiran, nilai setiap satunya (dengan undian atau pengesah), lakukan carian melalui BFS-rasuk atau DFS-jejak balik dalam had belanjawan panggilan, dan kembalikan keadaan akhir yang terbaik.

Catat bilangan nod dan skor penilai supaya anda boleh melaraskan cabang, kedalaman dan rasuk secara empirikal bagi setiap tugasan.

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)

Semakan Pantas

Pilih strategi pertimbangan yang betul.

Jawab dalam pelajaran interaktif

Rumusan

Perkara penting:

ToT menggeneralisasikan CoT menjadi pepohon carian dengan penjanaan pemikiran, penilaian keadaan dan algoritma carian.
Gunakan BFS dengan rasuk atau DFS dengan jejak balik; kekalkan faktor percabangan yang kecil untuk mengawal ledakan carian.
Penilai keadaan ialah teras utama; kukuhkannya dengan undian atau pengesah luaran.
Kos meningkat mengikut cabang x kedalaman x rasuk, jadi kuatkuasakan belanjawan panggilan, selalunya melalui carian yang mendahulukan yang terbaik.
Simpan ToT untuk masalah perancangan atau kombinatorial yang langkahnya boleh disahkan; kaedah ini berlebihan untuk penggesaan harian.

Percuma untuk bermula

Pelajari Kejuruteraan Arahan AI dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 53
Pelajaran: 199

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Penerokaan Pokok Pemikiran” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kejuruteraan Arahan AI, termasuk “Penerokaan Pokok Pemikiran”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kejuruteraan Arahan AI merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Penerokaan Pokok Pemikiran”?

Membina cabang dan menilai pemikiran. Anda berlatih Kejuruteraan Arahan AI menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kejuruteraan Arahan AI?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kejuruteraan Arahan AI di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Penerokaan Pokok Pemikiran” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kejuruteraan Arahan AI ini?

Ya. Setiap pelajaran Kejuruteraan Arahan AI menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Kejuruteraan Arahan AI