ai-agents-for-beginners

(Klik imej di atas untuk menonton video pelajaran ini)

Metakognisi dalam Ejen AI

Pengenalan

Selamat datang ke pelajaran mengenai 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 menamatkan pelajaran ini, anda akan dapat:

1. Memahami implikasi gelung pemikiran dalam definisi ejen.
2. Menggunakan teknik perancangan dan penilaian untuk membantu ejen yang membetulkan diri sendiri.
3. Mencipta ejen anda sendiri yang mampu mengubah kod untuk mencapai tugasan.

Pengenalan kepada Metakognisi

Metakognisi merujuk kepada proses kognitif tahap tinggi yang melibatkan memikirkan tentang pemikiran sendiri. Bagi ejen AI, ini bermakna mereka mampu menilai dan menyesuaikan tindakan mereka berdasarkan kesedaran diri dan pengalaman lalu. Metakognisi, atau “berfikir tentang berfikir,” adalah konsep penting dalam pembangunan sistem AI agentik. Ia melibatkan sistem AI yang menyedari proses dalaman mereka sendiri dan mampu memantau, mengawal, dan menyesuaikan tingkah laku mereka mengikut keadaan. Sama seperti kita apabila kita membaca keadaan sekeliling atau melihat masalah. Kesedaran diri ini boleh membantu sistem AI membuat keputusan yang lebih baik, mengenal pasti kesilapan, dan meningkatkan prestasi mereka dari masa ke masa — sekali lagi berkaitan dengan ujian Turing dan perdebatan sama ada AI akan mengambil alih.

Dalam konteks sistem AI agentik, metakognisi boleh membantu mengatasi beberapa cabaran, seperti:

• Ketelusan: Memastikan bahawa sistem AI boleh menerangkan pemikiran dan keputusan mereka.
• Pemikiran: Meningkatkan kemampuan sistem AI untuk mensintesis maklumat dan membuat keputusan yang tepat.
• Penyesuaian: Membenarkan sistem AI menyesuaikan diri dengan persekitaran baru dan keadaan yang berubah.
• Persepsi: Meningkatkan ketepatan sistem AI dalam mengenal pasti dan mentafsir data dari persekitaran mereka.

Apakah Metakognisi?

Metakognisi, atau “berfikir tentang berfikir,” adalah proses kognitif tahap tinggi yang melibatkan kesedaran diri dan pengawalan kendiri ke atas proses kognitif seseorang. Dalam bidang AI, metakognisi membolehkan ejen menilai dan menyesuaikan strategi serta tindakan mereka, menyebabkan keupayaan menyelesaikan masalah dan membuat keputusan yang lebih baik. Dengan memahami metakognisi, anda boleh mereka bentuk ejen AI yang bukan sahaja lebih bijak tetapi juga lebih mudah menyesuaikan diri dan cekap. Dalam metakognisi sebenar, anda akan melihat AI secara eksplisit berfikir tentang proses pemikirannya sendiri.

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

• Memerhatikan bahawa ia membuat kesilapan kerana terlalu bergantung kepada keutamaan pengguna dari sebelumnya, jadi ia mengubah strategi membuat keputusan, bukan hanya cadangan akhir.
• Mendiagnos corak seperti, “Apabila saya melihat pengguna menyebut ‘terlalu sesak,’ saya tidak hanya harus menghapuskan tarikan tertentu tetapi juga refleks bahawa kaedah saya memilih ‘tarikan utama’ adalah cacat jika saya sentiasa mengkedudukan berdasarkan populariti.”

Kepentingan Metakognisi dalam Ejen AI

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

• Refleksi Diri: Ejen boleh menilai prestasi sendiri dan mengenal pasti bidang untuk penambahbaikan.
• Kebolehsuaian: Ejen boleh mengubah strategi mereka berdasarkan pengalaman lalu dan persekitaran yang berubah.
• Pembetulan Kesilapan: Ejen boleh mengesan dan membetulkan kesilapan secara autonomi, menghasilkan keputusan yang lebih tepat.
• Pengurusan Sumber: Ejen boleh mengoptimumkan penggunaan sumber, seperti masa dan kuasa pengkomputeran, dengan merancang dan menilai tindakan mereka.

Komponen Ejen AI

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

• Persona: Personaliti dan ciri-ciri ejen yang menentukan bagaimana ia berinteraksi dengan pengguna.
• Alat: Keupayaan dan fungsi yang boleh dilakukan oleh ejen.
• Kemahiran: Pengetahuan dan kepakaran yang dimiliki oleh ejen.

Komponen-komponen ini bekerjasama untuk mewujudkan “unit kepakaran” yang boleh melaksanakan tugasan tertentu.

