ai-agents-for-beginners

Többügynökös tervezés

(Kattintson a fenti képre az óra videójának megtekintéséhez)

Metakogníció az MI-ügynökökben

Bevezetés

Üdvözöljük a metakognícióról szóló órán az MI-ügynökök kapcsán! Ez a fejezet kezdők számára készült, akik kíváncsiak arra, hogyan gondolkodhatnak az MI-ügynökök a saját gondolkodási folyamataikról. Az óra végére megérti a kulcsfontosságú fogalmakat, valamint gyakorlati példákkal lesz felvértezve a metakogníció alkalmazásához az MI-ügynökök tervezésében.

Tanulási célok

Az óra elvégzése után képes leszel:

  1. Megérteni a következtetéshurok jelentőségét az ügynökdefiníciókban.
  2. Használni tervezési és értékelési technikákat az önjavító ügynökök segítésére.
  3. Saját ügynököt létrehozni, amely képes kód manipulálására a feladatok végrehajtásához.

Bevezetés a metakognícióba

A metakogníció a magasabb rendű kognitív folyamatokra utal, amelyek magukban foglalják a saját gondolkodásról való gondolkodást. Az MI-ügynökök számára ez azt jelenti, hogy képesek értékelni és kiigazítani cselekvéseiket önismeretük és múltbéli tapasztalataik alapján. A metakogníció, vagyis a “gondolkodás a gondolkodásról” fontos fogalom az ügynök MI rendszerek fejlesztésében. Ez magában foglalja, hogy az MI rendszerek tisztában vannak saját belső folyamataikkal, és képesek monitorozni, szabályozni és ennek megfelelően alkalmazkodni viselkedésükhöz. Hasonlóan, mint amikor mi olvassuk a helyzetet vagy nézünk egy problémára. Ez az önismeret segítheti az MI rendszereket jobb döntések meghozatalában, hibák felismerésében és teljesítményük idővel történő javításában - megintcsak visszacsatolva a Turing-teszthez és a vitához arról, hogy az MI átveszi-e az irányítást.

Az ügynök MI rendszerek kontextusában a metakogníció több kihívást segíthet kezelni, például:

Mi a metakogníció?

A metakogníció, vagyis a “gondolkodás a gondolkodásról”, egy magasabb rendű kognitív folyamat, amely az öntudatot és a kognitív folyamatok önszabályozását foglalja magában. Az MI területén a metakogníció képessé teszi az ügynököket, hogy értékeljék és módosítsák stratégiáikat és cselekedeteiket, javítva ezáltal a probléma megoldási és döntéshozatali képességeiket. A metakogníció megértésével olyan MI-ügynököket tervezhetsz, amelyek nemcsak intelligensebbek, hanem alkalmazkodóképesebbek és hatékonyabbak is. Az igazi metakognícióban az MI kifejezetten a saját következtetéseiről gondolkodik.

Példa: „Az olcsóbb járatokat részesítettem előnyben, mert… Lehet, hogy kihagyom a közvetlen járatokat, ezért újra megnézem.” Nyomon követi, hogyan vagy miért választott egy bizonyos útvonalat.

A metakogníció fontossága az MI-ügynökökben

A metakogníciónak több fontos szerepe van az MI-ügynökök tervezésében:

A metakogníció fontossága

Egy MI-ügynök összetevői

Mielőtt belemerülnénk a metakognitív folyamatokba, alapvető fontosságú megérteni egy MI-ügynök alapvető összetevőit. Egy MI-ügynök általában a következőkből áll:

Ezek az összetevők együtt dolgoznak, hogy létrehozzanak egy „szaktudás egységet”, amely képes specifikus feladatokat ellátni.

Példa: Vegyünk egy utazási ügynököt, egy olyan ügynök szolgáltatást, amely nemcsak megtervezi az üdülésedet, hanem valós idejű adatok és korábbi ügyfélút tapasztalatok alapján módosítja is az útvonalát.

Példa: Metakogníció egy utazási ügynök szolgáltatásban

Képzeljük el, hogy egy AI által működtetett utazási ügynök szolgáltatást tervezel. Ez az ügynök, “Travel Agent”, segíti a felhasználókat vakációjuk megtervezésében. A metakogníció beépítéséhez a Travel Agentnek értékelnie és kiigazítania kell cselekvéseit önismerete és múltbéli tapasztalatai alapján. Íme, hogyan játszhat szerepet a metakogníció:

Jelenlegi feladat

A jelenlegi feladat egy felhasználó segítése Párizsba tervezett utazásában.

A feladat elvégzésének lépései

  1. Felhasználói preferenciák összegyűjtése: Kérdezd meg a felhasználót az utazási dátumokról, költségvetésről, érdeklődési körökről (például múzeumok, konyha, vásárlás) és bármilyen speciális igényről.
  2. Információk lekérése: Keress repülőjáratokat, szálláshelyeket, látnivalókat és éttermeket, amelyek megfelelnek a felhasználó preferenciáinak.
  3. Ajánlások generálása: Készíts személyre szabott útitervet járat részletekkel, szállásfoglalásokkal és javasolt tevékenységekkel.
  4. Visszajelzés alapján módosítás: Kérj visszajelzést a felhasználótól az ajánlásokról, és tegyél szükséges módosításokat.

Szükséges erőforrások

Tapasztalat és önelemzés

