ai-agents-for-beginners

עיצוב רב-סוכני

(לחץ על התמונה למעלה לצפייה בסרטון של השיעור)

מטה-קוגניציה בסוכני בינה מלאכותית

מבוא

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

יעדי הלמידה

לאחר השלמת השיעור, תוכלו:

  1. להבין את המשמעויות של לולאות היגיון בהגדרות סוכנים.
  2. להשתמש בטכניקות תכנון והערכה לסייע לסוכנים מתקנים עצמם.
  3. ליצור סוכנים שלכם שיוכלו לתמרן קוד כדי לבצע משימות.

מבוא למטה-קוגניציה

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

בהקשר של מערכות בינה מלאכותית סוכניות, מטה-קוגניציה יכולה לסייע להתמודד עם מספר אתגרים, כגון:

מהי מטה-קוגניציה?

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

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

חשיבות המטה-קוגניציה בסוכני AI

מטה-קוגניציה משחקת תפקיד מכריע בעיצוב סוכני בינה מלאכותית ממספר סיבות:

חשיבות המטה-קוגניציה

מרכיבים של סוכן בינה מלאכותית

בטרם נצלול לתהליכים מטה-קוגניטיביים, חשוב להבין את המרכיבים הבסיסיים של סוכן בינה מלאכותית. סוכן BAI כולל בדרך כלל:

מרכיבים אלה פועלים יחד ליצירת “יחידת מומחיות” המסוגלת לבצע משימות ספציפיות.

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

דוגמה: מטה-קוגניציה בשירות סוכן נסיעות

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

משימה נוכחית

המשימה הנוכחית היא לעזור למשתמש לתכנן טיול לפריז.

צעדים להשלמת המשימה

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

משאבים נדרשים

ניסיון והתבוננות עצמית

סוכן הנסיעות משתמש במטה-קוגניציה כדי להעריך את ביצועיו וללמוד מניסיון העבר. לדוגמה:

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

דוגמה מעשית למפתח

הנה דוגמה מפושטת כיצד יכול להיראות קוד של סוכן הנסיעות בשילוב מטה-קוגניציה:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        # חיפוש טיסות, מלונות ואטרקציות בהתבסס על העדפות
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        # ניתוח משוב והתאמת המלצות עתידיות
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# דוגמת שימוש
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

מדוע מטה-קוגניציה חשובה

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

2. תכנון בסוכנים

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

מרכיבי תכנון

דוגמה: הנה הצעדים שסוכן הנסיעות צריך לנקוט כדי לסייע למשתמש בתכנון הטיול ביעילות:

צעדים לסוכן הנסיעות

  1. איסוף העדפות משתמש
    • שאל את המשתמש לגבי פרטי תאריכי נסיעה, תקציב, תחומי עניין ודרישות ספציפיות.
    • דוגמאות: “מתי אתה מתכנן לטוס?” “מה טווח התקציב שלך?” “אילו פעילויות אתה אוהב בחופשה?”
  2. שליפת מידע
    • חפש אפשרויות רלוונטיות לנסיעה בהתבסס על העדפות המשתמש.
    • טיסות: חפש טיסות זמינות במסגרת התקציב ותאריכי הנסיעה המועדפים.
    • אירוח: מצא מלונות או נכסים להשכרה התואמים את העדפות המשתמש למיקום, מחיר ושירותים.
    • אטרקציות ומסעדות: זהה אטרקציות פופולריות, פעילויות ואפשרויות אוכל התואמות לתחומי העניין של המשתמש.
  3. יצירת המלצות
    • אסוף את המידע שנשלף למסלול מותאם אישית.
    • ספק פרטים כמו אפשרויות טיסה, הזמנות במלון ופעילויות מוצעות, תוך התאמת ההמלצות להעדפות המשתמש.
  4. הצגת המסלול למשתמש
    • שתף את המסלול המוצע עם המשתמש לעיון.
    • דוגמה: “הנה מסלול מוצע לטיול שלך לפריז. הוא כולל פרטי טיסה, הזמנות במלון ורשימת פעילויות ומסעדות מומלצות. אשמח לשמוע את התגובות שלך!”
  5. איסוף משוב
    • שאל את המשתמש לגבי המשוב על המסלול שהוצע.
    • דוגמאות: “האם אתה אוהב את אפשרויות הטיסה?” “האם המלון מתאים לצרכיך?” “האם יש פעילויות שברצונך להוסיף או להסיר?”
  6. התאמה על סמך המשוב
    • שנה את המסלול בהתבסס על המשוב של המשתמש.
    • בצע שינויים נדרשים בהמלצות הטיסה, האירוח והפעילויות כדי להתאים טוב יותר להעדפות המשתמש.
  7. אישור סופי
    • הצג את המסלול המעודכן למשתמש לאישור סופי.
    • דוגמה: “ביצעתי את ההתאמות בהתבסס על המשוב שלך. הנה המסלול המעודכן. הכל נראה טוב?”
  8. הזמנה ואישור הזמנות
    • לאחר שהמשתמש מאשר את המסלול, המשך להזמין טיסות, אירוח וכל פעילויות מתוכננות מראש.
    • שלח פרטי אישור למשתמש.
  9. מתן תמיכה שוטפת
    • היה זמין לסייע למשתמש עם שינויים או בקשות נוספות לפני ובמהלך הטיול.
    • דוגמה: “אם תזדקק לעזרה נוספת במהלך הטיול, אל תהסס לפנות אליי בכל עת!”