Contoh: Anggapkan ejen pelancongan, perkhidmatan ejen yang bukan sahaja merancang percutian anda tetapi juga menyesuaikan jalannya berdasarkan data masa nyata dan pengalaman perjalanan pelanggan sebelum ini.

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 memasukkan metakognisi, Ejen Pelancongan perlu menilai dan menyesuaikan tindakannya berdasarkan kesedaran diri dan pengalaman lalu. Berikut bagaimana metakognisi boleh berperanan:

Tugasan Semasa

Tugasan semasa ialah membantu pengguna merancang perjalanan ke Paris.

Langkah-langkah Menyelesaikan Tugasan

1. Kumpul Keutamaan Pengguna: Tanya pengguna tentang tarikh perjalanan, bajet, minat (contoh: muzium, masakan, membeli-belah), dan sebarang keperluan khusus.
2. Dapatkan Maklumat: Cari pilihan penerbangan, penginapan, tarikan dan restoran yang sepadan dengan keutamaan pengguna.
3. Hasilkan Cadangan: Sediakan itinerari yang diperibadikan dengan butiran penerbangan, tempahan hotel, dan aktiviti yang disyorkan.
4. Laraskan Berdasarkan Maklum Balas: Minta maklum balas pengguna tentang cadangan tersebut dan buat pelarasan yang perlu.

Sumber yang Diperlukan

• Akses kepada pangkalan data tempahan penerbangan dan hotel.
• Maklumat mengenai tarikan dan restoran di Paris.
• Data maklum balas pengguna dari interaksi sebelum ini.

Pengalaman dan Refleksi Diri

Ejen Pelancongan menggunakan metakognisi untuk menilai prestasi dan belajar dari pengalaman lalu. Contohnya:

1. Menganalisis Maklum Balas Pengguna: Ejen Pelancongan mengkaji maklum balas pengguna untuk menentukan cadangan mana yang diterima baik dan yang tidak. Ia menyesuaikan cadangan masa hadapannya.
2. Kebolehsuaian: Jika pengguna sebelum ini menyatakan tidak suka tempat yang sesak, Ejen Pelancongan akan mengelak mencadangkan tempat pelancongan popular pada waktu puncak di masa depan.
3. Pembetulan Kesilapan: Jika Ejen Pelancongan melakukan kesilapan dalam tempahan lalu, seperti mencadangkan hotel yang penuh ditempah, ia belajar untuk memeriksa ketersediaan dengan lebih teliti sebelum membuat cadangan.

Contoh Praktikal untuk Pembangun

Berikut adalah contoh ringkas kod Ejen Pelancongan yang 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):
        # Cari penerbangan, hotel, dan tempat menarik berdasarkan keutamaan
        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)
        # Menganalisis maklum balas dan melaraskan cadangan masa depan
        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

• Refleksi Diri: Ejen boleh menganalisis prestasi dan mengenal pasti bidang penambahbaikan.
• Kebolehsuaian: Ejen boleh mengubah strategi berdasarkan maklum balas dan keadaan yang berubah.
• Pembetulan Kesilapan: Ejen boleh mengesan dan membetulkan kesilapan secara autonomi.
• Pengurusan Sumber: Ejen boleh mengoptimumkan penggunaan sumber, seperti masa dan kuasa pengkomputeran.

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

---

2. Perancangan dalam Ejen

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

Elemen Perancangan

• Tugasan Semasa: Define tugasan dengan jelas.
• Langkah Menyelesaikan Tugasan: Bahagikan tugasan kepada langkah yang mudah diurus.
• Sumber Diperlukan: Kenal pasti sumber yang perlu.
• Pengalaman: Gunakan pengalaman lalu untuk merancang.

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

Langkah untuk Ejen Pelancongan

1. Kumpul Keutamaan Pengguna
   • Tanya pengguna tentang tarikh perjalanan, bajet, minat, dan keperluan khusus mereka.
   • Contoh: “Bila anda merancang untuk melancong?” “Berapa julat bajet anda?” “Aktiviti apa anda suka semasa bercuti?”
2. Dapatkan Maklumat
   • Cari pilihan perjalanan berdasarkan keutamaan pengguna.
   • Penerbangan: Cari penerbangan yang tersedia mengikut bajet dan tarikh pilihan pengguna.
   • Penginapan: Cari hotel atau sewaan yang sesuai dengan lokasi, harga dan kemudahan yang disukai pengguna.
   • Tarikan dan Restoran: Kenal pasti tarikan popular, aktiviti dan tempat makan yang sejajar dengan minat pengguna.
3. Hasilkan Cadangan
   • Kumpul maklumat yang diperoleh ke dalam itinerary yang diperibadikan.
   • Berikan butiran seperti pilihan penerbangan, tempahan hotel, dan aktiviti yang disyorkan, pastikan semua disesuaikan dengan keutamaan pengguna.
4. Sampaikan Itinerary kepada Pengguna
   • Kongsi jadual perjalanan yang dicadangkan dengan pengguna untuk semakan mereka.
   • Contoh: “Ini adalah jadual perjalanan yang dicadangkan untuk perjalanan anda ke Paris. Ia merangkumi butiran penerbangan, tempahan hotel, dan senarai aktiviti dan restoran yang disyorkan. Beritahu saya pendapat anda!”
