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 proses pemikiran mereka sendiri. Pada akhir pelajaran ini, anda akan memahami konsep utama dan dilengkapi dengan contoh praktikal untuk menerapkan metakognisi dalam reka bentuk 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 melaksanakan tugas.

Pengenalan kepada Metakognisi

Metakognisi merujuk kepada proses kognitif peringkat tinggi yang melibatkan pemikiran tentang pemikiran sendiri. Bagi ejen AI, ini bermaksud keupayaan untuk menilai dan menyesuaikan tindakan mereka berdasarkan kesedaran diri dan pengalaman lalu. Metakognisi, atau “berfikir tentang pemikiran,” adalah konsep penting dalam pembangunan sistem AI yang bersifat agen. Ia melibatkan sistem AI yang sedar tentang proses dalaman mereka sendiri dan mampu memantau, mengawal, dan menyesuaikan tingkah laku mereka dengan sewajarnya. Sama seperti kita membaca situasi atau menganalisis masalah. Kesedaran diri ini boleh membantu sistem AI membuat keputusan yang lebih baik, mengenal pasti kesilapan, dan meningkatkan prestasi mereka dari semasa ke semasa—sekali lagi merujuk kepada ujian Turing dan perdebatan sama ada AI akan mengambil alih.

Dalam konteks sistem AI yang bersifat agen, metakognisi boleh membantu menangani beberapa cabaran, seperti:

Apakah Metakognisi?

Metakognisi, atau “berfikir tentang pemikiran,” adalah proses kognitif peringkat tinggi yang melibatkan kesedaran diri dan pengawalan diri terhadap proses kognitif seseorang. Dalam bidang AI, metakognisi memperkasakan ejen untuk menilai dan menyesuaikan strategi dan tindakan mereka, yang membawa kepada keupayaan menyelesaikan masalah dan membuat keputusan yang lebih baik. Dengan memahami metakognisi, anda boleh mereka bentuk ejen AI yang bukan sahaja lebih pintar tetapi juga lebih fleksibel dan cekap. Dalam metakognisi sebenar, anda akan melihat AI secara eksplisit membuat penaakulan tentang penaakulan mereka sendiri.

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

Kepentingan Metakognisi dalam Ejen AI

Metakognisi memainkan peranan penting dalam reka bentuk ejen AI atas beberapa sebab:

Kepentingan Metakognisi

Komponen Ejen AI

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

Komponen-komponen ini bekerjasama untuk mencipta “unit kepakaran” yang boleh melaksanakan tugas tertentu.

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

Contoh: Metakognisi dalam Perkhidmatan Ejen Pelancongan

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

Tugas Semasa

Tugas semasa adalah membantu pengguna merancang perjalanan ke Paris.

Langkah untuk Menyelesaikan Tugas

  1. Mengumpul Keutamaan Pengguna: Tanya pengguna tentang tarikh perjalanan, bajet, minat (contohnya, muzium, masakan, membeli-belah), dan sebarang keperluan khusus.
  2. Mengambil Maklumat: Cari pilihan penerbangan, penginapan, tarikan, dan restoran yang sesuai dengan keutamaan pengguna.
  3. Menjana Cadangan: Sediakan jadual perjalanan yang diperibadikan dengan butiran penerbangan, tempahan hotel, dan aktiviti yang disyorkan.
  4. Menyesuaikan Berdasarkan Maklum Balas: Tanya pengguna untuk maklum balas tentang cadangan dan buat penyesuaian yang diperlukan.

Sumber Diperlukan

Pengalaman dan Refleksi 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 mana yang tidak. Ia menyesuaikan cadangan masa depannya dengan sewajarnya.
  2. Penyesuaian: Jika 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 membuat kesilapan dalam tempahan lalu, seperti mencadangkan hotel yang telah penuh, ia belajar untuk memeriksa ketersediaan dengan lebih teliti sebelum membuat cadangan.

Contoh Pemaju Praktikal

Berikut adalah contoh ringkas bagaimana kod Ejen Pelancongan mungkin kelihatan apabila menggabungkan 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):
        # 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)

Mengapa Metakognisi Penting

Dengan menggabungkan metakognisi, Ejen Pelancongan boleh memberikan cadangan perjalanan yang lebih diperibadikan dan tepat, meningkatkan pengalaman pengguna secara keseluruhan.

