ai-agents-for-beginners

(Bofya picha hapo juu kutazama video ya somo hili)

Metakujitambua kwa Mawakala wa AI

Utangulizi

Karibu kwenye somo la metakujitambua kwa mawakala wa AI! Sura hii imeundwa kwa wanaoanza ambao wanavutiwa na jinsi mawakala wa AI wanavyoweza kufikiria kuhusu mchakato wao wa kufikiri. Mwishoni mwa somo hili, utaelewa dhana muhimu na utakuwa na mifano ya vitendo ya kutumia metakujitambua katika muundo wa mawakala wa AI.

Malengo ya Kujifunza

Baada ya kukamilisha somo hili, utaweza:

Kuelewa athari za mizunguko ya kufikiri katika ufafanuzi wa mawakala.
Kutumia mbinu za kupanga na kutathmini kusaidia mawakala wanaojirekebisha.
Kuunda mawakala wako wenye uwezo wa kudhibiti msimbo ili kutimiza majukumu.

Utangulizi wa Metakujitambua

Metakujitambua inahusu michakato ya juu ya kiakili inayohusisha kufikiria kuhusu fikra za mtu mwenyewe. Kwa mawakala wa AI, hii inamaanisha kuwa na uwezo wa kutathmini na kurekebisha vitendo vyao kulingana na kujitambua na uzoefu wa zamani. Metakujitambua, au “kufikiria kuhusu kufikiri,” ni dhana muhimu katika maendeleo ya mifumo ya AI yenye uwezo wa kujitambua. Inahusisha mifumo ya AI kuwa na ufahamu wa michakato yao ya ndani na kuwa na uwezo wa kufuatilia, kudhibiti, na kubadilisha tabia yao ipasavyo. Kama tunavyofanya tunaposoma hali au kuangalia tatizo. Kujitambua huku kunaweza kusaidia mifumo ya AI kufanya maamuzi bora, kutambua makosa, na kuboresha utendaji wao kwa muda—tena ikihusiana na mtihani wa Turing na mjadala kuhusu kama AI itachukua nafasi.

Katika muktadha wa mifumo ya AI yenye uwezo wa kujitambua, metakujitambua inaweza kusaidia kushughulikia changamoto kadhaa, kama vile:

Uwazi: Kuhakikisha kuwa mifumo ya AI inaweza kuelezea sababu na maamuzi yao.
Kufikiri: Kuboresha uwezo wa mifumo ya AI kuchanganua taarifa na kufanya maamuzi sahihi.
Urekebishaji: Kuruhusu mifumo ya AI kubadilika kwa mazingira mapya na hali zinazobadilika.
Utambuzi: Kuboresha usahihi wa mifumo ya AI katika kutambua na kutafsiri data kutoka kwa mazingira yao.

Metakujitambua ni Nini?

Metakujitambua, au “kufikiria kuhusu kufikiri,” ni mchakato wa juu wa kiakili unaohusisha kujitambua na kujidhibiti kwa michakato ya kiakili ya mtu. Katika ulimwengu wa AI, metakujitambua huwapa mawakala uwezo wa kutathmini na kubadilisha mikakati na vitendo vyao, na hivyo kuboresha uwezo wa kutatua matatizo na kufanya maamuzi. Kwa kuelewa metakujitambua, unaweza kubuni mawakala wa AI ambao si tu wenye akili zaidi bali pia wanaoweza kubadilika na kuwa na ufanisi zaidi. Katika metakujitambua ya kweli, ungeona AI ikifikiri waziwazi kuhusu kufikiri kwake.

Mfano: “Nilipa kipaumbele ndege za bei nafuu kwa sababu… huenda nikakosa ndege za moja kwa moja, kwa hivyo acha niangalie tena.” Kufuatilia jinsi au kwa nini ilichagua njia fulani.

Kutambua kuwa ilifanya makosa kwa sababu ilitegemea sana mapendeleo ya mtumiaji kutoka mara ya mwisho, kwa hivyo inarekebisha mkakati wake wa kufanya maamuzi, si tu mapendekezo ya mwisho.
Kuchunguza mifumo kama, “Kila ninaposikia mtumiaji akitaja ‘imejaa sana,’ sipaswi tu kuondoa vivutio fulani bali pia kutafakari kuwa mbinu yangu ya kuchagua ‘vivutio vya juu’ ni mbovu ikiwa kila mara ninapanga kwa umaarufu.”

Umuhimu wa Metakujitambua kwa Mawakala wa AI

Metakujitambua ina jukumu muhimu katika muundo wa mawakala wa AI kwa sababu kadhaa:

Umuhimu wa Metakujitambua

Kujitafakari: Mawakala wanaweza kutathmini utendaji wao na kutambua maeneo yanayohitaji kuboreshwa.
Urekebishaji: Mawakala wanaweza kubadilisha mikakati yao kulingana na uzoefu wa zamani na mazingira yanayobadilika.
Urekebishaji wa Makosa: Mawakala wanaweza kugundua na kurekebisha makosa kwa kujitegemea, na hivyo kusababisha matokeo sahihi zaidi.
Usimamizi wa Rasilimali: Mawakala wanaweza kuboresha matumizi ya rasilimali, kama vile muda na nguvu ya kompyuta, kwa kupanga na kutathmini vitendo vyao.

Vipengele vya Wakala wa AI

Kabla ya kuingia katika michakato ya metakujitambua, ni muhimu kuelewa vipengele vya msingi vya wakala wa AI. Wakala wa AI kwa kawaida huwa na:

Persona: Utu na sifa za wakala, ambazo hufafanua jinsi unavyoshirikiana na watumiaji.
Zana: Uwezo na kazi ambazo wakala anaweza kutekeleza.
Ujuzi: Maarifa na utaalamu ambao wakala anamiliki.

