ai-agents-for-beginners

Multi-Agent Design

(คลิกที่ภาพด้านบนเพื่อดูวิดีโอของบทเรียนนี้)

การคิดเกี่ยวกับการคิดในตัวแทน AI

บทนำ

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

เป้าหมายการเรียนรู้

หลังจากจบบทเรียนนี้ คุณจะสามารถ:

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

การแนะนำเรื่องการคิดเกี่ยวกับการคิด

การคิดเกี่ยวกับการคิดหมายถึงกระบวนการทางปัญญาระดับสูงที่เกี่ยวข้องกับการคิดเกี่ยวกับการคิดของตัวเอง สำหรับตัวแทน AI หมายถึงความสามารถในการประเมินและปรับเปลี่ยนการกระทำของตัวเองโดยอิงจากการรับรู้ตัวเองและประสบการณ์ที่ผ่านมา การคิดเกี่ยวกับการคิด หรือ “การคิดเกี่ยวกับการคิด” เป็นแนวคิดสำคัญในการพัฒนาระบบ AI ที่มีความเป็นตัวแทน ซึ่งเกี่ยวข้องกับการที่ระบบ AI มีความตระหนักรู้ในกระบวนการภายในของตัวเอง และสามารถตรวจสอบ ควบคุม และปรับเปลี่ยนพฤติกรรมของตัวเองได้ เช่นเดียวกับที่เราทำเมื่อเราประเมินสถานการณ์หรือแก้ปัญหา ความตระหนักรู้ในตัวเองนี้สามารถช่วยให้ระบบ AI ตัดสินใจได้ดีขึ้น ระบุข้อผิดพลาด และปรับปรุงประสิทธิภาพของตัวเองเมื่อเวลาผ่านไป ซึ่งเชื่อมโยงกลับไปยังการทดสอบของทัวริงและการถกเถียงว่า AI จะเข้ามาแทนที่มนุษย์หรือไม่

ในบริบทของระบบ AI ที่มีความเป็นตัวแทน การคิดเกี่ยวกับการคิดสามารถช่วยแก้ไขความท้าทายหลายประการ เช่น:

การคิดเกี่ยวกับการคิดคืออะไร?

การคิดเกี่ยวกับการคิด หรือ “การคิดเกี่ยวกับการคิด” เป็นกระบวนการทางปัญญาระดับสูงที่เกี่ยวข้องกับการรับรู้ตัวเองและการควบคุมกระบวนการทางปัญญาของตัวเอง ในโลกของ AI การคิดเกี่ยวกับการคิดช่วยให้ตัวแทนสามารถประเมินและปรับเปลี่ยนกลยุทธ์และการกระทำของตัวเอง ซึ่งนำไปสู่ความสามารถในการแก้ปัญหาและการตัดสินใจที่ดีขึ้น โดยการเข้าใจการคิดเกี่ยวกับการคิด คุณสามารถออกแบบตัวแทน AI ที่ไม่เพียงแต่ฉลาดขึ้น แต่ยังปรับตัวและมีประสิทธิภาพมากขึ้น ในการคิดเกี่ยวกับการคิดที่แท้จริง คุณจะเห็น AI ให้เหตุผลอย่างชัดเจนเกี่ยวกับการให้เหตุผลของตัวเอง

ตัวอย่าง: “ฉันให้ความสำคัญกับเที่ยวบินราคาถูกเพราะ… ฉันอาจพลาดเที่ยวบินตรง ดังนั้นให้ฉันตรวจสอบอีกครั้ง” การติดตามว่าเหตุใดหรืออย่างไรที่มันเลือกเส้นทางหนึ่ง

ความสำคัญของการคิดเกี่ยวกับการคิดในตัวแทน AI

การคิดเกี่ยวกับการคิดมีบทบาทสำคัญในการออกแบบตัวแทน AI ด้วยเหตุผลหลายประการ:

ความสำคัญของการคิดเกี่ยวกับการคิด

องค์ประกอบของตัวแทน AI

ก่อนที่จะเจาะลึกกระบวนการคิดเกี่ยวกับการคิด สิ่งสำคัญคือต้องเข้าใจองค์ประกอบพื้นฐานของตัวแทน AI ตัวแทน AI โดยทั่วไปประกอบด้วย:

องค์ประกอบเหล่านี้ทำงานร่วมกันเพื่อสร้าง “หน่วยความเชี่ยวชาญ” ที่สามารถทำงานเฉพาะได้

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

ตัวอย่าง: การคิดเกี่ยวกับการคิดในบริการตัวแทนการท่องเที่ยว

