ai-agents-for-beginners

(Klõpsa pildil üleval, et vaadata selle õppetunni videot)

Metakognitsioon tehisintellekti agentides

Sissejuhatus

Tere tulemast metakognitsiooni õppetundi tehisintellekti agentides! See peatükk on mõeldud algajatele, kes on uudishimulikud, kuidas tehisintellekti agentidel on võimalik mõelda omaenda mõtlemisprotsesside üle. Selle õppetunni lõpuks mõistad võtmekontseptsioone ning omandad praktilisi näiteid, kuidas rakendada metakognitsiooni tehisintellekti agentide kujundamisel.

Õpieesmärgid

Pärast selle õppetunni läbimist suudad:

Mõista järelduslõksude mõju agentide määratlustes.
Kasutada planeerimise ja hindamise meetodeid enesekorrektsiooni võimelistel agentidel.
Luua omaenda agente, kes suudavad koodi manipuleerida ülesannete täitmiseks.

Sissejuhatus metakognitsiooni

Metakognitsioon viitab kõrgema taseme kognitiivsetele protsessidele, mis hõlmavad mõtlemist omaenda mõtlemise üle. Tehisintellekti agentide puhul tähendab see võimet hinnata ja kohandada oma tegusid iseenda teadlikkuse ja varasemate kogemuste põhjal. Metakognitsioon ehk „mõtlemine mõtlemise üle“ on oluline mõiste agentsete tehisintellektisüsteemide arendamisel. See hõlmab teadlikkust omaenda sisemistest protsessidest ning võimet neid jälgida, reguleerida ja oma käitumist kohandada. Nii nagu meie teeme, kui „loeme ruumi“ või vaatame probleemi. See eneseteadlikkus aitab tehisintellektil teha paremaid otsuseid, tuvastada vigu ja parandada oma võimekust aja jooksul – mis viitab taas Turingi testile ja vaidlusele selle üle, kas tehisintellekt võtab kontrolli üle.

Agentsete tehisintellekti süsteemide kontekstis aitab metakognitsioon lahendada mitmeid väljakutseid, nagu näiteks:

Läbipaistvus: kindlustada, et tehisintellekti süsteemid suudavad seletada oma mõttekäike ja otsuseid.
Järeldamine: parandada tehisintellekti süsteemide võimet sünteesida informatsiooni ja teha kaalutletud otsuseid.
Kohandumine: võimaldada tehisintellekti süsteemidel kohaneda uute keskkondade ja muutuvate tingimustega.
Taju: parandada tehisintellekti süsteemide täpsust andmete äratundmisel ja tõlgendamisel keskkonnast.

Mis on metakognitsioon?

Metakognitsioon ehk „mõtlemine mõtlemise üle“ on kõrgema taseme kognitiivne protsess, mis hõlmab eneseteadlikkust ja enda kognitiivsete protsesside eneseregulatsiooni. Tehisintellekti valdkonnas annab metakognitsioon agentidele võime hinnata ja kohandada oma strateegiaid ja tegusid, mis toob kaasa paremad probleemilahendus- ja otsustusoskused. Metakognitsiooni mõistmine võimaldab kujundada tehisintellekti agente, kes on mitte ainult targemad, vaid ka kohanemisvõimelisemad ja tõhusamad. Tõelises metakognitsioonis näeksime tehisintellekti selgesõnaliselt omaenda järelduste üle järeldamas.

Näide: „Ma eelistasin odavamaid lende, sest… Võib-olla jääb mul märkamata otselende, seega kontrollin uuesti.“ Jälgides, kuidas või miks valiti teatud marsruut.

Tuginedes sellele, et vigu tehti, sest liialt tugineti kasutaja eelistustele eelmisest korrast, mistõttu muudetakse otsustusstrateegiat, mitte ainult lõplikku soovitust.
Musterdiagnoos nagu: „Iga kord, kui kasutaja mainib ‘liiga rahvarohket’, ei tohiks ma mitte ainult eemaldada teatud vaatamisväärsusi, vaid peaksin ka aru saama, et minu meetod ‘tippatraktsioonide’ valimiseks on vigane, kui alati järjestan populaarsuse järgi.“

Metakognitsiooni tähtsus tehisintellekti agentides

Metakognitsioon mängib mitmel põhjusel tähtsat rolli tehisintellekti agentide kujundamisel:

Metakognitsiooni tähtsus

Eneserefleksioon: agentidel on võime hinnata oma sooritust ja tuvastada arenguvõimalusi.
Kohanemisvõime: agentidel on võime muuta oma strateegiaid varasemate kogemuste ja muutuvate keskkondade põhjal.
Vigade parandamine: agentidel on võime automaatselt vigu tuvastada ja parandada, mis viib täpsemate tulemusteni.
Ressursside haldamine: agentidel on võime optimeerida ressursside kasutamist, nagu aeg ja arvutusvõimsus, planeerides ja hinnates oma tegusid.

Tehisintellekti agendi komponendid

Enne metakognitiivsete protsesside süvitsi minekut on oluline mõista AI agendi põhilisi komponente. AI agent koosneb tavaliselt:

Persona: agenndi isiksus ja omadused, mis määratlevad, kuidas ta kasutajatega suhtleb.
Tööriistad: võimed ja funktsioonid, mida agent saab täita.
Osavused: teadmised ja ekspertiis, mida agent valdavad.

Need komponendid töötavad koos, luues „ekspertiisi üksuse“, mis suudab täita spetsiifilisi ülesandeid.

Näide: Kujuta ette reisibürood, mis mitte ainult ei planeeri sinu puhkust, vaid kohandab oma marsruuti reaalajas andmete ja varasemate kliendikogemuste põhjal.

Näide: metakognitsioon reisibüroo teenuses

Kujutame ette, et kujundad AI-ga tööle pandud reisibüroo teenust. See agent, „Reisibüroo Agent“, aitab kasutajatel planeerida oma puhkust. Metakognitsiooni kaasamiseks peab Reisibüroo Agent hindama ja kohandama oma tegusid eneseteadlikkuse ja varasemate kogemuste põhjal. Siin on, kuidas metakognitsioon võiks rolli mängida:

Praegune ülesanne

Praegune ülesanne on aidata kasutajal planeerida reisi Pariisi.

Sammud ülesande täitmiseks

Koguda kasutaja eelistusi: Küsida kasutajalt reisi kuupäevi, eelarvet, huvisid (nt muuseumid, köök, ostlemine) ja mingeid spetsiifilisi nõudeid.
Info hankimine: Otsida lendude, majutuse, vaatamisväärsuste ja restoranide valik, mis vastab kasutaja eelistustele.
Soovituste koostamine: Pakkuda isikupärastatud marsruuti koos lennuandmete, hotellibroneeringute ja soovitatud tegevustega.
Tagasiside alusel kohandamine: Küsida kasutajalt tagasisidet soovituste kohta ja teha vajalikud muudatused.

Vajalikud ressursid

Ligipääs lennu- ja hotelli broneerimisandmebaasidele.
Info Pariisi vaatamisväärsuste ja restoranide kohta.
Kasutajate tagasisideandmed varasematest suhtlustest.

Kogemus ja eneserefleksioon

Reisibüroo Agent kasutab metakognitsiooni, et hinnata oma sooritust ja õppida varasematest kogemustest. Näiteks:

Kasutajate tagasiside analüüs: Reisibüroo Agent vaatab üle kasutajate tagasiside, et määrata, millised soovitused olid hästi vastu võetud ja millised mitte. Ta kohandab vastavalt oma tulevasi ettepanekuid.
Kohanemisvõime: Kui kasutaja on varem maininud rahvarohkuse eelistamatust, väldib Reisibüroo Agent hiljem populaarseid turistikohad tippajal soovitamast.
Vigade parandamine: Kui Reisibüroo Agent tegi varem vea, näiteks soovitas täiesti broneeritud hotelli, õpib ta enne soovituste tegemist saadavust rangemalt kontrollima.

Praktiline arendaja näide

Siin on lihtsustatud näide sellest, kuidas Reisibüroo Agendi kood võib metakognitsiooni kaasamisel välja näha:

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):
        # Otsi lende, hotelle ja vaatamisväärsusi vastavalt eelistustele
        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)
        # Analüüsi tagasisidet ja kohanda tulevasi soovitusi
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Näidiskasutus
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)

Miks metakognitsioon on oluline

Eneserefleksioon: agentidel on võime analüüsida oma sooritust ja tuvastada arengukohti.
Kohanemisvõime: agentidel on võimalik muuta strateegiaid tagasiside ja muutuvate tingimuste põhjal.
Vigade parandamine: agentidel on võime ise tuvastada ja parandada vigu.
Ressursside haldamine: agentidel on võimalik optimeerida ressursside kasutamist, nagu aja ja arvutusvõimsuse.

Metakognitsiooni kaasamisega saab Reisibüroo Agent pakkuda personaalsemaid ja täpsemaid reisisoovitusi, parandades kasutajakogemust.

2. Planeerimine agentides

Planeerimine on kriitiline komponent tehisintellekti agendi käitumises. See hõlmab sammude kavandamist eesmärgi saavutamiseks, võttes arvesse praegust olekut, ressursse ja võimalikke takistusi.

Planeerimise elemendid

Praegune ülesanne: määratle ülesanne selgelt.
Sammud ülesande täitmiseks: jaga ülesanne hallatavateks sammudeks.
Vajalikud ressursid: tunnusta vajalikud ressursid.
Kogemus: kasuta varasemaid kogemusi planeerimise informeerimiseks.

Näide: Siin on sammud, mida Reisibüroo Agent peab kasutaja reisi planeerimiseks tõhusalt tegema:

Sammud Reisibüroo Agendi jaoks

Koguda kasutaja eelistused
- Küsi kasutajalt detaile nende reisi kuupäevade, eelarve, huvide ja spetsiifiliste nõuete kohta.
- Näited: „Millal plaanid reisida?“ „Mis on sinu eelarvevahemik?“ „Milliseid tegevusi sulle puhkusel meeldib teha?“
Info hankimine
- Otsi kasutaja eelistuste põhjal sobivaid reisivõimalusi.
- Lennud: Otsi saadaval olevaid lende kasutaja eelarve ja soovitud reisi kuupäevade raames.
- Majutus: Leia hotellid või rendikohad, mis vastavad kasutaja eelistustele asukoha, hinna ja mugavuste osas.
- Vaatamisväärsused ja restoranid: Tuvasta populaarsed vaatamisväärsused, tegevused ja söögikohad, mis sobivad kasutaja huvidega.
Soovituste koostamine
- Koosta hangitud info põhjal isikupärastatud reisiplaan.
- Paku üksikasju nagu lennuvalikud, hotellibroneeringud ja soovitatud tegevused, kohandades soovitusi vastavalt kasutaja eelistustele.
Esita kasutajale reisiplaan
- Jaga kasutajaga ettepanekut marsruudi ülevaatamiseks.
- Näide: „Siin on soovitatud marsruut sinu Pariisi reisi jaoks. See sisaldab lennuandmeid, hotellibroneeringuid ja nimekirja soovitatud tegevustest ning restoranidest. Anna teada oma arvamus!“
Tagasiside kogumine
- Küsi kasutajalt tagasisidet ettepanekute kohta.
- Näited: „Kas sulle meeldivad lennuvalikud?“ „Kas hotell sobib sinu vajadustega?“ „Kas on tegevusi, mida soovid lisada või eemaldada?“
Kohanda tagasiside põhjal
- Muuda reisiplaani vastavalt kasutaja tagasisidele.
- Tee vajalikud muudatused lennu-, majutus- ja tegevussuunistes, et paremini sobituda kasutaja eelistustega.
Lõplik kinnitamine
- Esita uuendatud reisiplaan kasutajale lõplikuks kinnitamiseks.
- Näide: „Olen teinud muudatused vastavalt sinu tagasisidele. Siin on uuendatud marsruut. Kas kõik tundub korras?“
Broneeringute tegemine ja kinnitamine
- Kui kasutaja kinnitab marsruudi, teosta lennuplaanide, majutuse ja eelplaneeritud tegevuste broneeringud.
- Saada kasutajale kinnitusandmed.
Jätkuv tugi
- Ole valmis kasutajat aitama muudatuste või lisasoovide korral enne ja reisi ajal.
- Näide: „Kui vajad abi reisi jooksul, võta minuga igal ajal ühendust!“