5. Kumpul Maklum Balas
   • Minta maklum balas daripada pengguna tentang jadual perjalanan tersebut.
   • Contoh: “Adakah anda suka pilihan penerbangan?” “Adakah hotel sesuai dengan keperluan anda?” “Adakah terdapat aktiviti yang anda ingin tambah atau keluarkan?”
6. Laraskan Berdasarkan Maklum Balas
   • Ubah suai jadual perjalanan berdasarkan maklum balas pengguna.
   • Buat perubahan yang perlu pada penerbangan, penginapan, dan cadangan aktiviti supaya lebih sepadan dengan keutamaan pengguna.
7. Pengesahan Akhir
   • Serahkan jadual perjalanan yang telah dikemas kini kepada pengguna untuk pengesahan akhir.
   • Contoh: “Saya telah membuat pelarasan berdasarkan maklum balas anda. Ini adalah jadual perjalanan terkini. Adakah semuanya nampak baik untuk anda?”
8. Tempah dan Sahkan Tempahan
   • Setelah pengguna meluluskan jadual perjalanan, teruskan membuat tempahan penerbangan, penginapan, dan aktiviti yang telah dirancang.
   • Hantar butiran pengesahan kepada pengguna.
9. Sediakan Sokongan Berterusan
   • Kekal bersedia membantu pengguna dengan sebarang perubahan atau permintaan tambahan sebelum dan semasa perjalanan mereka.
   • Contoh: “Jika anda memerlukan bantuan lanjut semasa perjalanan, jangan segan-segan 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)

# Contoh penggunaan dalam permintaan tempahan
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 Muatan Konteks Pratetap

Penjanaan Dipertingkatkan Pengambilan (RAG)

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

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

Pendekatan RAG Pembetulan

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

1. Teknik Promp: Menggunakan promp khusus untuk membimbing ejen dalam mendapatkan maklumat relevan.
2. Alat: Melaksanakan algoritma dan mekanisme yang membolehkan ejen menilai relevansi maklumat yang diperoleh dan menghasilkan jawapan yang tepat.
3. Penilaian: Sentiasa menilai prestasi ejen dan membuat pelarasan 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 Promp: Merumuskan pertanyaan carian berdasarkan input pengguna.
2. Alat: Menggunakan pemprosesan bahasa semula jadi dan algoritma pembelajaran mesin untuk mengkedudukan dan menapis keputusan carian.
3. Penilaian: Menganalisis maklum balas pengguna untuk mengenal pasti dan membetulkan ketidaktepatan dalam maklumat diperoleh.

RAG Pembetulan dalam Ejen Pelancongan

RAG Pembetulan (Penjanaan Dipertingkatkan Pengambilan) meningkatkan kebolehan AI untuk mengambil dan menjana maklumat sambil membetulkan sebarang ketidaktepatan. Mari lihat bagaimana Ejen Pelancongan boleh menggunakan pendekatan RAG Pembetulan untuk menyediakan cadangan perjalanan yang lebih tepat dan relevan.

Ini melibatkan:

• Teknik Promp: Menggunakan promp khusus untuk membimbing ejen dalam mendapatkan maklumat yang relevan.
• Alat: Melaksanakan algoritma dan mekanisme yang membolehkan ejen menilai relevansi maklumat diperoleh dan menghasilkan jawapan yang tepat.
• Penilaian: Sentiasa menilai prestasi ejen dan membuat pelarasan untuk meningkatkan ketepatan dan kecekapan.

Langkah-langkah Melaksanakan RAG Pembetulan dalam Ejen Pelancongan

1. Interaksi Awal dengan Pengguna
   • Ejen Pelancongan mengumpul keutamaan awal dari 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 mengenai 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 yang diperibadikan.

   • Contoh:

     itinerary = create_itinerary(flights, hotels, attractions)
     print("Suggested Itinerary:", itinerary)
     

4. Mengumpul Maklum Balas Pengguna
   • Ejen Pelancongan meminta maklum balas dari pengguna mengenai cadangan awal.

   • Contoh:

     feedback = {
         "liked": ["Louvre Museum"],
         "disliked": ["Eiffel Tower (too crowded)"]
     }
     

5. Proses RAG Pembetulan
   • Teknik Promp: 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 mengkedudukan dan menapis keputusan carian baru, menekankan relevansi 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 relevansi dan ketepatan cadangan dengan menganalisis maklum balas pengguna dan membuat pelarasan 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 adalah contoh kod Python yang dipermudahkan yang menggabungkan pendekatan RAG Pembetulan 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)

Muatan Konteks Pratetap

