Tree of Thought Prompting: איך זה עובד ודוגמאות

Tree of thought prompting גורם למודל שפה לעבוד על בעיה כמו שאתם אולי הייתם עובדים על דף: לרשום כמה צעדים הבאים אפשריים, לשפוט אילו מהם נראים מבטיחים, להמשיך אותם, ולנטוש ענף כשהוא לא מוביל לשום מקום. הרעיון מגיע מ-Yao et al. 2023, "Tree of Thoughts: Deliberate Problem Solving with Large Language Models". הוא מרחיב את chain of thought prompting, שעוקב אחרי קו היסק יחיד, לחיפוש על פני קווים רבים.

העמוד הזה מסביר איך השיטה המקורית עובדת, נותן לכם גרסה של פרומפט אחד לנסות ב-ChatGPT, ב-Claude או ב-Gemini, ומראה את הלולאה בקוד למקרים שבהם פרומפט אחד לא מספיק.

איך tree of thoughts עובד

המאמר מפרק את השיטה לארבע החלטות.

1. מה נחשב למחשבה. מחשבה היא צעד ביניים אחד, קטן מספיק כדי שהמודל יפיק אותו היטב וגדול מספיק כדי לשפוט אותו. בחידה מתמטית זו משוואה אחת; במשימת כתיבה זו תוכנית קצרה.
2. איך מייצרים מחשבות. מהפתרון החלקי הנוכחי, המודל מציע כמה צעדים הבאים מועמדים, בדגימה עצמאית או ברשימה בתשובה אחת.
3. איך מעריכים אותן. מבקשים מהמודל לדרג כל פתרון חלקי. המאמר השתמש בשני סגנונות: לתת ציון לכל מצב בנפרד (למשל "בטוח", "סביר" או "בלתי אפשרי"), או להראות למודל כמה מצבים ולתת לו להצביע על הטוב ביותר.
4. איך מחפשים. תוכנה שומרת את המצבים הטובים ביותר בכל רמה (חיפוש לרוחב, breadth-first search) או עוקבת אחרי ענף אחד לעומק וחוזרת אחורה כשההערכה אומרת שהוא חסר סיכוי (חיפוש לעומק, depth-first search).

קחו את משימת Game of 24 מהמאמר: להשתמש במספרים 4, 9, 10 ו-13 פעם אחת כל אחד, עם ארבע פעולות החשבון הבסיסיות, כדי להגיע ל-24. Chain of thought מתחייב למשוואה הראשונה שלו וחייב לחיות איתה. Tree of thoughts עשוי לנסות 13 - 9 = 4, 10 - 4 = 6 ו-4 + 9 = 13 כצעדים ראשונים, לשאול את המודל מאילו מספרים שנותרו עוד אפשר להגיע ל-24, לזנוח את המבוי הסתום (עם 10, 13 ו-13 אי אפשר להגיע ל-24), ולסיים ב-(10 - 4) * (13 - 9) = 24.

מה המאמר הראה

המחברים בחרו שלוש משימות ש-GPT-4 התקשה בהן גם עם chain of thought, כי כל אחת דורשת תכנון או חיפוש: Game of 24, משימת כתיבה יצירתית עם משפטי סיום קבועים, ותשבצים קטנים בגודל 5x5. עם GPT-4, חיפוש העץ פתר הרבה יותר חידות Game of 24 מאשר chain of thought prompting או מאשר דגימה של כמה שרשראות ולקיחת תשובת הרוב, והוא גם הצליח יותר בשתי המשימות האחרות.

המחיר הוא קריאות. כל צעד מועמד וכל הערכה הם בקשה נפרדת, ולכן בעיה פתורה אחת יכולה לקחת עשרות קריאות למודל, כש-chain of thought עולה אחת. העסקה הזו הגיונית לבעיות קשות ולא הגיונית בכלל לפשוטות.

Tree of thought בפרומפט אחד

אפשר לקרב את הרעיון בהודעה אחת: לבקש כמה גישות שונות, הכרעה לגבי כל אחת מול העובדות שנתתם, ופיתוח של זו ששרדה בלבד. הלשוניות שלמטה שולחות את אותה בעיה בשתי הדרכים.

תשובה ישירהTree of thought

EditCopy

אפליקציית הווב שלנו מהירה למשתמשים באירופה, אבל לוקח לה כ-12 שניות להיטען למשתמשים באוסטרליה. השרת נמצא בפרנקפורט. כשהעמוד נטען, הדפדפן שולח 40 בקשות API קטנות, אחת אחרי השנייה. מה הסיבה ומה עלינו לעשות?

Try it

Example replyReplies vary between models and runs.

הסיבה העיקרית היא המרחק הפיזי בין אוסטרליה לשרת שלכם בפרנקפורט. כל בקשה צריכה לנסוע לאירופה ובחזרה, ועם 40 בקשות בכל טעינת עמוד, העיכוב הזה מצטבר.

הפתרון הסטנדרטי הוא CDN (רשת להפצת תוכן). CDN שומר עותקים של האתר שלכם בשרתים ברחבי העולם, כך שמשתמשים באוסטרליה מורידים ממיקום קרוב במקום מפרנקפורט. רוב הספקים מאפשרים לשים אחד לפני אתר קיים בלי לשנות את הקוד.

אפשר גם לדחוס תמונות ולהפעיל שמירה במטמון של הדפדפן כדי לקצר עוד את זמן הטעינה.

התשובה הישירה לא מופרכת; היא אפילו סופרת את 40 הבקשות, אבל היא לקחה את ההסבר הראשון שהתאים ("מרחק") ורצה איתו. התשובה המסתעפת בדקה כל הסבר מול הפרטים בפרומפט, וכך שמה לב ש-"אחת אחרי השנייה" חשוב יותר מ-"אוסטרליה", ושה-CDN היה משאיר את קריאות ה-API בלי שינוי.