A Travel Agent metakogníciót használ teljesítménye értékelésére és múltbéli tapasztalatokból való tanulásra. Például:

  1. Felhasználói visszajelzések elemzése: A Travel Agent áttekinti a visszajelzéseket, hogy mely ajánlások voltak sikeresek, és melyek nem. Ennek alapján módosítja jövőbeli javaslatait.
  2. Alkalmazkodóképesség: Ha a felhasználó korábban jelezte, hogy nem kedveli a zsúfolt helyeket, a Travel Agent elkerüli a népszerű turistahelyeket csúcsidőben a jövőben.
  3. Hibajavítás: Ha a Travel Agent hibázott egy korábbi foglalásnál, például olyan szállodát javasolt, amely teljesen foglalt volt, megtanulja alaposabban ellenőrizni az elérhetőséget a javaslatok előtt.

Gyakorlati fejlesztői példa

Íme egy egyszerűsített példa arra, hogyan nézhet ki a Travel Agent kódja a metakogníció beépítésével:

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):
        # Repülőjáratok, szállodák és látnivalók keresése preferenciák alapján
        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)
        # Vélemények elemzése és a jövőbeni ajánlások módosítása
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Példa használat
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)

Miért fontos a metakogníció

A metakogníció beépítésével a Travel Agent személyre szabottabb és pontosabb utazási ajánlásokat tud nyújtani, javítva ezzel a felhasználói élményt.

2. Tervezés az ügynökökben

A tervezés az MI-ügynök viselkedésének kritikus része. Magában foglalja azokat a lépéseket, amelyek a cél eléréséhez szükségesek, figyelembe véve a jelenlegi állapotot, az erőforrásokat és a lehetséges akadályokat.

A tervezés elemei

Példa: Íme, milyen lépéseket kell megtennie a Travel Agentnek ahhoz, hogy hatékonyan segítse a felhasználót utazása megtervezésében:

Lépések a Travel Agent számára

  1. Felhasználói preferenciák összegyűjtése
    • Kérdezd meg a felhasználót az utazási dátumokról, költségvetésről, érdeklődési köreiről és bármilyen speciális igényről.
    • Példák: „Mikor tervez utazni?” „Mekkora a költségvetési keret?” „Milyen tevékenységeket kedvel vakáción?”
  2. Információk lekérése
    • Keress releváns utazási lehetőségeket a felhasználói preferenciák alapján.
    • Járatok: Keress elérhető járatokat a felhasználó költségvetésén belül és a kívánt dátumokra.
    • Szálláshelyek: Találj olyan szállodákat vagy bérelhető ingatlanokat, amelyek megfelelnek a felhasználó hely, ár és szolgáltatások iránti igényeinek.
    • Látnivalók és éttermek: Azonosíts népszerű látnivalókat, programokat és étkezési lehetőségeket, amelyek illeszkednek a felhasználó érdeklődéséhez.
  3. Ajánlások generálása
    • Állítsd össze az összegyűjtött információkat személyre szabott útitervvé.
    • Biztosíts részleteket, mint járat opciók, szállodafoglalás, és javasolt tevékenységek, ügyelve arra, hogy az ajánlások megfeleljenek a felhasználói preferenciáknak.
  4. Útiterv bemutatása a felhasználónak
    • Oszd meg a javasolt útitervet a felhasználóval áttekintésre.
    • Példa: „Íme egy javasolt útiterv Párizsi utazásához. Tartalmazza a járat részleteit, szállodai foglalásokat és ajánlott tevékenységek, éttermek listáját. Kérlek, mondd el a véleményed!”
  5. Visszajelzés gyűjtése
    • Kérj visszajelzést a felhasználótól a javasolt útitervhez.
    • Példák: „Tetszenek a járat opciók?” „Megfelel a szálloda az igényeidnek?” „Van olyan tevékenység, amit hozzáadnál vagy törölnél?”
  6. Módosítás visszajelzés alapján
    • Módosítsd az útitervet a felhasználó visszajelzése alapján.
    • Végezze el a szükséges változtatásokat a járatok, szállások és tevékenységek ajánlásaiban, hogy jobban illeszkedjenek a felhasználói igényekhez.
  7. Végső megerősítés
    • Mutasd be a frissített útitervet a felhasználónak végleges jóváhagyásra.
    • Példa: „Elvégeztem a módosításokat a visszajelzésed alapján. Íme a frissített útiterv. Minden rendben van így?”
  8. Foglalások megtétele és megerősítése
    • Ha a felhasználó jóváhagyja az útitervet, kezdődhetnek a járatok, szállások és előre tervezett tevékenységek foglalásai.
    • Küldj megerősítő részleteket a felhasználónak.
  9. Folyamatos támogatás nyújtása
    • Légy elérhető a felhasználó számára bármilyen változtatás vagy további kérés esetén az utazás előtt és alatt.
    • Példa: „Ha út közben bármi segítségre lenne szükséged, bármikor fordulhatsz hozzám!”

Példa interakció

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)

# Példa használat egy foglalási kérelemben
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. Javító RAG rendszer

Először is értsük meg a különbséget a RAG eszköz és a pre-emptív kontextusbetöltés között.

RAG kontra Kontextusbetöltés

Lekérdezés-alapú generálás (RAG)

A RAG ötvözi a lekérdező rendszert egy generatív modellel. Amikor egy lekérdezés érkezik, a lekérdező rendszer releváns dokumentumokat vagy adatokat keres egy külső forrásból, és ezeket az adatokat használja fel a generatív modell bemenetének kiegészítésére. Ez segíti a modellt abban, hogy pontosabb és kontextusban releváns válaszokat generáljon.

Egy RAG rendszerben az ügynök releváns információkat szerez be egy tudástárból, amelyeket aztán felhasznál megfelelő válaszok vagy cselekvések generálására.

Javító RAG megközelítés