דוגמת אינטראקציה

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# דוגמה לשימוש בתוך בקשת חריקה
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

3. מערכת RAG מתקנת

ראשית, בוא נתחיל בהבנת ההבדל בין כלי RAG לטעינת הקשר מוקדמת

RAG לעומת טעינת הקשר

הפעלה מתוגברת בהשלמת מידע (RAG)

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

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

גישת RAG מתקנת

גישת RAG מתקנת מתמקדת בשימוש בטכניקות RAG כדי לתקן שגיאות ולשפר את הדיוק של סוכני בינה מלאכותית. זה כולל:

  1. טכניקת עידוד: שימוש בעידודים ספציפיים להכוונת הסוכן לשליפת מידע רלוונטי.
  2. כלי: יישום אלגוריתמים ומנגנונים המאפשרים לסוכן להעריך את רלוונטיות המידע שנשלף ולייצר תגובות מדויקות.
  3. הערכה: הערכה מתמשכת של ביצועי הסוכן וביצוע התאמות לשיפור הדיוק והיעילות.

דוגמה: RAG מתקנת בסוכן חיפוש

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

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

RAG מתקנת בסוכן נסיעות

RAG מתקנת (Retrieval-Augmented Generation) משפרת את יכולת ה-AI לשלוף וליצור מידע תוך תיקון אי-דיוקים. נבדוק כיצד סוכן הנסיעות יכול להשתמש בגישת RAG מתקנת כדי לספק המלצות נסיעה מדויקות ורלוונטיות יותר.

זה כולל:

צעדים ליישום RAG מתקנת בסוכן נסיעות

  1. אינטראקציה ראשונית עם המשתמש
    • סוכן הנסיעות אוסף העדפות ראשוניות מהמשתמש, כמו יעד, תאריכי נסיעה, תקציב ותחומי עניין.

    • דוגמה:

      preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
  2. שליפת מידע
    • סוכן הנסיעות שולף מידע על טיסות, אירוח, אטרקציות ומסעדות בהתאם להעדפות המשתמש.

    • דוגמה:

      flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
  3. יצירת המלצות ראשוניות
    • סוכן הנסיעות משתמש במידע שנשלף כדי ליצור מסלול מותאם אישית.

    • דוגמה:

      itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)
  4. איסוף משוב מהמשתמש
    • סוכן הנסיעות מבקש מהמשתמש משוב על ההמלצות הראשוניות.

    • דוגמה:

      feedback = {
    "liked": ["Louvre Museum"],
    "disliked": ["Eiffel Tower (too crowded)"]
}
  5. תהליך RAG מתקנת
    • טכניקת עידוד: סוכן הנסיעות מנוסח שאילתות חיפוש חדשות בהתבסס על משוב המשתמש.

      • דוגמה:

        if "disliked" in feedback:
    preferences["avoid"] = feedback["disliked"]
    • כלי: סוכן הנסיעות משתמש באלגוריתמים לדרג ולסנן תוצאות חיפוש חדשות, תוך הדגשת הרלוונטיות על בסיס משוב המשתמש.

      • דוגמה:

        new_attractions = search_attractions(preferences)
new_itinerary = create_itinerary(flights, hotels, new_attractions)
print("Updated Itinerary:", new_itinerary)
    • הערכה: סוכן הנסיעות מעריך כל העת את הרלוונטיות והדיוק של המלצותיו על ידי ניתוח משוב משתמש וביצוע התאמות נדרשות.

      • דוגמה:

        def adjust_preferences(preferences, feedback):
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    return preferences

preferences = adjust_preferences(preferences, feedback)

דוגמה מעשית

הנה דוגמת קוד פייתון מפושטת המשולבת בגישת RAG מתקנת בסוכן הנסיעות:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)
        new_itinerary = self.generate_recommendations()
        return new_itinerary

# דוגמת שימוש
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
new_itinerary = travel_agent.adjust_based_on_feedback(feedback)
print("Updated Itinerary:", new_itinerary)

טעינת הקשר מוקדמת

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

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