2. Perancangan dalam Ejen

Perancangan adalah komponen kritikal dalam tingkah laku ejen AI. Ia melibatkan penyusunan langkah-langkah yang diperlukan untuk mencapai matlamat, dengan mempertimbangkan keadaan semasa, sumber, dan kemungkinan halangan.

Elemen Perancangan

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

Langkah untuk Ejen Pelancongan

  1. Mengumpul Keutamaan Pengguna
    • Tanya pengguna untuk butiran tentang tarikh perjalanan, bajet, minat, dan sebarang keperluan khusus.
    • Contoh: “Bilakah anda merancang untuk melancong?” “Apakah julat bajet anda?” “Apakah aktiviti yang anda nikmati semasa bercuti?”
  2. Mengambil Maklumat
    • Cari pilihan perjalanan yang relevan berdasarkan keutamaan pengguna.
    • Penerbangan: Cari penerbangan yang tersedia dalam bajet dan tarikh perjalanan pilihan pengguna.
    • Penginapan: Cari hotel atau hartanah sewa yang sesuai dengan keutamaan pengguna untuk lokasi, harga, dan kemudahan.
    • Tarikan dan Restoran: Kenal pasti tarikan, aktiviti, dan pilihan makan yang popular yang selaras dengan minat pengguna.
  3. Menjana Cadangan
    • Gabungkan maklumat yang diperoleh ke dalam jadual perjalanan yang diperibadikan.
    • Sediakan butiran seperti pilihan penerbangan, tempahan hotel, dan aktiviti yang disyorkan, dengan memastikan cadangan disesuaikan dengan keutamaan pengguna.
  4. Menyampaikan Jadual Perjalanan kepada Pengguna
    • Kongsi jadual perjalanan yang dicadangkan dengan pengguna untuk semakan mereka.
    • Contoh: “Berikut adalah jadual perjalanan yang dicadangkan untuk perjalanan anda ke Paris. Ia termasuk butiran penerbangan, tempahan hotel, dan senarai aktiviti dan restoran yang disyorkan. Beritahu saya pendapat anda!”
  5. Mengumpul Maklum Balas
    • Tanya pengguna untuk maklum balas tentang jadual perjalanan yang dicadangkan.
    • Contoh: “Adakah anda suka pilihan penerbangan ini?” “Adakah hotel ini sesuai untuk keperluan anda?” “Adakah terdapat sebarang aktiviti yang anda ingin tambah atau keluarkan?”
  6. Menyesuaikan Berdasarkan Maklum Balas
    • Ubah jadual perjalanan berdasarkan maklum balas pengguna.
    • Buat perubahan yang diperlukan pada cadangan penerbangan, penginapan, dan aktiviti untuk lebih sesuai dengan keutamaan pengguna.
  7. Pengesahan Akhir
    • Sampaikan jadual perjalanan yang dikemas kini kepada pengguna untuk pengesahan akhir.
    • Contoh: “Saya telah membuat penyesuaian berdasarkan maklum balas anda. Berikut adalah jadual perjalanan yang dikemas kini. Adakah semuanya kelihatan baik untuk 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. Memberikan Sokongan Berterusan
    • Tetap tersedia untuk membantu pengguna dengan sebarang perubahan atau permintaan tambahan sebelum dan semasa perjalanan mereka.
    • Contoh: “Jika anda memerlukan bantuan lanjut semasa perjalanan anda, jangan ragu untuk menghubungi saya pada bila-bila masa!”

Contoh Interaksi

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. Sistem RAG Pembetulan

Mari kita mulakan dengan memahami perbezaan antara Alat RAG dan Pemuatan Konteks Pra-emptif.

RAG vs Pemuatan Konteks

Penjanaan Augmentasi Pengambilan (RAG)

RAG menggabungkan sistem pengambilan dengan model generatif. Apabila pertanyaan dibuat, sistem pengambilan mengambil dokumen atau data yang relevan dari sumber luaran, dan maklumat yang diperoleh ini digunakan untuk menambah input kepada model generatif. Ini membantu model menghasilkan respons yang lebih tepat dan relevan secara kontekstual.

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

Pendekatan RAG Pembetulan