A Javító RAG megközelítés azzal foglalkozik, hogy RAG technikákat használjon az MI ügynökök hibáinak kijavítására és pontosságának javítására. Ez magában foglalja:

  1. Prompt technika: Speciális promptokat használ az ügynök vezetésére a releváns információk lekérésében.
  2. Eszköz: Algoritmusok és mechanizmusok megvalósítása, amelyek lehetővé teszik az ügynök számára a lekért információ relevanciájának értékelését és pontos válaszok generálását.
  3. Értékelés: Az ügynök teljesítményének folyamatos értékelése és a pontosság, hatékonyság javítása érdekében végzett módosítások.

Példa: Javító RAG egy keresőügynökben

Vegyünk egy keresőügynököt, amely webes információkat szerez be a felhasználói kérdések megválaszolására. A Javító RAG megközelítés magában foglalhatja:

  1. Prompt technika: Keresési lekérdezéseket fogalmaz meg a felhasználói bemenet alapján.
  2. Eszköz: Természetes nyelvfeldolgozó és gépi tanulási algoritmusok alkalmazása a keresési találatok rangsorolására és szűrésére.
  3. Értékelés: Felhasználói visszajelzések elemzése a lekért információ hibáinak azonosítására és javítására.

Javító RAG az utazási ügynökben

A Javító RAG (Retrieval-Augmented Generation) növeli az MI képességét az információ lekérésére és generálására, miközben kijavítja az esetleges pontatlanságokat. Nézzük meg, hogyan használhatja a Travel Agent a Javító RAG megközelítést pontosabb és relevánsabb utazási ajánlások nyújtásához.

Ez magában foglalja:

Lépések a Javító RAG megvalósításához a Travel Agentben

  1. Kezdeti felhasználói interakció
    • A Travel Agent összegyűjti a felhasználó kezdeti preferenciáit, mint például úticél, utazási dátumok, költségvetés és érdeklődés.

    • Példa:

      preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
  2. Információ lekérése
    • A Travel Agent lekéri a repülőjáratok, szállások, látnivalók és éttermek adatait a felhasználói preferenciák alapján.

    • Példa:

      flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
  3. Kezdeti ajánlások generálása
    • A Travel Agent a lekért információk alapján személyre szabott útitervet készít.

    • Példa:

      itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)
  4. Felhasználói visszajelzés gyűjtése
    • A Travel Agent kéri a felhasználó visszajelzését a kezdeti ajánlásokhoz.

    • Példa:

      feedback = {
    "liked": ["Louvre Museum"],
    "disliked": ["Eiffel Tower (too crowded)"]
}
  5. Javító RAG folyamat
    • Prompt technika: A Travel Agent új keresési lekérdezéseket fogalmaz meg a felhasználói visszajelzések alapján.

      • Példa:

        if "disliked" in feedback:
    preferences["avoid"] = feedback["disliked"]
    • Eszköz: A Travel Agent algoritmusokat használ a keresési eredmények rangsorolására és szűrésére, különös hangsúlyt fektetve a visszajelzések szerinti relevanciára.

      • Példa:

        new_attractions = search_attractions(preferences)
new_itinerary = create_itinerary(flights, hotels, new_attractions)
print("Updated Itinerary:", new_itinerary)
    • Értékelés: A Travel Agent folyamatosan értékeli az ajánlások relevanciáját és pontosságát a felhasználói visszajelzések elemzésével és szükséges módosításokkal.

      • Példa:

        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)

Gyakorlati példa

Itt egy egyszerűsített Python kód példa, amely beépíti a Javító RAG megközelítést a Travel Agentbe:

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

# Példa használat
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)

Pre-emptív Kontextusbetöltés

A megelőző kontextusbetöltés azt jelenti, hogy a modellt a lekérdezés feldolgozása előtt betöltjük a releváns kontextussal vagy háttérinformációval. Ez azt jelenti, hogy a modell már az elejétől hozzáfér ezekhez az információkhoz, ami segíthet abban, hogy tájékozottabb válaszokat generáljon anélkül, hogy a folyamat során további adatokat kellene lekérnie.

Íme egy egyszerűsített példa arra, hogyan nézhet ki a megelőző kontextusbetöltés egy utazási ügynök alkalmazás esetén Pythonban:

class TravelAgent:
    def __init__(self):
        # Népszerű úti célok és azok információinak előbetöltése
        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):
        # Úti cél információinak lekérése az előbetöltött kontextusból
        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}."

# Példa használat
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

Magyarázat

  1. Inicializálás (__init__ metódus): A TravelAgent osztály előre betölt egy szótárat, amely népszerű úti célokkal kapcsolatos információkat tartalmaz, mint Párizs, Tokió, New York és Sydney. Ez a szótár tartalmazza az országot, pénznemet, nyelvet és főbb látnivalókat minden célállomásra.

  2. Információk lekérése (get_destination_info metódus): Amikor a felhasználó lekérdez egy adott úti célt, a get_destination_info metódus lekéri a releváns információkat az előre betöltött kontextus szótárból.

Azáltal, hogy előre betölti a kontextust, az utazási ügynök alkalmazás gyorsan tud válaszolni a felhasználói lekérdezésekre anélkül, hogy valós időben kellene ezeket az információkat külső forrásból lekérnie. Ez hatékonyabbá és reszponzívabbá teszi az alkalmazást.

A terv kiindítása egy céllal az ismétlés előtt

Egy terv kiindítása egy céllal azt jelenti, hogy világos célt vagy kívánt eredményt határozunk meg előre. Ezzel a céllal a modell irányelvként használhatja az ismétlődő folyamat során. Ez segít abban, hogy minden ismétlés a kívánt eredmény elérése felé haladjon, így a folyamat hatékonyabbá és fókuszáltabbá válik.