class TravelAgent:
    def __init__(self):
        # טעינת מקומות פופולריים ומידע עליהם מראש
        self.context = {
            "Paris": {"country": "France", "currency": "Euro", "language": "French", "attractions": ["Eiffel Tower", "Louvre Museum"]},
            "Tokyo": {"country": "Japan", "currency": "Yen", "language": "Japanese", "attractions": ["Tokyo Tower", "Shibuya Crossing"]},
            "New York": {"country": "USA", "currency": "Dollar", "language": "English", "attractions": ["Statue of Liberty", "Times Square"]},
            "Sydney": {"country": "Australia", "currency": "Dollar", "language": "English", "attractions": ["Sydney Opera House", "Bondi Beach"]}
        }

    def get_destination_info(self, destination):
        # הבאת מידע על היעד מהקשר שטעון מראש
        info = self.context.get(destination)
        if info:
            return f"{destination}:\nCountry: {info['country']}\nCurrency: {info['currency']}\nLanguage: {info['language']}\nAttractions: {', '.join(info['attractions'])}"
        else:
            return f"Sorry, we don't have information on {destination}."

# דוגמת שימוש
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

הסבר

  1. אתחול (מתודת __init__): מחלקת TravelAgent טוענת מראש מילון המכיל מידע אודות יעדים פופולריים כמו פריז, טוקיו, ניו יורק וסידני. מילון זה כולל פרטים כמו מדינה, מטבע, שפה ואטרקציות עיקריות עבור כל יעד.

  2. שליפת מידע (מתודת get_destination_info): כאשר משתמש שואל על יעד מסוים, מתודת get_destination_info שולפת את המידע הרלוונטי ממילון ההקשר הטעון מראש.

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

יצירת בסיס לתוכנית עם מטרה לפני איטרציה

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

הנה דוגמה כיצד ניתן ליצור תוכנית נסיעות עם מטרה לפני איטרציה עבור סוכן נסיעות בפייתון:

תרחיש

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

שלבים

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

קוד פייתון

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def bootstrap_plan(self, preferences, budget):
        plan = []
        total_cost = 0

        for destination in self.destinations:
            if total_cost + destination['cost'] <= budget and self.match_preferences(destination, preferences):
                plan.append(destination)
                total_cost += destination['cost']

        return plan

    def match_preferences(self, destination, preferences):
        for key, value in preferences.items():
            if destination.get(key) != value:
                return False
        return True

    def iterate_plan(self, plan, preferences, budget):
        for i in range(len(plan)):
            for destination in self.destinations:
                if destination not in plan and self.match_preferences(destination, preferences) and self.calculate_cost(plan, destination) <= budget:
                    plan[i] = destination
                    break
        return plan

    def calculate_cost(self, plan, new_destination):
        return sum(destination['cost'] for destination in plan) + new_destination['cost']

# דוגמה לשימוש
destinations = [
    {"name": "Paris", "cost": 1000, "activity": "sightseeing"},
    {"name": "Tokyo", "cost": 1200, "activity": "shopping"},
    {"name": "New York", "cost": 900, "activity": "sightseeing"},
    {"name": "Sydney", "cost": 1100, "activity": "beach"},
]

preferences = {"activity": "sightseeing"}
budget = 2000

travel_agent = TravelAgent(destinations)
initial_plan = travel_agent.bootstrap_plan(preferences, budget)
print("Initial Plan:", initial_plan)

refined_plan = travel_agent.iterate_plan(initial_plan, preferences, budget)
print("Refined Plan:", refined_plan)

הסבר קוד

  1. אתחול (מתודת __init__): מחלקת TravelAgent מאותחלת עם רשימת יעדים פוטנציאליים, כאשר לכל יעד יש תכונות כמו שם, עלות וסוג פעילות.

  2. יצירת התוכנית (מתודת bootstrap_plan): מתודה זו יוצרת תוכנית נסיעות ראשונית על בסיס העדפות הלקוח והתקציב. היא עוברת על רשימת היעדים ומוסיפה אותם לתכנית אם הם מתאימים להעדפות הלקוח ומתאימים לתקציב.

  3. התאמת העדפות (מתודת match_preferences): מתודה זו בודקת אם יעד תואם להעדפות הלקוח.

  4. איטרציה על התכנית (מתודת iterate_plan): מתודה זו משכללת את התכנית הראשונית על ידי ניסיון להחליף כל יעד בתכנית בהתאמה טובה יותר, בהתחשב בהעדפות הלקוח ובמגבלות התקציב.

  5. חישוב עלות (מתודת calculate_cost): מתודה זו מחשבת את העלות הכוללת של התוכנית הנוכחית, כולל יעד חדש פוטנציאלי.

דוגמה לשימוש

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

ניצול מודל שפה גדול (LLM) לסידור מחדש ותגמול

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

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

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

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

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

הנה דוגמה כיצד סוכן נסיעות יכול להשתמש במודל שפה גדול (LLM) לסידור מחדש ותגמול של יעדי נסיעות בהתבסס על העדפות המשתמש בפייתון:

תרחיש - נסיעות בהתבסס על העדפות

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

