ai-agents-for-beginners

Reka Bentuk Multi-Ejen

(Klik imej di atas untuk menonton video pelajaran ini)

Metakognisi dalam Ejen AI

Pengenalan

Selamat datang ke pelajaran tentang metakognisi dalam ejen AI! Bab ini direka untuk pemula yang ingin tahu bagaimana ejen AI boleh memikirkan tentang proses pemikiran mereka sendiri. Pada akhir pelajaran ini, anda akan memahami konsep utama dan dilengkapi dengan contoh praktikal untuk menerapkan metakognisi dalam rekabentuk ejen AI.

Matlamat Pembelajaran

Selepas menyelesaikan pelajaran ini, anda akan dapat:

  1. Memahami implikasi gelung penaakulan dalam definisi ejen.
  2. Menggunakan teknik perancangan dan penilaian untuk membantu ejen membetulkan diri.
  3. Mencipta ejen anda sendiri yang mampu memanipulasi kod untuk menyelesaikan tugas.

Pengenalan kepada Metakognisi

Metakognisi merujuk kepada proses kognitif aras-tinggi yang melibatkan berfikir tentang pemikiran sendiri. Bagi ejen AI, ini bermakna mampu menilai dan menyesuaikan tindakan mereka berdasarkan kesedaran diri dan pengalaman lalu. Metakognisi, atau “berfikir tentang berfikir,” adalah konsep penting dalam pembangunan sistem AI beragen. Ia melibatkan sistem AI yang sedar tentang proses dalaman mereka sendiri dan mampu memantau, mengawal, dan menyesuaikan tingkah laku mereka sewajarnya. Serupa seperti yang kita lakukan apabila kita membaca suasana atau melihat pada satu masalah. Kesedaran diri ini dapat membantu sistem AI membuat keputusan yang lebih baik, mengenal pasti kesilapan, dan meningkatkan prestasi mereka dari masa ke masa — sekali lagi merujuk kepada ujian Turing dan perdebatan sama ada AI akan mengambil alih.

Dalam konteks sistem AI beragen, metakognisi boleh membantu menangani beberapa cabaran, seperti:

Apakah Metakognisi?

Metakognisi, atau “berfikir tentang berfikir,” adalah proses kognitif aras-tinggi yang melibatkan kesedaran diri dan pengawalan diri terhadap proses kognitif seseorang. Dalam domain AI, metakognisi memberi kuasa kepada ejen untuk menilai dan menyesuaikan strategi dan tindakan mereka, membawa kepada peningkatan penyelesaian masalah dan kemampuan membuat keputusan. Dengan memahami metakognisi, anda boleh mereka ejen AI yang bukan sahaja lebih pintar tetapi juga lebih mudah menyesuaikan diri dan cekap. Dalam metakognisi sejati, anda akan melihat AI secara eksplisit berfikir tentang penaakulan sendiri.

Contoh: “Saya mengutamakan penerbangan yang lebih murah kerana… Saya mungkin terlepas penerbangan terus, jadi biar saya semak semula.”. Menjejak bagaimana atau mengapa ia memilih laluan tertentu.

Kepentingan Metakognisi dalam Ejen AI

Metakognisi memainkan peranan penting dalam rekabentuk ejen AI atas beberapa sebab:

Kepentingan Metakognisi

Komponen Ejen AI

Sebelum menyelami proses metakognitif, adalah penting untuk memahami komponen asas ejen AI. Satu ejen AI biasanya terdiri daripada:

Komponen-komponen ini bekerja bersama untuk mencipta “unit kepakaran” yang boleh melaksanakan tugasan tertentu.

Contoh: Pertimbangkan seorang ejen pelancongan, perkhidmatan ejen yang bukan sahaja merancang percutian anda tetapi juga menyesuaikan laluan berdasarkan data masa nyata dan pengalaman perjalanan pelanggan lalu.

Contoh: Metakognisi dalam Perkhidmatan Ejen Pelancongan

Bayangkan anda sedang mereka perkhidmatan ejen pelancongan yang dikuasakan oleh AI. Ejen ini, “Ejen Pelancongan,” membantu pengguna merancang percutian mereka. Untuk memasukkan metakognisi, Ejen Pelancongan perlu menilai dan menyesuaikan tindakannya berdasarkan kesedaran diri dan pengalaman lalu. Berikut bagaimana metakognisi boleh berperanan:

Tugas Semasa

Tugas semasa adalah membantu pengguna merancang perjalanan ke Paris.

Langkah untuk Menyelesaikan Tugas

  1. Kumpul Keutamaan Pengguna: Tanya pengguna tentang tarikh perjalanan, bajet, minat (contohnya, muzium, masakan, membeli-belah), dan sebarang kehendak khusus.
  2. Dapatkan Maklumat: Cari pilihan penerbangan, penginapan, tarikan, dan restoran yang sesuai dengan keutamaan pengguna.
  3. Hasilkan Cadangan: Sediakan jadual perjalanan peribadi dengan butiran penerbangan, tempahan hotel, dan aktiviti yang dicadangkan.
  4. Sesuaikan Berdasarkan Maklum Balas: Tanya pengguna untuk maklum balas tentang cadangan dan buat penyesuaian yang perlu.

Sumber Diperlukan

Pengalaman dan Renungan Diri