Vipengele hivi hufanya kazi pamoja kuunda “kitengo cha utaalamu” ambacho kinaweza kutekeleza majukumu maalum.

Mfano: Fikiria wakala wa kusafiri, huduma za wakala ambazo si tu zinapanga likizo yako bali pia zinarekebisha njia yake kulingana na data ya wakati halisi na uzoefu wa safari za wateja wa zamani.

Mfano: Metakujitambua katika Huduma ya Wakala wa Kusafiri

Fikiria unaunda huduma ya wakala wa kusafiri inayotumia AI. Wakala huyu, “Wakala wa Kusafiri,” husaidia watumiaji kupanga likizo zao. Ili kuingiza metakujitambua, Wakala wa Kusafiri anahitaji kutathmini na kurekebisha vitendo vyake kulingana na kujitambua na uzoefu wa zamani. Hivi ndivyo metakujitambua inaweza kuchukua jukumu:

Kazi ya Sasa

Kazi ya sasa ni kumsaidia mtumiaji kupanga safari ya kwenda Paris.

Hatua za Kukamilisha Kazi

Kukusanya Mapendeleo ya Mtumiaji: Uliza mtumiaji kuhusu tarehe za kusafiri, bajeti, maslahi (mfano: makumbusho, vyakula, ununuzi), na mahitaji maalum.
Kupata Taarifa: Tafuta chaguo za ndege, malazi, vivutio, na migahawa inayolingana na mapendeleo ya mtumiaji.
Kutoa Mapendekezo: Toa ratiba ya kibinafsi yenye maelezo ya ndege, uhifadhi wa hoteli, na shughuli zilizopendekezwa.
Kurekebisha Kulingana na Maoni: Uliza mtumiaji maoni kuhusu mapendekezo na fanya marekebisho yanayohitajika.

Rasilimali Zinazohitajika

Ufikiaji wa hifadhidata za uhifadhi wa ndege na hoteli.
Taarifa kuhusu vivutio na migahawa ya Paris.
Data ya maoni ya mtumiaji kutoka kwa mwingiliano wa awali.

Uzoefu na Kujitafakari

Wakala wa Kusafiri hutumia metakujitambua kutathmini utendaji wake na kujifunza kutoka kwa uzoefu wa zamani. Kwa mfano:

Kuchambua Maoni ya Mtumiaji: Wakala wa Kusafiri hupitia maoni ya mtumiaji ili kubaini mapendekezo yaliyopokelewa vizuri na yale ambayo hayakupokelewa. Inarekebisha mapendekezo yake ya baadaye ipasavyo.
Urekebishaji: Ikiwa mtumiaji amewahi kutaja kutopenda maeneo yenye watu wengi, Wakala wa Kusafiri ataepuka kupendekeza maeneo maarufu wakati wa saa za kilele katika siku zijazo.
Urekebishaji wa Makosa: Ikiwa Wakala wa Kusafiri alifanya kosa katika uhifadhi wa zamani, kama kupendekeza hoteli iliyokuwa imejaa, inajifunza kuangalia upatikanaji kwa makini zaidi kabla ya kutoa mapendekezo.

Mfano wa Vitendo kwa Mwandishi wa Programu

Hapa kuna mfano rahisi wa jinsi msimbo wa Wakala wa Kusafiri unaweza kuonekana wakati wa kuingiza metakujitambua:

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

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

    def retrieve_information(self):
        # Search for flights, hotels, and attractions based on preferences
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        # Analyze feedback and adjust future recommendations
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Example usage
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

Kwa Nini Metakujitambua Ni Muhimu

Kujitafakari: Mawakala wanaweza kuchambua utendaji wao na kutambua maeneo yanayohitaji kuboreshwa.
Urekebishaji: Mawakala wanaweza kubadilisha mikakati kulingana na maoni na hali zinazobadilika.
Urekebishaji wa Makosa: Mawakala wanaweza kugundua na kurekebisha makosa kwa kujitegemea.
Usimamizi wa Rasilimali: Mawakala wanaweza kuboresha matumizi ya rasilimali, kama vile muda na nguvu ya kompyuta.

Kwa kuingiza metakujitambua, Wakala wa Kusafiri anaweza kutoa mapendekezo ya kusafiri yaliyo sahihi zaidi na ya kibinafsi, na hivyo kuboresha uzoefu wa mtumiaji kwa ujumla.

2. Upangaji kwa Mawakala

Upangaji ni sehemu muhimu ya tabia ya wakala wa AI. Inahusisha kuainisha hatua zinazohitajika kufanikisha lengo, kwa kuzingatia hali ya sasa, rasilimali, na vikwazo vinavyowezekana.

Vipengele vya Upangaji

Kazi ya Sasa: Fafanua kazi kwa uwazi.
Hatua za Kukamilisha Kazi: Gawanya kazi katika hatua zinazoweza kudhibitiwa.
Rasilimali Zinazohitajika: Tambua rasilimali zinazohitajika.
Uzoefu: Tumia uzoefu wa zamani kuarifu upangaji.

Mfano: Hizi ni hatua ambazo Wakala wa Kusafiri anahitaji kuchukua ili kumsaidia mtumiaji kupanga safari yao kwa ufanisi:

Hatua za Wakala wa Kusafiri