Pendekatan RAG Pembetulan memberi tumpuan kepada penggunaan teknik RAG untuk membetulkan kesilapan dan meningkatkan ketepatan ejen AI. Ini melibatkan:

  1. Teknik Pemacu: Menggunakan pemacu tertentu untuk membimbing ejen dalam mengambil maklumat yang relevan.
  2. Alat: Melaksanakan algoritma dan mekanisme yang membolehkan ejen menilai kesesuaian maklumat yang diperoleh dan menghasilkan respons yang tepat.
  3. Penilaian: Sentiasa menilai prestasi ejen dan membuat penyesuaian untuk meningkatkan ketepatan dan kecekapan.

Contoh: RAG Pembetulan dalam Ejen Carian

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

  1. Teknik Pemacu: Merumuskan pertanyaan carian berdasarkan input pengguna.
  2. Alat: Menggunakan pemprosesan bahasa semula jadi dan algoritma pembelajaran mesin untuk menyusun dan menapis hasil carian.
  3. Penilaian: Menganalisis maklum balas pengguna untuk mengenal pasti dan membetulkan ketidaktepatan dalam maklumat yang diperoleh.

RAG Pembetulan dalam Ejen Pelancongan

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

Ini melibatkan:

Langkah untuk Melaksanakan RAG Pembetulan dalam Ejen Pelancongan

  1. Interaksi Awal 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 mengambil maklumat tentang penerbangan, penginapan, tarikan, dan restoran berdasarkan keutamaan pengguna.

    • Contoh:

      flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
  3. Menjana Cadangan Awal
    • Ejen Pelancongan menggunakan maklumat yang diperoleh untuk menjana jadual perjalanan yang diperibadikan.

    • Contoh:

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

    • Contoh:

      feedback = {
    "liked": ["Louvre Museum"],
    "disliked": ["Eiffel Tower (too crowded)"]
}
  5. Proses RAG Pembetulan
    • Teknik Pemacu: 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 kesesuaian 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 kesesuaian dan ketepatan cadangannya dengan menganalisis maklum balas pengguna dan membuat penyesuaian yang diperlukan.

      • 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 adalah contoh kod Python ringkas yang menggabungkan pendekatan RAG Pembetulan dalam Ejen Pelancongan:

Muatkan Konteks Secara Awal

Muatkan Konteks Secara Awal melibatkan pemuatan maklumat latar belakang atau konteks yang relevan ke dalam model sebelum memproses pertanyaan. Ini bermaksud model mempunyai akses kepada maklumat ini dari awal, yang dapat membantu menghasilkan respons yang lebih bermaklumat tanpa perlu mendapatkan data tambahan semasa proses berlangsung.

Berikut adalah contoh ringkas bagaimana muatkan konteks secara awal mungkin kelihatan untuk aplikasi ejen pelancongan dalam Python:

Penjelasan

  1. Inisialisasi (kaedah __init__): Kelas TravelAgent memuatkan kamus yang mengandungi maklumat tentang destinasi popular seperti Paris, Tokyo, New York, dan Sydney. Kamus ini termasuk butiran seperti negara, mata wang, bahasa, dan tarikan utama untuk setiap destinasi.

  2. Mendapatkan Maklumat (get_destination_info method): Apabila pengguna bertanya tentang destinasi tertentu, kaedah get_destination_info mengambil maklumat yang relevan daripada kamus konteks yang telah dimuatkan.

Dengan memuatkan konteks secara awal, aplikasi ejen pelancongan dapat menjawab pertanyaan pengguna dengan cepat tanpa perlu mendapatkan maklumat ini daripada sumber luaran secara masa nyata. Ini menjadikan aplikasi lebih cekap dan responsif.

Memulakan Rancangan dengan Matlamat Sebelum Iterasi

Memulakan rancangan dengan matlamat melibatkan bermula dengan objektif atau hasil yang jelas. Dengan mendefinisikan matlamat ini terlebih dahulu, model boleh menggunakannya sebagai prinsip panduan sepanjang proses iterasi. Ini membantu memastikan setiap iterasi bergerak lebih dekat kepada mencapai hasil yang diinginkan, menjadikan proses lebih cekap dan fokus.

Berikut adalah contoh bagaimana anda boleh memulakan rancangan pelancongan dengan matlamat sebelum iterasi untuk ejen pelancongan dalam Python:

Senario