Ejen Pelancongan menggunakan metakognisi untuk menilai prestasinya dan belajar daripada pengalaman lalu. Sebagai contoh:

  1. Menganalisis Maklum Balas Pengguna: Ejen Pelancongan menyemak maklum balas pengguna untuk menentukan cadangan mana yang diterima baik dan yang tidak. Ia menyesuaikan cadangan masa depannya sewajarnya.
  2. Kebolehsuaian: Jika seorang pengguna sebelum ini menyebut tidak suka tempat yang sesak, Ejen Pelancongan akan mengelakkan mencadangkan tempat pelancongan popular pada waktu puncak pada masa hadapan.
  3. Pembetulan Ralat: Jika Ejen Pelancongan melakukan kesilapan dalam tempahan lalu, seperti mencadangkan hotel yang sudah penuh, ia belajar untuk memeriksa ketersediaan dengan lebih teliti sebelum membuat cadangan.

Contoh Praktikal untuk Pembangun

Berikut contoh ringkas bagaimana kod Ejen Pelancongan mungkin kelihatan apabila memasukkan metakognisi:

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):
        # Cari penerbangan, hotel, dan tarikan berdasarkan pilihan
        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)
        # Analisis maklum balas dan laraskan cadangan masa hadapan
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Contoh penggunaan
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)

Mengapa Metakognisi Penting

Dengan memasukkan metakognisi, Ejen Pelancongan dapat memberikan cadangan perjalanan yang lebih peribadi dan tepat, meningkatkan pengalaman keseluruhan pengguna.

2. Perancangan dalam Ejen

Perancangan adalah komponen kritikal tingkah laku ejen AI. Ia melibatkan merangka langkah-langkah yang diperlukan untuk mencapai sesuatu matlamat, mengambil kira keadaan semasa, sumber, dan halangan yang mungkin.

Elemen Perancangan

Contoh: Berikut langkah yang perlu diambil oleh Ejen Pelancongan untuk membantu pengguna merancang perjalanan mereka dengan berkesan:

Langkah untuk Ejen Pelancongan

  1. Kumpul Keutamaan Pengguna
    • Tanya pengguna untuk butiran tentang tarikh perjalanan, bajet, minat, dan sebarang kehendak khusus.
    • Contoh: “Bilakah anda merancang untuk melancong?” “Apakah julat bajet anda?” “Aktiviti apa yang anda gemari semasa bercuti?”
  2. Dapatkan Maklumat
    • Cari pilihan perjalanan yang relevan berdasarkan keutamaan pengguna.
    • Penerbangan: Cari penerbangan yang tersedia dalam bajet pengguna dan tarikh perjalanan yang dipilih.
    • Penginapan: Cari hotel atau penginapan yang sepadan dengan keutamaan pengguna untuk lokasi, harga, dan kemudahan.
    • Tarikan dan Restoran: Kenal pasti tarikan popular, aktiviti, dan pilihan makan yang selari dengan minat pengguna.
  3. Hasilkan Cadangan
    • Kumpulkan maklumat yang diperoleh ke dalam jadual perjalanan peribadi.
    • Berikan butiran seperti pilihan penerbangan, tempahan hotel, dan aktiviti yang dicadangkan, pastikan cadangan disesuaikan dengan keutamaan pengguna.
  4. Bentangkan Jadual Perjalanan kepada Pengguna
    • Kongsi cadangan jadual perjalanan dengan pengguna untuk semakan mereka.
    • Contoh: “Berikut adalah cadangan jadual perjalanan untuk lawatan anda ke Paris. Ia termasuk butiran penerbangan, tempahan hotel, dan senarai aktiviti serta restoran yang dicadangkan. Beritahu saya pendapat anda!”
  5. Kumpul Maklum Balas
    • Tanya pengguna untuk maklum balas tentang jadual yang dicadangkan.
    • Contoh: “Adakah anda suka pilihan penerbangan?” “Adakah hotel sesuai dengan keperluan anda?” “Adakah terdapat aktiviti yang anda ingin tambahkan atau keluarkan?”
  6. Sesuaikan Berdasarkan Maklum Balas
    • Ubah jadual perjalanan berdasarkan maklum balas pengguna.
    • Buat perubahan yang perlu pada cadangan penerbangan, penginapan, dan aktiviti untuk lebih sesuai dengan keutamaan pengguna.
  7. Pengesahan Akhir
    • Bentangkan jadual perjalanan yang dikemas kini kepada pengguna untuk pengesahan akhir.
    • Contoh: “Saya telah membuat pelarasan berdasarkan maklum balas anda. Berikut jadual perjalanan yang dikemaskini. Adakah semuanya kelihatan baik bagi anda?”
  8. Tempah dan Sahkan Tempahan
    • Setelah pengguna meluluskan jadual perjalanan, teruskan dengan menempah penerbangan, penginapan, dan sebarang aktiviti yang telah dirancang.
    • Hantar butiran pengesahan kepada pengguna.
  9. Sediakan Sokongan Berterusan
    • Kekal tersedia untuk membantu pengguna dengan sebarang perubahan atau permintaan tambahan sebelum dan semasa perjalanan mereka.
    • Contoh: “Jika anda memerlukan bantuan lanjut semasa perjalanan, sila hubungi saya bila-bila masa!”

Interaksi Contoh

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)