Íme egy példa arra, hogyan indíthat el egy utazási tervet egy céllal az ismétlés előtt egy utazási ügynök számára Pythonban:

Forgatókönyv

Egy utazási ügynök szeretne személyre szabott nyaralási tervet készíteni egy ügyfél számára. A cél az, hogy egy olyan utazási útvonalat hozzon létre, amely maximalizálja az ügyfél elégedettségét a preferenciáik és a költségvetésük alapján.

Lépések

  1. Határozzuk meg az ügyfél preferenciáit és költségvetését.
  2. Indítsuk el az első tervet ezen preferenciák alapján.
  3. Ismételjük meg a tervet annak finomításához, optimalizálva az ügyfél elégedettségét.

Python kód

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

# Példa használat
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)

Kódmagyarázat

  1. Inicializálás (__init__ metódus): A TravelAgent osztályt egy listával inicializáljuk, amely potenciális úti célokat tartalmaz, mindegyikhez név, ár és tevékenységtípus attribútumokkal.

  2. A terv kiindítása (bootstrap_plan metódus): Ez a metódus létrehoz egy kezdeti utazási tervet az ügyfél preferenciái és költségvetése alapján. Végigmegy az úti célokon, és hozzáadja őket a tervhez, ha megfelelnek az ügyfél preferenciáinak és beleférnek a költségvetésbe.

  3. Preferenciák egyeztetése (match_preferences metódus): Ez a metódus ellenőrzi, hogy egy úti cél megfelel-e az ügyfél preferenciáinak.

  4. A terv ismétlése (iterate_plan metódus): Ez a metódus finomítja a kezdeti tervet, megpróbálva egy jobb egyezést találni minden úti cél helyett, figyelembe véve az ügyfél preferenciáit és a költségvetési korlátokat.

  5. Költség számítása (calculate_cost metódus): Ez a metódus kiszámítja az aktuális terv összköltségét, beleértve egy potenciális új úti célt is.

Példa használat

A terv világos céllal történő kiindítása (például az ügyfél elégedettségének maximalizálása) és annak ismétlése révén az utazási ügynök személyre szabott és optimalizált utazási útitervet tud készíteni az ügyfél számára. Ez a megközelítés biztosítja, hogy az utazási terv az elejétől összhangban legyen az ügyfél preferenciáival és költségvetésével, és minden ismétléssel javuljon.

Az LLM kihasználása rangsorolásra és pontozásra

A nagy nyelvi modelleket (LLM-eket) rangsorolásra és pontozásra lehet használni azáltal, hogy értékelik a lekért dokumentumok vagy a generált válaszok relevanciáját és minőségét. Íme, hogyan működik:

Lekérés: Az első lekérési lépés egy jelölt dokumentumkészletet vagy válaszokat hoz létre a lekérdezés alapján.

Újrarrangsorolás: Az LLM értékeli ezeket a jelölteket, és azok relevanciája és minősége szerint újrarangsorolja őket. Ez a lépés biztosítja, hogy a legrelevánsabb és legmagasabb minőségű információ jelenjen meg először.

Pontozás: Az LLM pontokat rendel minden jelölthöz, tükrözve azok relevanciáját és minőségét. Ez segít a legjobb válasz vagy dokumentum kiválasztásában a felhasználónak.

Az LLM-ek rangsorolásra és pontozásra való kihasználásával a rendszer pontosabb és kontextuálisan relevánsabb információt tud nyújtani, javítva a felhasználói élményt.

Íme egy példa arra, hogyan használhat egy utazási ügynök egy nagy nyelvi modellt (LLM-et) az utazási célállomások újrarangsorolására és pontozására a felhasználói preferenciák alapján Pythonban:

Forgatókönyv - Utazás preferenciák alapján

Egy utazási ügynök a legjobb utazási célállomásokat szeretné ajánlani egy ügyfél számára a preferenciái alapján. Az LLM segít az úti célok újrarangsorolásában és pontozásában, hogy a legmegfelelőbb lehetőségek kerüljenek bemutatásra.

Lépések:

  1. Gyűjtsük össze a felhasználó preferenciáit.
  2. Lekérjük a potenciális utazási célállomások listáját.
  3. Az LLM segítségével újrarangsoroljuk és pontozzuk a célállomásokat a felhasználói preferenciák alapján.

Íme, hogyan frissítheti a korábbi példát az Azure OpenAI szolgáltatás használatára:

Követelmények

  1. Szüksége van egy Azure előfizetésre.
  2. Hozzon létre egy Azure OpenAI erőforrást, és szerezze be az API kulcsát.

Példa Python kód

import requests
import json

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

    def get_recommendations(self, preferences, api_key, endpoint):
        # Készíts egy promptot az Azure OpenAI számára
        prompt = self.generate_prompt(preferences)
        
        # Határozd meg a fejlécet és a terhelést a kéréshez
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # Hívd meg az Azure OpenAI API-t a rangsorolt és értékelt célpontok megszerzéséhez
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # Válaszd ki és add vissza a javaslatokat
        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

# Példa használat
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)

