AI Prompt Engineering · บทเรียน

การสำรวจความคิดแบบต้นไม้

การแตกแขนงและประเมินความคิด

การสำรวจความคิดแบบต้นไม้ เป็นบทเรียน AI Prompt Engineering ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Prompt Engineering และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Prompt Engineering มีบทเรียนทั้งหมด 4 บทเรียน

จากสายการคิดสู่ต้นไม้

ต้นไม้แห่งความคิด (ToT, Yao และคณะ, 2023) ขยายการให้เหตุผลเป็นสายจากเส้นทางเชิงเส้นเพียงเส้นเดียวไปเป็น ต้นไม้ค้นหาของคำตอบบางส่วน แต่ละโหนดคือแนวคิดระหว่างทางที่สอดคล้องกัน และแต่ละกิ่งสำรวจการต่อยอดทางเลือกอื่น

วิธีนี้เปิดโอกาสให้โมเดลไตร่ตรอง โดยสร้างขั้นตอนถัดไปหลายแบบ ประเมินแต่ละแบบ เก็บแบบที่มีแนวโน้มดีไว้ และย้อนกลับจากทางตัน ทำให้เลียนแบบการแก้ปัญหาอย่างเป็นระบบแทนการยึดติดกับแนวคิดแรก

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

องค์ประกอบทั้งสี่ของ ToT

ระบบ ToT มีตัวเลือกด้านการออกแบบสี่ประการ ได้แก่ การแยกย่อยแนวคิด (ขั้นตอนหนึ่งคืออะไร) ตัวสร้างแนวคิด (จะเสนอขั้นตอนถัดไปอย่างไร) ตัวประเมินสถานะ (จะให้คะแนนคำตอบบางส่วนอย่างไร) และ อัลกอริทึมการค้นหา (BFS, DFS หรือ best-first)

แต่ละองค์ประกอบอาจเป็นพรอมป์ต์หรือนโยบายแยกกัน การออกแบบ ToT หมายถึงการกำหนดองค์ประกอบทั้งสี่ให้เหมาะกับงานของคุณ

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
}

การสร้างแนวคิดที่เป็นตัวเลือก

กลยุทธ์การสร้างมีสองแบบ ได้แก่ สุ่มตัวอย่างแนวคิดที่เป็นอิสระกันหลายแนวคิดด้วยอุณหภูมิระดับปานกลาง (เหมาะเมื่อพื้นที่ตัวเลือกมีความหลากหลายมาก) หรือ เสนอขั้นตอนถัดไปที่แตกต่างกันเป็นชุดภายในพรอมป์ต์เดียว (เหมาะเมื่อต้องการตัวเลือกที่แตกต่างกันอย่างชัดเจน)

ควรสร้างจำนวนกิ่งแตกแขนงไม่มากนัก (มักอยู่ที่ 3 ถึง 5) เพราะตัวเลือกที่มากเกินไปจะทำให้การค้นหาและต้นทุนเพิ่มขึ้นอย่างรวดเร็ว

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

การประเมินสถานะ

ตัวประเมินสถานะคือสิ่งที่ทำให้ ToT เป็นมากกว่าการสุ่มตัวอย่างแบบไร้ทิศทาง ตัวประเมินจะให้คะแนนว่าคำตอบบางส่วนมีแนวโน้มดีเพียงใด โดยอาจใช้พรอมป์ต์ให้คะแนน (ให้คะแนนสถานะนี้ตั้งแต่ 1 ถึง 10 ตามความคืบหน้าในการแก้ปัญหา) หรือพรอมป์ต์ลงคะแนน (สถานะใดในบรรดาสถานะเหล่านี้มีแนวโน้มดีที่สุด)

การลงคะแนนระหว่างตัวเลือกมักทนทานกว่าการให้คะแนนแบบสัมบูรณ์ เพราะโมเดลตัดสินเชิงเปรียบเทียบได้ง่ายกว่า

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 พร้อมการค้นหาแบบลำแสง