# Contoh penggunaan dalam permintaan mengejek
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. Sistem RAG Korektif

Pertama sekali mari kita mulakan dengan memahami perbezaan antara Alat RAG dan Pemuatan Konteks Awal

RAG vs Context Loading

Retrieval-Augmented Generation (RAG)

RAG menggabungkan sistem pengambilan dengan model generatif. Apabila satu pertanyaan dibuat, sistem pengambilan mengambil dokumen atau data yang relevan dari sumber luaran, dan maklumat yang diambil ini digunakan untuk memperkayakan input kepada model generatif. Ini membantu model menghasilkan respons yang lebih tepat dan sesuai konteks.

Dalam sistem RAG, ejen mendapatkan maklumat relevan dari pangkalan pengetahuan dan menggunakannya untuk menghasilkan respons atau tindakan yang sesuai.

Pendekatan RAG Korektif

Pendekatan RAG Korektif fokus pada penggunaan teknik RAG untuk membetulkan ralat dan meningkatkan ketepatan ejen AI. Ini melibatkan:

  1. Teknik Pemanggilan Prompt: Menggunakan prompt khusus untuk membimbing ejen dalam mengambil maklumat yang relevan.
  2. Alat: Melaksanakan algoritma dan mekanisme yang membolehkan ejen menilai kaitan maklumat yang diambil dan menghasilkan respons yang tepat.
  3. Penilaian: Sentiasa menilai prestasi ejen dan membuat penyesuaian untuk meningkatkan ketepatan dan kecekapan.

Contoh: RAG Korektif dalam Ejen Carian

Pertimbangkan ejen carian yang mengambil maklumat dari web untuk menjawab pertanyaan pengguna. Pendekatan RAG Korektif mungkin melibatkan:

  1. Teknik Pemanggilan Prompt: Merumuskan pertanyaan carian berdasarkan input pengguna.
  2. Alat: Menggunakan pemprosesan bahasa semulajadi dan algoritma pembelajaran mesin untuk menyusun ranking dan menapis hasil carian.
  3. Penilaian: Menganalisis maklum balas pengguna untuk mengenal pasti dan membetulkan ketidaktepatan dalam maklumat yang diambil.

RAG Korektif dalam Ejen Pelancongan

RAG Korektif (Retrieval-Augmented Generation) meningkatkan keupayaan AI untuk mengambil dan menghasilkan maklumat sambil membetulkan sebarang ketidaktepatan. Mari lihat bagaimana Ejen Pelancongan boleh menggunakan pendekatan RAG Korektif untuk menyediakan cadangan perjalanan yang lebih tepat dan relevan.

Ini melibatkan:

Langkah untuk Melaksanakan RAG Korektif dalam Ejen Pelancongan

  1. Interaksi Awal dengan Pengguna
    • Ejen Pelancongan mengumpul keutamaan awal daripada pengguna, seperti destinasi, tarikh perjalanan, bajet, dan minat.

    • Contoh:

      preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
  2. Pengambilan Maklumat
    • Ejen Pelancongan mendapatkan maklumat tentang penerbangan, penginapan, tarikan, dan restoran berdasarkan keutamaan pengguna.

    • Contoh:

      flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
  3. Menghasilkan Cadangan Awal
    • Ejen Pelancongan menggunakan maklumat yang diambil untuk menghasilkan jadual perjalanan peribadi.

    • Contoh:

      itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)
  4. Mengumpul Maklum Balas Pengguna
    • Ejen Pelancongan meminta maklum balas daripada pengguna mengenai cadangan awal.

    • Contoh:

      feedback = {
    "liked": ["Louvre Museum"],
    "disliked": ["Eiffel Tower (too crowded)"]
}
  5. Proses RAG Korektif
    • Teknik Pemanggilan Prompt: Ejen Pelancongan merumuskan pertanyaan carian baru berdasarkan maklum balas pengguna.

      • Contoh:

        if "disliked" in feedback:
    preferences["avoid"] = feedback["disliked"]
    • Alat: Ejen Pelancongan menggunakan algoritma untuk menyusun dan menapis hasil carian baru, menekankan kaitan berdasarkan maklum balas pengguna.

      • Contoh:

        new_attractions = search_attractions(preferences)
new_itinerary = create_itinerary(flights, hotels, new_attractions)
print("Updated Itinerary:", new_itinerary)
    • Penilaian: Ejen Pelancongan sentiasa menilai kaitan dan ketepatan cadangannya dengan menganalisis maklum balas pengguna dan membuat penyesuaian yang perlu.

      • Contoh:

        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)

Contoh Praktikal

Berikut contoh kod Python yang dipermudahkan yang memasukkan pendekatan RAG Korektif dalam Ejen Pelancongan:

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

# Contoh penggunaan
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)

Pemuatan Konteks Awal

Pre-emptive Context Load involves loading relevant context or background information into the model before processing a query. This means the model has access to this information from the start, which can help it generate more informed responses without needing to retrieve additional data during the process.

Here’s a simplified example of how a pre-emptive context load might look for a travel agent application in Python:

class TravelAgent:
    def __init__(self):
        # Pramuat destinasi popular dan maklumatnya
        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):
        # Dapatkan maklumat destinasi daripada konteks yang telah dimuatkan terlebih dahulu
        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}."

# Contoh penggunaan
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