שלבים:

  1. איסוף העדפות המשתמש.
  2. שליפת רשימת יעדי נסיעות פוטנציאליים.
  3. שימוש ב-LLM לסידור מחדש ותגמול היעדים בהתאם להעדפות המשתמש.

כך תוכלו לעדכן את הדוגמה הקודמת לשימוש בשירותי Azure OpenAI:

דרישות

  1. יש להחזיק במנוי Azure.
  2. ליצור משאב Azure OpenAI ולקבל את מפתח ה-API שלך.

דוגמת קוד פייתון

import requests
import json

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def get_recommendations(self, preferences, api_key, endpoint):
        # צור פקודה עבור Azure OpenAI
        prompt = self.generate_prompt(preferences)
        
        # הגדר כותרות ותוכן עבור הבקשה
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # קרא ל-API של Azure OpenAI כדי לקבל את היעדים המדורגים והמתוקננים
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # חילוץ והחזרת ההמלצות
        recommendations = response_data['choices'][0]['text'].strip().split('\n')
        return recommendations

    def generate_prompt(self, preferences):
        prompt = "Here are the travel destinations ranked and scored based on the following user preferences:\n"
        for key, value in preferences.items():
            prompt += f"{key}: {value}\n"
        prompt += "\nDestinations:\n"
        for destination in self.destinations:
            prompt += f"- {destination['name']}: {destination['description']}\n"
        return prompt

# דוגמה לשימוש
destinations = [
    {"name": "Paris", "description": "City of lights, known for its art, fashion, and culture."},
    {"name": "Tokyo", "description": "Vibrant city, famous for its modernity and traditional temples."},
    {"name": "New York", "description": "The city that never sleeps, with iconic landmarks and diverse culture."},
    {"name": "Sydney", "description": "Beautiful harbour city, known for its opera house and stunning beaches."},
]

preferences = {"activity": "sightseeing", "culture": "diverse"}
api_key = 'your_azure_openai_api_key'
endpoint = 'https://your-endpoint.com/openai/deployments/your-deployment-name/completions?api-version=2022-12-01'

travel_agent = TravelAgent(destinations)
recommendations = travel_agent.get_recommendations(preferences, api_key, endpoint)
print("Recommended Destinations:")
for rec in recommendations:
    print(rec)

הסבר קוד - בוקר העדפות

  1. אתחול: מחלקת TravelAgent מאותחלת עם רשימת יעדי נסיעות פוטנציאליים, כאשר לכל יעד יש תכונות כמו שם ותיאור.

  2. קבלת המלצות (מתודת get_recommendations): מתודה זו יוצרת פרומפט לשירות Azure OpenAI בהתבסס על העדפות המשתמש ובוחרת קריאת HTTP POST ל-API של Azure OpenAI כדי לקבל יעדים מסודרים מחדש ומדורגים.

  3. יצירת פרומפט (מתודת generate_prompt): מתודה זו בונה פרומפט ל-Azure OpenAI, כולל העדפות המשתמש ורשימת היעדים. הפרומפט מנחה את המודל לסדר מחדש ולתגמל את היעדים בהתאם להעדפות שניתנו.

  4. קריאת API: ספריית requests משמשת לביצוע קריאת HTTP POST לנקודת הקצה של Azure OpenAI API. התגובה מכילה את היעדים המסודרים מחדש ומדורגים.

  5. דוגמה לשימוש: סוכן הנסיעות אוסף את העדפות המשתמש (למשל, עניין בסיורי תרבות מגוונים) ומשתמש בשירות Azure OpenAI כדי לקבל המלצות מסודרות מחדש ומדורגות ליעדי נסיעות.

יש לוודא להחליף את your_azure_openai_api_key במפתח ה-API האמיתי שלך ואת https://your-endpoint.com/... בכתובת הנקודת הקצה האמיתית של הפריסה שלך ב-Azure OpenAI.

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

RAG: טכניקת פרומפטינג מול כלי

יצירה מוגברת בשליפה (Retrieval-Augmented Generation - RAG) יכולה להיות גם טכניקת פרומפטינג וגם כלי בפיתוח סוכני AI. הבנת ההבדל בין השניים יכולה לעזור לך לנצל את RAG בצורה יעילה יותר בפרויקטים שלך.

RAG כטכניקת פרומפטינג

מה זה?

איך זה עובד:

  1. ניסוח פרומפטים: יצירת פרומפטים או שאילתות מסודרות היטב על בסיס המשימה שבידך או הקלט של המשתמש.
  2. שליפת מידע: שימוש בפרומפטים לחיפוש נתונים רלוונטיים מתוך בסיס ידע או מערכת קיימת.
  3. יצירת תגובה: שילוב המידע שנשלף עם מודלי AI גנרטיביים ליצירת תגובה שלמה וקוהרנטית.

דוגמה בסוכן נסיעות:

RAG ככלי

מה זה?