Näidissuhtlus

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)

# Näide kasutamisest broneerimistaotluses
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. Paranduslik RAG süsteem

Alustuseks mõistame erinevust RAG-tööriista ja ennetava konteksti laadimise vahel.

RAG vs konteksti laadimine

Päringutel põhinev loomeprotsess (RAG)

RAG ühendab otsingusüsteemi genereeriva mudeliga. Kui esitatakse päring, otsingusüsteem hangib asjakohased dokumendid või andmed välistest allikatest ning see hangitud teave kasutatakse genereeriva mudeli sisendi täiustamiseks. See aitab mudelil genereerida täpsemaid ja kontekstikohasemaid vastuseid.

RAG süsteemis hangib agent asjakohast teavet teadmusbaasist ning kasutab seda sobivate vastuste või tegude genereerimiseks.

Paranduslik RAG lähenemine

Paranduslik RAG lähenemine keskendub RAG-tehnikate kasutamisele vigade parandamiseks ja tehisintellekti agentide täpsuse parandamiseks. See hõlmab:

Päringutehnika: konkreetsete päringute kasutamine, et suunata agenti asjakohase teabe hankimisel.
Tööriist: algoritmide ja mehhanismide rakendamine, mis võimaldavad agendil hinnata hangitud teabe asjakohasust ja genereerida täpseid vastuseid.
Hindamine: pidev agendi soorituse hindamine ja muudatuste tegemine täpsuse ja efektiivsuse parandamiseks.

Näide: paranduslik RAG otsinguagensis

Mõtle otsinguagendile, kes hangib veebist infot kasutajate päringutele vastamiseks. Paranduslik RAG võib hõlmata:

Päringutehnika: kasutaja sisendi põhjal otsingupäringute koostamine.
Tööriist: loomuliku keele töötlemise ja masinõppe algoritmide kasutamine otsingutulemuste järjestamiseks ja filtreerimiseks.
Hindamine: kasutajate tagasiside analüüs, et tuvastada ja parandada hankitud teabe ebatäpsusi.

Paranduslik RAG Reisibüroos

Paranduslik RAG (Retrieval-Augmented Generation) parandab tehisintellekti suutlikkust teavet hankida ja genereerida, samal ajal vigu parandades. Vaatame, kuidas Reisibüroo Agent saab kasutada paranduslikku RAG-i, et pakkuda täpsemaid ja asjakohasemaid reisisoovitusi.

See hõlmab:

Päringutehnika: konkreetsete päringute kasutamine, et suunata agenti asjakohase teabe hankimisel.
Tööriist: algoritmide ja mehhanismide rakendamine, mis võimaldavad agendil hinnata hangitud teabe asjakohasust ja genereerida täpseid vastuseid.
Hindamine: pidev agendi soorituse hindamine ja muudatuste tegemine täpsuse ja efektiivsuse parandamiseks.

Sammud parandusliku RAG rakendamiseks Reisibüroos

Esmane kasutajasuhtlus

Reisibüroo Agent kogub kasutajalt esmased eelistused, nagu sihtkoht, reisi kuupäevad, eelarve ja huvialad.

Näide:

preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}

Informatsiooni hankimine
- Reisibüroo Agent hangib infot lendude, majutuse, vaatamisväärsuste ja restoranide kohta kasutaja eelistuste põhjal.
- Näide:
```
flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
```
Esialgsete soovituste genereerimine
- Reisibüroo Agent kasutab hangitud infot isikupärase marsruudi koostamiseks.
- Näide:
```
itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)
```
Kasutajate tagasiside kogumine
- Reisibüroo Agent küsib kasutajalt tagasisidet esialgsete soovituste kohta.
- Näide:
```
feedback = {
    "liked": ["Louvre Museum"],
    "disliked": ["Eiffel Tower (too crowded)"]
}
```

Paranduslik RAG protsess

Päringutehnika: Reisibüroo Agent koostab uued otsingupäringud kasutaja tagasiside põhjal.
- Näide:
```
if "disliked" in feedback:
    preferences["avoid"] = feedback["disliked"]
```

Tööriist: Reisibüroo Agent kasutab algoritme, et järjestada ja filtreerida uusi otsingutulemusi, rõhutades kasutaja tagasiside alusel asjakohasust.

Näide:

new_attractions = search_attractions(preferences)
new_itinerary = create_itinerary(flights, hotels, new_attractions)
print("Updated Itinerary:", new_itinerary)

Hindamine: Reisibüroo Agent hindab pidevalt oma soovituste asjakohasust ja täpsust, analüüsides kasutajate tagasisidet ning tehes vajalikke kohandusi.

Näide:

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)

Praktiline näidis

Siin on lihtsustatud Python koodi näidis, mis sisaldab parandusliku RAG lähenemise rakendamist Reisibüroo Agendis:

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

# Näidis kasutus
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)

Ennetav konteksti laadimine

Ettenägelik konteksti laadimine hõlmab asjakohase konteksti või taustateabe laadimist mudelisse enne päringu töötlemist. See tähendab, et mudelil on sellele teabele juurdepääs algusest peale, mis aitab tal genereerida informeeritumaid vastuseid ilma, et oleks vaja protsessi käigus täiendavat andmetevahetust.

Siin on lihtsustatud näide sellest, kuidas ettenägelikku konteksti laadimine võiks välja näha reisikorraldaja rakenduses Pythonis:

class TravelAgent:
    def __init__(self):
        # Eellaadige populaarsed sihtkohad ja nende teave
        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):
        # Hangi sihtkoha teave eelnevalt laetud kontekstist
        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}."

# Näidiskasutus
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

Selgitus

Algatamine (__init__ meetod): TravelAgent klass laeb eelnevalt sõnastikku, mis sisaldab teavet populaarsete sihtkohtade kohta nagu Pariis, Tokio, New York ja Sydney. See sõnastik sisaldab üksikasju, nagu riik, valuuta, keel ja peamised vaatamisväärsused iga sihtkoha kohta.
Teabe pärimine (get_destination_info meetod): Kui kasutaja küsib konkreetse sihtkoha kohta, toob get_destination_info meetod vastava info eelnevalt laetud kontekstisõnastikust.

Konteksti eel-laadimise abil saab reisikorraldaja rakendus kiiresti reageerida kasutajate päringutele, ilma et peaks reaalajas välisest allikast teavet otsima. See muudab rakenduse efektiivsemaks ja reageerimisvõimelisemaks.

Plaani algatamine eesmärgiga enne iteratsiooni

Plaani algatamine eesmärgiga tähendab selge eesmärgi või soovitud tulemuse määratlemist. Selle eesmärgi varajane määratlemine võimaldab mudelil kasutada seda juhisena kogu iteratiivse protsessi vältel. See aitab tagada, et iga iteratsioon viib soovitud tulemuse saavutamisele lähemale, muutes protsessi tõhusamaks ja sihipärasemaks.

Siin on näide, kuidas võiksite reisikorraldaja jaoks Pythoni keeles enne iteratsiooni algatada reisiplaani eesmärgiga:

Stsenaarium

Reisikorraldaja soovib planeerida kliendile kohandatud puhkuse. Eesmärgiks on luua reisiplaan, mis maksimeerib kliendi rahulolu vastavalt tema eelistustele ja eelarvele.

Sammud

Määratle kliendi eelistused ja eelarve.
Algata algne plaan nende eelistuste põhjal.
Tee iteratsioone plaani täpsustamiseks, optimeerides kliendi rahulolu.

Python kood

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

# Näidis kasutus
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)

Koodi selgitus

Algatamine (__init__ meetod): TravelAgent klass algatatakse potentsiaalsete sihtkohtade nimekirjaga, kus igaühel on omadused nagu nimi, hind ja tegevuse tüüp.
Plaani algatamine (bootstrap_plan meetod): See meetod loob algse reisiplaani kliendi eelistuste ja eelarve põhjal. See läbib sihtkohtade nimekirja ja lisab sihtkohad plaani, kui need vastavad kliendi eelistustele ja mahuvad eelarvesse.
Eelistuste sobitamine (match_preferences meetod): See meetod kontrollib, kas sihtkoht vastab kliendi eelistustele.
Plaani iteratsioon (iterate_plan meetod): See meetod täpsustab algset plaani, püüdes asendada iga sihtkoha parema sobivusega, võttes arvesse kliendi eelistusi ja eelarvepiiranguid.
Kulu arvutamine (calculate_cost meetod): See meetod arvutab praeguse plaani kogukulu, sealhulgas potentsiaalne uus sihtkoht.

Näidis kasutamine

Algne plaan: Reisikorraldaja loob algse plaani kliendi eelistuste põhjal vaatamisväärsuste nägemiseks eelarvega 2000 dollarit.
Täiendatud plaan: Reisikorraldaja teeb plaani iteratsioone, optimeerides kliendi eelistuste ja eelarve alusel.

Plaani alustades selge eesmärgiga (nt kliendi rahulolu maksimeerimine) ja iteratiivselt plaani täiustades saab reisikorraldaja luua kohandatud ja optimeeritud reisiplaani kliendile. See lähenemine tagab, et reisiplaan vastab algusest peale kliendi eelistustele ja eelarvele ning paraneb iga iteratsiooniga.

LLM-i ärakasutamine ümberjärjestamiseks ja hindamiseks

Suured keelemudelid (LLM-id) saavad aidata ümberjärjestamisel ja hindamisel, hinnates leitud dokumentide või genereeritud vastuste asjakohasust ja kvaliteeti. See toimib järgmiselt:

Päring: Esmane päring toob tagasi kandidaaddokumendid või vastused päringu alusel.

Ümberjärjestamine: LLM hindab kandidaate ning järjestab need olulisuse ja kvaliteedi alusel ümber. See tagab, et kõige asjakohasem ja kvaliteetsem info esitatakse esimesena.

Hindamine: LLM määrab igale kandidaadile skoori, mis peegeldab nende asjakohasust ja kvaliteeti. See aitab valida kasutajale parima vastuse või dokumendi.

Kasutades LLM-i ümberjärjestamiseks ja hindamiseks, saab süsteem pakkuda täpsemat ning kontekstitundlikumat teavet, parandades kasutajakogemust.

Siin on näide, kuidas reisikorraldaja võiks kasutada suurt keelemudelit (LLM) teha reisisihtkohtade ümberjärjestamist ja hindamist kasutaja eelistuste põhjal Pythonis:

Stsenaarium - Reis eelistuste põhjal

Reisikorraldaja soovib soovitada kliendile parimaid reisisihtkohti kasutaja eelistuste põhjal. LLM aitab sihtkohad ümberjärjestada ja hinnata, et tagada kõige asjakohasemate valikute esitamine.

Sammud:

Koguge kasutaja eelistused.
Tooge välja potentsiaalsete reisisihtkohtade nimekiri.
Kasutage LLM-i sihtkohtade ümberjärjestamiseks ja hindamiseks kasutaja eelistuste põhjal.

Siin on näide, kuidas saate eelmist näidet uuendada, kasutades Azure OpenAI teenuseid:

Nõuded

Teil peab olema Azure tellimus.
Looge Azure OpenAI ressurss ja hankige oma API võti.

Näidis Pythoni kood