Penjelasan

  1. Initialization (__init__ method): The TravelAgent class pre-loads a dictionary containing information about popular destinations such as Paris, Tokyo, New York, and Sydney. This dictionary includes details like the country, currency, language, and major attractions for each destination.

  2. Retrieving Information (get_destination_info method): When a user queries about a specific destination, the get_destination_info method fetches the relevant information from the pre-loaded context dictionary.

By pre-loading the context, the travel agent application can quickly respond to user queries without having to retrieve this information from an external source in real-time. This makes the application more efficient and responsive.

Memulakan Pelan dengan Matlamat Sebelum Mengulangi

Bootstrapping a plan with a goal involves starting with a clear objective or target outcome in mind. By defining this goal upfront, the model can use it as a guiding principle throughout the iterative process. This helps ensure that each iteration moves closer to achieving the desired outcome, making the process more efficient and focused.

Here’s an example of how you might bootstrap a travel plan with a goal before iterating for a travel agent in Python:

Senario

A travel agent wants to plan a customized vacation for a client. The goal is to create a travel itinerary that maximizes the client’s satisfaction based on their preferences and budget.

Langkah-langkah

  1. Define the client’s preferences and budget.
  2. Bootstrap the initial plan based on these preferences.
  3. Iterate to refine the plan, optimizing for the client’s satisfaction.

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

# Contoh penggunaan
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)

Penjelasan Kod

  1. Initialization (__init__ method): The TravelAgent class is initialized with a list of potential destinations, each having attributes like name, cost, and activity type.

  2. Bootstrapping the Plan (bootstrap_plan method): This method creates an initial travel plan based on the client’s preferences and budget. It iterates through the list of destinations and adds them to the plan if they match the client’s preferences and fit within the budget.

  3. Matching Preferences (match_preferences method): This method checks if a destination matches the client’s preferences.

  4. Iterating the Plan (iterate_plan method): This method refines the initial plan by trying to replace each destination in the plan with a better match, considering the client’s preferences and budget constraints.

  5. Calculating Cost (calculate_cost method): This method calculates the total cost of the current plan, including a potential new destination.

Contoh Penggunaan

By bootstrapping the plan with a clear goal (e.g., maximizing client satisfaction) and iterating to refine the plan, the travel agent can create a customized and optimized travel itinerary for the client. This approach ensures that the travel plan aligns with the client’s preferences and budget from the start and improves with each iteration.

Memanfaatkan LLM untuk Penyusunan Semula dan Pemberian Skor

Large Language Models (LLMs) can be used for re-ranking and scoring by evaluating the relevance and quality of retrieved documents or generated responses. Here’s how it works:

Retrieval: The initial retrieval step fetches a set of candidate documents or responses based on the query.

Re-ranking: The LLM evaluates these candidates and re-ranks them based on their relevance and quality. This step ensures that the most relevant and high-quality information is presented first.

Scoring: The LLM assigns scores to each candidate, reflecting their relevance and quality. This helps in selecting the best response or document for the user.

By leveraging LLMs for re-ranking and scoring, the system can provide more accurate and contextually relevant information, improving the overall user experience.

Here’s an example of how a travel agent might use a Large Language Model (LLM) for re-ranking and scoring travel destinations based on user preferences in Python:

Senario - Perjalanan berdasarkan Keutamaan

A travel agent wants to recommend the best travel destinations to a client based on their preferences. The LLM will help re-rank and score the destinations to ensure the most relevant options are presented.

Langkah-langkah:

  1. Collect user preferences.
  2. Retrieve a list of potential travel destinations.
  3. Use the LLM to re-rank and score the destinations based on user preferences.

Here’s how you can update the previous example to use Azure OpenAI Services:

Keperluan

  1. You need to have an Azure subscription.
  2. Create an Azure OpenAI resource and get your API key.

Contoh Kod Python

import requests
import json

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

    def get_recommendations(self, preferences, api_key, endpoint):
        # Jana prompt untuk Azure OpenAI
        prompt = self.generate_prompt(preferences)
        
        # Tentukan header dan payload untuk permintaan
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # Panggil API Azure OpenAI untuk mendapatkan destinasi yang disusun semula dan dinilai
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # Ekstrak dan kembalikan cadangan
        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

# Contoh penggunaan
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)

Penjelasan Kod - Preference Booker

  1. Initialization: The TravelAgent class is initialized with a list of potential travel destinations, each having attributes like name and description.

  2. Getting Recommendations (get_recommendations method): This method generates a prompt for the Azure OpenAI service based on the user’s preferences and makes an HTTP POST request to the Azure OpenAI API to get re-ranked and scored destinations.

  3. Generating Prompt (generate_prompt method): This method constructs a prompt for the Azure OpenAI, including the user’s preferences and the list of destinations. The prompt guides the model to re-rank and score the destinations based on the provided preferences.

  4. API Call: The requests library is used to make an HTTP POST request to the Azure OpenAI API endpoint. The response contains the re-ranked and scored destinations.

  5. Example Usage: The travel agent collects user preferences (e.g., interest in sightseeing and diverse culture) and uses the Azure OpenAI service to get re-ranked and scored recommendations for travel destinations.

Make sure to replace your_azure_openai_api_key with your actual Azure OpenAI API key and https://your-endpoint.com/... with the actual endpoint URL of your Azure OpenAI deployment.