איך זה עובד:

  1. שילוב: הטמעת RAG במבנה של סוכן ה-AI, המאפשר לו לטפל אוטומטית במשימות השליפה והיצירה.
  2. אוטומציה: הכלי מנהל את התהליך כולו, מקבלת קלט המשתמש ועד יצירת התגובה הסופית, ללא צורך בפרומפטים מפורשים בכל שלב.
  3. יעילות: משפר את ביצועי הסוכן על ידי ייעול תהליך השליפה והיצירה, ומאפשר תגובות מהירות ומדויקות יותר.

דוגמה בסוכן נסיעות:

השוואה

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

דוגמאות מעשיות

דוגמה לטכניקת פרומפטינג:

def search_museums_in_paris():
    prompt = "Find top museums in Paris"
    search_results = search_web(prompt)
    return search_results

museums = search_museums_in_paris()
print("Top Museums in Paris:", museums)

דוגמה לכלי:

class Travel_Agent:
    def __init__(self):
        self.rag_tool = RAGTool()

    def get_museums_in_paris(self):
        user_input = "I want to visit museums in Paris."
        response = self.rag_tool.retrieve_and_generate(user_input)
        return response

travel_agent = Travel_Agent()
museums = travel_agent.get_museums_in_paris()
print("Top Museums in Paris:", museums)

הערכת רלוונטיות

הערכת רלוונטיות היא היבט חיוני בביצועי סוכן AI. היא מבטיחה שהמידע שנשלף ונוצר על ידי הסוכן הוא מתאים, מדויק ושימושי למשתמש. נבחן כיצד להעריך רלוונטיות בסוכני AI, כולל דוגמאות מעשיות וטכניקות.

מושגים מרכזיים בהערכת רלוונטיות

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

טכניקות מעשיות להערכת רלוונטיות

  1. ציוני רלוונטיות:
    • הקצאת ציון רלוונטיות לכל פריט שנשלף על סמך עד כמה הוא תואם לשאילתת המשתמש ולהעדפותיו.

    • דוגמה:

      def relevance_score(item, query):
    score = 0
    if item['category'] in query['interests']:
        score += 1
    if item['price'] <= query['budget']:
        score += 1
    if item['location'] == query['destination']:
        score += 1
    return score
  2. סינון ודירוג:
    • סינון פריטים לא רלוונטיים ודירוג הפריטים הנותרים על פי ציוני הרלוונטיות.

    • דוגמה:

      def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # החזר את 10 הפריטים הרלוונטיים העליונים
  3. עיבוד שפה טבעית (NLP):
    • שימוש בטכניקות NLP להבנת שאילתת המשתמש ושליפת מידע רלוונטי.

    • דוגמה:

      def process_query(query):
    # השתמש ב-NLP כדי לחלץ מידע מרכזי מהשאילתא של המשתמש
    processed_query = nlp(query)
    return processed_query
  4. שילוב משוב משתמש:
    • איסוף משוב משתמש על ההמלצות שניתנו ושימוש בו לכיוון הערכות הרלוונטיות העתידיות.

    • דוגמה:

      def adjust_based_on_feedback(feedback, items):
    for item in items:
        if item['name'] in feedback['liked']:
            item['relevance'] += 1
        if item['name'] in feedback['disliked']:
            item['relevance'] -= 1
    return items

דוגמה: הערכת רלוונטיות בסוכן נסיעות

הנה דוגמה מעשית כיצד סוכן הנסיעות יכול להעריך את רלוונטיות ההמלצות לנסיעות:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        ranked_hotels = self.filter_and_rank(hotels, self.user_preferences)
        itinerary = create_itinerary(flights, ranked_hotels, attractions)
        return itinerary

    def filter_and_rank(self, items, query):
        ranked_items = sorted(items, key=lambda item: self.relevance_score(item, query), reverse=True)
        return ranked_items[:10]  # החזר את 10 הפריטים הרלוונטיים ביותר

    def relevance_score(self, item, query):
        score = 0
        if item['category'] in query['interests']:
            score += 1
        if item['price'] <= query['budget']:
            score += 1
        if item['location'] == query['destination']:
            score += 1
        return score

    def adjust_based_on_feedback(self, feedback, items):
        for item in items:
            if item['name'] in feedback['liked']:
                item['relevance'] += 1
            if item['name'] in feedback['disliked']:
                item['relevance'] -= 1
        return items

# דוגמת שימוש
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_items = travel_agent.adjust_based_on_feedback(feedback, itinerary['hotels'])
print("Updated Itinerary with Feedback:", updated_items)

חיפוש עם כוונה

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