Kukusanya Mapendeleo ya Mtumiaji
- Uliza mtumiaji maelezo kuhusu tarehe za kusafiri, bajeti, maslahi, na mahitaji maalum.
- Mfano: “Unapanga kusafiri lini?” “Bajeti yako ni kiasi gani?” “Unapenda shughuli gani wakati wa likizo?”
Kupata Taarifa
- Tafuta chaguo za kusafiri zinazofaa kulingana na mapendeleo ya mtumiaji.
- Ndege: Tafuta ndege zinazopatikana ndani ya bajeti ya mtumiaji na tarehe za kusafiri zinazopendekezwa.
- Malazi: Tafuta hoteli au mali za kukodisha zinazolingana na mapendeleo ya mtumiaji kuhusu eneo, bei, na huduma.
- Vivutio na Migahawa: Tambua vivutio maarufu, shughuli, na chaguo za kula zinazolingana na maslahi ya mtumiaji.
Kutoa Mapendekezo
- Kusanya taarifa zilizopatikana katika ratiba ya kibinafsi.
- Toa maelezo kama chaguo za ndege, uhifadhi wa hoteli, na shughuli zilizopendekezwa, ukihakikisha mapendekezo yamepangwa kulingana na mapendeleo ya mtumiaji.
Kuwasilisha Ratiba kwa Mtumiaji
- Shiriki ratiba iliyopendekezwa na mtumiaji kwa ukaguzi wao.
- Mfano: “Hii hapa ratiba iliyopendekezwa kwa safari yako ya kwenda Paris. Inajumuisha maelezo ya ndege, uhifadhi wa hoteli, na orodha ya shughuli na migahawa iliyopendekezwa. Niambie maoni yako!”
Kukusanya Maoni
- Uliza mtumiaji maoni kuhusu ratiba iliyopendekezwa.
- Mfano: “Je, unapenda chaguo za ndege?” “Je, hoteli inafaa mahitaji yako?” “Kuna shughuli zozote ungependa kuongeza au kuondoa?”
Kurekebisha Kulingana na Maoni
- Rekebisha ratiba kulingana na maoni ya mtumiaji.
- Fanya mabadiliko yanayohitajika kwa mapendekezo ya ndege, malazi, na shughuli ili yaendane vyema na mapendeleo ya mtumiaji.
Uthibitisho wa Mwisho
- Wasilisha ratiba iliyorekebishwa kwa mtumiaji kwa uthibitisho wa mwisho.
- Mfano: “Nimefanya marekebisho kulingana na maoni yako. Hii hapa ratiba iliyorekebishwa. Je, kila kitu kinaonekana sawa kwako?”
Uhifadhi na Uthibitisho wa Uhifadhi
- Mara mtumiaji anapokubali ratiba, endelea na uhifadhi wa ndege, malazi, na shughuli zilizopangwa.
- Tuma maelezo ya uthibitisho kwa mtumiaji.
Kutoa Msaada wa Kuendelea
- Kuwa tayari kusaidia mtumiaji na mabadiliko yoyote au maombi ya ziada kabla na wakati wa safari yao.
- Mfano: “Ikiwa unahitaji msaada wowote zaidi wakati wa safari yako, usisite kunijulisha wakati wowote!”

Mfano wa Mwingiliano

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

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

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Example usage within a booing request
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

3. Mfumo wa Marekebisho wa RAG

Kwanza, hebu tuanze kwa kuelewa tofauti kati ya Zana ya RAG na Upakiaji wa Muktadha wa Kuzuia Mapema.

RAG vs Upakiaji wa Muktadha

Utoaji wa Taarifa Ulioimarishwa na Urejeshaji (RAG)

RAG huunganisha mfumo wa urejeshaji na mfano wa kizazi. Wakati swali linapoulizwa, mfumo wa urejeshaji hupata hati au data husika kutoka kwa chanzo cha nje, na taarifa hii iliyorejeshwa hutumika kuimarisha pembejeo kwa mfano wa kizazi. Hii husaidia mfano kutoa majibu sahihi zaidi na yanayofaa kwa muktadha.

Katika mfumo wa RAG, wakala hurejesha taarifa husika kutoka kwa hifadhidata ya maarifa na kuitumia kutoa majibu au vitendo vinavyofaa.

Njia ya Marekebisho ya RAG

Njia ya Marekebisho ya RAG inalenga kutumia mbinu za RAG kurekebisha makosa na kuboresha usahihi wa mawakala wa AI. Hii inahusisha:

Mbinu ya Kutoa Maoni: Kutumia maoni maalum kuongoza wakala katika kurejesha taarifa husika.
Zana: Kutekeleza algoriti na mifumo inayowezesha wakala kutathmini umuhimu wa taarifa iliyorejeshwa na kutoa majibu sahihi.
Tathmini: Kuendelea kutathmini utendaji wa wakala na kufanya marekebisho ili kuboresha usahihi na ufanisi wake.

Mfano: Marekebisho ya RAG katika Wakala wa Utafutaji

Fikiria wakala wa utafutaji anayerejesha taarifa kutoka mtandao ili kujibu maswali ya mtumiaji. Njia ya Marekebisho ya RAG inaweza kuhusisha:

Mbinu ya Kutoa Maoni: Kuunda maswali ya utafutaji kulingana na pembejeo ya mtumiaji.
Zana: Kutumia usindikaji wa lugha asilia na algoriti za kujifunza mashine kupanga na kuchuja matokeo ya utafutaji.
Tathmini: Kuchambua maoni ya mtumiaji ili kutambua na kurekebisha makosa katika taarifa iliyorejeshwa.

Marekebisho ya RAG katika Wakala wa Kusafiri

Marekebisho ya RAG (Utoaji wa Taarifa Ulioimarishwa na Urejeshaji) huongeza uwezo wa AI wa kurejesha na kutoa taarifa huku ikirekebisha makosa yoyote. Hebu tuone jinsi Wakala wa Kusafiri anaweza kutumia njia ya Marekebisho ya RAG kutoa mapendekezo ya kusafiri yaliyo sahihi zaidi na yanayofaa.

Hii inahusisha:

Mbinu ya Kutoa Maoni: Kutumia maoni maalum kuongoza wakala katika kurejesha taarifa husika.
Zana: Kutekeleza algoriti na mifumo inayowezesha wakala kutathmini umuhimu wa taarifa iliyorejeshwa na kutoa majibu sahihi.
Tathmini: Kuendelea kutathmini utendaji wa wakala na kufanya marekebisho ili kuboresha usahihi na ufanisi wake.