import requests
import json

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

    def get_recommendations(self, preferences, api_key, endpoint):
        # Genereeri päring Azure OpenAI jaoks
        prompt = self.generate_prompt(preferences)
        
        # Määra päised ja päringu andmed
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # Kutsu Azure OpenAI API-d, et saada ümberjärjestatud ja hinnatud sihtkohad
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # Eemalda ja tagasta soovitused
        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

# Näidis kasutus
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)

Koodi selgitus - eelistuste broneerija

Algatamine: TravelAgent klass algatatakse potentsiaalsete reisisihtkohtade nimekirjaga, kus igaühel on omadused nagu nimi ja kirjeldus.
Soovituste hankimine (get_recommendations meetod): See meetod genereerib päringu Azure OpenAI teenusele vastavalt kasutaja eelistustele ning saadab HTTP POST päringu Azure OpenAI API-le, et saada ümberjärjestatud ja hinnatud sihtkohad.
Päringu genereerimine (generate_prompt meetod): See meetod koostab päringu Azure OpenAI teenusele, mis sisaldab kasutaja eelistusi ja sihtkohtade nimekirja. Päring juhib mudelit ümberjärjestama ja hindama sihtkohti vastavalt antud eelistustele.
API kõne: requests teek kasutatakse HTTP POST päringu tegemiseks Azure OpenAI API lõpp-punktile. Vastuses on ümberjärjestatud ja hinnatud sihtkohad.
Näidis kasutamine: Reisikorraldaja kogub kasutaja eelistused (nt huvi vaatamisväärsuste ja mitmekesise kultuuri vastu) ning kasutab Azure OpenAI teenust soovituste ümberjärjestamiseks ja hindamiseks.

Veenduge, et asendate your_azure_openai_api_key oma tegeliku Azure OpenAI API võtmega ja https://your-endpoint.com/... oma Azure OpenAI juurutuse tegeliku lõpp-punkti URL-iga.

Kasutades LLM-i ümberjärjestamiseks ja hindamiseks, saab reisikorraldaja pakkuda klientidele isikupärasemaid ja asjakohasemaid reisisoovitusi, parandades nende üldist kogemust.

RAG: päringutehnika vs tööriist

Retrieval-Augmented Generation (RAG) võib olla nii päringutehnika kui ka tööriist AI agentide arendamisel. Mõistmine, mis vahe on nende vahel, aitab teil RAG-i oma projektides tõhusamalt kasutada.

RAG päringutehnikana

Mis see on?

Päringutehnikana tähendab RAG spetsiifiliste päringute või päringu-promptide koostamist, et suunata asjakohase teabe otsimist suurest tekstikogumist või andmebaasist. Seda teavet kasutatakse seejärel vastuste või tegevuste genereerimiseks.

Kuidas see töötab:

Päringute koostamine: Loo ülesande või kasutaja sisendi põhjal hästi struktureeritud päringud või prompt’id.
Teabe otsimine: Kasuta päringuid, et otsida asjakohast teavet olemasolevast teadmistebaasist või andmekogumist.
Vastuse genereerimine: Ühenda leitud teave generatiivsete AI mudelitega, et toota põhjalik ja sidus vastus.

Näide reisikorraldajast:

Kasutaja sisend: “Ma tahan külastada Pariisi muuseume.”
Päring: “Leia Pariisi parimad muuseumid.”
Leitud teave: Andmed Louvre’ist, Musée d’Orsay’st jne.
Genereeritud vastus: “Siin on mõned Pariisi tipptasemel muuseumid: Louvre’i muuseum, Musée d’Orsay ja Centre Pompidou.”

RAG tööriistana

Mis see on?

Tööriistana on RAG integreeritud süsteem, mis automatiseerib otsimise ja genereerimise protsessi, muutes arendajatel keerukate AI funktsioonide rakendamise lihtsamaks ilma, et iga päringu jaoks käsitsi prompt’e koostada oleks vaja.

Kuidas see töötab:

Integreerimine: Sisesta RAG AI agendi arhitektuuri, võimaldades tal automaatselt hallata otsingu ja genereerimise ülesandeid.
Automatiseerimine: Tööriist juhib kogu protsessi, alates kasutaja sisendi vastuvõtmisest kuni lõpliku vastuse genereerimiseni, ilma et oleks vaja iga sammu jaoks spetsiaalseid prompt’e.
Tõhusus: Parandab agendi toimivust, sujuvamaks tehes otsingu ja genereerimise protsessi, võimaldades kiiremaid ja täpsemaid vastuseid.

Näide reisikorraldajast:

Kasutaja sisend: “Ma tahan külastada Pariisi muuseume.”
RAG tööriist: võtab automaatselt informatsiooni muuseumide kohta ja genereerib vastuse.
Genereeritud vastus: “Siin on mõned Pariisi tipptasemel muuseumid: Louvre’i muuseum, Musée d’Orsay ja Centre Pompidou.”

Võrdlus

Aspekt	Päringutehnika	Tööriist
Manuaalne vs Automaatne	Käsitsi koostatud prompt’id iga päringu jaoks.	Automatiseeritud protsess otsimiseks ja genereerimiseks.
Kontroll	Pakub rohkem kontrolli otsimise protsessi üle.	Sujuvam ja automatiseeritud otsing ja genereerimine.
Paindlikkus	Võimaldab kohandatud prompt’e vastavalt spetsiifilistele vajadustele.	Tõhusam suurte lahenduste puhul.
Keerukus	Nõuab prompt’ide koostamist ja häälestamist.	Kergem integreerida AI agendi arhitektuuri.

Praktilised näited

Päringutehnika näide:

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)

Tööriista näide:

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)

Asjakohasuse hindamine

Asjakohasuse hindamine on AI agendi toimivuse oluline aspekt. See tagab, et agendi poolt leitav ja genereeritav teave on sobiv, täpne ja kasulik kasutajale. Vaatame, kuidas asjakohasust AI agentides hinnata, sh praktilised näited ja tehnikad.

Põhimõisted asjakohasuse hindamisel