תבנית לשימוש חוזר

אותו מבנה עובד להחלטות עיצוב ולתוכניות. מלאו את הבעיה ואת הקריטריונים שחשובים לכם; התשובה מראה את ברירת המחדל כשהיא מולאה.

להסתעף, לשפוט, לבחור

EditCopy

Fill inבעיהקריטריוניםענפים

בעיה: הצוות שלנו, שלושה אנשים, צריך לבחור איך לפרוס API קטן ב-Node.js. קריטריונים: עלות חודשית, זמן הקמה, תחזוקה שוטפת הצע 3 גישות שונות באמת. לכל אחת, דרג אותה מול כל קריטריון בשורה קצרה אחת ותן הכרעה: לשמור או לזנוח. אחר כך פתח רק את הגישה הטובה ביותר לחמישה צעדים ראשונים קונקרטיים. אם שתי גישות שקולות, אמור איזה מידע יכריע ביניהן.

Try it

Example replyReplies vary between models and runs.

פלטפורמה כשירות (אירוח אפליקציות מנוהל) עלות: בינונית, עולה עם התעבורה. הקמה: פחות משעה מ-repo ב-Git. תחזוקה: נמוכה, המארח מעדכן את מערכת ההפעלה. לשמור.

שרת וירטואלי משלכם עלות: הנמוכה ביותר. הקמה: יום לשרת, ל-TLS ולמנהל תהליכים. תחזוקה: גבוהה, העדכונים וההפעלות מחדש עליכם. לזנוח לצוות של שלושה.

פונקציות serverless עלות: נמוכה מאוד בהיקף קטן. הקמה: בינונית, ייתכן שאפליקציית שרת קיימת תצטרך מבנה מחדש. תחזוקה: נמוכה, אבל cold starts מוסיפים השהיה. לשמור כמקום שני.

הטובה ביותר: פלטפורמה כשירות. צעדים ראשונים:

1. להוסיף סקריפט הפעלה ולקרוא את הפורט ממשתנה סביבה.
2. להעביר סודות להגדרות הסביבה של המארח.
3. לחבר את ה-repository ולפרוס את הענף הראשי.
4. להוסיף endpoint לבדיקת תקינות.
5. להגדיר התראת הוצאות.

איפה הפרומפט האחד לא מספיק

גרסת הפרומפט האחד שומרת על אוצר המילים של השיטה, אבל מאבדת את רוב המנגנון.

• אין חזרה אחורה אמיתית. המודל כותב את כל הענפים וההכרעות במעבר אחד. אם צעד 3 של הענף שנבחר נכשל, שום דבר לא מחזיר אותו לצעד 1.
• השופט הוא הכותב. אותה תשובה שהציעה רעיון גם מדרגת אותו, ולכן היא נוטה להעדיף את הענף שכבר היה לה בראש. במאמר, ההערכה היא קריאה נפרדת שמתבצעת אחרי שהמועמדים קיימים.
• הענפים לא עצמאיים. רעיונות שמופיעים בתשובה אחת משפיעים זה על זה ולעתים קרובות מסתיימים כווריאציות על נושא אחד. לבקש גישות "שונות באמת", כמו שהתבנית עושה, דוחף נגד זה אבל לא מבטל את זה.
• מודלי היסק כבר מסתעפים. מודלים שחושבים לפני שהם עונים מנסים וזונחים גישות באופן פנימי. אצלם הפרומפט מוסיף פחות דיוק; הערך שנשאר לו הוא שאתם רואים את האפשרויות שנדחו ויכולים לחלוק על הנימוק.

להריץ חיפוש עץ אמיתי בקוד

השיטה המלאה היא לולאה בתוכנה שלכם: לייצר צעדים מועמדים, לתת ציון לכל פתרון חלקי בקריאה נפרדת, לשמור את הטובים ביותר, ולחזור. זו גרסת breadth-first מינימלית עם OpenAI Python SDK; אותה צורה עובדת עם כל ספק.

from openai import OpenAI

client = OpenAI()
MODEL = "your-model-id"  # e.g. from your provider's model list

def ask(prompt, temperature=0.7):
    response = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "user", "content": prompt}],
        temperature=temperature,
    )
    return response.choices[0].message.content.strip()

def propose(problem, path, k=3):
    steps = "\n".join(path) or "(none yet)"
    prompt = f"Problem: {problem}\nSteps so far:\n{steps}\nPropose the next step only."
    return [ask(prompt) for _ in range(k)]

def score(problem, path):
    steps = "\n".join(path)
    prompt = (f"Problem: {problem}\nPartial solution:\n{steps}\n"
              "How likely is this to lead to a correct solution? Reply with a number from 1 to 10 only.")
    try:
        return float(ask(prompt, temperature=0))
    except ValueError:
        return 0.0

def tree_of_thought(problem, depth=3, keep=2):
    frontier = [[]]
    for _ in range(depth):
        candidates = [path + [step] for path in frontier for step in propose(problem, path)]
        candidates.sort(key=lambda p: score(problem, p), reverse=True)
        frontier = candidates[:keep]
    return frontier[0]

עם depth=3, keep=2 ושלוש הצעות לכל מצב, הרצה אחת מבצעת כשלושים קריאות. במשימות רבות, self-consistency prompting (כמה תשובות מלאות, הצבעת רוב) או רצף קבוע של שלבים עם prompt chaining משיגים את רוב התועלת בפחות קריאות. פנו לעץ כשהמשימה דורשת חיפוש: הרבה צעדים ראשונים אפשריים, ודרך לזהות מבוי סתום מוקדם.