Memuat Konteks Pendahuluan melibatkan memuatkan konteks atau maklumat latar belakang yang berkaitan ke dalam model sebelum memproses pertanyaan. Ini bermakna model mempunyai akses kepada maklumat ini dari awal, yang boleh membantunya menjana tindak balas yang lebih bermaklumat tanpa perlu mendapatkan data tambahan semasa proses tersebut.

Berikut adalah contoh ringkas bagaimana pemuatan konteks pendahuluan mungkin kelihatan untuk aplikasi ejen perjalanan dalam Python:

class TravelAgent:
    def __init__(self):
        # Muat naik destinasi popular dan maklumatnya terlebih dahulu
        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):
        # Ambil maklumat destinasi dari konteks yang telah dimuat naik
        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. Inisialisasi (kaedah __init__): Kelas TravelAgent memuat terlebih dahulu sebuah kamus yang mengandungi maklumat tentang destinasi popular seperti Paris, Tokyo, New York, dan Sydney. Kamus ini merangkumi butiran seperti negara, mata wang, bahasa, dan tarikan utama untuk setiap destinasi.

2. Mengambil Maklumat (kaedah get_destination_info): Apabila pengguna bertanya tentang destinasi tertentu, kaedah get_destination_info mengambil maklumat yang berkaitan dari kamus konteks yang telah dimuat terlebih dahulu.

Dengan memuat terlebih dahulu konteks, aplikasi ejen perjalanan boleh memberi respons dengan cepat kepada pertanyaan pengguna tanpa perlu mendapatkan maklumat ini dari sumber luaran secara masa nyata. Ini menjadikan aplikasi lebih cekap dan responsif.

Memulakan Pelan dengan Matlamat Sebelum Mengulangi

Memulakan pelan dengan matlamat melibatkan bermula dengan objektif atau hasil sasaran yang jelas. Dengan mendefinisikan matlamat ini dari awal, model boleh menggunakannya sebagai prinsip panduan sepanjang proses berulang. Ini membantu memastikan setiap pengulangan semakin menghampiri pencapaian hasil yang diinginkan, menjadikan proses lebih cekap dan fokus.

Berikut adalah contoh bagaimana anda boleh memulakan pelan perjalanan dengan matlamat sebelum mengulangi untuk ejen perjalanan dalam Python:

Senario

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

Langkah-langkah

1. Tentukan keutamaan dan bajet pelanggan.
2. Mulakan pelan awal berdasarkan keutamaan tersebut.
3. Ulang proses untuk memperbaiki pelan, mengoptimumkan kepuasan pelanggan.

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. Inisialisasi (kaedah __init__): Kelas TravelAgent diinisialisasi dengan senarai destinasi berpotensi, setiap satu mempunyai atribut seperti nama, kos, dan jenis aktiviti.

2. Memulakan Pelan (kaedah bootstrap_plan): Kaedah ini mencipta pelan perjalanan awal berdasarkan keutamaan dan bajet pelanggan. Ia mengulangi senarai destinasi dan menambahkannya ke pelan jika ia sesuai dengan keutamaan pelanggan dan muat dalam bajet.

3. Mencocok Keutamaan (kaedah match_preferences): Kaedah ini memeriksa jika destinasi sesuai dengan keutamaan pelanggan.

4. Mengulangi Pelan (kaedah iterate_plan): Kaedah ini memperbaiki pelan awal dengan cuba menggantikan setiap destinasi dalam pelan dengan pilihan yang lebih sesuai, mengambil kira keutamaan pelanggan dan had bajet.

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

Contoh Penggunaan

• Pelan Awal: Ejen perjalanan mencipta pelan awal berdasarkan keutamaan pelanggan untuk lawatan dan bajet sebanyak $2000.
• Pelan Dipertingkatkan: Ejen perjalanan mengulangi pelan tersebut, mengoptimumkan untuk keutamaan pelanggan dan bajet.

Dengan memulakan pelan dengan matlamat yang jelas (contohnya, memaksimumkan kepuasan pelanggan) dan mengulangi untuk memperbaiki pelan, ejen perjalanan boleh menghasilkan jadual perjalanan yang disesuaikan dan dioptimumkan untuk pelanggan. Pendekatan ini memastikan pelan perjalanan selaras dengan keutamaan dan bajet pelanggan dari awal dan terus bertambah baik dengan setiap pengulangan.

Memanfaatkan LLM untuk Penstoran Semula dan Pengskoran

Model Bahasa Besar (LLM) boleh digunakan untuk penstoran semula dan pengskoran dengan menilai kepentingan dan kualiti dokumen yang diperoleh atau tindak balas yang dijana. Berikut adalah cara ia berfungsi:

Pemulihan: Langkah pemulihan awal mengambil sekumpulan dokumen calon atau tindak balas berdasarkan pertanyaan.

Penstoran Semula: LLM menilai calon-calon ini dan mengubah susunannya berdasarkan kepentingan dan kualiti. Langkah ini memastikan maklumat paling relevan dan bermutu tinggi dipaparkan terlebih dahulu.