Seorang ejen pelancongan ingin merancang percutian yang disesuaikan untuk pelanggan. Matlamatnya adalah untuk mencipta jadual perjalanan yang memaksimumkan kepuasan pelanggan berdasarkan keutamaan dan bajet mereka.

Langkah-langkah

  1. Tentukan keutamaan dan bajet pelanggan.
  2. Mulakan rancangan awal berdasarkan keutamaan ini.
  3. Iterasi untuk memperhalusi rancangan, mengoptimumkan kepuasan pelanggan.

Penjelasan Kod

  1. Inisialisasi (kaedah __init__): Kelas TravelAgent diinisialisasi dengan senarai destinasi berpotensi, setiap satu mempunyai atribut seperti nama, kos, dan jenis aktiviti.

  2. Memulakan Rancangan (bootstrap_plan method): Kaedah ini mencipta rancangan awal berdasarkan keutamaan dan bajet pelanggan. Ia melalui senarai destinasi dan menambahnya ke rancangan jika ia sesuai dengan keutamaan pelanggan dan sesuai dengan bajet.

  3. Memadankan Keutamaan (match_preferences method): Kaedah ini memeriksa sama ada destinasi sesuai dengan keutamaan pelanggan.

  4. Iterasi Rancangan (iterate_plan method): Kaedah ini memperhalusi rancangan awal dengan cuba menggantikan setiap destinasi dalam rancangan dengan padanan yang lebih baik, dengan mengambil kira keutamaan dan kekangan bajet pelanggan.

  5. Mengira Kos (calculate_cost method): Kaedah ini mengira jumlah kos rancangan semasa, termasuk destinasi baru yang berpotensi.

Contoh Penggunaan

Dengan memulakan rancangan dengan matlamat yang jelas (contohnya, memaksimumkan kepuasan pelanggan) dan mengiterasi untuk memperhalusi rancangan, ejen pelancongan dapat mencipta jadual perjalanan yang disesuaikan dan dioptimumkan untuk pelanggan. Pendekatan ini memastikan rancangan pelancongan selaras dengan keutamaan dan bajet pelanggan dari awal dan bertambah baik dengan setiap iterasi.

Memanfaatkan LLM untuk Penilaian Semula dan Pemarkahan

Model Bahasa Besar (LLM) boleh digunakan untuk penilaian semula dan pemarkahan dengan menilai relevansi dan kualiti dokumen yang diperoleh atau respons yang dihasilkan. Berikut adalah cara ia berfungsi:

Pengambilan: Langkah pengambilan awal mendapatkan satu set dokumen atau respons calon berdasarkan pertanyaan.

Penilaian Semula: LLM menilai calon-calon ini dan menyusun semula mereka berdasarkan relevansi dan kualiti. Langkah ini memastikan maklumat yang paling relevan dan berkualiti tinggi dipersembahkan terlebih dahulu.

Pemarkahan: LLM memberikan skor kepada setiap calon, mencerminkan relevansi dan kualiti mereka. Ini membantu dalam memilih respons atau dokumen terbaik untuk pengguna.

Dengan memanfaatkan LLM untuk penilaian semula dan pemarkahan, sistem dapat memberikan maklumat yang lebih tepat dan relevan secara kontekstual, meningkatkan pengalaman pengguna secara keseluruhan.

Berikut adalah contoh bagaimana ejen pelancongan mungkin menggunakan Model Bahasa Besar (LLM) untuk penilaian semula dan pemarkahan destinasi pelancongan berdasarkan keutamaan pengguna dalam Python:

Senario - Pelancongan Berdasarkan Keutamaan

Seorang ejen pelancongan ingin mencadangkan destinasi pelancongan terbaik kepada pelanggan berdasarkan keutamaan mereka. LLM akan membantu menyusun semula dan memberikan skor kepada destinasi untuk memastikan pilihan yang paling relevan dipersembahkan.

Langkah-langkah:

  1. Kumpulkan keutamaan pengguna.
  2. Dapatkan senarai destinasi pelancongan yang berpotensi.
  3. Gunakan LLM untuk menyusun semula dan memberikan skor kepada destinasi berdasarkan keutamaan pengguna.