By leveraging the LLM for re-ranking and scoring, the travel agent can provide more personalized and relevant travel recommendations to clients, enhancing their overall experience.

RAG: Prompting Technique vs Tool

Retrieval-Augmented Generation (RAG) can be both a prompting technique and a tool in the development of AI agents. Understanding the distinction between the two can help you leverage RAG more effectively in your projects.

RAG as a Prompting Technique

Apakah ia?

Bagaimana ia berfungsi:

  1. Rumuskan Prompt: Cipta prompt atau pertanyaan yang berstruktur baik berdasarkan tugas yang diperlukan atau input pengguna.
  2. Ambil Maklumat: Gunakan prompt untuk mencari data yang relevan dari pangkalan pengetahuan atau set data yang sedia ada.
  3. Jana Respons: Gabungkan maklumat yang diambil dengan model AI generatif untuk menghasilkan respons yang komprehensif dan koheren.

Contoh dalam Ejen Pelancongan:

RAG as a Tool

Apakah ia?

Bagaimana ia berfungsi:

  1. Integrasi: Masukkan RAG ke dalam seni bina ejen AI, membolehkannya mengendalikan tugas pengambilan dan penjanaan secara automatik.
  2. Automasi: Alat ini mengurus keseluruhan proses, dari menerima input pengguna hingga menjana respons akhir, tanpa memerlukan prompt eksplisit untuk setiap langkah.
  3. Kecekapan: Meningkatkan prestasi ejen dengan merapikan proses pengambilan dan penjanaan, membolehkan respons yang lebih pantas dan lebih tepat.

Contoh dalam Ejen Pelancongan:

Perbandingan

Aspect Prompting Technique Tool
Manual vs Automatic Formulasi prompt secara manual untuk setiap pertanyaan. Proses automatik untuk pengambilan dan penjanaan.
Control Menawarkan lebih kawalan ke atas proses pengambilan. Menyelaraskan dan mengautomasikan proses pengambilan dan penjanaan.
Flexibility Membenarkan prompt yang disesuaikan berdasarkan keperluan tertentu. Lebih cekap untuk implementasi skala besar.
Complexity Memerlukan perumusan dan penyelarasan prompt. Lebih mudah untuk diintegrasikan dalam seni bina ejen AI.

Contoh Praktikal

Contoh Teknik Prompting:

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)

Contoh Alat:

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)

Menilai Relevansi

Evaluating relevancy is a crucial aspect of AI agent performance. It ensures that the information retrieved and generated by the agent is appropriate, accurate, and useful to the user. Let’s explore how to evaluate relevancy in AI agents, including practical examples and techniques.

Konsep Utama dalam Menilai Relevansi

  1. Context Awareness:
    • Ejen mesti memahami konteks pertanyaan pengguna untuk mengambil dan menjana maklumat yang relevan.
    • Contoh: Jika pengguna bertanya “restoran terbaik di Paris,” ejen harus mengambil kira pilihan pengguna, seperti jenis masakan dan bajet.
  2. Accuracy:
    • Maklumat yang diberikan oleh ejen harus betul dari segi fakta dan terkini.
    • Contoh: Mencadangkan restoran yang sedang dibuka dengan ulasan baik dan bukannya pilihan yang lapuk atau ditutup.
  3. User Intent:
    • Ejen harus menilai niat pengguna di sebalik pertanyaan untuk menyediakan maklumat yang paling relevan.
    • Contoh: Jika pengguna meminta “hotel bajet,” ejen harus mengutamakan pilihan yang mampu milik.
  4. Feedback Loop:
    • Mengumpulkan dan menganalisis maklum balas pengguna secara berterusan membantu ejen memperhalusi proses penilaian relevansinya.
    • Contoh: Menggabungkan penilaian dan maklum balas pengguna terhadap cadangan terdahulu untuk memperbaiki respons masa depan.

Teknik Praktikal untuk Menilai Relevansi

  1. Relevance Scoring:
    • Berikan skor relevansi kepada setiap item yang diambil berdasarkan sejauh mana ia sepadan dengan pertanyaan dan pilihan pengguna.

    • Contoh:

      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. Filtering and Ranking:
    • Tapis item yang tidak relevan dan susun yang tinggal berdasarkan skor relevansi mereka.

    • Contoh:

      def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # Kembalikan 10 item paling relevan
  3. Natural Language Processing (NLP):
    • Gunakan teknik NLP untuk memahami pertanyaan pengguna dan mengambil maklumat yang relevan.

    • Contoh:

      def process_query(query):
    # Gunakan NLP untuk mengekstrak maklumat utama daripada pertanyaan pengguna
    processed_query = nlp(query)
    return processed_query
  4. User Feedback Integration:
    • Kumpulkan maklum balas pengguna tentang cadangan yang diberikan dan gunakan ia untuk menyesuaikan penilaian relevansi akan datang.

    • Contoh:

      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

Contoh: Menilai Relevansi dalam Ejen Pelancongan

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]  # Kembalikan 10 item paling relevan

    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

# Contoh penggunaan
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)

Carian dengan Niat

Searching with intent involves understanding and interpreting the underlying purpose or goal behind a user’s query to retrieve and generate the most relevant and useful information. This approach goes beyond simply matching keywords and focuses on grasping the user’s actual needs and context.