ลองจินตนาการว่าคุณกำลังออกแบบบริการตัวแทนการท่องเที่ยวที่ขับเคลื่อนด้วย AI ตัวแทนนี้ “Travel Agent” ช่วยผู้ใช้วางแผนวันหยุดของพวกเขา เพื่อรวมการคิดเกี่ยวกับการคิด Travel Agent จำเป็นต้องประเมินและปรับเปลี่ยนการกระทำของตัวเองโดยอิงจากการรับรู้ตัวเองและประสบการณ์ที่ผ่านมา นี่คือวิธีที่การคิดเกี่ยวกับการคิดสามารถมีบทบาท:

งานปัจจุบัน

งานปัจจุบันคือช่วยผู้ใช้วางแผนการเดินทางไปปารีส

ขั้นตอนในการทำงานให้สำเร็จ

  1. รวบรวมความชอบของผู้ใช้: ถามผู้ใช้เกี่ยวกับวันที่เดินทาง งบประมาณ ความสนใจ (เช่น พิพิธภัณฑ์ อาหาร ช้อปปิ้ง) และข้อกำหนดเฉพาะ
  2. ค้นหาข้อมูล: ค้นหาเที่ยวบิน ตัวเลือกที่พัก สถานที่ท่องเที่ยว และร้านอาหารที่ตรงกับความชอบของผู้ใช้
  3. สร้างคำแนะนำ: ให้แผนการเดินทางส่วนบุคคลพร้อมรายละเอียดเที่ยวบิน การจองโรงแรม และกิจกรรมที่แนะนำ
  4. ปรับเปลี่ยนตามความคิดเห็น: ขอความคิดเห็นจากผู้ใช้เกี่ยวกับคำแนะนำและทำการปรับเปลี่ยนตามความจำเป็น

ทรัพยากรที่จำเป็น

ประสบการณ์และการสะท้อนตัวเอง

Travel Agent ใช้การคิดเกี่ยวกับการคิดเพื่อประเมินประสิทธิภาพของตัวเองและเรียนรู้จากประสบการณ์ที่ผ่านมา เช่น:

  1. การวิเคราะห์ความคิดเห็นของผู้ใช้: Travel Agent ทบทวนความคิดเห็นของผู้ใช้เพื่อพิจารณาว่าคำแนะนำใดได้รับการตอบรับที่ดีและคำแนะนำใดไม่ได้รับการตอบรับดี มันปรับเปลี่ยนคำแนะนำในอนาคตตามนั้น
  2. การปรับตัว: หากผู้ใช้เคยกล่าวถึงความไม่ชอบสถานที่ที่มีคนเยอะ Travel Agent จะหลีกเลี่ยงการแนะนำสถานที่ท่องเที่ยวยอดนิยมในช่วงเวลาที่มีคนเยอะในอนาคต
  3. การแก้ไขข้อผิดพลาด: หาก Travel Agent เคยทำผิดพลาดในการจอง เช่น แนะนำโรงแรมที่เต็มแล้ว มันจะเรียนรู้ที่จะตรวจสอบความพร้อมใช้งานอย่างเข้มงวดมากขึ้นก่อนที่จะให้คำแนะนำ

ตัวอย่างสำหรับนักพัฒนา

นี่คือตัวอย่างโค้ดที่เรียบง่ายของ Travel Agent ที่รวมการคิดเกี่ยวกับการคิด:

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):
        # Search for flights, hotels, and attractions based on preferences
        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)
        # Analyze feedback and adjust future recommendations
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Example usage
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)

ทำไมการคิดเกี่ยวกับการคิดถึงสำคัญ

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

2. การวางแผนในตัวแทน

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

องค์ประกอบของการวางแผน

ตัวอย่าง: นี่คือขั้นตอนที่ Travel Agent ต้องดำเนินการเพื่อช่วยผู้ใช้วางแผนการเดินทางอย่างมีประสิทธิภาพ:

ขั้นตอนสำหรับ Travel Agent

  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)

# Example usage within a booing request
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 vs Context Loading

การสร้างแบบเสริมด้วยการดึงข้อมูล (RAG)

RAG รวมระบบการดึงข้อมูลเข้ากับโมเดลการสร้าง เมื่อมีการตั้งคำถาม ระบบการดึงข้อมูลจะดึงเอกสารหรือข้อมูลที่เกี่ยวข้องจากแหล่งข้อมูลภายนอก และข้อมูลที่ดึงมานี้จะถูกใช้เพื่อเสริมอินพุตให้กับโมเดลการสร้าง สิ่งนี้ช่วยให้โมเดลสร้างคำตอบที่แม่นยำและเกี่ยวข้องกับบริบทมากขึ้น