Kódmagyarázat - Preferencia foglaló

  1. Inicializálás: A TravelAgent osztályt egy potenciális utazási célállomásokat tartalmazó lista alapján inicializálják, mindegyikhez név és leírás tartozik.

  2. Ajánlások lekérése (get_recommendations metódus): Ez a metódus promptot generál az Azure OpenAI szolgáltatás számára a felhasználó preferenciái alapján, és HTTP POST kérést küld az Azure OpenAI API-nak, hogy újrarangsorolt és pontozott célállomásokat kapjon.

  3. Prompt generálása (generate_prompt metódus): Ez a metódus összeállít egy promptot az Azure OpenAI-hoz, amely tartalmazza a felhasználó preferenciáit és az úti célok listáját. A prompt irányítja a modellt, hogy az adott preferenciák alapján újrarangsorolja és pontozza az úti célokat.

  4. API hívás: A requests könyvtár használatával HTTP POST kérést küldenek az Azure OpenAI API végpontjára. A válasz tartalmazza az újrarangsorolt és pontozott úti célokat.

  5. Példa használat: Az utazási ügynök összegyűjti a felhasználó preferenciáit (például városnézés és változatos kultúra iránti érdeklődés), majd az Azure OpenAI szolgáltatást használva újrarangsorolt és pontozott ajánlásokat kér az utazási célokról.

Ne felejtse el kicserélni a your_azure_openai_api_key részt a tényleges Azure OpenAI API kulcsára, és a https://your-endpoint.com/... részt az Azure OpenAI telepítésének tényleges végpont URL-jére.

Az LLM kihasználásával az újrarangsorolásra és pontozásra az utazási ügynök személyre szabottabb és relevánsabb utazási ajánlatokat tud nyújtani az ügyfeleknek, javítva az általános élményt.

RAG: Prompting Technika vs Eszköz

A Retrieval-Augmented Generation (RAG) lehet egyszerre prompting technika és eszköz az AI ügynökök fejlesztésében. A kettő közötti különbség megértése segíthet hatékonyabban kihasználni a RAG-et a projektjeiben.

RAG mint Prompting Technika

Mi ez?

Hogyan működik:

  1. Promptok megfogalmazása: Készítsen jól strukturált promptokat vagy lekérdezéseket az adott feladat vagy felhasználói bemenet alapján.
  2. Információ lekérése: Használja ezeket a promptokat releváns adatok keresésére egy előre meglévő tudásbázisból vagy adatkészletből.
  3. Válasz generálása: Kösse össze a lekért információkat generatív AI modellekkel, hogy átfogó és koherens választ hozzon létre.

Példa utazási ügynöknél:

RAG mint Eszköz

Mi ez?

Hogyan működik:

  1. Integráció: Beágyazza a RAG-et az AI ügynök architektúrájába, amely automatikusan kezeli a lekérés és generálás feladatokat.
  2. Automatizálás: Az eszköz az egész folyamatot kezeli, a felhasználói bemenettől a végső válasz generálásáig, anélkül, hogy minden lépéshez explicit promptokra lenne szükség.
  3. Hatékonyság: Javítja az ügynök teljesítményét azzal, hogy egyszerűsíti a lekérés és generálás folyamatát, gyorsabb és pontosabb válaszokat tesz lehetővé.

Példa utazási ügynöknél:

Összehasonlítás

Szempont Prompting Technika Eszköz
Kézi vs Automatikus Kézi promptok megfogalmazása minden lekérdezéshez. Automatizált folyamat a lekéréshez és generáláshoz.
Irányítás Több kontrollt nyújt a lekérési folyamat felett. Egyszerűsíti és automatizálja a lekérés és generálás folyamatát.
Rugalmasság Egyedi promptokat tesz lehetővé specifikus igényekhez. Hatékonyabb nagy volumenű alkalmazásokhoz.
Bonyolultság Promptok kidolgozását és finomhangolását igényli. Könnyebb integrálni AI ügynök architektúrájába.

Gyakorlati példák

Példa a Prompting Technikára:

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)

Példa Eszközre:

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)

Relevancia értékelése

A relevancia értékelése kulcsfontosságú az AI ügynökök teljesítményében. Biztosítja, hogy az ügynök által lekért és generált információk megfelelőek, pontosak és hasznosak legyenek a felhasználó számára. Nézzük meg, hogyan értékelhetjük a relevanciát AI ügynököknél, gyakorlati példákkal és technikákkal.

A relevancia értékelésének kulcsfogalmai

  1. Kontextus tudatosság:
    • Az ügynöknek értenie kell a felhasználói lekérdezés kontextusát, hogy releváns információt nyerjen ki és generáljon.
    • Példa: Ha a felhasználó azt kéri, hogy “legjobb éttermek Párizsban”, az ügynöknek figyelembe kell vennie az étel típusára és költségvetésre vonatkozó preferenciákat.
  2. Pontosság:
    • Az ügynök által szolgáltatott információnak tényszerűen helyesnek és naprakésznek kell lennie.
    • Példa: Az aktuálisan nyitva tartó, jó véleményekkel rendelkező éttermek ajánlása, nem pedig elavult vagy bezárt helyek.
  3. Felhasználói szándék:
    • Az ügynöknek ki kell következtetnie a felhasználó szándékát a lekérdezés mögött, hogy a legrelevánsabb információt nyújtsa.
    • Példa: Ha a felhasználó “költséghatékony hoteleket” kér, az ügynök prioritásként kezeli a megfizethető opciókat.
  4. Visszacsatolási ciklus:
    • A folyamatos felhasználói visszajelzések gyűjtése és elemzése segít az ügynök relevancia értékelési folyamatának finomításában.
    • Példa: A korábbi ajánlásokhoz kapott értékelések és visszajelzések beépítése a jövőbeli válaszok javítása érdekében.