Konsep Utama dalam Carian dengan Niat

  1. Understanding User Intent:
    • Niat pengguna boleh dikategorikan kepada tiga jenis utama: informatif, navigasi, dan transaksional.
      • Informational Intent: Pengguna mencari maklumat tentang sesuatu topik (contohnya, “Apa muzium terbaik di Paris?”).
      • Navigational Intent: Pengguna mahu pergi ke laman web atau halaman tertentu (contohnya, “laman rasmi Louvre Museum”).
      • Transactional Intent: Pengguna bertujuan melakukan transaksi, seperti menempah penerbangan atau membuat pembelian (contohnya, “Tempah penerbangan ke Paris”).
  2. Context Awareness:
    • Menganalisis konteks pertanyaan pengguna membantu mengenal pasti niat mereka dengan tepat. Ini termasuk mengambil kira interaksi sebelumnya, pilihan pengguna, dan butiran khusus pertanyaan semasa.
  3. Natural Language Processing (NLP):
    • Teknik NLP digunakan untuk memahami dan mentafsir pertanyaan berbahasa semula jadi yang diberikan oleh pengguna. Ini termasuk tugas seperti pengecaman entiti, analisis sentimen, dan pemparsean pertanyaan.
  4. Personalization:
    • Mengperibadikan hasil carian berdasarkan sejarah, pilihan, dan maklum balas pengguna meningkatkan relevansi maklumat yang diambil.

Contoh Praktikal: Carian dengan Niat dalam Ejen Pelancongan

Mari ambil Travel Agent sebagai contoh untuk melihat bagaimana carian dengan niat boleh dilaksanakan.

  1. Mengumpulkan Keutamaan Pengguna

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

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

  2. Memahami Niat Pengguna

    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. Kesedaran Konteks 
    def analyze_context(query, user_history):
    # Gabungkan pertanyaan semasa dengan sejarah pengguna untuk memahami konteks
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

  4. Cari dan Peribadikan Keputusan

    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):
    # Contoh logik carian untuk niat maklumat
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # Contoh logik carian untuk niat navigasi
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # Contoh logik carian untuk niat transaksi
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # Contoh logik penyesuaian peribadi
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # Kembalikan 10 keputusan teratas yang diperibadikan

  5. Contoh Penggunaan

    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. Menjana Kod sebagai Alat

Ejen penjana kod menggunakan model AI untuk menulis dan menjalankan kod, menyelesaikan masalah kompleks dan mengautomasikan tugas.

Ejen Penjana Kod

Ejen penjana kod menggunakan model AI generatif untuk menulis dan menjalankan kod. Ejen-ejen ini boleh menyelesaikan masalah kompleks, mengautomasikan tugas, dan memberikan pandangan yang berharga dengan menjana dan menjalankan kod dalam pelbagai bahasa pengaturcaraan.

Aplikasi Praktikal

  1. Penjanaan Kod Automatik: Hasilkan serpihan kod untuk tugas tertentu, seperti analisis data, web scraping, atau pembelajaran mesin.
  2. SQL sebagai RAG: Gunakan pertanyaan SQL untuk mengambil dan mengubah suai data daripada pangkalan data.
  3. Penyelesaian Masalah: Cipta dan jalankan kod untuk menyelesaikan masalah tertentu, seperti mengoptimumkan algoritma atau menganalisis data.

Contoh: Ejen Penjana Kod untuk Analisis Data

Bayangkan anda mereka ejen penjana kod. Begini cara ia mungkin berfungsi:

  1. Tugas: Menganalisis set data untuk mengenal pasti trend dan corak.
  2. Langkah-langkah:
    • Muatkan set data ke dalam alat analisis data.
    • Jana pertanyaan SQL untuk menapis dan mengagregatkan data.
    • Jalankan pertanyaan dan ambil keputusan.
    • Gunakan keputusan untuk menjana visualisasi dan pandangan.
  3. Sumber Diperlukan: Akses kepada set data, alat analisis data, dan keupayaan SQL.
  4. Pengalaman: Gunakan keputusan analisis lampau untuk meningkatkan ketepatan dan kepentingan analisis masa depan.

Contoh: Ejen Penjana Kod untuk Ejen Perjalanan

Dalam contoh ini, kita akan mereka sebuah ejen penjana kod, Ejen Perjalanan, untuk membantu pengguna merancang perjalanan mereka dengan menjana dan menjalankan kod. Ejen ini boleh mengendalikan tugas seperti mendapatkan pilihan perjalanan, menapis keputusan, dan menyusun jadual perjalanan menggunakan AI generatif.

Gambaran Keseluruhan Ejen Penjana Kod

  1. Mengumpul Keutamaan Pengguna: Mengumpul input pengguna seperti destinasi, tarikh perjalanan, bajet, dan minat.
  2. Menjana Kod untuk Mengambil Data: Menjana serpihan kod untuk mendapatkan data tentang penerbangan, hotel, dan tarikan.
  3. Menjalankan Kod yang Dijana: Menjalankan kod yang dijana untuk mendapatkan maklumat masa nyata.
  4. Menjana Jadual Perjalanan: Menyusun data yang diperoleh ke dalam pelan perjalanan peribadi.
  5. Melaraskan Berdasarkan Maklum Balas: Menerima maklum balas pengguna dan menjana semula kod jika perlu untuk memperbaiki keputusan.