ในระบบ RAG ตัวแทนจะดึงข้อมูลที่เกี่ยวข้องจากฐานความรู้และใช้ข้อมูลนั้นเพื่อสร้างคำตอบหรือการกระทำที่เหมาะสม

วิธีการ RAG แบบแก้ไข

วิธีการ RAG แบบแก้ไขมุ่งเน้นไปที่การใช้เทคนิค RAG เพื่อแก้ไขข้อผิดพลาดและปรับปรุงความแม่นยำของตัวแทน AI สิ่งนี้เกี่ยวข้องกับ:

  1. เทคนิคการตั้งคำถาม: ใช้คำถามเฉพาะเพื่อแนะนำตัวแทนในการดึงข้อมูลที่เกี่ยวข้อง
  2. เครื่องมือ: ใช้อัลกอริทึมและกลไกที่ช่วยให้ตัวแทนสามารถประเมินความเกี่ยวข้องของข้อมูลที่ดึงมาและสร้างคำตอบที่แม่นยำ
  3. การประเมินผล: ประเมินประสิทธิภาพของตัวแทนอย่างต่อเนื่องและทำการปรับเปลี่ยนเพื่อปรับปรุงความแม่นยำและประสิทธิภาพ

ตัวอย่าง: RAG แบบแก้ไขในตัวแทนค้นหา

ลองนึกถึงตัวแทนค้นหาที่ดึงข้อมูลจากเว็บเพื่อตอบคำถามของผู้ใช้ วิธีการ RAG แบบแก้ไขอาจเกี่ยวข้องกับ:

  1. เทคนิคการตั้งคำถาม: การสร้างคำถามค้นหาตามอินพุตของผู้ใช้
  2. เครื่องมือ: ใช้การประมวลผลภาษาธรรมชาติและอัลกอริทึมการเรียนรู้ของเครื่องเพื่อจัดอันดับและกรองผลการค้นหา
  3. การประเมินผล: วิเคราะห์ความคิดเห็นของผู้ใช้เพื่อระบุและแก้ไขความไม่ถูกต้องในข้อมูลที่ดึงมา

RAG แบบแก้ไขใน Travel Agent

RAG แบบแก้ไข (Retrieval-Augmented Generation) ช่วยเพิ่มความสามารถของ

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

# Example usage
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)

การโหลดบริบทล่วงหน้า

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

ตัวอย่างง่าย ๆ ของการโหลดบริบทล่วงหน้าสำหรับแอปพลิเคชันตัวแทนท่องเที่ยวใน Python:

class TravelAgent:
    def __init__(self):
        # Pre-load popular destinations and their information
        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):
        # Fetch destination information from pre-loaded context
        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}."

# Example usage
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

คำอธิบาย

  1. การเริ่มต้น (__init__ method): คลาส TravelAgent โหลดพจนานุกรมที่มีข้อมูลเกี่ยวกับสถานที่ยอดนิยม เช่น ปารีส โตเกียว นิวยอร์ก และซิดนีย์ พจนานุกรมนี้รวมถึงรายละเอียดต่าง ๆ เช่น ประเทศ สกุลเงิน ภาษา และสถานที่ท่องเที่ยวสำคัญของแต่ละจุดหมายปลายทาง

  2. การดึงข้อมูล (get_destination_info method): เมื่อผู้ใช้สอบถามเกี่ยวกับจุดหมายปลายทางเฉพาะ get_destination_info จะดึงข้อมูลที่เกี่ยวข้องจากพจนานุกรมบริบทที่โหลดไว้ล่วงหน้า

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

การเริ่มต้นแผนด้วยเป้าหมายก่อนการวนซ้ำ

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

ตัวอย่างของการเริ่มต้นแผนการเดินทางด้วยเป้าหมายก่อนการวนซ้ำสำหรับตัวแทนท่องเที่ยวใน Python:

สถานการณ์

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

ขั้นตอน

  1. กำหนดความชอบและงบประมาณของลูกค้า
  2. เริ่มต้นแผนเบื้องต้นตามความชอบเหล่านี้
  3. วนซ้ำเพื่อปรับปรุงแผน โดยเพิ่มความพึงพอใจของลูกค้าให้สูงสุด

โค้ด Python

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']