Gyakorlati technikák a relevancia értékelésére

  1. Relevancia pontozás:
    • Minden lekért elemhez relevancia pontot rendel a felhasználói lekérdezés és preferenciák egyezése alapján.

    • Példa:

      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. Szűrés és rangsorolás:
    • Kisziűri a nem releváns elemeket, és a maradékot relevancia pontszám alapján rangsorolja.

    • Példa:

      def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # Adja vissza a 10 legrelevánsabb elemet
  3. Természetes nyelv feldolgozás (NLP):
    • NLP technikákat használ a felhasználói lekérdezés megértésére és releváns információ lekérésére.

    • Példa:

      def process_query(query):
    # Használjon NLP-t a felhasználó lekérdezésének kulcsfontosságú információinak kinyeréséhez
    processed_query = nlp(query)
    return processed_query
  4. Felhasználói visszajelzés integrálása:
    • Gyűjt felhasználói visszajelzéseket az ajánlásokról, és ezeket használja a jövőbeli relevancia értékelések finomhangolására.

    • Példa:

      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

Példa: Relevancia értékelése utazási ügynöknél

Íme egy gyakorlati példa arra, hogyan értékelheti a Travel Agent az utazási ajánlások relevanciáját:

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]  # Visszaadja a 10 legrelevánsabb elemet

    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

# Példa használat
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)

Keresés szándékkal

A keresés szándékkal azt jelenti, hogy megérti és értelmezi a felhasználó lekérdezése mögött álló célt vagy szándékot, hogy a legrelevánsabb és leghasznosabb információt nyerje ki és generálja. Ez a megközelítés túlmutat a kulcsszavak egyszerű egyeztetésén, és a felhasználó valós igényeinek és kontextusának megértésére összpontosít.

A keresés szándékának kulcsfogalmai

  1. Felhasználói szándék megértése:
    • A felhasználói szándék három fő típusra osztható: információs, navigációs és tranzakciós.
      • Információs szándék: A felhasználó információt keres egy témáról (pl. “Melyek a legjobb múzeumok Párizsban?”).
      • Navigációs szándék: A felhasználó egy adott weboldalra vagy oldalra akar navigálni (pl. “Louvre Múzeum hivatalos weboldal”).
      • Tranzakciós szándék: A felhasználó tranzakciót akar végrehajtani, például repülőjegyet foglalni vagy vásárolni (pl. “Foglaljak repülőjegyet Párizsba”).
  2. Kontextus tudatosság:
    • A felhasználói lekérdezés kontextusának elemzése segít pontosan azonosítani a szándékot. Ez magában foglalja a korábbi interakciók, a felhasználói preferenciák és a jelenlegi lekérdezés részleteit.
  3. Természetes nyelv feldolgozás (NLP):
    • NLP technikákat alkalmaznak a természetes nyelvű lekérdezések megértésére és értelmezésére, ideértve az entitásfelismerést, érzelemelemzést és lekérdezés elemzést.
  4. Személyre szabás:
    • A keresési eredmények személyre szabása a felhasználó előzményei, preferenciái és visszajelzései alapján javítja a lekért információ relevanciáját.

Gyakorlati példa: Keresés szándékkal az utazási ügynöknél

Nézzük meg a Travel Agent példáját, hogy hogyan valósítható meg a keresés szándékkal.

  1. Felhasználó preferenciáinak összegyűjtése

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

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

  2. Felhasználói szándék megértése

    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. Kontextus tudatosság

    def analyze_context(query, user_history):
    # Kombinálja a jelenlegi lekérdezést a felhasználó előzményeivel a kontextus megértéséhez
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

  4. Keresés és eredmények személyre szabása

    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):
    # Példa keresési logika információs szándékra
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # Példa keresési logika navigációs szándékra
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # Példa keresési logika tranzakciós szándékra
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # Példa személyre szabási logika
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # Visszaadja a 10 legjobb személyre szabott eredményt

  5. Használati példa

    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. Kód generálása eszközként

A kód generáló ügynökök AI modelleket használnak kód írására és végrehajtására, komplex problémák megoldására és feladatok automatizálására.

Kód generáló ügynökök

A kód generáló ügynökök generatív AI modelleket használnak kód írására és futtatására. Ezek az ügynökök képesek összetett problémák megoldására, feladatok automatizálására és értékes betekintések nyújtására különböző programozási nyelveken kód generálásával és futtatásával.

Gyakorlati alkalmazások

  1. Automatikus kód generálás: Kód részletek generálása specifikus feladatokra, például adat elemzésre, webes adatgyűjtésre vagy gépi tanulásra.
  2. SQL mint RAG: SQL lekérdezések használata adatok lekérésére és manipulálására adatbázisokból.
  3. Problémamegoldás: Kód létrehozása és végrehajtása specifikus problémák megoldására, például algoritmusok optimalizálására vagy adat elemzésre.

Példa: Kód generáló ügynök adat elemzéshez

Képzeld el, hogy tervezel egy kód generáló ügynököt. Így működhet:

  1. Feladat: Egy adatkészlet elemzése trendek és minták azonosítására.
  2. Lépések:
    • Betölti az adatkészletet egy adat elemző eszközbe.
    • SQL lekérdezéseket generál az adatok szűrésére és aggregálására.
    • Végrehajtja a lekérdezéseket és lekéri az eredményeket.
    • Az eredményeket vizualizációk és betekintések generálására használja.
  3. Szükséges források: Hozzáférés az adatkészlethez, adat elemző eszközök és SQL képességek.
  4. Tapasztalat: Korábbi elemzési eredmények felhasználása a jövőbeni elemzések pontosságának és relevanciájának javítására.

Példa: Kód generáló ügynök Utazási Ügynök számára