Kontekstitunnetus:
- Agent peab mõistma kasutaja päringu konteksti, et leida ja genereerida asjakohast teavet.
- Näide: Kui kasutaja küsib “Parimad restoranid Pariisis,” peab agent arvestama kasutaja eelistusi nagu köögitüüp ja eelarve.
Täpsus:
- Agent poolt antud teave peaks olema faktipõhine ja ajakohane.
- Näide: Soovitada hetkel avatud restorane heade arvustustega, mitte aegunud või suletud valikuid.
Kasutaja eesmärk:
- Agent peaks tuletama kasutaja eesmärgi päringu taga, et pakkuda kõige asjakohasemat teavet.
- Näide: Kui kasutaja otsib “eelarvesõbralikke hotelle,” peaks agent seada esikohale taskukohased valikud.
Tagasiside tsükkel:
- Kasutajate tagasiside kogumine ja analüüs aitavad agendil oma asjakohasuse hindamise protsessi täiustada.
- Näide: Varasemate soovituste hinnangute ja kommentaaride arvestamine tulevaste vastuste paremaks muutmiseks.

Praktilised tehnikad asjakohasuse hindamiseks

Asjakohasuse skoorimine:

Määrake igale leitud üksusele asjakohasuse skoor vastavalt sellele, kui hästi see vastab kasutaja päringule ja eelistustele.

Näide:

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

Filtreerimine ja järjestamine:

Eemaldage ebaolulised üksused ja järjestage ülejäänud nende asjakohasuse skoori alusel.

Näide:

def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # Tagasta 10 asjakohasemat eset

Looduskeele töötlemine (NLP):

Kasutage NLP meetodeid kasutaja päringu mõistmiseks ja asjakohase info otsimiseks.

Näide:

def process_query(query):
    # Kasutage NLP-d, et kasutaja päringust olulist teavet välja võtta
    processed_query = nlp(query)
    return processed_query

Kasutajate tagasiside integreerimine:

Koguge kasutajate tagasisidet antud soovituste kohta ja kasutage seda tulevaste asjakohasushindamiste kohandamiseks.

Näide:

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

Näide: asjakohasuse hindamine reisikorraldaja juures

Siin on praktiline näide sellest, kuidas reisikorraldaja saab hinnata reisis soovituste asjakohasust:

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]  # Tagasta 10 kõige asjakohasemat elementi

    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

# Näidis kasutusjuhtum
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)

Otsing eesmärgiga

Otsing eesmärgiga tähendab kasutaja päringu taga oleva sügavama eesmärgi või kavatsuse mõistmist ja tõlgendamist, et leida ja genereerida kõige asjakohasemat ja kasulikumat teavet. See lähenemine ületab lihtsalt märksõnade sobitamise ja keskendub kasutaja tegelike vajaduste ja konteksti mõistmisele.

Põhimõisted otsingus eesmärgiga

Kasutaja eesmärgi mõistmine:
- Kasutaja kavatsust saab jagada kolmeks põhiliigiks: informatiivne, navigatsiooniline ja tehinguline.
  - Informatiivne eesmärk: Kasutaja otsib teavet mingi teema kohta (nt “Millised on Pariisi parimad muuseumid?”).
  - Navigatsiooniline eesmärk: Kasutaja soovib jõuda konkreetsele veebilehele või saidile (nt “Louvre’i muuseumi ametlik veebileht”).
  - Tehinguline eesmärk: Kasutaja soovib teha tehingut, näiteks lennupileti broneerimist või ostu (nt “Broneeri lend Pariisi”).
Kontekstitunnetus:
- Kasutaja päringu konteksti analüüs aitab täpselt kindlaks teha tema kavatsust. See hõlmab varasemate interaktsioonide, kasutaja eelistuste ja praeguse päringu spetsiifiliste üksikasjade kaalumist.
Looduskeele töötlemine (NLP):
- NLP meetodid aitavad mõista ja tõlgendada kasutaja poolt antud loomuliku keele päringuid. See hõlmab ülesandeid nagu entiteedi tuvastamine, sentimentide analüüs ja päringu parsimine.
Isikupärastamine:
- Otsingutulemuste isikupärastamine kasutaja ajaloo, eelistuste ja tagasiside põhjal parandab leitud info asjakohasust.

Praktiline näide: otsing eesmärgiga reisikorraldaja juures

Vaatame näitena reisikorraldajat, et näha, kuidas saab otsingut eesmärgiga ellu viia.

Kasutaja eelistuste kogumine

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

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

Kasutaja eesmärgi mõistmine

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"

Kontekstitunnetus

def analyze_context(query, user_history):
    # Ühenda praegune päring kasutaja ajaloo kontekstist arusaamiseks
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

Otsi ja personaalsem tee tulemusi

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):
    # Näidisotsingulogiika informatiivse sihtotstarbe jaoks
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # Näidisotsingulogiika navigeeriva sihtotstarbe jaoks
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # Näidisotsingulogiika tehingulise sihtotstarbe jaoks
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # Näidis isikupärastamise loogika
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # Tagasta 10 parimat isikupärastatud tulemust

Näidis kasutamine

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. Koodi genereerimine tööriistana

Koodi genereerivad agendid kasutavad tehisintellekti mudeleid koodi kirjutamiseks ja täitmiseks, lahendades keerukaid probleeme ja automatiseerides ülesandeid.

Koodi genereerivad agendid

Koodi genereerivad agendid kasutavad generatiivset AI mudelit koodi kirjutamiseks ja käivitamiseks. Need agendid suudavad lahendada keerukaid probleeme, automatiseerida ülesandeid ja pakkuda väärtuslikke teadmisi, genereerides ja käivitades koodi erinevates programmeerimiskeeltes.

Praktilised rakendused

Automatiseeritud koodi genereerimine: Genereeri koodilõike konkreetsete ülesannete jaoks, nagu andmeanalüüs, veebipüük või masinõpe.
SQL RAG-ina: Kasuta SQL-päringuid andmete pärimiseks ja manipuleerimiseks andmebaasidest.
Probleemide lahendamine: Loo ja käivita koodi spetsiifiliste probleemide lahendamiseks, näiteks algoritmide optimeerimiseks või andmete analüüsimiseks.