ToT แบบ ค้นหาโดยขยายตามระดับจะขยายโหนดแนวหน้าทั้งหมดทีละระดับ แล้วเก็บไว้เฉพาะโหนดที่มีคะแนนจากตัวประเมินสูงสุดจำนวน b โหนด (เรียกว่าลำแสง) วิธีนี้จำกัดการแตกแขนงที่เพิ่มขึ้นอย่างรวดเร็ว ขณะเดียวกันก็สำรวจหลายแนวทางพร้อมกัน

ความกว้างของลำแสง b เป็นการแลกเปลี่ยนระหว่างความกว้างของการสำรวจกับต้นทุน ความกว้าง 5 และความลึก 3 เป็นจุดเริ่มต้นที่ใช้กันบ่อยสำหรับปริศนาที่มีโครงสร้าง

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 พร้อมการย้อนกลับ

ToT แบบ ค้นหาเชิงลึกจะดำดิ่งไปตามกิ่งที่มีแนวโน้มดีที่สุด และ ย้อนกลับเมื่อผู้ประเมินเห็นว่าสถานะนั้นไม่มีทางสำเร็จ วิธีนี้เหมาะกับปัญหาที่มีแนวคิดชัดเจนว่าสถานะบางส่วนใดเป็นไปไม่ได้ เช่น ปริศนาเงื่อนไขจำกัด

การตัดกิ่งที่เป็นไปไม่ได้ตั้งแต่เนิ่น ๆ เป็นจุดเพิ่มประสิทธิภาพหลัก เพราะช่วยหลีกเลี่ยงการขยายต้นไม้ย่อยที่ไม่มีทางสำเร็จโดยเปล่าประโยชน์

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 เทียบกับความสอดคล้องในตนเอง

ความสอดคล้องในตนเองจะสุ่มสายการคิด ที่สมบูรณ์ซึ่งเป็นอิสระต่อกันแล้วลงคะแนน ส่วน ToT จะ ชี้นำการสำรวจอย่างแข็งขันด้วยการประเมินระหว่างทางและการย้อนกลับ โดยทุ่มการคำนวณไปยังส่วนที่มีแนวโน้มดี

ToT โดดเด่นในปัญหาที่ต้องวางแผน ต้องค้นหา หรือมีข้อผิดพลาดช่วงต้นที่ทำให้ล้มเหลวทั้งกระบวนการ (เกม 24 ปริศนาอักษรไขว้ และการวางแผน) สำหรับงานที่สร้างสายการคิดหลากหลายได้ในราคาต่ำและมีคำตอบแบบไม่ต่อเนื่อง ความสอดคล้องในตนเองจะเรียบง่ายกว่าและมักเพียงพอ

# 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

ต้นทุนพุ่งสูงและงบประมาณ

ToT มีต้นทุนสูง เพราะแต่ละโหนดทำให้เกิดการเรียกใช้ทั้งการสร้างและการประเมิน ต้นทุนรวมจะเพิ่มขึ้นโดยประมาณตามจำนวนกิ่ง x ความลึก x จำนวนลำแสง รวมกับการเรียกใช้ตัวประเมิน หากไม่มี งบประมาณที่กำหนดตายตัว ต้นทุนอาจพุ่งสูงได้

จำกัดจำนวนการเรียกใช้ LLM ทั้งหมด ใช้การค้นหาแบบเลือกสิ่งที่ดีที่สุดก่อนเพื่อทุ่มงบประมาณให้กับโหนดแนวหน้าที่มีคุณค่าสูงสุด และใช้คำตอบบางส่วนที่ดีที่สุดเป็นทางเลือกสำรองเมื่องบประมาณหมด

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

ความน่าเชื่อถือของตัวประเมิน

คุณภาพของ ToT จะดีได้เท่ากับ ตัวประเมินของมันเท่านั้น ตัวประเมินที่ปรับเทียบผิดอาจตัดกิ่งที่ถูกต้องทิ้ง หรือไล่ตามทางตัน คุณสามารถปรับปรุงได้ด้วยการลงคะแนน (ประเมินแต่ละสถานะหลายครั้ง) ตัวอย่างประกอบแบบใช้ตัวอย่างเล็กน้อยของสถานะที่ดีและไม่ดี หรือตัวตรวจสอบภายนอก (การทดสอบหน่วย ตัวแก้โจทย์ หรือตัวตรวจสอบ)