Pelaksanaan Langkah demi Langkah

  1. Mengumpul Keutamaan Pengguna

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

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

  2. Menjana Kod untuk Mengambil Data

    def generate_code_to_fetch_data(preferences):
    # Contoh: Jana kod untuk mencari penerbangan berdasarkan keutamaan pengguna
    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):
    # Contoh: Jana kod untuk mencari hotel
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

  3. Menjalankan Kod yang Dijana

    def execute_code(code):
    # Jalankan kod yang dihasilkan menggunakan 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. Menjana Jadual Perjalanan

    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. Melaraskan Berdasarkan Maklum Balas

    def adjust_based_on_feedback(feedback, preferences):
    # Laraskan keutamaan berdasarkan maklum balas pengguna
    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)
   
# Jana semula dan jalankan kod dengan keutamaan yang dikemas kini
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)

Memanfaatkan kesedaran persekitaran dan penalaran

Berdasarkan skema jadual memang boleh meningkatkan proses penjanaan pertanyaan dengan memanfaatkan kesedaran persekitaran dan penalaran.

Berikut adalah contoh bagaimana ini boleh dilakukan:

  1. Memahami Skema: Sistem akan memahami skema jadual dan menggunakan maklumat ini untuk mengakar proses penjanaan pertanyaan.
  2. Melaraskan Berdasarkan Maklum Balas: Sistem akan melaraskan keutamaan pengguna berdasarkan maklum balas dan berfikir tentang medan mana dalam skema yang perlu dikemas kini.
  3. Menjana dan Menjalankan Pertanyaan: Sistem akan menjana dan menjalankan pertanyaan untuk mendapatkan data penerbangan dan hotel yang dikemas kini berdasarkan keutamaan baru.

Berikut adalah contoh kod Python yang dikemas kini yang menggabungkan konsep-konsep ini:

def adjust_based_on_feedback(feedback, preferences, schema):
    # Laraskan keutamaan berdasarkan maklum balas pengguna
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Penalaran berdasarkan skema untuk melaraskan keutamaan lain yang berkaitan
    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):
    # Logik tersuai untuk melaraskan keutamaan berdasarkan skema dan maklum balas
    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):
    # Hasilkan kod untuk mendapatkan data penerbangan berdasarkan keutamaan yang dikemas kini
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Hasilkan kod untuk mendapatkan data hotel berdasarkan keutamaan yang dikemas kini
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # Mensimulasikan pelaksanaan kod dan mengembalikan data tiruan
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Hasilkan jadual perjalanan berdasarkan penerbangan, hotel, dan tarikan
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

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

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

# Hasilkan semula dan jalankan kod dengan keutamaan yang dikemas kini
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)

Penjelasan - Tempahan Berdasarkan Maklum Balas

  1. Kesedaran Skema: Kamus schema mentakrifkan bagaimana keutamaan harus disesuaikan berdasarkan maklum balas. Ia merangkumi medan seperti favorites dan avoid, dengan penyesuaian yang sepadan.
  2. Melaraskan Keutamaan (adjust_based_on_feedback method): Kaedah ini melaraskan keutamaan berdasarkan maklum balas pengguna dan skema.
  3. Penyesuaian Berdasarkan Persekitaran (adjust_based_on_environment method): Kaedah ini menyesuaikan penyesuaian berdasarkan skema dan maklum balas.
  4. Menjana dan Menjalankan Pertanyaan: Sistem menjana kod untuk mendapatkan data penerbangan dan hotel yang dikemas kini berdasarkan keutamaan yang disesuaikan dan mensimulasikan pelaksanaan pertanyaan ini.
  5. Menjana Jadual Perjalanan: Sistem mencipta jadual perjalanan yang dikemas kini berdasarkan data penerbangan, hotel, dan tarikan yang baru.

Dengan menjadikan sistem peka kepada persekitaran dan melakukan penalaran berdasarkan skema, ia boleh menjana pertanyaan yang lebih tepat dan relevan, yang membawa kepada cadangan perjalanan yang lebih baik dan pengalaman pengguna yang lebih diperibadikan.

Menggunakan SQL sebagai Teknik Retrieval-Augmented Generation (RAG)

SQL (Structured Query Language) adalah alat yang berkuasa untuk berinteraksi dengan pangkalan data. Apabila digunakan sebagai sebahagian daripada pendekatan Retrieval-Augmented Generation (RAG), SQL boleh mengambil data yang relevan daripada pangkalan data untuk memaklumkan dan menjana respons atau tindakan dalam ejen AI. Mari kita terokai bagaimana SQL boleh digunakan sebagai teknik RAG dalam konteks Ejen Perjalanan.

Konsep Utama

  1. Interaksi Pangkalan Data:
    • SQL digunakan untuk membuat pertanyaan kepada pangkalan data, mengambil maklumat yang relevan, dan mengubah suai data.
    • Contoh: Mendapatkan butiran penerbangan, maklumat hotel, dan tarikan daripada pangkalan data perjalanan.
  2. Integrasi dengan RAG:
    • Pertanyaan SQL dijana berdasarkan input dan keutamaan pengguna.
    • Data yang diambil kemudian digunakan untuk menjana cadangan atau tindakan yang diperibadikan.
  3. Penjanaan Pertanyaan Dinamik:
    • Ejen AI menjana pertanyaan SQL dinamik berdasarkan konteks dan keperluan pengguna.
    • Contoh: Menyesuaikan pertanyaan SQL untuk menapis keputusan berdasarkan bajet, tarikh, dan minat.