Näide: Koodi genereeriv agent andmeanalüüsiks

Kujutle, et kavandad koodi genereerivat agenti. Siin on, kuidas see võiks toimida:

Ülesanne: Analüüsida andmestikku trendide ja mustrite tuvastamiseks.
Sammud:
- Laadi andmestik andmeanalüüsi tööriista.
- Genereeri SQL-päringud andmete filtreerimiseks ja kogumiseks.
- Käivita päringud ja võta tulemused vastu.
- Kasuta tulemusi visualiseerimiste ja teadmiste loomiseks.
Vajalikud ressursid: Juurdepääs andmestikule, andmeanalüüsi tööriistad ja SQL võimalused.
Kogemus: Kasuta varasemaid analüüsi tulemusi tulevaste analüüside täpsuse ja asjakohasuse parandamiseks.

Näide: Koodi genereeriv agent reisibüroole

Selles näites kavandame koodi genereeriva agendi, nimega Reisibüroo, mis aitab kasutajatel reisi planeerida, genereerides ja käivitades koodi. See agent suudab toime tulla ülesannetega nagu reisivõimaluste otsimine, tulemuste filtreerimine ja reisi kavandamine, kasutades generatiivset AI-d.

Koodi genereeriva agendi ülevaade

Kasutaja eelistuste kogumine: Kogub kasutaja sisendi, nagu sihtkoht, reisi kuupäevad, eelarve ja huvid.
Koodi genereerimine andmete hankimiseks: Genereerib koodilõigud lendude, hotellide ja vaatamisväärsuste andmete saamiseks.
Genereeritud koodi käivitamine: Käivitab genereeritud koodi, et hankida reaalajas teavet.
Reisi kavandamine: Koondab hangitud andmed isikupärastatud reisi plaaniks.
Tagasiside põhjal kohandamine: Võtab kasutaja tagasisidet ja vajadusel genereerib koodi uuesti, et tulemusi täpsustada.

Samm-sammuline rakendus

Kasutaja eelistuste kogumine

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

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

Koodi genereerimine andmete hankimiseks

def generate_code_to_fetch_data(preferences):
    # Näide: genereeri kood, et otsida lende kasutaja eelistuste põhjal
    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):
    # Näide: genereeri kood, et otsida hotelle
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

Genereeritud koodi käivitamine

def execute_code(code):
    # Käivita genereeritud kood kasutades 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)

Reisi kavandamine

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)

Tagasiside põhjal kohandamine

def adjust_based_on_feedback(feedback, preferences):
    # Kohanda eelistusi kasutaja tagasiside põhjal
    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)
   
# Genereeri uuesti ja täida kood uuendatud eelistustega
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)

Keskkonna teadlikkuse ja järeldamise kasutamine

Tabeli skeemi põhjal saab päringute genereerimise protsessi tõesti täiustada, kasutades keskkonna teadlikkust ja järeldamist.

Siin on näide, kuidas seda saab teha:

Skeemi mõistmine: Süsteem mõistab tabeli skeemi ja kasutab seda teavet päringute genereerimise juurde mahamääramiseks.
Tagasiside põhjal kohandamine: Süsteem kohandab kasutaja eelistusi tagasiside järgi ja teeb järelduseid, milliseid skeemi välju on vaja värskendada.
Päringute genereerimine ja täitmine: Süsteem genereerib ja täidab päringud, et hankida uuendatud lennu- ja hotelliteavet uute eelistuste alusel.

Siin on uuendatud Python koodi näide, mis hõlmab neid kontseptsioone:

def adjust_based_on_feedback(feedback, preferences, schema):
    # Kohanda eelistusi kasutajate tagasiside põhjal
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Loogika skeemi põhjal teiste seotud eelistuste kohandamiseks
    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):
    # Kohandatud loogika eelistuste muutmiseks skeemi ja tagasiside põhjal
    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):
    # Genereeri kood lennuandmete hankimiseks värskendatud eelistuste alusel
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Genereeri kood hotelliandmete hankimiseks värskendatud eelistuste alusel
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # Simuleeri koodi täitmist ja tagasta testandmed
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Genereeri marsruut lendude, hotellide ja vaatamisväärsuste põhjal
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

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

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

# Genereeri uuesti ja täida kood värskendatud eelistustega
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)

Selgitus – broneerimine tagasiside põhjal

Skeemi teadlikkus: schema sõnastik määratleb, kuidas eelistusi tagasiside põhjal kohandada. See sisaldab välju nagu favorites ja avoid vastavate kohandustega.
Eelistuste kohandamine (adjust_based_on_feedback meetod): See meetod kohandab eelistusi kasutaja tagasiside ja skeemi põhjal.
Keskkonnapõhised kohandused (adjust_based_on_environment meetod): See meetod kohandab muudatusi skeemi ja tagasiside põhjal.
Päringute genereerimine ja täitmine: Süsteem genereerib koodi, et hankida uuendatud lendude ja hotellide andmed kohandatud eelistuste põhjal ning simuleerib nendega päringute täitmist.
Reisi kavandamine: Süsteem loob uuendatud reisi kava uute lennu-, hotelli- ja vaatamisväärsuste andmete põhjal.

Keskkonna teadlikuks muutmise ja skeemi põhise järeldamise abil suudab süsteem genereerida täpsemaid ja asjakohasemaid päringuid, pakkudes paremaid reisisoovitusi ja personaalset kasutajakogemust.

SQL kasutamine otsingupõhise generatsiooni (RAG) tehnikana

SQL (struktureeritud päringukeel) on võimas tööriist andmebaasidega suhtlemiseks. Kui kasutada seda osa otsingupõhisest generatsiooni (RAG) lähenemisest, saab SQL-andmebaasidest olulisi andmeid pärida, et tehisintellekti agentide vastuseid või tegevusi parandada ja genereerida. Vaatleme, kuidas SQL-i saab RAG tehnikana reisibüroo kontekstis kasutada.