# Example usage
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__ method): คลาส TravelAgent ถูกเริ่มต้นด้วยรายการจุดหมายปลายทางที่มีคุณสมบัติเช่น ชื่อ ค่าใช้จ่าย และประเภทกิจกรรม

  2. การเริ่มต้นแผน (bootstrap_plan method): เมธอดนี้สร้างแผนการเดินทางเบื้องต้นตามความชอบและงบประมาณของลูกค้า โดยวนซ้ำผ่านรายการจุดหมายปลายทางและเพิ่มเข้าไปในแผนหากตรงกับความชอบของลูกค้าและอยู่ในงบประมาณ

  3. การจับคู่ความชอบ (match_preferences method): เมธอดนี้ตรวจสอบว่าจุดหมายปลายทางตรงกับความชอบของลูกค้าหรือไม่

  4. การวนซ้ำแผน (iterate_plan method): เมธอดนี้ปรับปรุงแผนเบื้องต้นโดยพยายามแทนที่จุดหมายปลายทางแต่ละแห่งในแผนด้วยตัวเลือกที่ดีกว่า โดยพิจารณาความชอบและข้อจำกัดด้านงบประมาณของลูกค้า

  5. การคำนวณค่าใช้จ่าย (calculate_cost method): เมธอดนี้คำนวณค่าใช้จ่ายรวมของแผนปัจจุบัน รวมถึงจุดหมายปลายทางใหม่ที่อาจเพิ่มเข้ามา

ตัวอย่างการใช้งาน

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

การใช้ LLM เพื่อการจัดอันดับใหม่และการให้คะแนน

Large Language Models (LLMs) สามารถใช้เพื่อการจัดอันดับใหม่และการให้คะแนนโดยการประเมินความเกี่ยวข้องและคุณภาพของเอกสารที่ดึงมา หรือคำตอบที่สร้างขึ้น นี่คือวิธีการทำงาน:

การดึงข้อมูล: ขั้นตอนการดึงข้อมูลเริ่มต้นจะดึงชุดเอกสารหรือคำตอบที่เป็นไปได้ตามคำถาม

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

การให้คะแนน: LLM ให้คะแนนแต่ละตัวเลือก ซึ่งสะท้อนถึงความเกี่ยวข้องและคุณภาพของตัวเลือกนั้น ๆ สิ่งนี้ช่วยในการเลือกคำตอบหรือเอกสารที่ดีที่สุดสำหรับผู้ใช้

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

ตัวอย่างของการใช้ LLM เพื่อการจัดอันดับใหม่และการให้คะแนนจุดหมายปลายทางการเดินทางตามความชอบของผู้ใช้ใน Python:

สถานการณ์ - การเดินทางตามความชอบ

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

ขั้นตอน:

  1. รวบรวมความชอบของผู้ใช้
  2. ดึงรายการจุดหมายปลายทางที่เป็นไปได้
  3. ใช้ LLM เพื่อจัดอันดับใหม่และให้คะแนนจุดหมายปลายทางตามความชอบของผู้ใช้

นี่คือวิธีการอัปเดตตัวอย่างก่อนหน้าเพื่อใช้ Azure OpenAI Services:

ข้อกำหนด

  1. คุณต้องมีการสมัครสมาชิก Azure
  2. สร้างทรัพยากร Azure OpenAI และรับ API key ของคุณ

โค้ด Python ตัวอย่าง

import requests
import json

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

    def get_recommendations(self, preferences, api_key, endpoint):
        # Generate a prompt for the Azure OpenAI
        prompt = self.generate_prompt(preferences)
        
        # Define headers and payload for the request
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # Call the Azure OpenAI API to get the re-ranked and scored destinations
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # Extract and return the recommendations
        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

# Example usage
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)

คำอธิบายโค้ด - Preference Booker

  1. การเริ่มต้น: คลาส TravelAgent ถูกเริ่มต้นด้วยรายการจุดหมายปลายทางที่เป็นไปได้ ซึ่งแต่ละรายการมีคุณสมบัติเช่น ชื่อและคำอธิบาย

  2. การรับคำแนะนำ (get_recommendations method): เมธอดนี้สร้าง prompt สำหรับบริการ Azure OpenAI ตามความชอบของผู้ใช้ และทำการ HTTP POST request ไปยัง API ของ Azure OpenAI เพื่อรับจุดหมายปลายทางที่จัดอันดับใหม่และให้คะแนน

  3. การสร้าง Prompt (generate_prompt method): เมธอดนี้สร้าง prompt สำหรับ Azure OpenAI รวมถึงความชอบของผู้ใช้และรายการจุดหมายปลายทาง Prompt นี้นำทางโมเดลให้จัดอันดับใหม่และให้คะแนนจุดหมายปลายทางตามความชอบที่ให้ไว้

  4. การเรียก API: ไลบรารี requests ถูกใช้เพื่อทำ HTTP POST request ไปยัง endpoint API ของ Azure OpenAI คำตอบประกอบด้วยจุดหมายปลายทางที่จัดอันดับใหม่และให้คะแนน

  5. ตัวอย่างการใช้งาน: ตัวแทนท่องเที่ยวรวบรวมความชอบของผู้ใช้ (เช่น ความสนใจในการเที่ยวชมสถานที่และวัฒนธรรมที่หลากหลาย) และใช้บริการ Azure OpenAI เพื่อรับคำแนะนำที่จัดอันดับใหม่และให้คะแนนสำหรับจุดหมายปลายทางการเดินทาง