Ebben a példában egy kód generáló ügynököt, az Utazási Ügynököt tervezünk, hogy segítsen a felhasználóknak utazásuk tervezésében kód generálásával és végrehajtásával. Ez az ügynök képes kezelni olyan feladatokat, mint utazási opciók lekérése, eredmények szűrése és útiterv összeállítása generatív AI segítségével.

A kód generáló ügynök áttekintése

  1. Felhasználói preferenciák gyűjtése: Összegyűjti a felhasználó inputját, mint például az úti célt, utazási időpontokat, költségvetést és érdeklődési köröket.
  2. Kód generálása az adatok lekéréséhez: Kód részleteket generál repülőjáratokról, szállodákról és látnivalókról szóló adatok lekéréséhez.
  3. Generált kód végrehajtása: A generált kód lefuttatása a valós idejű információk lekérésére.
  4. Útiterv készítése: Az összegyűjtött adatok személyre szabott utazási tervbe foglalása.
  5. Visszajelzés alapján történő igazítás: Felhasználói visszajelzés fogadása, és szükség esetén a kód újbóli generálása az eredmények finomítására.

Lépésről lépésre történő megvalósítás

  1. Felhasználói preferenciák gyűjtése

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

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

  2. Adatlekéréshez kód generálása

    def generate_code_to_fetch_data(preferences):
    # Példa: Kód generálása a felhasználói preferenciák alapján történő járatkereséshez
    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):
    # Példa: Kód generálása szállodakereséshez
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

  3. Generált kód végrehajtása

    def execute_code(code):
    # A generált kód futtatása az exec használatával
    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. Útiterv generálása

    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. Visszajelzés alapján történő igazítás

    def adjust_based_on_feedback(feedback, preferences):
    # Az előnyöket a felhasználói visszajelzések alapján módosítani
    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)
   
# A kódot az új előnyökkel újragenerálni és végrehajtani
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)

Környezettudatosság és érvelés kihasználása

Az adattábla sémája valóban javíthatja a lekérdezés generálási folyamatát a környezettudatosság és érvelés alkalmazásával.

Íme egy példa arra, hogyan valósítható ez meg:

  1. Sémaalapú megértés: A rendszer meg fogja érteni az adattábla sémáját, és ezt az információt használja a lekérdezés generálásának alapjaként.
  2. Visszajelzés szerinti igazítás: A rendszer a visszajelzés alapján módosítja a felhasználói preferenciákat, és megfontolja, mely mezőket kell frissíteni a sémában.
  3. Lekérdezések generálása és végrehajtása: A rendszer generálja és végrehajtja a lekérdezéseket, hogy az új preferenciák alapján frissített repülő- és szállodaadatokat szerezzen.

Itt egy frissített Python példa, amely ezeket a koncepciókat tartalmazza:

def adjust_based_on_feedback(feedback, preferences, schema):
    # Felhasználói visszajelzések alapján igazítsa a beállításokat
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Sémára alapozott érvelés a kapcsolódó beállítások módosításához
    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):
    # Egyedi logika a beállítások igazításához séma és visszajelzés alapján
    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):
    # Kód generálása a frissített beállítások alapján történő járatinformáció lekéréséhez
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Kód generálása a frissített beállítások alapján történő szállodainformáció lekéréséhez
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # Kód végrehajtásának szimulálása és tesztadatok visszaadása
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Úti terv készítése járatok, szállodák és látnivalók alapján
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# Példa séma
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# Példa használatra
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# Kód újragenerálása és végrehajtása a frissített beállításokkal
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)

Magyarázat - Foglalás visszajelzés alapján

  1. Sémaalapú tudatosság: A schema szótár meghatározza, hogyan kell a visszajelzés alapján a preferenciákat módosítani. Tartalmaz mezőket, mint favorites és avoid, megfelelő beállításokkal.
  2. Preferenciák igazítása (adjust_based_on_feedback metódus): Ez a metódus a felhasználói visszajelzés és a séma alapján módosítja a preferenciákat.
  3. Környezeti módosítások (adjust_based_on_environment metódus): Ez a metódus a séma és a visszajelzés alapján egyéni igazításokat végez.
  4. Lekérdezések generálása és végrehajtása: A rendszer generál kódot a frissített repülő- és szállodaadatok lekéréséhez a módosított preferenciák alapján, és szimulálja ezek végrehajtását.
  5. Útiterv generálása: A rendszer új útitervet készít az új repülő-, szálloda- és látnivalóadatok alapján.

A rendszer környezettudatossá tétele és a séma alapján történő érvelés révén pontosabb és relevánsabb lekérdezések generálhatók, ami jobb utazási ajánlásokhoz és személyre szabottabb felhasználói élményhez vezet.

SQL használata lekérdezés-alapú generálás (RAG) technikaként

Az SQL (Structured Query Language) egy hatékony eszköz az adatbázisok kezelésére. Amikor lekérdezés-alapú generálás (RAG) megközelítés részeként használjuk, az SQL releváns adatokat szerez be az adatbázisokból, hogy információt szolgáltasson és válaszokat vagy műveleteket generáljon AI ügynökök számára. Vizsgáljuk meg, hogyan használható az SQL RAG technikaként az Utazási Ügynök kontextusában.