Penjelasan Kod - Pemesan Keutamaan

  1. Inisialisasi: Kelas TravelAgent diinisialisasi dengan senarai destinasi pelancongan yang berpotensi, setiap satu mempunyai atribut seperti nama dan deskripsi.

  2. Mendapatkan Cadangan (get_recommendations method): Kaedah ini menghasilkan prompt untuk perkhidmatan Azure OpenAI berdasarkan keutamaan pengguna dan membuat permintaan HTTP POST kepada API Azure OpenAI untuk mendapatkan destinasi yang disusun semula dan diberi skor.

  3. Menjana Prompt (generate_prompt method): Kaedah ini membina prompt untuk Azure OpenAI, termasuk keutamaan pengguna dan senarai destinasi. Prompt ini membimbing model untuk menyusun semula dan memberikan skor kepada destinasi berdasarkan keutamaan yang diberikan.

  4. Panggilan API: Perpustakaan requests digunakan untuk membuat permintaan HTTP POST kepada endpoint API Azure OpenAI. Respons mengandungi destinasi yang disusun semula dan diberi skor.

  5. Contoh Penggunaan: Ejen pelancongan mengumpulkan keutamaan pengguna (contohnya, minat terhadap bersiar-siar dan budaya yang pelbagai) dan menggunakan perkhidmatan Azure OpenAI untuk mendapatkan cadangan destinasi pelancongan yang disusun semula dan diberi skor.

Pastikan untuk menggantikan your_azure_openai_api_key dengan kunci API Azure OpenAI sebenar anda dan https://your-endpoint.com/... dengan URL endpoint sebenar bagi penyebaran Azure OpenAI anda.

Dengan memanfaatkan LLM untuk penilaian semula dan pemarkahan, ejen pelancongan dapat memberikan cadangan pelancongan yang lebih diperibadikan dan relevan kepada pelanggan, meningkatkan pengalaman mereka secara keseluruhan.

RAG: Teknik Prompting vs Alat

Retrieval-Augmented Generation (RAG) boleh menjadi teknik prompting dan alat dalam pembangunan agen AI. Memahami perbezaan antara kedua-duanya dapat membantu anda memanfaatkan RAG dengan lebih berkesan dalam projek anda.

RAG sebagai Teknik Prompting

Apa itu?

Bagaimana ia berfungsi:

  1. Merumuskan Prompt: Cipta prompt atau pertanyaan yang terstruktur dengan baik berdasarkan tugas atau input pengguna.
  2. Mengambil Maklumat: Gunakan prompt untuk mencari data yang relevan daripada pangkalan pengetahuan atau dataset yang sedia ada.
  3. Menghasilkan Respons: Gabungkan maklumat yang diperoleh dengan model AI generatif untuk menghasilkan respons yang komprehensif dan koheren.

RAG sebagai Alat

Apa itu?

Bagaimana ia berfungsi:

  1. Integrasi: Gabungkan RAG dalam seni bina agen AI, membolehkan ia secara automatik mengendalikan tugas pengambilan dan penjanaan.
  2. Automasi: Alat ini menguruskan keseluruhan proses, daripada menerima input pengguna hingga menghasilkan respons akhir, tanpa memerlukan prompt eksplisit untuk setiap langkah.
  3. Kecekapan: Meningkatkan prestasi agen dengan menyelaraskan proses pengambilan dan penjanaan, membolehkan respons yang lebih cepat dan tepat.

Perbandingan

| Aspek | Teknik Prompting | Alat | |————————|———————————————————|——————————————————-| | Manual vs Automatik| Perumusan prompt secara manual untuk setiap pertanyaan. | Proses automatik untuk pengambilan dan penjanaan. | | Kawalan | Memberikan lebih kawalan terhadap proses pengambilan. | Menyelaraskan dan mengautomasi pengambilan dan penjanaan.| | Fleksibiliti | Membolehkan prompt yang disesuaikan berdasarkan keperluan tertentu. | Lebih cekap untuk pelaksanaan berskala besar. | | Kerumitan | Memerlukan perumusan dan penyesuaian prompt. | Lebih mudah untuk diintegrasikan dalam seni bina agen AI. |

Contoh Praktikal: Mencari Berdasarkan Niat dalam Ejen Pelancongan

Mari kita ambil Ejen Pelancongan sebagai contoh untuk melihat bagaimana pencarian berdasarkan niat boleh dilaksanakan.

  1. Mengumpul 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):
    # Combine current query with user history to understand context
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

  4. Mencari dan Memperibadikan Hasil

    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. 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 melaksanakan kod, menyelesaikan masalah kompleks dan mengautomasi tugas.