อย่าลืมแทนที่ your_azure_openai_api_key ด้วย API key จริงของ Azure OpenAI และ https://your-endpoint.com/... ด้วย URL endpoint จริงของการใช้งาน Azure OpenAI ของคุณ

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

RAG: เทคนิคการสร้าง Prompt vs เครื่องมือ

การสร้างและการดึงข้อมูล (Retrieval-Augmented Generation หรือ RAG) สามารถเป็นได้ทั้งเทคนิคการสร้าง Prompt และเครื่องมือในกระบวนการพัฒนา AI การเข้าใจความแตกต่างระหว่างสองสิ่งนี้สามารถช่วยให้คุณใช้ RAG ได้อย่างมีประสิทธิภาพในโครงการของคุณ

RAG ในฐานะเทคนิคการสร้าง Prompt

คืออะไร?

วิธีการทำงาน:

  1. สร้าง Prompt: สร้าง Prompt หรือคำถามที่มีโครงสร้างดีตามงานที่ต้องทำหรือข้อมูลที่ผู้ใช้ป้อน
  2. ดึงข้อมูล: ใช้ Prompt เพื่อค้นหาข้อมูลที่เกี่ยวข้องจากฐานความรู้หรือชุดข้อมูลที่มีอยู่
  3. สร้างคำตอบ: รวมข้อมูลที่ดึงมาเข้ากับโมเดล AI เพื่อสร้างคำตอบที่ครอบคลุมและสอดคล้อง

ตัวอย่างในตัวแทนท่องเที่ยว:

RAG ในฐานะเครื่องมือ

คืออะไร?

วิธีการทำงาน:

  1. การรวมระบบ: ฝัง RAG ไว้ในสถาปัตยกรรมของ AI agent เพื่อให้สามารถจัดการงานการดึงข้อมูลและการสร้างคำตอบได้โดยอัตโนมัติ
  2. การทำงานอัตโนมัติ: เครื่องมือจัดการกระบวนการทั้งหมด ตั้งแต่การรับข้อมูลผู้ใช้ไปจนถึงการสร้างคำตอบสุดท้าย โดยไม่ต้องใช้ Prompt สำหรับแต่ละขั้นตอน
  3. ประสิทธิภาพ: เพิ่มประสิทธิภาพของ agent โดยการปรับปรุงกระบวนการดึงข้อมูลและการสร้างคำตอบ ทำให้ตอบสนองได้รวดเร็วและแม่นยำมากขึ้น

ตัวอย่างในตัวแทนท่องเที่ยว:

การเปรียบเทียบ

ด้าน เทคนิคการสร้าง Prompt เครื่องมือ
การทำงานด้วยตนเอง vs อัตโนมัติ การสร้าง Prompt ด้วยตนเองสำหรับแต่ละคำถาม กระบวนการดึงข้อมูลและการสร้างคำตอบอัตโนมัติ
การควบคุม ให้การควบคุมกระบวนการดึงข้อมูลมากขึ้น ทำให้กระบวนการดึงข้อมูลและการสร้างคำตอบง่ายขึ้น
ความยืดหยุ่น อนุญาตให้ปรับแต่ง Prompt ตามความต้องการเฉพาะ มีประสิทธิภาพมากขึ้นสำหรับการใช้งานขนาดใหญ่
ความซับซ้อน ต้องสร้างและปรับแต่ง Prompt ง่ายต่อการรวมเข้ากับสถาปัตยกรรมของ AI agent

ตัวอย่างการใช้งานจริง

ตัวอย่างเทคนิคการสร้าง Prompt:

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 agent ซึ่งช่วยให้มั่นใจได้ว่าข้อมูลที่ดึงมาและสร้างขึ้นโดย agent นั้นเหมาะสม ถูกต้อง และเป็นประโยชน์ต่อผู้ใช้ มาดูกันว่าการประเมินความเกี่ยวข้องใน AI agent ทำงานอย่างไร รวมถึงตัวอย่างและเทคนิคการใช้งานจริง