Aplikasi

Contoh: Seorang ejen analisis data:

  1. Tugas: Menganalisis set data untuk mencari trend.
  2. Langkah-langkah:
    • Muatkan set data.
    • Jana pertanyaan SQL untuk menapis data.
    • Jalankan pertanyaan dan ambil keputusan.
    • Jana visualisasi dan pandangan.
  3. Sumber: Akses set data, keupayaan SQL.
  4. Pengalaman: Gunakan keputusan lampau untuk memperbaiki analisis masa depan.

Contoh Praktikal: Menggunakan SQL dalam Ejen Perjalanan

  1. Mengumpul Keutamaan Pengguna

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

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

  2. Menjana Pertanyaan 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. Menjalankan Pertanyaan 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. Menjana Cadangan

    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)

Contoh Pertanyaan SQL

  1. Pertanyaan Penerbangan

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

  2. Pertanyaan Hotel

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

  3. Pertanyaan Tarikan

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

Dengan memanfaatkan SQL sebagai sebahagian daripada teknik Retrieval-Augmented Generation (RAG), ejen AI seperti Ejen Perjalanan dapat secara dinamik mengambil dan menggunakan data yang relevan untuk memberikan cadangan yang tepat dan diperibadikan.

Contoh Metakognisi

Untuk menunjukkan pelaksanaan metakognisi, mari kita cipta sebuah ejen ringkas yang merenungkan proses pembuatan keputusannya semasa menyelesaikan sesuatu masalah. Untuk contoh ini, kita akan bina sistem di mana ejen cuba mengoptimumkan pemilihan hotel, tetapi kemudian menilai proses pemikirannya sendiri dan melaraskan strateginya apabila ia membuat kesilapan atau pilihan yang tidak optimum.

Kita akan mensimulasikannya menggunakan contoh asas di mana ejen memilih hotel berdasarkan gabungan harga dan kualiti, tetapi ia akan “merenung” ke atas keputusannya dan melaraskan sewajarnya.

Bagaimana ini menggambarkan metakognisi:

  1. Keputusan Awal: Ejen akan memilih hotel termurah, tanpa memahami impak kualiti.
  2. Refleksi dan Penilaian: Selepas pilihan awal, ejen akan menyemak sama ada hotel itu adalah pilihan “buruk” menggunakan maklum balas pengguna. Jika ia mendapati kualiti hotel terlalu rendah, ia akan merenungkan rasionalnya.
  3. Melaraskan Strategi: Ejen menyesuaikan strateginya berdasarkan refleksi dan beralih daripada “termurah” kepada “kualiti_tertinggi”, sekali gus memperbaiki proses pembuatan keputusannya dalam iterasi akan datang.

Berikut adalah contoh:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # Menyimpan hotel yang dipilih sebelum ini
        self.corrected_choices = []  # Menyimpan pilihan yang diperbetulkan
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # Strategi yang tersedia

    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]
        # Anggap kita mempunyai maklum balas pengguna yang memberitahu sama ada pilihan terakhir bagus atau tidak
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # Laraskan strategi jika pilihan sebelumnya tidak memuaskan
            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"

# Mensimulasikan senarai hotel (harga dan kualiti)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# Cipta ejen
agent = HotelRecommendationAgent()

# Langkah 1: Ejen mencadangkan sebuah hotel menggunakan strategi "paling murah"
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# Langkah 2: Ejen menilai semula pilihan dan melaraskan strategi jika perlu
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# Langkah 3: Ejen mencadangkan semula, kali ini menggunakan strategi yang dilaraskan
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

Kebolehan Metakognisi Ejen

Kunci di sini ialah keupayaan ejen untuk:

Ini adalah bentuk ringkas metakognisi di mana sistem mampu melaraskan proses penalarannya berdasarkan maklum balas dalaman.

Kesimpulan

Metakognisi adalah alat yang berkuasa yang boleh meningkatkan keupayaan ejen AI dengan ketara. Dengan memasukkan proses metakognitif, anda boleh mereka ejen yang lebih pintar, mudah menyesuaikan diri, dan cekap. Gunakan sumber tambahan untuk terus meneroka dunia metakognisi yang menarik dalam ejen AI.

Ada Lagi Soalan mengenai Corak Reka Bentuk Metakognisi?

Sertai the Microsoft Foundry Discord untuk bertemu dengan pelajar lain, menghadiri sesi waktu pejabat dan mendapatkan jawapan kepada soalan Ejen AI anda.

Pelajaran Sebelumnya

Multi-Agent Design Pattern

Pelajaran Seterusnya

ELEMENTS AI Agents in Production

Penafian: Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI Co‑op Translator (https://github.com/Azure/co-op-translator). Walaupun kami berusaha untuk ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi ralat atau ketidaktepatan. Dokumen asal dalam bahasa ibundanya hendaklah dianggap sebagai sumber yang berwibawa. Untuk maklumat yang kritikal, disyorkan terjemahan profesional oleh penterjemah manusia. Kami tidak bertanggungjawab terhadap sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.

This site is open source. Improve this page.