Hatua za Kutekeleza Marekebisho ya RAG katika Wakala wa Kusafiri

Mwingiliano wa Awali na Mtumiaji
- Wakala wa Kusafiri hukusanya mapendeleo ya awali kutoka kwa mtumiaji, kama vile marudio, tarehe za kusafiri, bajeti, na masl ```python 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

Example usage

travel_agent = Travel_Agent() preferences = { “destination”: “Paris”, “dates”: “2025-04-01 to 2025-04-10”, “budget”: “moderate”, “interests”: [“museums”, “cuisine”] } travel_agent.gather_preferences(preferences) itinerary = travel_agent.generate_recommendations() print(“Suggested Itinerary:”, itinerary) feedback = {“liked”: [“Louvre Museum”], “disliked”: [“Eiffel Tower (too crowded)”]} new_itinerary = travel_agent.adjust_based_on_feedback(feedback) print(“Updated Itinerary:”, new_itinerary)

### Upakiaji wa Muktadha wa Awali

Upakiaji wa Muktadha wa Awali unahusisha kupakia muktadha au taarifa muhimu kwenye modeli kabla ya kushughulikia swali. Hii inamaanisha modeli inakuwa na ufikiaji wa taarifa hizi tangu mwanzo, jambo ambalo linaweza kusaidia kutoa majibu yenye taarifa zaidi bila hitaji la kupata data ya ziada wakati wa mchakato.

Hapa kuna mfano rahisi wa jinsi upakiaji wa muktadha wa awali unaweza kuonekana kwa programu ya wakala wa kusafiri katika Python:

```python
class TravelAgent:
    def __init__(self):
        # Pre-load popular destinations and their information
        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):
        # Fetch destination information from pre-loaded context
        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}."

# Example usage
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

Maelezo

Uanzishaji (Njia ya __init__): Darasa la TravelAgent linapakia kamusi inayojumuisha taarifa kuhusu maeneo maarufu kama Paris, Tokyo, New York, na Sydney. Kamusi hii inajumuisha maelezo kama nchi, sarafu, lugha, na vivutio vikuu kwa kila eneo.
Kupata Taarifa (Njia ya get_destination_info): Wakati mtumiaji anauliza kuhusu eneo fulani, njia ya get_destination_info inachukua taarifa husika kutoka kwenye kamusi ya muktadha iliyopakiwa awali.

Kwa kupakia muktadha mapema, programu ya wakala wa kusafiri inaweza kujibu maswali ya watumiaji haraka bila hitaji la kupata taarifa hizi kutoka chanzo cha nje kwa wakati halisi. Hii inafanya programu kuwa bora zaidi na yenye mwitikio wa haraka.

Kuanzisha Mpango na Lengo Kabla ya Kurudia

Kuanzisha mpango na lengo kunahusisha kuanza na malengo au matokeo wazi yaliyokusudiwa. Kwa kufafanua lengo hili mapema, modeli inaweza kulitumia kama mwongozo katika mchakato wa kurudia. Hii husaidia kuhakikisha kila hatua inakaribia kufanikisha matokeo yaliyokusudiwa, na kufanya mchakato kuwa bora na wenye mwelekeo.

Hapa kuna mfano wa jinsi unavyoweza kuanzisha mpango wa kusafiri na lengo kabla ya kurudia kwa wakala wa kusafiri katika Python:

Hali

Wakala wa kusafiri anataka kupanga likizo maalum kwa mteja. Lengo ni kuunda ratiba ya safari inayoongeza kuridhika kwa mteja kulingana na mapendeleo yao na bajeti.

Hatua

Fafanua mapendeleo ya mteja na bajeti.
Anzisha mpango wa awali kulingana na mapendeleo haya.
Rudia ili kuboresha mpango, ukizingatia kuridhika kwa mteja.

Msimbo wa Python

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

    def bootstrap_plan(self, preferences, budget):
        plan = []
        total_cost = 0

        for destination in self.destinations:
            if total_cost + destination['cost'] <= budget and self.match_preferences(destination, preferences):
                plan.append(destination)
                total_cost += destination['cost']

        return plan

    def match_preferences(self, destination, preferences):
        for key, value in preferences.items():
            if destination.get(key) != value:
                return False
        return True

    def iterate_plan(self, plan, preferences, budget):
        for i in range(len(plan)):
            for destination in self.destinations:
                if destination not in plan and self.match_preferences(destination, preferences) and self.calculate_cost(plan, destination) <= budget:
                    plan[i] = destination
                    break
        return plan

    def calculate_cost(self, plan, new_destination):
        return sum(destination['cost'] for destination in plan) + new_destination['cost']

# Example usage
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)

Maelezo ya Msimbo

Uanzishaji (Njia ya __init__): Darasa la TravelAgent linaanzishwa na orodha ya maeneo yanayowezekana, kila moja likiwa na sifa kama jina, gharama, na aina ya shughuli.
Kuanzisha Mpango (Njia ya bootstrap_plan): Njia hii huunda mpango wa awali wa safari kulingana na mapendeleo ya mteja na bajeti. Inapitia orodha ya maeneo na kuyaongeza kwenye mpango ikiwa yanalingana na mapendeleo ya mteja na yanaendana na bajeti.
Kulinganisha Mapendeleo (Njia ya match_preferences): Njia hii hukagua ikiwa eneo linalingana na mapendeleo ya mteja.
Kurudia Mpango (Njia ya iterate_plan): Njia hii inaboresha mpango wa awali kwa kujaribu kubadilisha kila eneo kwenye mpango na chaguo bora zaidi, ikizingatia mapendeleo ya mteja na vikwazo vya bajeti.
Kuhesabu Gharama (Njia ya calculate_cost): Njia hii huhesabu gharama ya jumla ya mpango wa sasa, ikijumuisha eneo jipya linalowezekana.