แนวคิดสำคัญในการประเมินความเกี่ยวข้อง

  1. การรับรู้บริบท:
    • agent ต้องเข้าใจบริบทของคำถามของผู้ใช้เพื่อดึงและสร้างข้อมูลที่เกี่ยวข้อง
    • ตัวอย่าง: หากผู้ใช้ถามว่า “ร้านอาหารที่ดีที่สุดในปารีส” agent ควรพิจารณาความชอบของผู้ใช้ เช่น ประเภทอาหารและงบประมาณ
  2. ความถูกต้อง:
    • ข้อมูลที่ agent ให้ควรถูกต้องตามข้อเท็จจริงและทันสมัย
    • ตัวอย่าง: แนะนำร้านอาหารที่เปิดอยู่ในปัจจุบันและมีรีวิวดีแทนที่จะเป็นตัวเลือกที่ล้าสมัยหรือปิดไปแล้ว
  3. เจตนาของผู้ใช้:
    • agent ควรอนุมานเจตนาของผู้ใช้เบื้องหลังคำถามเพื่อให้ข้อมูลที่เกี่ยวข้องที่สุด
    • ตัวอย่าง: หากผู้ใช้ถามว่า “โรงแรมราคาประหยัด” agent ควรจัดลำดับความสำคัญตัวเลือกที่มีราคาถูก
  4. วงจรป้อนกลับ:
    • การรวบรวมและวิเคราะห์ความคิดเห็นของผู้ใช้อย่างต่อเนื่องช่วยให้ agent ปรับปรุงกระบวนการประเมินความเกี่ยวข้อง
    • ตัวอย่าง: การรวมคะแนนและความคิดเห็นของผู้ใช้เกี่ยวกับคำแนะนำก่อนหน้าเพื่อปรับปรุงคำตอบในอนาคต

เทคนิคการประเมินความเกี่ยวข้อง

  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]  # Return top 10 relevant items
  3. การประมวลผลภาษาธรรมชาติ (NLP):
    • ใช้เทคนิค NLP เพื่อทำความเข้าใจคำถามของผู้ใช้และดึงข้อมูลที่เกี่ยวข้อง

    • ตัวอย่าง:

      def process_query(query):
    # Use NLP to extract key information from the user's query
    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

ตัวอย่าง: การประเมินความเกี่ยวข้องในตัวแทนท่องเที่ยว

นี่คือตัวอย่างการใช้งานจริงของ Travel Agent ในการประเมินความเกี่ยวข้องของคำแนะนำการเดินทาง:

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]  # Return top 10 relevant items

    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

# Example usage
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. การทำความเข้าใจเจตนาของผู้ใช้:
    • เจตนาของผู้ใช้สามารถแบ่งออกเป็นสามประเภทหลัก: การให้ข้อมูล การนำทาง และการทำธุรกรรม

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

        ตัวอย่างการใช้งานจริง: การค้นหาด้วยเจตนาใน Travel Agent

มาดูตัวอย่าง Travel Agent เพื่อดูว่าการค้นหาด้วยเจตนาสามารถนำไปใช้ได้อย่างไร

  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):
    # Combine current query with user history to understand context
    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):
    # Example search logic for informational intent
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # Example search logic for navigational intent
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # Example search logic for transactional intent
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # Example personalization logic
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # Return top 10 personalized results

  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. การสร้างโค้ดเป็นเครื่องมือ

ตัวแทนที่สร้างโค้ดใช้โมเดล AI ในการเขียนและรันโค้ด เพื่อแก้ปัญหาที่ซับซ้อนและทำงานอัตโนมัติ

ตัวแทนที่สร้างโค้ด

ตัวแทนที่สร้างโค้ดใช้โมเดล AI เชิงสร้างสรรค์ในการเขียนและรันโค้ด ตัวแทนเหล่านี้สามารถแก้ปัญหาที่ซับซ้อน ทำงานอัตโนมัติ และให้ข้อมูลเชิงลึกที่มีคุณค่าโดยการสร้างและรันโค้ดในภาษาการเขียนโปรแกรมต่าง ๆ

การใช้งานจริง

  1. การสร้างโค้ดอัตโนมัติ: สร้างโค้ดสำหรับงานเฉพาะ เช่น การวิเคราะห์ข้อมูล การดึงข้อมูลจากเว็บ หรือการเรียนรู้ของเครื่อง
  2. SQL เป็น RAG: ใช้คำสั่ง SQL เพื่อดึงและจัดการข้อมูลจากฐานข้อมูล
  3. การแก้ปัญหา: สร้างและรันโค้ดเพื่อแก้ปัญหาเฉพาะ เช่น การปรับปรุงอัลกอริทึมหรือการวิเคราะห์ข้อมูล

ตัวอย่าง: ตัวแทนที่สร้างโค้ดสำหรับการวิเคราะห์ข้อมูล