Ejen Penjana Kod

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

Aplikasi Praktikal

  1. Penjanaan Kod Automatik: Menjana potongan kod untuk tugas tertentu, seperti analisis data, pengikisan web, atau pembelajaran mesin.
  2. SQL sebagai RAG: Menggunakan pertanyaan SQL untuk mendapatkan dan memanipulasi data daripada pangkalan data.
  3. Penyelesaian Masalah: Membuat dan melaksanakan kod untuk menyelesaikan masalah tertentu, seperti mengoptimumkan algoritma atau menganalisis data.

Contoh: Ejen Penjana Kod untuk Analisis Data

Bayangkan anda sedang mereka bentuk ejen penjana kod. Berikut adalah cara ia mungkin berfungsi:

  1. Tugas: Menganalisis set data untuk mengenal pasti trend dan corak.
  2. Langkah:
    • Memuatkan set data ke dalam alat analisis data.
    • Menjana pertanyaan SQL untuk menapis dan mengagregat data.
    • Melaksanakan pertanyaan dan mendapatkan hasil.
    • Menggunakan hasil untuk menjana visualisasi dan pandangan.
  3. Sumber Diperlukan: Akses kepada set data, alat analisis data, dan keupayaan SQL.
  4. Pengalaman: Menggunakan hasil analisis terdahulu untuk meningkatkan ketepatan dan relevansi analisis masa depan.

Contoh: Ejen Penjana Kod untuk Ejen Pelancongan

Dalam contoh ini, kita akan mereka bentuk ejen penjana kod, Ejen Pelancongan, untuk membantu pengguna merancang perjalanan mereka dengan menjana dan melaksanakan kod. Ejen ini boleh mengendalikan tugas seperti mendapatkan pilihan perjalanan, menapis hasil, 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 Mendapatkan Data: Menjana potongan kod untuk mendapatkan data tentang penerbangan, hotel, dan tarikan.
  3. Melaksanakan Kod yang Dijana: Menjalankan kod yang dijana untuk mendapatkan maklumat masa nyata.
  4. Menjana Jadual Perjalanan: Menyusun data yang diperoleh ke dalam rancangan perjalanan yang diperibadikan.
  5. Menyesuaikan Berdasarkan Maklum Balas: Menerima maklum balas pengguna dan menjana semula kod jika perlu untuk memperhalusi hasil.

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 Mendapatkan Data

    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. Melaksanakan Kod yang Dijana

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

    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)

Memanfaatkan Kesedaran Persekitaran dan Penaakulan

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

Berikut adalah contoh bagaimana ini boleh dilakukan:

  1. Memahami Skema: Sistem akan memahami skema jadual dan menggunakan maklumat ini untuk menyokong penjanaan pertanyaan.
  2. Menyesuaikan Berdasarkan Maklum Balas: Sistem akan menyesuaikan keutamaan pengguna berdasarkan maklum balas dan menilai medan mana dalam skema yang perlu dikemas kini.
  3. Menjana dan Melaksanakan Pertanyaan: Sistem akan menjana dan melaksanakan pertanyaan untuk mendapatkan data penerbangan dan hotel yang dikemas kini berdasarkan keutamaan baharu.

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

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)

Penjelasan - Tempahan Berdasarkan Maklum Balas

  1. Kesedaran Skema: Kamus schema mentakrifkan bagaimana keutamaan harus disesuaikan berdasarkan maklum balas. Ia termasuk medan seperti favorites dan avoid, dengan pelarasan yang sepadan.
  2. Menyesuaikan Keutamaan (kaedah adjust_based_on_feedback): Kaedah ini menyesuaikan keutamaan berdasarkan maklum balas pengguna dan skema.
  3. Pelarasan Berdasarkan Persekitaran (kaedah adjust_based_on_environment): Kaedah ini menyesuaikan pelarasan berdasarkan skema dan maklum balas.
  4. Menjana dan Melaksanakan 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 baharu.

Dengan menjadikan sistem sedar persekitaran dan berfikir berdasarkan skema, ia boleh menjana pertanyaan yang lebih tepat dan relevan, menghasilkan cadangan perjalanan yang lebih baik dan pengalaman pengguna yang diperibadikan.

Menggunakan SQL sebagai Teknik Retrieval-Augmented Generation (RAG)