Matumizi ya Mfano

Mpango wa Awali: Wakala wa kusafiri huunda mpango wa awali kulingana na mapendeleo ya mteja ya kutembelea vivutio na bajeti ya $2000.
Mpango Ulioboreshwa: Wakala wa kusafiri hurudia mpango, akiboresha kwa mapendeleo ya mteja na bajeti.

Kwa kuanzisha mpango na lengo wazi (mfano, kuongeza kuridhika kwa mteja) na kurudia ili kuboresha mpango, wakala wa kusafiri anaweza kuunda ratiba ya safari iliyobinafsishwa na iliyoboreshwa kwa mteja. Njia hii inahakikisha kuwa mpango wa safari unalingana na mapendeleo na bajeti ya mteja tangu mwanzo na unaboreshwa kwa kila hatua.

Kutumia LLM kwa Upangaji Upya na Uwekaji Alama

Mifano Mikubwa ya Lugha (LLMs) inaweza kutumika kwa upangaji upya na uwekaji alama kwa kutathmini umuhimu na ubora wa nyaraka zilizopatikana au majibu yaliyotolewa. Hivi ndivyo inavyofanya kazi:

Upatikanaji: Hatua ya awali ya upatikanaji inachukua seti ya nyaraka au majibu yanayowezekana kulingana na swali.

Upangaji Upya: LLM inatathmini wagombea hawa na kuwapanga upya kulingana na umuhimu na ubora wao. Hatua hii inahakikisha kuwa taarifa muhimu na za ubora wa juu zinawasilishwa kwanza.

Uwekaji Alama: LLM inatoa alama kwa kila mgombea, ikionyesha umuhimu na ubora wao. Hii husaidia kuchagua jibu au nyaraka bora zaidi kwa mtumiaji.

Kwa kutumia LLMs kwa upangaji upya na uwekaji alama, mfumo unaweza kutoa taarifa sahihi zaidi na inayolingana na muktadha, kuboresha uzoefu wa mtumiaji kwa ujumla.

Hapa kuna mfano wa jinsi wakala wa kusafiri anaweza kutumia Mfano Mkubwa wa Lugha (LLM) kwa upangaji upya na uwekaji alama wa maeneo ya kusafiri kulingana na mapendeleo ya mtumiaji katika Python:

Hali - Kusafiri kulingana na Mapendeleo

Wakala wa kusafiri anataka kupendekeza maeneo bora ya kusafiri kwa mteja kulingana na mapendeleo yao. LLM itasaidia kupanga upya na kuweka alama maeneo ili kuhakikisha chaguo muhimu zaidi yanawasilishwa.

Hatua:

Kukusanya mapendeleo ya mtumiaji.
Kupata orodha ya maeneo ya kusafiri yanayowezekana.
Kutumia LLM kupanga upya na kuweka alama maeneo kulingana na mapendeleo ya mtumiaji.

Hivi ndivyo unavyoweza kusasisha mfano wa awali ili kutumia Huduma za Azure OpenAI:

Mahitaji

Unahitaji kuwa na usajili wa Azure.
Unda rasilimali ya Azure OpenAI na upate funguo zako za API.

Msimbo wa Mfano wa Python

import requests
import json

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

    def get_recommendations(self, preferences, api_key, endpoint):
        # Generate a prompt for the Azure OpenAI
        prompt = self.generate_prompt(preferences)
        
        # Define headers and payload for the request
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # Call the Azure OpenAI API to get the re-ranked and scored destinations
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # Extract and return the recommendations
        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

# Example usage
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)

Maelezo ya Msimbo - Mchagua Mapendeleo

Uanzishaji: Darasa la TravelAgent linaanzishwa na orodha ya maeneo ya kusafiri yanayowezekana, kila moja likiwa na sifa kama jina na maelezo.
Kupata Mapendekezo (Njia ya get_recommendations): Njia hii huunda maelezo kwa huduma ya Azure OpenAI kulingana na mapendeleo ya mtumiaji na hufanya ombi la HTTP POST kwa API ya Azure OpenAI ili kupata maeneo yaliyopangwa upya na kuwekwa alama.
Kuunda Maelezo (Njia ya generate_prompt): Njia hii huunda maelezo kwa Azure OpenAI, ikijumuisha mapendeleo ya mtumiaji na orodha ya maeneo. Maelezo haya yanaongoza modeli kupanga upya na kuweka alama maeneo kulingana na mapendeleo yaliyotolewa.
Ombi la API: Maktaba ya requests inatumika kufanya ombi la HTTP POST kwa sehemu ya mwisho ya API ya Azure OpenAI. Jibu linajumuisha maeneo yaliyopangwa upya na kuwekwa alama.
Matumizi ya Mfano: Wakala wa kusafiri anakusanya mapendeleo ya mtumiaji (mfano, kupendezwa na vivutio na tamaduni tofauti) na kutumia huduma ya Azure OpenAI kupata mapendekezo yaliyopangwa upya na kuwekwa alama kwa maeneo ya kusafiri.

Hakikisha unabadilisha your_azure_openai_api_key na funguo yako halisi ya API ya Azure OpenAI na https://your-endpoint.com/... na URL halisi ya sehemu ya mwisho ya Azure OpenAI.

Kwa kutumia LLM kwa upangaji upya na uwekaji alama, wakala wa kusafiri anaweza kutoa mapendekezo ya kusafiri yaliyobinafsishwa na yanayofaa zaidi kwa wateja, kuboresha uzoefu wao kwa ujumla.

Mfano wa Kivitendo: Kutafuta kwa Nia katika Wakala wa Usafiri

Hebu tuchukue Wakala wa Usafiri kama mfano wa kuona jinsi kutafuta kwa nia kunavyoweza kutekelezwa.

Kukusanya Mapendeleo ya Mtumiaji

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

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

Kuelewa Nia ya Mtumiaji

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"