ลองจินตนาการว่าคุณกำลังออกแบบตัวแทนที่สร้างโค้ด นี่คือวิธีการทำงาน:

  1. งาน: วิเคราะห์ชุดข้อมูลเพื่อระบุแนวโน้มและรูปแบบ
  2. ขั้นตอน:
    • โหลดชุดข้อมูลเข้าสู่เครื่องมือวิเคราะห์ข้อมูล
    • สร้างคำสั่ง SQL เพื่อกรองและรวมข้อมูล
    • รันคำสั่งและดึงผลลัพธ์
    • ใช้ผลลัพธ์เพื่อสร้างภาพและข้อมูลเชิงลึก
  3. ทรัพยากรที่ต้องการ: การเข้าถึงชุดข้อมูล เครื่องมือวิเคราะห์ข้อมูล และความสามารถ SQL
  4. ประสบการณ์: ใช้ผลการวิเคราะห์ที่ผ่านมาเพื่อปรับปรุงความแม่นยำและความเกี่ยวข้องของการวิเคราะห์ในอนาคต

ตัวอย่าง: ตัวแทนที่สร้างโค้ดสำหรับ Travel Agent

ในตัวอย่างนี้ เราจะออกแบบตัวแทนที่สร้างโค้ด Travel Agent เพื่อช่วยผู้ใช้วางแผนการเดินทางโดยการสร้างและรันโค้ด ตัวแทนนี้สามารถจัดการงาน เช่น การดึงตัวเลือกการเดินทาง การกรองผลลัพธ์ และการจัดทำแผนการเดินทางโดยใช้ AI เชิงสร้างสรรค์

ภาพรวมของตัวแทนที่สร้างโค้ด

  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):
    # Example: Generate code to search for flights based on user 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):
    # Example: Generate code to search for hotels
    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):
    # Execute the generated code using 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):
    # Adjust preferences based on user feedback
    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)
   
# Regenerate and execute code with updated 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. สร้างและรันคำสั่ง: ระบบจะสร้างและรันคำสั่งเพื่อดึงข้อมูลเที่ยวบินและโรงแรมที่อัปเดตตามความต้องการใหม่

นี่คือตัวอย่างโค้ด Python ที่ปรับปรุงแนวคิดเหล่านี้:

def adjust_based_on_feedback(feedback, preferences, schema):
    # Adjust preferences based on user feedback
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Reasoning based on schema to adjust other related preferences
    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):
    # Custom logic to adjust preferences based on schema and feedback
    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):
    # Generate code to fetch flight data based on updated preferences
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Generate code to fetch hotel data based on updated preferences
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # Simulate execution of code and return mock data
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Generate itinerary based on flights, hotels, and attractions
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# Example schema
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# Example usage
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# Regenerate and execute code with updated 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, 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 (Structured Query Language) เป็นเครื่องมือที่ทรงพลังสำหรับการโต้ตอบกับฐานข้อมูล เมื่อใช้เป็นส่วนหนึ่งของแนวทาง Retrieval-Augmented Generation (RAG) SQL สามารถดึงข้อมูลที่เกี่ยวข้องจากฐานข้อมูลเพื่อแจ้งและสร้างการตอบสนองหรือการกระทำในตัวแทน AI มาดูกันว่า SQL สามารถใช้เป็นเทคนิค RAG ในบริบทของ Travel Agent ได้อย่างไร

แนวคิดสำคัญ

  1. การโต้ตอบกับฐานข้อมูล:
    • ใช้ SQL เพื่อดึงข้อมูลที่เกี่ยวข้องและจัดการข้อมูล
    • ตัวอย่าง: ดึงรายละเอียดเที่ยวบิน ข้อมูลโรงแรม และสถานที่ท่องเที่ยวจากฐานข้อมูลการเดินทาง
  2. การรวมเข้ากับ RAG:
    • สร้างคำสั่ง SQL ตามข้อมูลและความต้องการของผู้ใช้
    • ใช้ข้อมูลที่ดึงมาเพื่อสร้างคำแนะนำหรือการกระทำที่ปรับแต่งเฉพาะบุคคล
  3. การสร้างคำสั่งแบบไดนามิก:
    • ตัวแทน AI สร้างคำสั่ง SQL แบบไดนามิกตามบริบทและความต้องการของผู้ใช้
    • ตัวอย่าง: ปรับแต่งคำสั่ง SQL เพื่อกรองผลลัพธ์ตามงบประมาณ วันที่ และความสนใจ

การใช้งาน