Kulcsfogalmak

  1. Adatbázis-kezelés:
    • Az SQL az adatbázisok lekérdezésére, releváns információk lekérésére és adatok manipulálására szolgál.
    • Példa: Repülőjárat részletek, szálloda információk és látnivalók lekérése egy utazási adatbázisból.
  2. Integráció a RAG-gal:
    • Az SQL lekérdezések a felhasználói input és preferenciák alapján generálódnak.
    • A lekért adatokat személyre szabott ajánlások vagy műveletek generálására használják.
  3. Dinamikus lekérdezés generálás:
    • Az AI ügynök dinamikus SQL lekérdezéseket generál a kontextus és a felhasználói igények alapján.
    • Példa: SQL lekérdezések testre szabása az eredmények szűrésére költségvetés, dátumok és érdeklődési körök szerint.

Alkalmazások

Példa: Egy adat elemző ügynök:

  1. Feladat: Egy adatkészlet elemzése a trendek feltárására.
  2. Lépések:
    • Adatkészlet betöltése.
    • SQL lekérdezések generálása az adatok szűrésére.
    • Lekérdezések végrehajtása és eredmények lekérése.
    • Vizualizációk és betekintések generálása.
  3. Források: Hozzáférés az adatkészlethez, SQL képességek.
  4. Tapasztalat: Korábbi eredmények felhasználása a jövőbeni elemzések javítására.

Gyakorlati példa: SQL használata az Utazási Ügynökben

  1. Felhasználói preferenciák gyűjtése

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

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

  2. SQL lekérdezések generálása

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

  3. SQL lekérdezések végrehajtása

    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. Ajánlások generálása

    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)

Példa SQL lekérdezések

  1. Repülőjárat lekérdezés

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

  2. Szálloda lekérdezés

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

  3. Látnivaló lekérdezés

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

Az SQL lekérdezés-alapú generálás (RAG) technika alkalmazásával az AI ügynökök, például az Utazási Ügynök dinamikusan lekérhetik és felhasználhatják a releváns adatokat, hogy pontos és személyre szabott ajánlásokat nyújtsanak.

Példa metakognícióra

Ahhoz, hogy bemutassunk egy metakogníciós megvalósítást, hozzunk létre egy egyszerű ügynököt, amely visszatekint döntéshozatali folyamatára miközben problémát old meg. Ehhez a példához olyan rendszert készítünk, ahol az ügynök megpróbál optimalizálni egy szálloda választást, de ezután értékeli saját érvelését és stratégiáját módosítja, ha hibákat vagy szuboptimális döntéseket hoz.

Ezt egy alapvető példán keresztül szimuláljuk, ahol az ügynök ár és minőség kombinációja alapján választ szállodákat, majd “visszatekint” döntéseire és ennek megfelelően módosít.

Hogyan illusztrálja ez a metakogníciót:

  1. Kezdeti döntés: Az ügynök a legolcsóbb szállodát választja, minőségi hatás megértése nélkül.
  2. Visszatekintés és értékelés: A kezdeti választás után az ügynök ellenőrzi, hogy a szálloda “rossz” választás-e a felhasználói visszajelzések alapján. Ha az derül ki, hogy a szálloda minősége túl alacsony volt, az ügynök reflektál érvelésére.
  3. Stratégia igazítása: Az ügynök a visszatekintés alapján módosítja stratégiáját: a “legolcsóbbról” a “legjobb minőségre” vált, ezzel javítva döntéshozatali folyamatát a jövőbeni iterációk során.

Íme egy példa:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # Elmenti a korábban kiválasztott szállodákat
        self.corrected_choices = []  # Elmenti a javított választásokat
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # Elérhető stratégiák

    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]
        # Tegyük fel, hogy van felhasználói visszajelzésünk, amely megmutatja, hogy az utolsó választás jó volt-e vagy sem
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # A stratégia módosítása, ha az előző választás nem volt kielégítő
            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"

# Szimulál egy szállodalistát (ár és minőség)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# Létrehoz egy ügynököt
agent = HotelRecommendationAgent()

# 1. lépés: Az ügynök a "legolcsóbb" stratégia alkalmazásával ajánl egy szállodát
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# 2. lépés: Az ügynök átgondolja a választást és szükség esetén módosítja a stratégiát
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# 3. lépés: Az ügynök újra ajánl, ezúttal a módosított stratégiát használva
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

Ügynökök metakognitív képességei

A kulcs itt az ügynök képessége:

Ez egy egyszerű metakogníció forma, ahol a rendszer képes a belső visszacsatolás alapján módosítani érvelési folyamatát.

Összefoglalás

A metakogníció egy erőteljes eszköz, amely jelentősen javíthatja az AI ügynökök képességeit. Metakognitív folyamatok beépítésével intelligensebb, alkalmazkodóbb és hatékonyabb ügynököket tervezhetsz. Használd a további forrásokat a metakogníció izgalmas világának mélyebb felfedezéséhez az AI ügynökökben.

További kérdéseid vannak a Metakogníció tervezési mintájával kapcsolatban?

Csatlakozz a Microsoft Foundry Discord szerverhez, hogy más tanulókkal találkozhass, részt vehess konzultációkon, és megválaszoltathasd AI ügynökökkel kapcsolatos kérdéseidet.

Korábbi lecke

Többügynökös tervezési minta

Következő lecke

AI ügynökök a gyakorlatban

Jogi nyilatkozat: Ez a dokumentum az AI fordítási szolgáltatás, a Co-op Translator segítségével készült. Bár az pontosságra törekszünk, kérjük, vegye figyelembe, hogy az automatikus fordítások hibákat vagy pontatlanságokat tartalmazhatnak. Az eredeti dokumentum az anyanyelvén tekintendő hiteles forrásnak. Fontos információk esetén professzionális emberi fordítást javasolunk. Nem vállalunk felelősséget semmilyen félreértésért vagy téves értelmezésért, amely ebből a fordításból ered.

This site is open source. Improve this page.