เมื่อมีการตรวจสอบตามวัตถุประสงค์ได้ (สมการเป็นจริงหรือไม่ โค้ดผ่านหรือไม่) ควรเลือกใช้การตรวจสอบนั้นแทนการตัดสินของ 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

การประยุกต์ใช้ในทางปฏิบัติ

ToT ให้ผลคุ้มค่าในปัญหากลุ่มแคบ ๆ แต่มีคุณค่า ได้แก่ การวางแผนหลายขั้นตอน ปริศนาเชิงการจัดวาง และงานที่การตรวจสอบขั้นตอนหนึ่งมีต้นทุนต่ำกว่าการแก้ปัญหาทั้งหมด สำหรับการใช้พรอมป์ต์ในชีวิตประจำวันส่วนใหญ่ ToT ถือว่าเกินความจำเป็น

สำหรับโมเดลที่มีความสามารถด้านการให้เหตุผลในตัวและมีการค้นหาที่แข็งแกร่ง การวางโครง ToT อย่างชัดเจนมักเพิ่มต้นทุนโดยได้ประโยชน์ไม่มาก ควรทดสอบเปรียบเทียบก่อนนำไปใช้

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'

ตัวแก้โจทย์ ToT แบบพื้นฐาน

ตั้งแต่ต้นจนจบ ให้กำหนดขั้นตอน เสนอกลุ่มแนวคิดที่แตกแขนงไม่มาก ประเมินแต่ละแนวคิด (ด้วยการลงคะแนนหรือตัวตรวจสอบ) ค้นหาด้วย BFS แบบใช้ลำแสงหรือ DFS แบบย้อนกลับภายใต้งบประมาณการเรียกใช้ และส่งคืนสถานะปลายทางที่ดีที่สุด

บันทึกจำนวนโหนดและคะแนนของตัวประเมิน เพื่อให้คุณปรับจำนวนกิ่ง ความลึก และจำนวนลำแสงตามข้อมูลจริงของแต่ละงานได้

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)

ตรวจสอบอย่างรวดเร็ว

เลือกกลยุทธ์การไตร่ตรองที่เหมาะสม

ทบทวน

ประเด็นสำคัญ:

ToT ขยาย CoT ให้เป็นต้นไม้ค้นหาที่มีการสร้างแนวคิด การประเมินสถานะ และอัลกอริทึมการค้นหา
ใช้ BFS ร่วมกับลำแสง หรือ DFS ร่วมกับการย้อนกลับ และจำกัดจำนวนกิ่งแตกแขนงเพื่อควบคุมการแตกแขนงที่เพิ่มขึ้นอย่างรวดเร็ว
ตัวประเมินสถานะคือหัวใจสำคัญ ควรทำให้แข็งแกร่งขึ้นด้วยการลงคะแนนหรือตัวตรวจสอบภายนอก
ต้นทุนเพิ่มขึ้นตามจำนวนกิ่ง x ความลึก x จำนวนลำแสง จึงต้องบังคับใช้งบประมาณการเรียกใช้ โดยมักใช้การค้นหาแบบเลือกสิ่งที่ดีที่สุดก่อน
ควรสงวน ToT ไว้สำหรับปัญหาด้านการวางแผนหรือการจัดวางเชิงผสมที่ตรวจสอบขั้นตอนได้ เพราะเกินความจำเป็นสำหรับการใช้พรอมป์ต์ในชีวิตประจำวัน

คำถามที่พบบ่อย

บทเรียน “การสำรวจความคิดแบบต้นไม้” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การสำรวจความคิดแบบต้นไม้” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส AI Prompt Engineering ให้อัปเกรดเป็น CoddyKit PRO คอร์ส AI Prompt Engineering มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การสำรวจความคิดแบบต้นไม้”

การแตกแขนงและประเมินความคิด คุณปฏิบัติ AI Prompt Engineering ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน AI Prompt Engineering หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน AI Prompt Engineering บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การสำรวจความคิดแบบต้นไม้” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน AI Prompt Engineering นี้ได้ไหม

ได้ บทเรียน AI Prompt Engineering ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ AI Prompt Engineering