Pengskoran: LLM memberikan skor kepada setiap calon, yang mencerminkan kepentingan dan kualiti mereka. Ini membantu memilih tindak balas atau dokumen terbaik untuk pengguna.

Dengan memanfaatkan LLM untuk penstoran semula dan pengskoran, sistem boleh memberikan maklumat yang lebih tepat dan relevan secara kontekstual, memperbaiki pengalaman pengguna secara keseluruhan.

Berikut adalah contoh bagaimana seorang ejen perjalanan mungkin menggunakan Model Bahasa Besar (LLM) untuk penstoran semula dan pengskoran destinasi perjalanan berdasarkan keutamaan pengguna dalam Python:

Senario - Perjalanan Berdasarkan Keutamaan

Seorang ejen perjalanan ingin mencadangkan destinasi perjalanan terbaik kepada pelanggan berdasarkan keutamaan mereka. LLM akan membantu menstoran semula dan mengskor destinasi untuk memastikan pilihan paling relevan dipaparkan.

Langkah-langkah:

1. Kumpul keutamaan pengguna.
2. Dapatkan senarai destinasi perjalanan berpotensi.
3. Gunakan LLM untuk menstoran semula dan mengskor destinasi berdasarkan keutamaan pengguna.

Berikut adalah cara anda boleh mengemas kini contoh sebelumnya untuk menggunakan Perkhidmatan Azure OpenAI:

Keperluan

1. Anda perlu memiliki langganan Azure.
2. Cipta sumber Azure OpenAI dan dapatkan kunci API anda.

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 arahan untuk Azure OpenAI
        prompt = self.generate_prompt(preferences)
        
        # Tetapkan pengepala dan muatan 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 telah disusun semula dan diberikan skor
        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 - Penempah Keutamaan

1. Inisialisasi: Kelas TravelAgent diinisialisasi dengan senarai destinasi perjalanan berpotensi, setiap satu mempunyai atribut seperti nama dan keterangan.

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

3. Menjana Arahan (kaedah generate_prompt): Kaedah ini membina arahan untuk Azure OpenAI, termasuk keutamaan pengguna dan senarai destinasi. Arahan ini membimbing model untuk menstoran semula dan mengskor destinasi berdasarkan keutamaan yang diberikan.

4. Panggilan API: Perpustakaan requests digunakan untuk membuat permintaan HTTP POST ke titik akhir API Azure OpenAI. Respons mengandungi destinasi yang sudah distrukturkan semula dan diberi skor.

5. Contoh Penggunaan: Ejen perjalanan mengumpul keutamaan pengguna (contohnya, minat dalam pelancongan dan budaya pelbagai) dan menggunakan perkhidmatan Azure OpenAI untuk mendapatkan cadangan destinasi perjalanan yang telah distrukturkan 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 titik akhir sebenar untuk deployment Azure OpenAI anda.

Dengan memanfaatkan LLM untuk penstoran semula dan pengskoran, ejen perjalanan boleh memberikan cadangan perjalanan yang lebih diperibadikan dan relevan kepada pelanggan, meningkatkan pengalaman keseluruhan mereka.

RAG: Teknik Prompt vs Alat

Penjanaan Beraugmen Pemulihan (RAG) boleh menjadi kedua-dua teknik prompt dan alat dalam pembangunan ejen AI. Memahami perbezaan antara kedua-duanya boleh membantu anda memanfaatkan RAG dengan lebih berkesan dalam projek anda.

RAG sebagai Teknik Prompt

Apa itu?

• Sebagai teknik prompt, RAG melibatkan merumuskan pertanyaan atau arahan khusus untuk mengarahkan pemulihan maklumat yang relevan dari korpus besar atau pangkalan data. Maklumat ini kemudian digunakan untuk menjana respons atau tindakan.

Bagaimana ia berfungsi:

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

Contoh dalam Ejen Perjalanan:

• Input Pengguna: “Saya mahu melawat muzium di Paris.”
• Prompt: “Cari muzium teratas di Paris.”
• Maklumat Diperoleh: Butiran mengenai Muzium Louvre, Musée d’Orsay, dan lain-lain.
• Respons Dijana: “Berikut adalah beberapa muzium teratas di Paris: Muzium Louvre, Musée d’Orsay, dan Pusat Pompidou.”

RAG sebagai Alat

Apa itu?

• Sebagai alat, RAG adalah sistem bersepadu yang mengautomasikan proses pemulihan dan penjanaan, memudahkan pembangun melaksanakan fungsi AI yang kompleks tanpa perlu merangka prompt secara manual untuk setiap pertanyaan.

Bagaimana ia berfungsi:

1. Integrasi: Tanam RAG dalam seni bina ejen AI, membolehkan ia mengendalikan tugas pemulihan dan penjanaan secara automatik.
2. Automasi: Alat ini menguruskan keseluruhan proses, dari menerima input pengguna hingga menjana respons akhir, tanpa memerlukan prompt yang jelas untuk setiap langkah.
3. Kecekapan: Meningkatkan prestasi ejen dengan mempermudahkan proses pemulihan dan penjanaan, membolehkan respons yang lebih cepat dan tepat.

Contoh dalam Ejen Perjalanan:

• Input Pengguna: “Saya mahu melawat muzium di Paris.”
• Alat RAG: Secara automatik mengambil maklumat tentang muzium dan menjana respons.
• Respons Dijana: “Berikut adalah beberapa muzium teratas di Paris: Muzium Louvre, Musée d’Orsay, dan Pusat Pompidou.”

Perbandingan

Aspek	Teknik Prompt	Alat
Manual vs Automatik	Perumusan prompt manual untuk setiap pertanyaan.	Proses automatik untuk pemulihan dan penjanaan.
Kawalan	Menawarkan kawalan lebih terhadap proses pemulihan.	Melancarkan dan mengautomasikan pemulihan dan penjanaan.
Fleksibiliti	Membenarkan prompt yang disesuaikan berdasarkan keperluan spesifik.	Lebih cekap untuk pelaksanaan skala besar.
Kerumitan	Memerlukan penyusunan dan penyelarasan prompt.	Lebih mudah disepadukan dalam seni bina ejen AI.

Contoh Praktikal

Contoh Teknik Prompt:

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

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

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 Kepentingan

Menilai kepentingan adalah aspek penting dalam prestasi ejen AI. Ia memastikan maklumat yang diperoleh dan dijana oleh ejen adalah sesuai, tepat, dan berguna kepada pengguna. Mari kita terokai cara menilai kepentingan dalam ejen AI, termasuk contoh praktikal dan teknik.

Konsep Utama dalam Menilai Kepentingan

1. Kesedaran Konteks:
   • 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 keutamaan pengguna seperti jenis masakan dan bajet.
2. Ketepatan:
   • Maklumat yang diberikan oleh ejen haruslah betul secara fakta dan terkini.
   • Contoh: Mencadangkan restoran yang masih dibuka dengan ulasan baik bukannya pilihan yang sudah lama atau tutup.
3. Niat Pengguna:
   • Ejen harus menilai niat sebenar pengguna di sebalik pertanyaan untuk memberikan maklumat paling relevan.
   • Contoh: Jika pengguna bertanya “hotel bajet,” ejen mesti mengutamakan pilihan yang mampu milik.
4. Sistem Maklum Balas:
   • Mengumpul dan menganalisis maklum balas pengguna secara berterusan membantu ejen memperbaiki proses penilaian kepentingan.
   • Contoh: Memasukkan penarafan pengguna dan maklum balas pada cadangan terdahulu untuk meningkatkan respons akan datang.

Teknik Praktikal untuk Menilai Kepentingan

1. Pengskoran Kepentingan:
   • Memberi skor kepentingan kepada setiap item yang diperoleh berdasarkan sejauh mana ia memenuhi pertanyaan dan keutamaan 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. Penapisan dan Penarafan:
   • Menapis keluar item yang tidak relevan dan menyusun yang tinggal berdasarkan skor kepentingannya.

   • Contoh:

     def filter_and_rank(items, query):
         ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
         return ranked_items[:10]  # Pulangkan 10 item paling relevan
     

3. Pemprosesan Bahasa Semula Jadi (NLP):
   • Menggunakan teknik NLP untuk memahami pertanyaan pengguna dan mengambil maklumat yang relevan.

   • Contoh:

     def process_query(query):
         # Gunakan NLP untuk mendapatkan maklumat penting daripada pertanyaan pengguna
         processed_query = nlp(query)
         return processed_query
     

4. Integrasi Maklum Balas Pengguna:
   • Mengumpul maklum balas pengguna terhadap cadangan yang diberikan dan menggunakannya untuk menyesuaikan penilaian kepentingan di masa hadapan.

   • 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 Kepentingan dalam Ejen Perjalanan

Berikut adalah contoh praktikal bagaimana Ejen Perjalanan boleh menilai kepentingan cadangan perjalanan:

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]  # Pulangkan 10 item teratas yang berkaitan

    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)

Mencari dengan Niat

Mencari dengan niat melibatkan memahami dan mentafsir tujuan atau matlamat di sebalik pertanyaan pengguna untuk mengambil dan menjana maklumat yang paling relevan dan berguna. Pendekatan ini melangkaui sekadar memadankan kata kunci dan memfokuskan pada memahami keperluan sebenar dan konteks pengguna.

Konsep Utama dalam Mencari dengan Niat