Uelewa wa Muktadha

def analyze_context(query, user_history):
    # Combine current query with user history to understand context
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

Kutafuta na Kubinafsisha Matokeo

def search_with_intent(query, preferences, user_history):
    intent = identify_intent(query)
    context = analyze_context(query, user_history)
    if intent == "informational":
        search_results = search_information(query, preferences)
    elif intent == "navigational":
        search_results = search_navigation(query)
    elif intent == "transactional":
        search_results = search_transaction(query, preferences)
    personalized_results = personalize_results(search_results, user_history)
    return personalized_results

def search_information(query, preferences):
    # Example search logic for informational intent
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # Example search logic for navigational intent
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # Example search logic for transactional intent
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # Example personalization logic
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # Return top 10 personalized results

Mfano wa Matumizi

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. Kuzalisha Msimbo kama Zana

Wakala wa kuzalisha msimbo hutumia mifano ya AI kuandika na kutekeleza msimbo, kutatua matatizo magumu na kuendesha kazi kiotomatiki.

Wakala wa Kuzalisha Msimbo

Wakala wa kuzalisha msimbo hutumia mifano ya AI ya kizazi kuandika na kutekeleza msimbo. Wakala hawa wanaweza kutatua matatizo magumu, kuendesha kazi kiotomatiki, na kutoa maarifa muhimu kwa kuzalisha na kutekeleza msimbo katika lugha mbalimbali za programu.

Matumizi ya Kivitendo

Kuzalisha Msimbo Kiotomatiki: Kuzalisha vipande vya msimbo kwa kazi maalum, kama vile uchambuzi wa data, uchakataji wa wavuti, au ujifunzaji wa mashine.
SQL kama RAG: Kutumia maswali ya SQL kupata na kudhibiti data kutoka kwa hifadhidata.
Kutatua Matatizo: Kuunda na kutekeleza msimbo kutatua matatizo maalum, kama vile kuboresha algorithimu au kuchambua data.

Mfano: Wakala wa Kuzalisha Msimbo kwa Uchambuzi wa Data

Fikiria unaunda wakala wa kuzalisha msimbo. Hivi ndivyo unavyoweza kufanya kazi:

Kazi: Kuchambua seti ya data ili kutambua mienendo na mifumo.
Hatua:
- Pakia seti ya data kwenye zana ya uchambuzi wa data.
- Zalisha maswali ya SQL kuchuja na kujumlisha data.
- Tekeleza maswali na pata matokeo.
- Tumia matokeo kuzalisha vielelezo na maarifa.
Rasilimali Zinazohitajika: Ufikiaji wa seti ya data, zana za uchambuzi wa data, na uwezo wa SQL.
Uzoefu: Tumia matokeo ya uchambuzi wa awali kuboresha usahihi na umuhimu wa uchambuzi wa baadaye.

Mfano: Wakala wa Kuzalisha Msimbo kwa Wakala wa Usafiri

Katika mfano huu, tutaunda wakala wa kuzalisha msimbo, Wakala wa Usafiri, kusaidia watumiaji kupanga safari zao kwa kuzalisha na kutekeleza msimbo. Wakala huyu anaweza kushughulikia kazi kama vile kupata chaguo za usafiri, kuchuja matokeo, na kuandaa ratiba kwa kutumia AI ya kizazi.

Muhtasari wa Wakala wa Kuzalisha Msimbo

Kukusanya Mapendeleo ya Mtumiaji: Hukusanya maoni ya mtumiaji kama vile marudio, tarehe za safari, bajeti, na maslahi.
Kuzalisha Msimbo wa Kupata Data: Huzalisha vipande vya msimbo kupata data kuhusu ndege, hoteli, na vivutio.
Kutekeleza Msimbo Uliogenezwa: Hutekeleza msimbo uliogenezwa kupata taarifa za wakati halisi.
Kuandaa Ratiba: Hujumuisha data iliyopatikana kuwa mpango wa safari uliobinafsishwa.
Kurekebisha Kulingana na Maoni: Hupokea maoni ya mtumiaji na kuzalisha tena msimbo ikiwa ni lazima kuboresha matokeo.

Utekelezaji Hatua kwa Hatua

Kukusanya Mapendeleo ya Mtumiaji

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

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

Kuzalisha Msimbo wa Kupata Data

def generate_code_to_fetch_data(preferences):
    # Example: Generate code to search for flights based on user preferences
    code = f"""
    def search_flights():
        import requests
        response = requests.get('https://api.example.com/flights', params={preferences})
        return response.json()
    """
    return code

def generate_code_to_fetch_hotels(preferences):
    # Example: Generate code to search for hotels
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

Kutekeleza Msimbo Uliogenezwa

def execute_code(code):
    # Execute the generated code using exec
    exec(code)
    result = locals()
    return result

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
   
flight_code = generate_code_to_fetch_data(preferences)
hotel_code = generate_code_to_fetch_hotels(preferences)
   
flights = execute_code(flight_code)
hotels = execute_code(hotel_code)

print("Flight Options:", flights)
print("Hotel Options:", hotels)

Kuandaa Ratiba

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)

Kurekebisha Kulingana na Maoni

def adjust_based_on_feedback(feedback, preferences):
    # Adjust preferences based on user feedback
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    return preferences

feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences)
   
# Regenerate and execute code with updated preferences
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)
   
updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)
   
updated_itinerary = generate_itinerary(updated_flights, updated_hotels, attractions)
print("Updated Itinerary:", updated_itinerary)

Kutumia Uelewa wa Mazingira na Utoaji Sababu

Kulingana na mpangilio wa jedwali, mfumo unaweza kuboresha mchakato wa kizazi cha maswali kwa kutumia uelewa wa mazingira na utoaji sababu.

Hapa kuna mfano wa jinsi hii inaweza kufanyika:

Kuelewa Mpangilio: Mfumo utaelewa mpangilio wa jedwali na kutumia taarifa hii kuimarisha kizazi cha maswali.
Kurekebisha Kulingana na Maoni: Mfumo utarekebisha mapendeleo ya mtumiaji kulingana na maoni na kufikiria ni sehemu gani za mpangilio zinahitaji kusasishwa.
Kuzalisha na Kutekeleza Maswali: Mfumo utazalisha na kutekeleza maswali kupata data mpya ya ndege na hoteli kulingana na mapendeleo mapya.

Hapa kuna mfano wa msimbo wa Python uliosasishwa unaojumuisha dhana hizi:

def adjust_based_on_feedback(feedback, preferences, schema):
    # Adjust preferences based on user feedback
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Reasoning based on schema to adjust other related preferences
    for field in schema:
        if field in preferences:
            preferences[field] = adjust_based_on_environment(feedback, field, schema)
    return preferences

def adjust_based_on_environment(feedback, field, schema):
    # Custom logic to adjust preferences based on schema and feedback
    if field in feedback["liked"]:
        return schema[field]["positive_adjustment"]
    elif field in feedback["disliked"]:
        return schema[field]["negative_adjustment"]
    return schema[field]["default"]

def generate_code_to_fetch_data(preferences):
    # Generate code to fetch flight data based on updated preferences
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Generate code to fetch hotel data based on updated preferences
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # Simulate execution of code and return mock data
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Generate itinerary based on flights, hotels, and attractions
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

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

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

# Regenerate and execute code with updated preferences
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)

updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)

updated_itinerary = generate_itinerary(updated_flights, updated_hotels, feedback["liked"])
print("Updated Itinerary:", updated_itinerary)

Maelezo - Kuhifadhi Kulingana na Maoni

Uelewa wa Mpangilio: Kamusi ya schema inafafanua jinsi mapendeleo yanavyopaswa kurekebishwa kulingana na maoni. Inajumuisha sehemu kama favorites na avoid, pamoja na marekebisho yanayolingana.
Kurekebisha Mapendeleo (adjust_based_on_feedback method): Njia hii inarekebisha mapendeleo kulingana na maoni ya mtumiaji na mpangilio.
Marekebisho Yanayotegemea Mazingira (adjust_based_on_environment method): Njia hii inabinafsisha marekebisho kulingana na mpangilio na maoni.
Kuzalisha na Kutekeleza Maswali: Mfumo huzalisha msimbo kupata data mpya ya ndege na hoteli kulingana na mapendeleo yaliyorekebishwa na kuiga utekelezaji wa maswali haya.
Kuandaa Ratiba: Mfumo huunda ratiba iliyosasishwa kulingana na data mpya ya ndege, hoteli, na vivutio.

Kwa kufanya mfumo uwe na uelewa wa mazingira na utoaji sababu kulingana na mpangilio, unaweza kuzalisha maswali sahihi zaidi na muhimu, na hivyo kutoa mapendekezo bora ya usafiri na uzoefu wa mtumiaji uliobinafsishwa.

Kutumia SQL kama Mbinu ya Retrieval-Augmented Generation (RAG)

SQL (Structured Query Language) ni zana yenye nguvu ya kuingiliana na hifadhidata. Inapotumika kama sehemu ya mbinu ya Retrieval-Augmented Generation (RAG), SQL inaweza kupata data muhimu kutoka kwa hifadhidata ili kuarifu na kuzalisha majibu au vitendo katika mawakala wa AI. Hebu tuchunguze jinsi SQL inavyoweza kutumika kama mbinu ya RAG katika muktadha wa Wakala wa Usafiri.

Dhana Muhimu

Mwingiliano na Hifadhidata:
- SQL hutumika kuuliza hifadhidata, kupata taarifa muhimu, na kudhibiti data.
- Mfano: Kupata maelezo ya ndege, hoteli, na vivutio kutoka kwa hifadhidata ya usafiri.
Ujumuishaji na RAG:
- Maswali ya SQL yanazalishwa kulingana na maoni na mapendeleo ya mtumiaji.
- Data iliyopatikana hutumika kuzalisha mapendekezo au vitendo vilivyobinafsishwa.
Kizazi Dinamiki cha Maswali:
- Wakala wa AI huzalisha maswali ya SQL dinamiki kulingana na muktadha na mahitaji ya mtumiaji.
- Mfano: Kubinafsisha maswali ya SQL kuchuja matokeo kulingana na bajeti, tarehe, na maslahi.

Matumizi

Kuzalisha Msimbo Kiotomatiki: Kuzalisha vipande vya msimbo kwa kazi maalum.
SQL kama RAG: Kutumia maswali ya SQL kudhibiti data.
Kutatua Matatizo: Kuunda na kutekeleza msimbo kutatua matatizo.

Mfano:
Wakala wa uchambuzi wa data:

Kazi: Kuchambua seti ya data ili kupata mienendo.
Hatua:
- Pakia seti ya data.
- Zalisha maswali ya SQL kuchuja data.
- Tekeleza maswali na pata matokeo.
- Zalisha vielelezo na maarifa.
Rasilimali: Ufikiaji wa seti ya data, uwezo wa SQL.
Uzoefu: Tumia matokeo ya awali kuboresha uchambuzi wa baadaye.

Mfano wa Kivitendo: Kutumia SQL katika Wakala wa Usafiri

Kukusanya Mapendeleo ya Mtumiaji

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

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

Kuzalisha Maswali ya SQL

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

Kutekeleza Maswali ya SQL

import sqlite3

def execute_sql_query(query, database="travel.db"):
    connection = sqlite3.connect(database)
    cursor = connection.cursor()
    cursor.execute(query)
    results = cursor.fetchall()
    connection.close()
    return results

Kuzalisha Mapendekezo

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)

Mfano wa Maswali ya SQL

Swali la Ndege

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

Swali la Hoteli

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