מושגים מרכזיים בחיפוש עם כוונה

  1. הבנת כוונת המשתמש:
    • כוונת המשתמש יכולה להתחלק לשלושה סוגים עיקריים: מידע, ניווט וטרנזקציה.
      • כוונה מידעית: המשתמש מחפש מידע בנושא (למשל, “מהם המוזיאונים הטובים ביותר בפריז?”).
      • כוונה ניווטית: המשתמש רוצה לנווט לאתר או דף מסוים (למשל, “אתר רשמי של מוזיאון הלובר”).
      • כוונה טרנזקציונית: המשתמש שואף לבצע פעולה כגון הזמנת טיסה או רכישת מוצר (למשל, “הזמן טיסה לפריז”).
  2. מודעות להקשר:
    • ניתוח הקשר השאילתה של המשתמש מסייע בזיהוי מדויק של כוונתו. זה כולל התייחסות לאינטראקציות קודמות, העדפות המשתמש ופרטים ספציפיים בשאילתה הנוכחית.
  3. עיבוד שפה טבעית (NLP):
    • טכניקות NLP משמשות להבנה ופרשנות של שאילתות השפה הטבעית שהמשתמשים מספקים. זה כולל משימות כמו זיהוי ישויות, ניתוח סנטימנט וניתוח השאילתה.
  4. התאמה אישית:
    • התאמת תוצאות החיפוש בהתבסס על היסטוריית המשתמש, העדפותיו ומשובו משפרת את רלוונטיות המידע שנשלף.

דוגמה מעשית: חיפוש עם כוונה בסוכן נסיעות

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

  1. איסוף העדפות המשתמש

    class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

  2. הבנת כוונת המשתמש

    def identify_intent(query):
    if "book" in query or "purchase" in query:
        return "transactional"
    elif "website" in query or "official" in query:
        return "navigational"
    else:
        return "informational"

  3. מודעות להקשר

    def analyze_context(query, user_history):
    # שלב את השאילתה הנוכחית עם היסטוריית המשתמש כדי להבין את ההקשר
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

  4. חיפוש והתאמת תוצאות אישית

    def search_with_intent(query, preferences, user_history):
    intent = identify_intent(query)
    context = analyze_context(query, user_history)
    if intent == "informational":
        search_results = search_information(query, preferences)
    elif intent == "navigational":
        search_results = search_navigation(query)
    elif intent == "transactional":
        search_results = search_transaction(query, preferences)
    personalized_results = personalize_results(search_results, user_history)
    return personalized_results

def search_information(query, preferences):
    # דוגמא ללוגיקת חיפוש למטרת מידע
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # דוגמא ללוגיקת חיפוש למטרת ניווט
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # דוגמא ללוגיקת חיפוש למטרת טרנזקציה
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # דוגמא ללוגיקת התאמה אישית
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # החזר את 10 התוצאות האישיות הטובות ביותר

  5. שימוש לדוגמה

    travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
user_history = ["Louvre Museum website", "Book flight to Paris"]
query = "best museums in Paris"
results = search_with_intent(query, preferences, user_history)
print("Search Results:", results)

4. יצירת קוד ככלי

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

סוכני יצירת קוד

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

יישומים מעשיים

  1. יצירת קוד מאוטומטת: יצירת קטעי קוד למשימות ספציפיות, כגון ניתוח נתונים, גירוד רשת, או למידת מכונה.
  2. SQL ככלי RAG: שימוש בשאילתות SQL לשליפה ומניפולציה של נתונים מבסיסי נתונים.
  3. פתרון בעיות: יצירה והרצה של קוד לפתרון בעיות ספציפיות, כגון אופטימיזציה של אלגוריתמים או ניתוח נתונים.

דוגמה: סוכן יצירת קוד לניתוח נתונים

דמיין שאתה מפתח סוכן יצירת קוד. כך זה יכול לעבוד:

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

דוגמה: סוכן יצירת קוד לסוכן נסיעות

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

סקירה של סוכן יצירת הקוד

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

ביצוע שלב אחר שלב

  1. איסוף העדפות משתמש

    class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

  2. יצירת קוד לאחזור נתונים

    def generate_code_to_fetch_data(preferences):
    # דוגמה: יצירת קוד לחיפוש טיסות בהתאם להעדפות המשתמש
    code = f"""
    def search_flights():
        import requests
        response = requests.get('https://api.example.com/flights', params={preferences})
        return response.json()
    """
    return code

def generate_code_to_fetch_hotels(preferences):
    # דוגמה: יצירת קוד לחיפוש בתי מלון
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

  3. הרצת הקוד שנוצר

    def execute_code(code):
    # הפעל את הקוד שנוצר באמצעות exec
    exec(code)
    result = locals()
    return result

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
   
flight_code = generate_code_to_fetch_data(preferences)
hotel_code = generate_code_to_fetch_hotels(preferences)
   
flights = execute_code(flight_code)
hotels = execute_code(hotel_code)

print("Flight Options:", flights)
print("Hotel Options:", hotels)

  4. יצירת מסלול נסיעה

    def generate_itinerary(flights, hotels, attractions):
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

attractions = search_attractions(preferences)
itinerary = generate_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)

  5. התאמה בהתאם למשוב

    def adjust_based_on_feedback(feedback, preferences):
    # התאם העדפות בהתבסס על משוב המשתמש
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    return preferences

feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences)
   
# הפק מחדש והרץ קוד עם העדפות מעודכנות
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)
   
updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)
   
updated_itinerary = generate_itinerary(updated_flights, updated_hotels, attractions)
print("Updated Itinerary:", updated_itinerary)

ניצול מודעות סביבתית והסקת מסקנות

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

הנה דוגמה כיצד ניתן לעשות זאת:

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

הנה דוגמה מעודכנת בקוד פייתון שמשלבת את הקונספטים האלה:

def adjust_based_on_feedback(feedback, preferences, schema):
    # התאמת העדפות בהתבסס על משוב המשתמש
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # הנמקה מבוססת תרשים להתאמת עדפות קשורות אחרות
    for field in schema:
        if field in preferences:
            preferences[field] = adjust_based_on_environment(feedback, field, schema)
    return preferences

def adjust_based_on_environment(feedback, field, schema):
    # לוגיקה מותאמת אישית להתאמת העדפות בהתבסס על תרשים ומשוב
    if field in feedback["liked"]:
        return schema[field]["positive_adjustment"]
    elif field in feedback["disliked"]:
        return schema[field]["negative_adjustment"]
    return schema[field]["default"]

def generate_code_to_fetch_data(preferences):
    # יצירת קוד לשליפת נתוני טיסות בהתבסס על העדפות מעודכנות
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # יצירת קוד לשליפת נתוני מלונות בהתבסס על העדפות מעודכנות
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # סימולציה של הרצת הקוד והחזרת נתוני דמה
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # יצירת מסלול טיול המבוסס על טיסות, מלונות ואטרקציות
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# דוגמת תרשים
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# דוגמת שימוש
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# יצירת קוד מחדש והפעלתו עם העדפות מעודכנות
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)

updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)

updated_itinerary = generate_itinerary(updated_flights, updated_hotels, feedback["liked"])
print("Updated Itinerary:", updated_itinerary)

הסבר - הזמנה בהתבסס על משוב

  1. מודעות למבנה: מילון schema מגדיר כיצד להסתגל לעדפות בהתבסס על משוב. כולל שדות כמו favorites ו-avoid עם התאמות תואמות.
  2. התאמת העדפות (adjust_based_on_feedback method): מתודה זו מתאימה את ההעדפות על סמך משוב המשתמש והמבנה.
  3. התאמות מבוססות סביבה (adjust_based_on_environment method): מתודה זו מותאמת את ההתאמות בהתבסס על המבנה והמשוב.
  4. יצירה והרצת שאילתות: המערכת יוצרת קוד לאחזור נתונים מעודכנים וטסים ובתי מלון בהתאם להעדפות המותאמות ומדמה את ביצוע השאילתות.
  5. יצירת מסלול נסיעה: המערכת יוצרת מסלול נסיעה מעודכן על בסיס הנתונים החדשים של טיסות, בתי מלון ואטרקציות.

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

שימוש ב-SQL כטכניקת Retrieval-Augmented Generation (RAG)

SQL (שפת שאילתות מובנית) היא כלי עוצמתי לאינטראקציה עם בסיסי נתונים. כאשר משתמשים בה כחלק מגישת Retrieval-Augmented Generation (RAG), SQL יכולה לשלוף נתונים רלוונטיים מבסיסי נתונים כדי ליידע וליצור תגובות או פעולות בסוכני בינה מלאכותית. נבדוק כיצד SQL יכולה לשמש כטכניקת RAG בהקשר של סוכן נסיעות.

מושגים מפתח

  1. אינטראקציה עם בסיס נתונים:
    • SQL משמשת לשאילת בסיסי נתונים, שליפת מידע רלוונטי ומניפולציה בנתונים.
    • דוגמה: אחזור פרטי טיסות, מידע על בתי מלון ואטרקציות מבסיס נתוני טיולים.
  2. שילוב עם RAG:
    • שאילתות SQL נוצרות בהתבסס על קלט והעדפות המשתמש.
    • הנתונים שנשלפו משמשים ליצירת המלצות מותאמות או פעולות.
  3. יצירה דינמית של שאילתות:
    • הסוכן הגנרטיבי יוצר שאילתות SQL דינמיות בהתבסס על ההקשר וצרכי המשתמש.
    • דוגמה: התאמת שאילתות SQL לסינון תוצאות בהתאם לתקציב, תאריכים ותחומי עניין.

יישומים

דוגמה: סוכן לניתוח נתונים:

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

דוגמה מעשית: שימוש ב-SQL בסוכן נסיעות

  1. איסוף העדפות משתמש

    class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

  2. יצירת שאילתות SQL

    def generate_sql_query(table, preferences):
    query = f"SELECT * FROM {table} WHERE "
    conditions = []
    for key, value in preferences.items():
        conditions.append(f"{key}='{value}'")
    query += " AND ".join(conditions)
    return query

  3. הרצת שאילתות SQL

    import sqlite3