1. Memahami Niat Pengguna:
   • Niat pengguna boleh dikategorikan kepada tiga jenis utama: informasi, navigasi, dan transaksi.
     • Niat Informasi: Pengguna mencari maklumat tentang topik (contohnya, “Apakah muzium terbaik di Paris?”).
     • Niat Navigasi: Pengguna ingin menavigasi ke laman web atau halaman tertentu (contohnya, “laman rasmi Muzium Louvre”).
     • Niat Transaksi: Pengguna berhasrat melakukan transaksi, seperti menempah penerbangan atau membuat pembelian (contohnya, “Tempah penerbangan ke Paris”).
2. Kesedaran Konteks:
   • Menganalisis konteks pertanyaan pengguna membantu mengenal pasti niat mereka dengan tepat. Ini termasuk mempertimbangkan interaksi sebelumnya, keutamaan pengguna, dan butiran khusus pertanyaan semasa.
3. Pemprosesan Bahasa Semula Jadi (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 parsing pertanyaan.
4. Personalisasi:
   • Memperibadikan hasil carian berdasarkan sejarah, keutamaan, dan maklum balas pengguna meningkatkan kepentingan maklumat yang diperoleh.

Contoh Praktikal: Mencari dengan Niat dalam Ejen Perjalanan

Mari kita ambil contoh Ejen Perjalanan untuk melihat bagaimana mencari dengan 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):
       # Gabungkan carian semasa dengan sejarah pengguna untuk memahami konteks
       context = {
           "current_query": query,
           "user_history": user_history
       }
       return context
   

4. Cari dan Personalisasi 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]  # Pulangkan 10 keputusan peribadi teratas
   

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 menjana kod menggunakan model AI untuk menulis dan menjalankan kod, menyelesaikan masalah kompleks dan mengautomasikan tugas.

Ejen Menjana Kod

Ejen menjana kod menggunakan model AI generatif untuk menulis dan menjalankan kod. Ejen ini boleh menyelesaikan masalah kompleks, mengautomasikan tugas, dan menyediakan 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, pembersihan web, atau pembelajaran mesin.
2. SQL sebagai RAG: menggunakan pertanyaan SQL untuk mendapatkan dan memanipulasi data dari pangkalan data.
3. Penyelesaian Masalah: mencipta dan menjalankan kod untuk menyelesaikan masalah tertentu, seperti mengoptimumkan algoritma atau menganalisis data.

Contoh: Ejen Menjana Kod untuk Analisis Data

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

1. Tugas: Menganalisis set data untuk mengenal pasti trend dan pola.
2. Langkah:
   • Memuatkan set data ke dalam alat analisis data.
   • Menjana pertanyaan SQL untuk menapis dan mengagregat data.
   • Menjalankan pertanyaan dan mendapatkan keputusan.
   • Menggunakan keputusan untuk menjana visualisasi dan pandangan.
3. Sumber Diperlukan: Akses ke set data, alat analisis data, dan keupayaan SQL.
4. Pengalaman: Menggunakan keputusan analisis lalu untuk meningkatkan ketepatan dan relevansi analisis akan datang.

Contoh: Ejen Menjana Kod untuk Ejen Pelancongan

Dalam contoh ini, kita akan mereka bentuk ejen menjana kod, Ejen Pelancongan, untuk membantu pengguna dalam 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 Menjana 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. Menjalankan Kod Dijana: Menjalankan kod yang dijana untuk mendapatkan maklumat masa nyata.
4. Menjana Jadual Perjalanan: Menyusun data yang diperoleh menjadi pelan perjalanan yang diperibadikan.
5. Melaras 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 Mendapatkan 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 Dijana

   def execute_code(code):
       # Laksanakan kod yang dijana 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. Melaras Berdasarkan Maklum Balas

   def adjust_based_on_feedback(feedback, preferences):
       # Laraskan pilihan 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)
      
   # Jelajah semula dan laksanakan kod dengan pilihan yang dikemaskini
   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 mendasari penjanaan pertanyaan.
2. Melaras Berdasarkan Maklum Balas: Sistem akan melaras keutamaan pengguna berdasarkan maklum balas dan mempertimbangkan 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 dikemaskini yang menggabungkan 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 khusus 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):
    # Jana kod untuk mendapatkan data penerbangan berdasarkan keutamaan terkini
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Jana kod untuk mendapatkan data hotel berdasarkan keutamaan terkini
    return f"fetch_hotels(preferences={preferences})"

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

def generate_itinerary(flights, hotels, attractions):
    # Jana 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 laksanakan kod dengan keutamaan terkini
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 skema mentakrifkan cara keutamaan perlu dilaras berdasarkan maklum balas. Ia termasuk medan seperti favorites dan avoid, dengan pelarasan yang sepadan.
2. Melaras Keutamaan (adjust_based_on_feedback method): Kaedah ini melaras keutamaan berdasarkan maklum balas pengguna dan skema.
3. Pelarasan Berdasarkan Persekitaran (adjust_based_on_environment method): Kaedah ini menyesuaikan pelarasan 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 dilaras dan mensimulasikan pelaksanaan pertanyaan ini.
5. Menjana Jadual Perjalanan: Sistem mencipta jadual perjalanan yang dikemas kini berdasarkan data penerbangan, hotel, dan tarikan baru.

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