Swali la Vivutio

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

Kwa kutumia SQL kama sehemu ya mbinu ya Retrieval-Augmented Generation (RAG), mawakala wa AI kama Wakala wa Usafiri wanaweza kupata na kutumia data muhimu kwa njia dinamiki ili kutoa mapendekezo sahihi na yaliyobinafsishwa.

Mfano wa Metakujitambua

Ili kuonyesha utekelezaji wa metakujitambua, hebu tuunde wakala rahisi anayefikiria juu ya mchakato wake wa kufanya maamuzi wakati wa kutatua tatizo. Katika mfano huu, tutaunda mfumo ambapo wakala anajaribu kuboresha chaguo la hoteli, lakini kisha anapitia mchakato wake wa kufikiri na kurekebisha mkakati wake anapofanya makosa au chaguo duni.

Tutatumia mfano rahisi ambapo wakala huchagua hoteli kulingana na mchanganyiko wa bei na ubora, lakini “anafikiria” juu ya maamuzi yake na kurekebisha ipasavyo.

Jinsi Hii Inaonyesha Metakujitambua:

Uamuzi wa Awali: Wakala atachagua hoteli ya bei nafuu zaidi, bila kuelewa athari za ubora.
Kutafakari na Kutathmini: Baada ya chaguo la awali, wakala atakagua ikiwa hoteli ni “chaguo mbaya” kwa kutumia maoni ya mtumiaji. Ikiwa ubora wa hoteli ni wa chini sana, atafakari juu ya sababu zake.
Kurekebisha Mkakati: Wakala atarekebisha mkakati wake kulingana na tafakari yake, akibadilisha kutoka “bei nafuu zaidi” hadi “ubora wa juu zaidi,” na hivyo kuboresha mchakato wake wa kufanya maamuzi katika majaribio yajayo.

Hapa kuna mfano:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # Stores the hotels chosen previously
        self.corrected_choices = []  # Stores the corrected choices
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # Available strategies

    def recommend_hotel(self, hotels, strategy):
        """
        Recommend a hotel based on the chosen strategy.
        The strategy can either be 'cheapest' or 'highest_quality'.
        """
        if strategy == 'cheapest':
            recommended = min(hotels, key=lambda x: x['price'])
        elif strategy == 'highest_quality':
            recommended = max(hotels, key=lambda x: x['quality'])
        else:
            recommended = None
        self.previous_choices.append((strategy, recommended))
        return recommended

    def reflect_on_choice(self):
        """
        Reflect on the last choice made and decide if the agent should adjust its strategy.
        The agent considers if the previous choice led to a poor outcome.
        """
        if not self.previous_choices:
            return "No choices made yet."

        last_choice_strategy, last_choice = self.previous_choices[-1]
        # Let's assume we have some user feedback that tells us whether the last choice was good or not
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # Adjust strategy if the previous choice was unsatisfactory
            new_strategy = 'highest_quality' if last_choice_strategy == 'cheapest' else 'cheapest'
            self.corrected_choices.append((new_strategy, last_choice))
            return f"Reflecting on choice. Adjusting strategy to {new_strategy}."
        else:
            return "The choice was good. No need to adjust."

    def get_user_feedback(self, hotel):
        """
        Simulate user feedback based on hotel attributes.
        For simplicity, assume if the hotel is too cheap, the feedback is "bad".
        If the hotel has quality less than 7, feedback is "bad".
        """
        if hotel['price'] < 100 or hotel['quality'] < 7:
            return "bad"
        return "good"

# Simulate a list of hotels (price and quality)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# Create an agent
agent = HotelRecommendationAgent()

# Step 1: The agent recommends a hotel using the "cheapest" strategy
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# Step 2: The agent reflects on the choice and adjusts strategy if necessary
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# Step 3: The agent recommends again, this time using the adjusted strategy
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

Uwezo wa Metakujitambua wa Wakala

Jambo kuu hapa ni uwezo wa wakala wa:

Kutathmini chaguo zake za awali na mchakato wa kufanya maamuzi.
Kurekebisha mkakati wake kulingana na tafakari hiyo, yaani, metakujitambua kwa vitendo.

Hii ni aina rahisi ya metakujitambua ambapo mfumo una uwezo wa kurekebisha mchakato wake wa kufikiri kulingana na maoni ya ndani.

Hitimisho

Metakujitambua ni zana yenye nguvu inayoweza kuboresha kwa kiasi kikubwa uwezo wa mawakala wa AI. Kwa kujumuisha michakato ya metakujitambua, unaweza kubuni mawakala ambao ni werevu zaidi, wanaoweza kubadilika, na wenye ufanisi. Tumia rasilimali za ziada kuchunguza zaidi ulimwengu wa kuvutia wa metakujitambua katika mawakala wa AI.

Una Maswali Zaidi Kuhusu Muundo wa Metakujitambua?

Jiunge na Azure AI Foundry Discord kukutana na wanafunzi wengine, kuhudhuria saa za ofisi, na kupata majibu ya maswali yako kuhusu Mawakala wa AI.

Somo Lililopita

Muundo wa Mawakala Wengi

Somo Lijalo

Mawakala wa AI katika Uzalishaji

Kanusho:
Hati hii imetafsiriwa kwa kutumia huduma ya kutafsiri ya AI Co-op Translator. Ingawa tunajitahidi kuhakikisha usahihi, tafadhali fahamu kuwa tafsiri za kiotomatiki zinaweza kuwa na makosa au kutokuwa sahihi. Hati ya asili katika lugha yake ya awali inapaswa kuzingatiwa kama chanzo cha mamlaka. Kwa taarifa muhimu, tafsiri ya kitaalamu ya binadamu inapendekezwa. Hatutawajibika kwa kutoelewana au tafsiri zisizo sahihi zinazotokana na matumizi ya tafsiri hii.

This site is open source. Improve this page.