SQL (Structured Query Language) ialah alat yang berkuasa untuk berinteraksi dengan pangkalan data. Apabila digunakan sebagai sebahagian daripada pendekatan Retrieval-Augmented Generation (RAG), SQL boleh mendapatkan 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 Pelancongan.

Konsep Utama

  1. Interaksi Pangkalan Data:
    • SQL digunakan untuk membuat pertanyaan kepada pangkalan data, mendapatkan maklumat yang relevan, dan memanipulasi data.
    • Contoh: Mendapatkan butiran penerbangan, maklumat hotel, dan tarikan daripada pangkalan data pelancongan.
  2. Integrasi dengan RAG:
    • Pertanyaan SQL dijana berdasarkan input dan keutamaan pengguna.
    • Data yang diperoleh 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 hasil berdasarkan bajet, tarikh, dan minat.

Aplikasi

Contoh: Ejen analisis data:

  1. Tugas: Menganalisis set data untuk mencari trend.
  2. Langkah:
    • Memuatkan set data.
    • Menjana pertanyaan SQL untuk menapis data.
    • Melaksanakan pertanyaan dan mendapatkan hasil.
    • Menjana visualisasi dan pandangan.
  3. Sumber: Akses kepada set data, keupayaan SQL.
  4. Pengalaman: Menggunakan hasil terdahulu untuk meningkatkan analisis masa depan.

Contoh Praktikal: Menggunakan SQL dalam Ejen Pelancongan

  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. Melaksanakan 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 Pelancongan boleh mendapatkan dan menggunakan data yang relevan secara dinamik untuk memberikan cadangan yang tepat dan diperibadikan.

Contoh Metakognisi

Untuk menunjukkan pelaksanaan metakognisi, mari kita cipta ejen mudah yang merenung proses membuat keputusannya semasa menyelesaikan masalah. Dalam contoh ini, kita akan membina sistem di mana ejen cuba mengoptimumkan pilihan hotel, tetapi kemudian menilai proses pemikirannya sendiri dan menyesuaikan strateginya apabila ia membuat kesilapan atau pilihan yang kurang baik.

Kita akan mensimulasikan ini menggunakan contoh asas di mana ejen memilih hotel berdasarkan gabungan harga dan kualiti, tetapi ia akan “merenung” keputusannya dan menyesuaikan diri sewajarnya.

Bagaimana ini menggambarkan metakognisi:

  1. Keputusan Awal: Ejen akan memilih hotel termurah, tanpa memahami kesan kualiti.
  2. Renungan dan Penilaian: Selepas pilihan awal, ejen akan memeriksa sama ada hotel itu adalah pilihan “buruk” menggunakan maklum balas pengguna. Jika ia mendapati bahawa kualiti hotel terlalu rendah, ia merenung pemikirannya.
  3. Menyesuaikan Strategi: Ejen menyesuaikan strateginya berdasarkan renungan, beralih daripada “termurah” kepada “kualiti_tertinggi”, dengan itu meningkatkan proses membuat keputusannya dalam iterasi masa depan.

Berikut adalah contohnya:

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']}")

Kebolehan Metakognisi Ejen

Perkara utama di sini ialah keupayaan ejen untuk:

Ini adalah bentuk metakognisi yang mudah di mana sistem mampu menyesuaikan proses pemikirannya berdasarkan maklum balas dalaman.

Kesimpulan

Metakognisi adalah alat yang berkuasa yang boleh meningkatkan keupayaan ejen AI secara signifikan. Dengan menggabungkan proses metakognitif, anda boleh mereka bentuk ejen yang lebih pintar, boleh menyesuaikan diri, dan cekap. Gunakan sumber tambahan untuk meneroka dunia metakognisi dalam ejen AI dengan lebih mendalam.

Ada Lagi Soalan tentang Corak Reka Bentuk Metakognisi?

Sertai Azure AI Foundry Discord untuk bertemu dengan pelajar lain, menghadiri sesi soal jawab, dan mendapatkan jawapan kepada soalan anda tentang Ejen AI.

Pelajaran Sebelumnya

Corak Reka Bentuk Multi-Ejen

Pelajaran Seterusnya

Ejen AI dalam Pengeluaran

Penafian:
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI Co-op Translator. Walaupun kami berusaha untuk memastikan ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat yang kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.

This site is open source. Improve this page.