Peamised mõisted

Andmebaasi suhtlus:
- SQL-i kasutatakse päringute tegemiseks, asjakohase info hankimiseks ja andmete manipuleerimiseks.
- Näide: lennuandmete, hotelliteabe ja vaatamisväärsuste hankimine reiside andmebaasist.
Integratsioon RAG-iga:
- SQL-päringud genereeritakse kasutaja sisendi ja eelistuste alusel.
- Hankitud andmeid kasutatakse seejärel personaalsemate soovituste ja tegevuste loomiseks.
Dünaamiline päringute genereerimine:
- AI agent genereerib dünaamilisi SQL päringuid konteksti ja kasutaja vajaduste põhjal.
- Näide: SQL-päringute kohandamine tulemuste filtreerimiseks eelarve, kuupäevade ja huvide järgi.

Rakendused

Automaatne koodi genereerimine: genereeri koodilõike spetsiifilisteks ülesanneteks.
SQL RAG-ina: kasuta SQL-päringuid andmete manipuleerimiseks.
Probleemide lahendamine: loo ja käivita koodi probleemide lahendamiseks.

Näide: Andmeanalüüsagent:

Ülesanne: analüüsida andmestikku trendide leidmiseks.
Sammud:
- Laadi andmestik.
- Genereeri SQL-päringud andmete filtreerimiseks.
- Käivita päringud ja võta tulemused vastu.
- Genereeri visualiseeringuid ja teadmisi.
Ressursid: juurdepääs andmestikule, SQL võimalused.
Kogemus: kasuta varasemaid tulemusi tulevaste analüüside parandamiseks.

Praktiline näide: SQL kasutamine reisibüroos

Kasutaja eelistuste kogumine

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

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

SQL päringute genereerimine

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

SQL päringute käivitamine

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

Soovituste genereerimine

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)

Näidis SQL päringud

Lennu päring

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

Hotelli päring

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

Vaatamisväärsuste päring

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

SQL-i kasutamine otsingupõhise generatsiooni (RAG) osana võimaldab AI agentidel nagu Reisibüroo dünaamiliselt hankida ja kasutada asjakohast teavet täpsete ja isikupärastatud soovituste andmiseks.

Metakognitsiooni näide

Metakognitsiooni rakenduse demonstreerimiseks loome lihtsa agendi, kes reflekteerib oma otsustusprotsessile probleemi lahendamise ajal. Selle näite jaoks loome süsteemi, kus agent üritab optimeerida hotelli valikut, kuid seejärel hindab enda põhjendust ja kohandab strateegiat vigade või ebapiisavate valikute korral.

Simuleerime seda lihtsa näitega, kus agent valib hotellid hinna ja kvaliteedi kombinatsiooni põhjal, kuid see “reflekteerib” oma otsuseid ja teeb vastavad kohandused.

Kuidas see metakognitsiooni illustreerib:

Esialgne otsus: agent valib odavaima hotelli, ilma kvaliteedimõju mõistmata.
Refleksioon ja hindamine: pärast esialgset valikut kontrollib agent kasutaja tagasiside abil, kas hotell oli “halb” valik. Kui selgub, et hotelli kvaliteet oli liiga madal, mõtiskleb agent oma põhjenduse üle.
Strateegia kohandamine: agent kohandab strateegiat refleksiooni põhjal, vahetades “odavaima” valiku “kõrgeima kvaliteedi” vastu, parandades seeläbi tulevasi otsuseid.

Siin on näide:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # Salvestab eelnevalt valitud hotellid
        self.corrected_choices = []  # Salvestab parandatud valikud
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # Olemasolevad strateegiad

    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]
        # Oletame, et meil on kasutajate tagasiside, mis ütleb, kas viimane valik oli hea või mitte
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # Kohanda strateegiat, kui eelmine valik oli rahuldamatu
            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"

# Simuleeri hotellide nimekirja (hind ja kvaliteet)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# Loo agent
agent = HotelRecommendationAgent()

# Samm 1: Agent soovitab hotelli, kasutades "odavaima" strateegiat
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# Samm 2: Agent mõtiskleb valiku üle ja kohandab strateegiat vajadusel
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# Samm 3: Agent soovitab uuesti, seekord kasutades kohandatud strateegiat
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

Agendi metakognitsioonivõimed

Peamine on agendi võime:

Hinnata oma varasemaid valikuid ja otsustusprotsessi.
Kohandada strateegiat selle refleksiooni põhjal ehk metakognitsioon käigus.

See on lihtne metakognitsiooni vorm, kus süsteem suudab kohandada oma järeldusprotsessi sisemise tagasiside põhjal.

Kokkuvõte

Metakognitsioon on võimas tööriist, mis võib oluliselt parandada AI agentide võimeid. Metakognitiivsete protsesside kaasamine võimaldab teil kujundada agende, kes on targemad, kohanemisvõimelisemad ja tõhusamad. Kasutage täiendavaid ressursse, et veelgi süvitsi mõista metakognitsiooni põnevat maailma AI agentides.

Kas teil on metakognitsiooni disainimustriga rohkem küsimusi?

Liituge Microsoft Foundry Discordiga, et kohtuda teiste õppijatega, osaleda tööaegadel ja saada AI agentide küsimustele vastused.

Eelmine õppetund

Mitme agendi disainimuster

Järgmine õppetund

AI agendid tootmises

Lahtiütlus: See dokument on tõlgitud kasutades AI tõlketeenust Co-op Translator. Kuigi me püüdleme täpsuse poole, palun pange tähele, et automatiseeritud tõlgetes võib esineda vigu või ebatäpsusi. Originaaldokument selle emakeeles tuleks pidada autoriteetseks allikaks. Olulise teabe puhul soovitatakse kasutada professionaalset inimtõlget. Me ei vastuta selle tõlkega seotud eksimustest või valesti mõistmistest.

This site is open source. Improve this page.