Menggunakan SQL sebagai Teknik Penjanaan Tambahan Berdasarkan Pencarian (RAG)

SQL (Structured Query Language) ialah alat berkuasa untuk berinteraksi dengan pangkalan data. Apabila digunakan sebagai sebahagian daripada pendekatan Penjanaan Tambahan Berdasarkan Pencarian (RAG), SQL boleh mendapatkan data yang relevan dari pangkalan data untuk memaklumkan dan menjana tindak balas atau tindakan dalam ejen AI. Mari kita teroka bagaimana SQL boleh digunakan sebagai teknik RAG dalam konteks Ejen Pelancongan.

Konsep Utama

1. Interaksi Pangkalan Data:
   • SQL digunakan untuk menyoal pangkalan data, mendapatkan maklumat relevan, dan memanipulasi data.
   • Contoh: Mendapatkan maklumat penerbangan, hotel, dan tarikan dari pangkalan data pelancongan.
2. Integrasi dengan RAG:
   • Pertanyaan SQL dijana berdasarkan input dan keutamaan pengguna.
   • Data yang diperoleh kemudiannya 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

• Penjanaan Kod Automatik: Menjana potongan kod untuk tugas khusus.
• SQL sebagai RAG: Menggunakan pertanyaan SQL untuk memanipulasi data.
• Penyelesaian Masalah: Mencipta dan menjalankan kod untuk menyelesaikan masalah.

Contoh: Ejen analisis data:

1. Tugas: Menganalisis set data untuk mencari trend.
2. Langkah:
   • Memuatkan set data.
   • Menjana pertanyaan SQL untuk menapis data.
   • Menjalankan pertanyaan dan mendapatkan keputusan.
   • Menjana visualisasi dan pandangan.
3. Sumber: Akses set data, keupayaan SQL.
4. Pengalaman: Menggunakan keputusan lalu untuk memperbaiki 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. 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 teknik Penjanaan Tambahan Berdasarkan Pencarian (RAG), ejen AI seperti Ejen Pelancongan boleh secara dinamik mendapatkan dan menggunakan data relevan untuk menyediakan cadangan yang tepat dan diperibadikan.

Contoh Metakognisi

Jadi untuk menunjukkan pelaksanaan metakognisi, mari kita cipta ejen mudah yang merenung proses pengambilan keputusannya semasa menyelesaikan masalah. Untuk contoh ini, kita akan bina sistem di mana ejen cuba mengoptimumkan pilihan hotel, tetapi kemudian menilai penalarannya sendiri dan melaraskan strateginya apabila membuat kesilapan atau pilihan yang tidak optimum.

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

Bagaimana ini menggambarkan metakognisi:

1. Keputusan Awal: Ejen akan memilih hotel termurah, tanpa memahami impak kualiti.
2. Renungan dan Penilaian: Selepas pilihan awal, ejen akan memeriksa sama ada hotel itu pilihan “buruk” menggunakan maklum balas pengguna. Jika ia mendapati kualiti hotel terlalu rendah, ia akan merenung penalarannya.
3. Melaras Strategi: Ejen melaras strateginya berdasarkan renungan tersebut dengan beralih dari “termurah” ke “kualiti_tertinggi”, dengan itu memperbaiki proses pengambilan 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 telah 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]
        # Mari anggap kita mempunyai maklum balas pengguna yang memberitahu sama ada pilihan terakhir adalah baik 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}
]

# Membuat agen
agent = HotelRecommendationAgent()

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

# Langkah 2: Agen memikirkan pilihan dan melaraskan strategi jika perlu
reflection_result = agent.reflect_on_choice()
print(reflection_result)

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

Kebolehan Metakognisi Ejen

Perkara penting di sini ialah keupayaan ejen untuk:

• Menilai pilihan dan proses pengambilan keputusannya yang lepas.
• Melaras strateginya berdasarkan renungan itu iaitu metakognisi dalam tindakan.

Ini ialah bentuk mudah metakognisi di mana sistem mampu melaras proses penalarannya berdasarkan maklum balas dalaman.

Kesimpulan

Metakognisi ialah alat yang berkuasa yang boleh meningkatkan kebolehan ejen AI secara signifikan. Dengan menggabungkan proses metakognitif, anda boleh mereka bentuk ejen yang lebih pintar, mudah menyesuaikan diri, dan cekap. Gunakan sumber tambahan untuk meneroka lebih lanjut dunia menarik metakognisi dalam ejen AI.

Ada Soalan Lagi mengenai Corak Reka Bentuk Metakognisi?

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

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 ketepatan, sila ambil maklum bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang sahih. Untuk maklumat penting, terjemahan oleh manusia profesional adalah disyorkan. Kami tidak bertanggungjawab terhadap sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.

This site is open source. Improve this page.