ตัวอย่าง: ตัวแทนวิเคราะห์ข้อมูล:

  1. งาน: วิเคราะห์ชุดข้อมูลเพื่อค้นหาแนวโน้ม
  2. ขั้นตอน:
    • โหลดชุดข้อมูล
    • สร้างคำสั่ง SQL เพื่อกรองข้อมูล
    • รันคำสั่งและดึงผลลัพธ์
    • สร้างภาพและข้อมูลเชิงลึก
  3. ทรัพยากร: การเข้าถึงชุดข้อมูล ความสามารถ SQL
  4. ประสบการณ์: ใช้ผลลัพธ์ที่ผ่านมาเพื่อปรับปรุงการวิเคราะห์ในอนาคต

ตัวอย่างการใช้งาน SQL ใน Travel Agent

  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) ตัวแทน AI เช่น Travel Agent สามารถดึงและใช้ข้อมูลที่เกี่ยวข้องเพื่อให้คำแนะนำที่แม่นยำและปรับแต่งเฉพาะบุคคล

ตัวอย่างของ Metacognition

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

เราจะจำลองสิ่งนี้โดยใช้ตัวอย่างพื้นฐานที่ตัวแทนเลือกโรงแรมตามราคาถูกที่สุดและคุณภาพ แต่จะ “สะท้อน” การตัดสินใจของตัวเองและปรับเปลี่ยนตามนั้น

วิธีที่แสดงให้เห็น metacognition:

  1. การตัดสินใจครั้งแรก: ตัวแทนจะเลือกโรงแรมที่ราคาถูกที่สุด โดยไม่คำนึงถึงผลกระทบด้านคุณภาพ
  2. การสะท้อนและประเมินผล: หลังจากการเลือกครั้งแรก ตัวแทนจะตรวจสอบว่าโรงแรมเป็น “ตัวเลือกที่ไม่ดี” หรือไม่โดยใช้ความคิดเห็นของผู้ใช้ หากพบว่าคุณภาพของโรงแรมต่ำเกินไป ตัวแทนจะสะท้อนเหตุผลของตัวเอง
  3. การปรับกลยุทธ์: ตัวแทนปรับกลยุทธ์โดยเปลี่ยนจาก “ราคาถูกที่สุด” เป็น “คุณภาพสูงสุด” เพื่อปรับปรุงกระบวนการตัดสินใจในอนาคต

นี่คือตัวอย่าง:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # Stores the hotels chosen previously
        self.corrected_choices = []  # Stores the corrected choices
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # Available strategies

    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]
        # Let's assume we have some user feedback that tells us whether the last choice was good or not
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # Adjust strategy if the previous choice was unsatisfactory
            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"

# Simulate a list of hotels (price and quality)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# Create an agent
agent = HotelRecommendationAgent()

# Step 1: The agent recommends a hotel using the "cheapest" strategy
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# Step 2: The agent reflects on the choice and adjusts strategy if necessary
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# Step 3: The agent recommends again, this time using the adjusted strategy
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

ความสามารถ metacognition ของตัวแทน

จุดสำคัญคือความสามารถของตัวแทนในการ:

นี่เป็นรูปแบบพื้นฐานของ metacognition ที่ระบบสามารถปรับกระบวนการให้เหตุผลของตัวเองตามความคิดเห็นภายใน

สรุป

Metacognition เป็นเครื่องมือที่ทรงพลังที่สามารถเพิ่มความสามารถของตัวแทน AI ได้อย่างมาก โดยการรวมกระบวนการ metacognitive คุณสามารถออกแบบตัวแทนที่ฉลาด ปรับตัวได้ และมีประสิทธิภาพมากขึ้น ใช้ทรัพยากรเพิ่มเติมเพื่อสำรวจโลกที่น่าสนใจของ metacognition ในตัวแทน AI

มีคำถามเพิ่มเติมเกี่ยวกับรูปแบบการออกแบบ Metacognition หรือไม่?

เข้าร่วม Azure AI Foundry Discord เพื่อพบกับผู้เรียนคนอื่น ๆ เข้าร่วมชั่วโมงให้คำปรึกษา และรับคำตอบสำหรับคำถามเกี่ยวกับตัวแทน AI ของคุณ

บทเรียนก่อนหน้า

รูปแบบการออกแบบ Multi-Agent

บทเรียนถัดไป

ตัวแทน AI ในการผลิต

ข้อจำกัดความรับผิดชอบ:
เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI Co-op Translator แม้ว่าเราจะพยายามให้การแปลมีความถูกต้อง แต่โปรดทราบว่าการแปลอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้อง เอกสารต้นฉบับในภาษาดั้งเดิมควรถือเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ ขอแนะนำให้ใช้บริการแปลภาษามืออาชีพ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความผิดที่เกิดจากการใช้การแปลนี้

This site is open source. Improve this page.