def execute_sql_query(query, database="travel.db"):
    connection = sqlite3.connect(database)
    cursor = connection.cursor()
    cursor.execute(query)
    results = cursor.fetchall()
    connection.close()
    return results

  4. יצירת המלצות

    def generate_recommendations(preferences):
    flight_query = generate_sql_query("flights", preferences)
    hotel_query = generate_sql_query("hotels", preferences)
    attraction_query = generate_sql_query("attractions", preferences)
       
    flights = execute_sql_query(flight_query)
    hotels = execute_sql_query(hotel_query)
    attractions = execute_sql_query(attraction_query)
       
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = generate_recommendations(preferences)
print("Suggested Itinerary:", itinerary)

שאילתות SQL לדוגמה

  1. שאילתת טיסה

    SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-10' AND budget='moderate';

  2. שאילתת מלון

    SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate';

  3. שאילתת אטרקציה

    SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';

על ידי שימוש ב-SQL כחלק מטכניקת Retrieval-Augmented Generation (RAG), סוכני בינה מלאכותית כמו סוכן נסיעות יכולים לאחזר באופן דינמי ולהשתמש בנתונים רלוונטיים כדי לספק המלצות מדויקות ומותאמות אישית.

דוגמה למטה-קוגניציה

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

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

כיצד זה מאיר את המטה-קוגניציה:

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

הנה דוגמה:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # מאחסן את המלונות שנבחרו קודם
        self.corrected_choices = []  # מאחסן את הבחירות המתוקנות
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # אסטרטגיות זמינות

    def recommend_hotel(self, hotels, strategy):
        """
        Recommend a hotel based on the chosen strategy.
        The strategy can either be 'cheapest' or 'highest_quality'.
        """
        if strategy == 'cheapest':
            recommended = min(hotels, key=lambda x: x['price'])
        elif strategy == 'highest_quality':
            recommended = max(hotels, key=lambda x: x['quality'])
        else:
            recommended = None
        self.previous_choices.append((strategy, recommended))
        return recommended

    def reflect_on_choice(self):
        """
        Reflect on the last choice made and decide if the agent should adjust its strategy.
        The agent considers if the previous choice led to a poor outcome.
        """
        if not self.previous_choices:
            return "No choices made yet."

        last_choice_strategy, last_choice = self.previous_choices[-1]
        # נניח שיש לנו משוב משתמש שמספר לנו אם הבחירה האחרונה הייתה טובה או לא
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # להתאים את האסטרטגיה אם הבחירה הקודמת לא הייתה מספקת
            new_strategy = 'highest_quality' if last_choice_strategy == 'cheapest' else 'cheapest'
            self.corrected_choices.append((new_strategy, last_choice))
            return f"Reflecting on choice. Adjusting strategy to {new_strategy}."
        else:
            return "The choice was good. No need to adjust."

    def get_user_feedback(self, hotel):
        """
        Simulate user feedback based on hotel attributes.
        For simplicity, assume if the hotel is too cheap, the feedback is "bad".
        If the hotel has quality less than 7, feedback is "bad".
        """
        if hotel['price'] < 100 or hotel['quality'] < 7:
            return "bad"
        return "good"

# לדמות רשימת מלונות (מחיר ואיכות)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# ליצור סוכן
agent = HotelRecommendationAgent()

# שלב 1: הסוכן ממליץ על מלון באמצעות אסטרטגיית "הכי זול"
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# שלב 2: הסוכן משקף את הבחירה ומתקן את האסטרטגיה אם יש צורך
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# שלב 3: הסוכן ממליץ שוב, הפעם באמצעות האסטרטגיה המתוקנת
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

יכולות מטה-קוגניציה של סוכנים

המפתח כאן הוא יכולתו של הסוכן:

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

סיכום

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

יש לך עוד שאלות על תבנית העיצוב של מטה-קוגניציה?

הצטרף ל-Microsoft Foundry Discord כדי להיפגש עם לומדים אחרים, להשתתף בשעות קבלה ולקבל מענה לשאלות על סוכני בינה מלאכותית.

שיעור קודם

תבנית עיצוב רב-סוכנית

שיעור הבא

סוכני בינה מלאכותית בפרודקשן

כתב ויתור: מסמך זה תורגם באמצעות שירות תרגום אוטומטי Co-op Translator. למרות שאנו שואפים לדיוק, יש לקחת בחשבון שתרגומים אוטומטיים עלולים להכיל שגיאות או אי-דיוקים. יש להחשיב את המסמך המקורי בשפתו הטבעית כמקור הסמכות. למידע קריטי מומלץ להשתמש בתרגום מקצועי על ידי מתרגם אדם. אנו לא אחראים לכל אי-הבנה או פירוש שגוי הנובע מהשימוש בתרגום זה.

This site is open source. Improve this page.