ai-agents-for-beginners

Multi-Agent Design

(ចុចលើរូបភាពខាងលើដើម្បីមើលវីដេអូមេរៀននេះ)

ការគិតពីការគិត (Metacognition) ក្នុងភ្នាក់ងារបច្ចេកវិទ្យាបញ្ញាសិប្បនិម្មិត

បំណើត

ស្វាគមន៍មកកាន់មេរៀនអំពីការគិតពីការគិតក្នុងភ្នាក់ងារបច្ចេកវិទ្យាបញ្ញាសិប្បនិម្មិត! ជំពូកនេះត្រូវបានរចនាសម្រាប់អ្នកចាប់ផ្តើមដែលចង់ដឹងពីរបៀបដែលភ្នាក់ងារបញ្ញាសិប្បនិម្មិតអាចគិតអំពីដំណើរការគិតរបស់ខ្លួន។ នៅចុងបញ្ចប់មេរៀននេះ អ្នកនឹងយល់ពីគំនិតស្នូល និងមានឧទាហរណ៍ជាក់ស្តែងដើម្បីអនុវត្តការគិតពីការគិតក្នុងការរចនាភ្នាក់ងារបញ្ញាសិប្បនិម្មិត។

គោលបំណងសិក្សា

បន្ទាប់ពីបញ្ចប់មេរៀននេះ អ្នកនឹងអាច៖

  1. យល់ពីផលប៉ះពាល់នៃវិលការវិភាគក្នុងការកំណត់ភ្នាក់ងារ។
  2. ប្រើបច្ចេកទេសផែនការ និងការវាយតម្លៃដើម្បីជួយភ្នាក់ងារដែលអាចកែតម្រូវខ្លួនបាន។
  3. បង្កើតភ្នាក់ងាររបស់អ្នកផ្ទាល់ដែលអាចលេងល្បិចកូដបានដើម្បីបំពេញភារកិច្ច។

បំណើតទៅកាន់ការគិតពីការគិត

ការគិតពីការគិតមានន័យជាជំហានគិតជាថ្នាក់ខ្ពស់ដែលពាក់ព័ន្ធនឹងការគិតអំពីដំណើរការគិតរបស់ខ្លួន។ សម្រាប់ភ្នាក់ងារបញ្ញាសិប្បនិម្មិត នេះមានន័យថាអាចវាយតម្លៃ និងកែសម្រួលសកម្មភាពរបស់ខ្លួនដោយផ្អែកលើការយល់ដឹងខ្លួន និងបទពិសោធន៍ពីមុន។ ការគិតពីការគិត ឬ “ការគិតអំពីការគិត” គឺជាគំនិតសំខាន់មួយនៅក្នុងការអភិវឌ្ឍប្រព័ន្ធភ្នាក់ងារបញ្ញាសិប្បនិម្មិត។ វាផ្ដោតទៅលើប្រព័ន្ធ AI ដែលមានការយល់ដឹងពីដំណើរការជិតខាងរបស់ខ្លួន ហើយអាចត្រួតពិនិត្យ គ្រប់គ្រង និងប្តូរភាពប្រតិបត្តិការតាមបានយ៉ាងត្រឹមត្រូវ។ ដូចជាអ្នកធ្វើពេលដែលយើងអានស្ថានភាព ឬមើលបញ្ហា។ ការយល់ដឹងខ្លួននេះអាចជួយប្រព័ន្ធ AI ទទួលបានការសម្រេចចិត្តល្អប្រសើរជាងមុន ស្គាល់កំហុស និងពង្រឹងការប្រតិបត្តិការរបស់ខ្លួនយ៉ាងមានប្រសិទ្ធិភាពលើរយៈពេល - ជំនួយទាក់ទងកាន់សាកល្បង Turing និងការជជែកគ្នាពីការតើបច្ចេកវិទ្យាបញ្ញាសិប្បនិម្មិតនឹងគ្រប់គ្រងមនុស្ស។

ក្នុងបរិបទប្រព័ន្ធ AI ភ្នាក់ងារ ការគិតពីការគិតអាចជួយដោះស្រាយបញ្ហាជាច្រើន ដូចជា៖

តើ Metacognition ជាអ្វី?

ការគិតពីការគិត ឬ “ការគិតអំពីការគិត” ជាដំណើរការគិតនៅថ្នាក់ខ្ពស់ដែលពាក់ព័ន្ធនឹងការយល់ដឹងខ្លួន និងការគ្រប់គ្រងដើម្បីបង្កើតឲ្យដំណើរការគិតរបស់ខ្លួនមានប្រសិទ្ធភាព។ ក្នុងវិស័យ AI វាបង្កើតឲ្យភ្នាក់ងារអាចវាយតម្លៃ និងប្តូរយុទ្ធសាស្រ្តនិងសកម្មភាពដើម្បីធ្វើឱ្យដំណោះស្រាយបញ្ហានិងសម្រួលការសម្រេចចិត្តកាន់តែប្រសើរឡើង។ ដោយស្គាល់ការគិតពីការគិត អ្នកអាចរចនាភ្នាក់ងារបញ្ញាសិប្បនិម្មិតដែលមានភាពឆ្លាតវៃ និងឆ្លើយតបបានល្អប្រសើរនិងមានប្រសិទ្ធភាពកាន់តែខ្ពស់។ ក្នុងការគិតពីការគិតពិតប្រាកដ អ្នកនឹងឃើញ AI កំពុងធ្វើការវិភាគយ៉ាងច្បាស់លាស់អំពីការវិភាគរបស់វា។

ឧទាហរណ៍៖ “ខ្ញុំបានផ្តល់សារៈសំខាន់ដល់ការហោះយន្តថោកជាងទេ ព្រោះ… ខ្ញុំអាចខកខានដល់ការហោះយន្តត្រង់ៗ ដូច្នេះខ្ញុំនឹងត្រួតពិនិត្យម្ដងទៀត។” តាមដានរបៀបឬហេតុផលដែលវាជ្រើសរើសមួយផ្លូវនេះ។

សារៈសំខាន់នៃការគិតពីការគិតក្នុងភ្នាក់ងារបញ្ញាសិប្បនិម្មិត

ការគិតពីការគិតមានតួនាទីសំខាន់ក្នុងការរចនាភ្នាក់ងារបញ្ញាសិប្បនិម្មិតដោយហេតុផលជាច្រើន៖

Importance of Metacognition

សមាសធាតុរបស់ភ្នាក់ងារបញ្ញាសិប្បនិម្មិត

មុនចូលទៅដំណើរការគិតពីការគិត វាមានសារៈសំខាន់ក្នុងការយល់ពីសមាសធាតុមូលដ្ឋាននៃភ្នាក់ងារបញ្ញាសិប្បនិម្មិត។ ភ្នាក់ងារបញ្ញាសិប្បនិម្មិតស្ទើរតែមាន៖

សមាសធាតុទាំងនេះ​ធ្វើការរួមគ្នាដើម្បីបង្កើតជា “ឯកតាការជំនាញ” ដែលអាចអនុវត្តភារកិច្ចជាក់លាក់។

ឧទាហរណ៍: គិតពីភ្នាក់ងារធ្វើដំណើរ ដែលបម្រើការងារមិនត្រឹមតែដើម្បីរៀបចំថ្ងៃច្បារកំសាន្តរបស់អ្នកទេ តែថែមទាំងកែប្រែលំហូរតាមទិន្នន័យពេលវេលាពិតនិងបទពិសោធ៍របស់អតិថិជនពីមុន។

ឧទាហរណ៍៖ ការគិតពីការគិតក្នុងសេវាកម្មភ្នាក់ងារធ្វើដំណើរ

សូមស្រមៃថាអ្នកកំពុងរចនាសេវាកម្មភ្នាក់ងារធ្វើដំណើរដោយមាន AI ជាជំនួយ។ ភ្នាក់ងារនេះ “ភ្នាក់ងារធ្វើដំណើរ” ជួយអ្នកប្រើរៀបចំការឈប់សម្រាករបស់ពួកគេ។ ដើម្បីបញ្ចូលការគិតពីការគិត ទាមទារឲ្យភ្នាក់ងារធ្វើដំណើរវាយតម្លៃ និងកែប្រែសកម្មភាពរបស់ខ្លួនដោយផ្អែកលើការយល់ដឹងខ្លួន និងបទពិសោធន៍មុន។ នេះជាផ្លូវដែលការគិតពីការគិតអាចជួយ។

ភារកិច្ចបច្ចុប្បន្ន

ភារកិច្ចបច្ចុប្បន្នគឺជួយអ្នកប្រើរៀបចំដំណើរទៅទីក្រុងប៉ារីស។

ជំហានសំរាប់បញ្ចប់ភារកិច្ច

១។ ប្រមូលចំណូលចិត្តអ្នកប្រើ៖ សួរអំពីកាលបរិច្ឆេទធ្វើដំណើរ ប្រាក់ថវិកា ចំណង់ចិត្ត (ដូចជា សារមន្ទីរ ម្ហូប អ្នកទិញសំលៀកបញ្ជា) និងតម្រូវការពិសេសណាមួយ។ ២។ ស្វែងរកព័ត៌មាន៖ រកមើលជម្រើសអាកាសយានដ្ឋាន កន្លែងស្នាក់នៅ កន្លែងទាក់ទាញ និងភោជនីយដ្ឋាន ដែលស្របតាមចំណូលចិត្តអ្នកប្រើ។ ៣។ បង្កើតអនុសាសន៍៖ ផ្តល់ផែនការបុគ្គលរសជាតិ រួមទាំងព័ត៌មាននៅលើតម្លៃសំបុត្រ សណ្ឋាគារ និងកម្មវិធីសកម្មភាពដែលបានណែនាំ។ ៤។ កែសំរួលដោយផ្អែកលើមតិយោបល់៖ សួរមតិអ្នកប្រើពីអនុសាសន៍ ហើយកែប្រែបើមានការផ្លាស់ប្តូរត្រូវការ។

អត្ថធាតុដែលទាមទារ

បទពិសោធន៍ និងការប្រតិ្តភាគខ្លួន

ភ្នាក់ងារធ្វើដំណើរក្នុងការគិតពីការគិតវាយតម្លៃការធ្វើការរបស់ខ្លួន និងសិក្សាចេញពីបទពិសោធន៍មុន។ ឧទាហរណ៍៖

១។ វិភាគមតិយោបល់អ្នកប្រើ៖ ភ្នាក់ងារធ្វើដំណើរត្រួតពិនិត្យមតិយោបល់អ្នកប្រើដើម្បីកំណត់អនុសាសន៍ណាដែលទទួលបានការទទួលស្គាល់ល្អ និងដែលមិនបានទេ ហើយសម្រួលអនុសាសន៍នៅពេលក្រោយ។ ២។ ភាពអាចបត់បែនបាន៖ ប្រសិនបើអ្នកប្រើបានរាយការណ៍ពីការមិនចូលចិត្តកន្លែងជួរមនុស្សច្រើន ភ្នាក់ងារធ្វើដំណើរនឹងមិនណែនាំកន្លែងទេសចរណ៍ខ្លាំងពេលម៉ោងកំពូលជាច្រើនទេ។ ៣។ ការកែតម្រូវកំហុស៖ ប្រសិនបើភ្នាក់ងារធ្វើដំណើរធ្វើកំហុសក្នុងការកក់សណ្ឋាគារដូចជា ផ្តល់អាសយដ្ឋានសណ្ឋាគារពេញរួចហើយ វានឹងរៀនស្សើបមើលភាពអាចមានទុកចិត្តបានយ៉ាងតឹងរឹងមុនផ្តល់អនុសាសន៍។

ឧទាហរណ៍សម្រាប់អ្នកអភិវឌ្ឍន៍

នេះជាឧទាហរណ៍សាមញ្ញនៃកូដភ្នាក់ងារធ្វើដំណើរ ពេលបញ្ចូលការគិតពីការគិត:

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)

# ឧទាហរណ៍ប្រើប្រាស់
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)

ហេតុអ្វីបានជាការគិតពីការគិតមានសារៈសំខាន់

ដោយបញ្ចូលការគិតពីការគិត ភ្នាក់ងារធ្វើដំណើរអាចផ្តល់អនុសាសន៍ផ្ទាល់ខ្លួនប្រសើរ និងត្រឹមត្រូវខ្ពស់ បង្កើនបទពិសោធន៍អ្នកប្រើជាទូទៅ។

2. ការធ្វើផែនការ ក្នុងភ្នាក់ងារ

ការធ្វើផែនជាផ្នែកសំខាន់នៃអាកប្បកម្មភ្នាក់ងារបញ្ញាសិប្បនិម្មិត។ វារួមមានការរៀបចំហានដែលត្រូវការដើម្បីសម្រេចគោលដៅ ដោយគិតถึงស្ថានភាពបច្ចុប្បន្ន ធនធាន និងឧបសគ្គដែលអាចកើតមាន។

ធាតុរបស់ការធ្វើផែនការ

ឧទាហរណ៍: នេះជាជំហានដែលភ្នាក់ងារធ្វើដំណើរត្រូវជួយអ្នកប្រើក្នុងការរៀបចំដំណើរយ៉ាងមានប្រសិទ្ធិភាព៖

ជំហានសម្រាប់ភ្នាក់ងារធ្វើដំណើរ

១. ប្រមូលចំណូលចិត្តអ្នកប្រើ

២. ស្វែងរកព័ត៌មាន

៣. បង្កើតអនុសាសន៍

៤. បង្ហាញផែនការទៅអ្នកប្រើ

៥. ប្រមូលមតិយោបល់

៦. កែសំរួលដោយផ្អែកលើមតិយោបល់

៧. បញ្ជាក់ចុងក្រោយ

៨. កក់ និងបញ្ជាក់ ការកក់

៩. ផ្តល់ការគាំទ្រនៅពេលកំពុងធ្វើដំណើរ

ឧទាហរណ៍នៃការប្រាស្រ័យ

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)

# ការប្រើប្រាស់ឧទាហរណ៍នៅក្នុងសំណើបុក
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. ប្រព័ន្ធ RAG កែតម្រូវកំហុស

មុនដំបូង យើងចាប់ផ្តើមពីការយល់ពីភាពខុសគ្នារវាងឧបករណ៍ RAG និងការផ្ទុកបរិបទជាមុន

RAG vs Context Loading

ការបង្កើតតាមការទាញយកឯកសារ (Retrieval-Augmented Generation - RAG)

RAG បូកបញ្ចូលប្រព័ន្ធទាញយកជាមួយម៉ូដែលបង្កើត។ នៅពេលមានសំណួរមួយ ប្រព័ន្ធទាញយកនឹងយកឯកសារឬទិន្នន័យដែលពាក់ព័ន្ធពីកន្លែងខាងក្រៅ ហើយព័ត៌មានដែលបានទាញយកនោះត្រូវបានប្រើដើម្បីបង្កើតបញ្ញាម៉ូដែលឲ្យមានចម្លើយត្រឹមត្រូវនិងសមស្របនឹងបរិបទ។

ក្នុងប្រព័ន្ធ RAG ភ្នាក់ងារត្រូវទាញយកព័ត៌មានពាក់ព័ន្ធពីមូលដ្ឋានចំណេះដឹង ហើយប្រើព័ត៌មាននោះក្នុងការបង្កើតចម្លើយ ឬសកម្មភាពដែលសមស្រប។

វិធីសាស្រ្ត RAG កែតម្រូវកំហុស

វិធីសាស្រ្ត RAG កែតម្រូវកំហុសផ្ដោតលើការប្រើបច្ចេកទេស RAG ដើម្បីកែតម្រូវកំហុស និងពង្រឹងភាពត្រឹមត្រូវនៃភ្នាក់ងារបញ្ញាសិប្បនិម្មិត។ វារួមមាន៖

១. បច្ចេកទេសបញ្ចូលបញ្ជា (Prompting Technique)៖ ប្រើបញ្ជាគោលដៅជាក់លាក់ដើម្បីណែនាំភ្នាក់ងារទាញយកព័ត៌មានដែលពាក់ព័ន្ធ។ ២. ឧបករណ៍ (Tool)៖ អនុវត្ត thuật toán និងមេកានីស្មដែលជួយឲ្យភ្នាក់ងារវាយតម្លៃភាពពាក់ព័ន្ធនៃព័ត៌មានដែលបានទាញយក និងបង្កើតចម្លើយត្រឹមត្រូវ។ ៣. ការវាយតម្លៃ (Evaluation)៖ ប្រើវិធីសាស្រ្តវាយតម្លៃប្រតិបត្តិការភ្នាក់ងារ បន្ថែមវិធីកែប្រែដើម្បីប្រសើរឡើង។

ឧទាហរណ៍៖ RAG កែតម្រូវកំហុស​ក្នុងភ្នាក់ងារស្វែងរក

គិតពីភ្នាក់ងារស្វែងរកដែលទាញព័ត៌មាន​ពីវែបសាយដើម្បីឆ្លើយសំណួរអ្នកប្រើ។ វិធី RAG កែតម្រូវកំហុស អាចរួមមាន៖

១. បច្ចេកទេសបញ្ចូលបញ្ជា៖ កំណត់សំណួរស្វែងរកដោយផ្អែកលើបញ្ចូលរបស់អ្នកប្រើ។ ២. ឧបករណ៍៖ ប្រើការលៃតម្រូវភាសាធម្មជាតិ និង thuật toánការសិក្សាម៉ាស៊ីនដើម្បីចាត់ថ្នាក់និងច្រោះលទ្ធផលស្វែងរក។ ៣. ការវាយតម្លៃ៖ វិភាគមតិយោបល់អ្នកប្រើដើម្បីរកកំហុសក្នុងព័ត៌មានដែលបានទាញយក និងកែតម្រូវ។

RAG កែតម្រូវកំហុសក្នុងភ្នាក់ងារធ្វើដំណើរ

RAG កែតម្រូវកំហុស (Retrieval-Augmented Generation) ពង្រឹងសមត្ថភាព AI ក្នុងការទាញយក និងបង្កើតព័ត៌មាន ខណៈដែលកែតម្រូវកំហុស។ យើងមកមើលរបៀបដែលភ្នាក់ងារធ្វើដំណើរអាចប្រើវិធីសាស្រ្ត RAG កែតម្រូវកំហុស ដើម្បីផ្តល់អនុសាសន៍ធ្វើដំណើរបានត្រឹមត្រូវ និងពាក់ព័ន្ធជាងមុន។

នេះ រួមមាន៖

ជំហានសម្រាប់អនុវត្ត RAG កែតម្រូវកំហុសក្នុងភ្នាក់ងារធ្វើដំណើរ

១. ការប្រាស្រ័យជាមួយអ្នកប្រើដំបូង

២. ការទាញយកព័ត៌មាន

៣. បង្កើតអនុសាសន៍ដំបូង

៤. ប្រមូលមតិយោបល់អ្នកប្រើ

៥. ដំណើរការកែតម្រូវ RAG

ឧទាហរណ៍ជាក់ស្តែង

នេះជាឧទាហរណ៍កូដ ភាសា Python ធម្មតា ដែលបញ្ចូលវិធី RAG កែតម្រូវកំហុសក្នុងភ្នាក់ងារធ្វើដំណើរ៖

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

# ការប្រើប្រាស់ឧទាហរណ៍
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
new_itinerary = travel_agent.adjust_based_on_feedback(feedback)
print("Updated Itinerary:", new_itinerary)

ការផ្ទុកបរិបទជាមុន (Pre-emptive Context Load)

ការផ្ទុកបទបរិបទជាមុនពេល (Pre-emptive Context Load) វាយបញ្ចូលការផ្ទុកព័ត៌មានបរិបទឬព័ត៌មានផ្ទៃខាងក្រោយដែលពាក់ព័ន្ធទៅក្នុងម៉ូឌែលមុនពេលបំលែងសំណួរ។ អ្វីនេះមានន័យថា ម៉ូឌែលមានសមត្ថភាពចូលដំណើរការព័ត៌មាននេះតាំងពីដើម ដែលអាចជួយឱ្យវាបង្កើតចម្លើយដែលមានព័ត៌មានឲ្យបានច្បាស់ និងមានផ្ទាំង ច្រើនជាង ដោយមិនចាំបាច់យកព័ត៌មានបន្ថែមនៅពេលដំណើរការ។

នេះជាឧទាហរណ៍សាមញ្ញមួយនៃរបៀបដែលការផ្ទុកបទបរិបទជាមុនអាចមើលឃើញសម្រាប់កម្មវិធីភ្នាក់ងារធ្វើដំណើរជាមួយ Python៖

class TravelAgent:
    def __init__(self):
        # ដំណើរកម្សាន្ដពេញនិយម និងព័ត៌មានរបស់ពួកវាក្នុងការផ្ទុកជាមុន
        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):
        # ទាញយកព័ត៌មានគោលដៅពីបរិបទដែលបានផ្ទុកជាមុន
        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}."

# ឧទាហរណ៍ការប្រើប្រាស់
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

សេចក្ដីពន្យល់

  1. ការចាប់ផ្តើម (__init__ វិធីសាស្រ្ត): ថ្នាក់ TravelAgent ផ្ទុកតារាងពាក្យដែលមានព័ត៌មានអំពីគោលដៅដែលពេញនិយមដូចជា ប៉ារីស តូក្យូ នូវយ៉ក និងស៊ីដ្នីជាមុន។ តារាងពាក្យនេះមានព័ត៌មានដូចជាប្រទេសរបស់គោលដៅ លុយភាគ និងភាសា និងកន្លែងទាំងនានាដែលគួរទៅទស្សនា។

  2. ការទាញយកព័ត៌មាន (get_destination_info វិធីសាស្រ្ត): នៅពេលដែលអ្នកប្រើប្រាស់សួរអំពីគោលដៅណាមួយ វិធីសាស្រ្ត get_destination_info នាំយកព័ត៌មានដែលពាក់ព័ន្ធពីតារាងដែលបានផ្ទុកជាមុន។

ដោយការផ្ទុកបរិបទជាមុន កម្មវិធីភ្នាក់ងារធ្វើដំណើរអាចឆ្លើយតបរហ័សចំពោះសំណួរអ្នកប្រើដោយមិនចាំបាច់យកព័ត៌មានពីប្រភពខាងក្រៅពេលដែលកំពុងដំណើរការ។ នេះធ្វើឱ្យកម្មវិធីមានប្រសិទ្ធភាពខ្ពស់ និងឆ្លើយតបបានលឿន។

ការចាប់ផ្ដើមផែនការជាមួយគោលដៅមុនពេលធ្វើកំណែប្រែជាច្រើនដង

ការចាប់ផ្តើមផែនការជាមួយគោលដៅមានន័យថាចាប់ផ្តើមជាមួយគោលបំណង ឬលទ្ធផលដែលច្បាស់លាស់នៅក្នុងចិត្ត។ ដោយកំណត់គោលបំណងនេះពីដើម ម៉ូឌែលអាចប្រើវាជាគោលការណ៍ណែនាំជាទីបញ្ជាក្នុងដំណើរការកំណែប្រែជាច្រើនដង។ វាជួយធានាថាការកំណែប្រែក្នុងគ្រប់ដំណាក់កាលនាំឱ្យកាន់តែជិតស្និទ្ធទៅកាន់ការសម្រេចបានលទ្ធផលដែលចង់បាន បង្កើតដំណើរការឲ្យមានប្រសិទ្ធភាព និងផ្តោតលើគោលបំណង។

នេះជាឧទាហរណ៍ដែលបង្ហាញពីរបៀបដែលអ្នកអាចចាប់ផ្តើមផែនការធ្វើដំណើរជាមួយគោលបំណងមុនពេលធ្វើកំណែប្រែជាច្រើនដងសម្រាប់ភ្នាក់ងារធ្វើដំណើរក្នុង Python៖

ស៊េណារីយោ

ភ្នាក់ងារធ្វើដំណើរមានបំណងរៀបចំដំណើរកំសាន្តដែលបានប្ដូរតាមតម្រូវការសម្រាប់អតិថិជន។ គោលបំណងគឺបង្កើតផែនទីដំណើរកំសាន្តដែលបំលែងអារម្មណ៍គុណភាពរបស់អតិថិជនយ៉ាងគួរឱ្យសប្បាយចិត្តដោយផ្អែកលើចំណូលចិត្ត និងថវិកា។

ជំហាន

  1. កំណត់ចំណូលចិត្ត និងថវិការបស់អតិថិជន។
  2. ចាប់ផ្តើមផែនការដំបូងដោយផ្អែកលើចំណូលចិត្តទាំងនេះ។
  3. កំណែប្រែមួយចំនួនដើម្បីធ្វើឱ្យផែនការល្អឡើង សម្រាប់បទពិសោធន៍អតិថិជន។

កូដ 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']

# ការប្រើប្រាស់គំរូ
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)

សេចក្ដីពន្យល់កូដ

  1. ការចាប់ផ្តើម (__init__ វិធីសាស្រ្ត): ថ្នាក់ TravelAgent ត្រូវបានចាប់ផ្តើមជាមួយបញ្ជីគោលដៅសក្តានុពលដែលមានគុណលក្ខណៈដូចឈ្មោះ តម្លៃ និងប្រភេទសកម្មភាព។

  2. ការចាប់ផ្តើមផែនការ (bootstrap_plan វិធីសាស្រ្ត): វិធីសាស្រ្តនេះបង្កើតផែនការធ្វើដំណើរដំបូងដោយផ្អែកលើចំណូលចិត្ត និងថវិការបស់អតិថិជន។ វាបានធ្វើការបញ្ជូនតាមបញ្ជីគោលដៅ ហើយបន្ថែមទៅផែនការណ៍ប្រសិនបើគោលដៅគួរឱ្យចាប់អារម្មណ៍ទៅនឹងចំណូលចិត្ត និងសមរម្យក្នុងថវិកា។

  3. ការផ្គូផ្គងចំណូលចិត្ត (match_preferences វិធីសាស្រ្ត): វិធីសាស្រ្តនេះពិនិត្យថាគោលដៅត្រូវនឹងចំណូលចិត្តរបស់អតិថិជនទេឬទេ។

  4. កំណែប្រែផែនការ (iterate_plan វិធីសាស្រ្ត): វិធីសាស្រ្តនេះធ្វើឱ្យផែនការដំបូងច្បាស់លាស់ឡើង ដោយព្យាយាមប្តូរគោលដៅមួយៗក្នុងផែនការនៅជាមួយគោលដៅដែលសមរម្យជាងនេះ ដោយយកចំណូលចិត្ត និងការកំណត់ថវិកីឡើងវិញ។

  5. ការគណនាតម្លៃ (calculate_cost វិធីសាស្រ្ត): វិធីសាស្រ្តនេះគណនាតម្លៃសរុបនៃផែនការបច្ចុប្បន្ន បូករួមគោលដៅថ្មីដែលអាចមាន។

ឧទាហរណ៍ការប្រើប្រាស់

ដោយការចាប់ផ្តើមផែនការជាមួយគោលបំណងច្បាស់លាស់ (ឧ. បង្កើតអារម្មណ៍គុណភាពសម្រេចបានល្អបំផុត), ហើយធ្វើកំណែប្រែផែនការដើម្បីអាប់ដេតវា ភ្នាក់ងារធ្វើដំណើរអាចបង្កើតផែនដំណើរដែលផ្ទាល់ខ្លួន និងអាប់ធឹមល្អសម្រាប់អតិថិជន។ វិធីសាស្រ្តនេះធានាថា ផែនការធ្វើដំណើរត្រូវតាមចំណូលចិត្ត និងថវិការបស់អតិថិជនចាប់ពីដើម ហើយកាន់តែល្អឡើងក្នុងកំឡុងពេលកំណែប្រែទាំងឡាយ។

ការប្រើប្រាស់គុណសម្បត្តិរបស់ LLM សម្រាប់ការរៀបចំឡើងវិញ និងការចុំពិន្ទុ

ម៉ូឌែលភាសាធំ (LLMs) អាចប្រើសម្រាប់ការរៀបចំឡើងវិញ និងការចុំពិន្ទុ ដោយវាពិនិត្យពីភាពពាក់ព័ន្ធ និងគុណភាពនៃឯកសារដែលទាញ ឬចម្លើយដែលបង្កើត។ នេះជារបៀបវាធ្វើការខាងក្រោម៖

ការទាញយក៖ ជំហានដើមទាញយកឯកសារឬចម្លើយនានាដែលជាអ្នកស្នើសុំផ្អែកលើសំណួរ។

ការរៀបចំឡើងវិញ៖ LLM វាយតម្លៃលើឯកសារដែលទាញបាន ហើយរៀបចំឡើងវិញដោយផ្អែកលើភាពពាក់ព័ន្ធ និងគុណភាព។ ជំហាននេះធានាថាព័ត៌មានដែលពាក់ព័ន្ធ និងមានគុណភាពខ្ពស់បំផុតត្រូវបានបង្ហាញជាមុន។

ការចំម្លងពិន្ទុ៖ LLM អាចផ្តល់ពិន្ទុឲ្យគ្រប់ឯកសាររឺចម្លើយដែលជាជម្រើស ដើម្បីបង្ហាញពីភាពពាក់ព័ន្ធ និងគុណភាព។ វាជួយស្តែងថាជម្រើសល្អបំផុតត្រូវបានជ្រើសរើសសម្រាប់អ្នកប្រើប្រាស់។

ដោយប្រើប្រាស់ LLM សម្រាប់ការរៀបចំឡើងវិញ និងចំម្លងពិន្ទុ ប្រព័ន្ធអាចផ្ដល់ព័ត៌មានដែលមានភាពត្រឹមត្រូវ និងពាក់ព័ន្ធជាមួយបរិបទបានកាន់តែល្អ កែលម្អបទពិសោធន៍អ្នកប្រើសរុប។

នេះជាឧទាហរណ៍ពីរបៀបដែលភ្នាក់ងារធ្វើដំណើរអាចប្រើបច្ចេកវិជ្ជាម៉ូឌែលភាសាធំ (LLM) សម្រាប់ការរៀបចំឡើងវិញ និងចំម្លងពិន្ទុកគោលដៅធ្វើដំណើរផ្អែកលើចំណូលចិត្តរបស់អ្នកប្រើប្រាស់ក្នុង Python៖

ស៊េណារីយោ - ដំណើរកម្សាន្តផ្អែកលើចំណូលចិត្ត

ភ្នាក់ងារធ្វើដំណើរមានបំណងផ្តល់អនុសាសន៍គោលដៅធ្វើដំណើរល្អបំផុតទៅអតិថិជនផ្អែកលើចំណូលចិត្តរបស់ពួកគេ។ LLM នឹងជួយរៀបចំឡើងវិញ និងចំម្លងពិន្ទុគោលដៅដើម្បីធ្វើឱ្យប្រាកដថាគ្រប់ជម្រើសពាក់ព័ន្ធបំផុតត្រូវបានបង្ហាញ។

ជំហាន:

  1. ប្រមូលចំណូលចិត្តអ្នកប្រើ។
  2. ទាញបញ្ជីគោលដៅធ្វើដំណើរសក្តានុពល។
  3. ប្រើ LLM សម្រាប់រៀបចំឡើងវិញ និងចំម្លងពិន្ទុគោលដៅផ្អែកលើចំណូលចិត្តអ្នកប្រើ។

នេះគឺជារបៀបដែលអ្នកអាចធ្វើបច្ចុប្បន្នភាពឧទាហរណ៍មុននេះ ដើម្បីប្រើប្រាស់សេវាកម្ម Azure OpenAI៖

ទាមទារ

  1. អ្នកត្រូវមានជាវ Azure។
  2. បង្កើតធនធាន Azure OpenAI និងទទួលបានកូនសោ API របស់អ្នក។

ឧទាហរណ៍កូដ Python

import requests
import json

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

    def get_recommendations(self, preferences, api_key, endpoint):
        # បង្កើតការបញ្ជាទិសសម្រាប់ Azure OpenAI
        prompt = self.generate_prompt(preferences)
        
        # កំណត់មេដឹកនាំ និងទម្រង់ទិន្នន័យសម្រាប់សំណើ
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # ហៅ API Azure OpenAI ដើម្បីទទួលបានគោលដៅដែលបានចាត់ថ្នាក់ទំនងឡើងវិញនិងបានពិន្ទុ
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # ដកយក និងត្រឡប់ការផ្ដល់អនុសាសន៍
        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

# ឧទាហរណ៍នៃការប្រើប្រាស់
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)

សេចក្ដីពន្យល់កូដ - កម្មវិធីបញ្ជាក់ចំណូលចិត្ត

  1. ការចាប់ផ្តើម: ថ្នាក់ TravelAgent ត្រូវបានចាប់ផ្តើមជាមួយបញ្ជីគោលដៅធ្វើដំណើរសក្តានុពល ដែលមានគុណលក្ខណៈដូចឈ្មោះ និងការពិពណ៌នា។

  2. ទទួលបានអនុសាសន៍ (get_recommendations វិធីសាស្រ្ត): វិធីសាស្រ្តនេះបង្កើតបញ្ចូលសំរាប់សេវាកម្ម Azure OpenAI ផ្អែកលើចំណូលចិត្តរបស់អ្នកប្រើ និងធ្វើការស្នើសុំ HTTP POST ទៅ API Azure OpenAI ដើម្បីទទួលបានការរៀបចំឡើងវិញ និងចំម្លងពិន្ទុគោលដៅ។

  3. បង្កើតបញ្ចូលសំរាប់សំណើ (generate_prompt វិធីសាស្រ្ត): វិធីសាស្រ្តនេះកសាងបញ្ចូលសម្រាប់ Azure OpenAI ដែលរួមបញ្ចូលចំណូលចិត្តអ្នកប្រើ និងបញ្ជីគោលដៅ។ បញ្ចូលនេះណែនាំម៉ូឌែលឲ្យរៀបចំឡើងវិញ និងចំម្លងពិន្ទុគោលដៅ ដោយផ្អែកលើចំណូលចិត្តដែលបានផ្ដល់។

  4. ការហៅ API: ក្រុមហ៊ុន requests ត្រូវបានប្រើដើម្បីធ្វើសំណើ HTTP POST ទៅចំណុចបណ្ដាញ API Azure OpenAI។ ការឆ្លើយតបមានគោលដៅដែលបានរៀបចំឡើងវិញ និងចំម្លងពិន្ទុ។

  5. ឧទាហរណ៍ការប្រើប្រាស់: ភ្នាក់ងារធ្វើដំណើរប្រមូលចំណូលចិត្តអ្នកប្រើ (ឧ. ចំណាប់អារម្មណ៍ក្នុងការទស្សនាផ្លូវការ និងវប្បធម៌ចម្រុះ) ហើយប្រើសេវាកម្ម Azure OpenAI ដើម្បីទទួលបានអនុសាសន៍ដែលបានរៀបចំឡើងវិញ និងចំម្លងពិន្ទុ។

សូមប្រាកដជាប្ដូរទីតាំង your_azure_openai_api_key ជាទីតាំងកូនសោ API OpenAI របស់អ្នក និង https://your-endpoint.com/... ជា URL ចំណុចបណ្ដាញដាក់ប្រើប្រាស់ Azure OpenAI របស់អ្នក។

ដោយប្រើប្រាស់ LLM សម្រាប់ការរៀបចំឡើងវិញ និងចំម្លងពិន្ទុ ភ្នាក់ងារធ្វើដំណើរអាចផ្ដល់អនុសាសន៍ដែលផ្ទាល់ខ្លួន និងពាក់ព័ន្ធជាងមុន ដើម្បីជួយទទួលបានបទពិសោធន៍ល្អប្រសើរជាងមុនសម្រាប់អតិថិជន។

RAG: បច្ចេកទេសបញ្ចូលបញ្ហា (Prompting Technique) ទល់នឹងឧបករណ៍ (Tool)

ការបង្កើតបទបញ្ហាដាក់បន្ថែមពេលទាញយក (Retrieval-Augmented Generation - RAG) អាចជាបច្ចេកទេសបញ្ចូលបញ្ហា និងជាឧបករណ៍មួយក្នុងការច្នៃប្រឌិតភ្នាក់ងារយន្តករបញ្ញាសិប្បនិម្មិត (AI agents)។ ការយល់ដឹងពីភាពខុសគ្នារវាងពីរនេះអាចជួយអ្នកប្រើប្រាស់ RAG ឲ្យមានប្រសិទ្ធភាពកាន់តែច្រើនក្នុងគម្រោងរបស់អ្នក។

RAG ជាបច្ចេកទេសបញ្ចូលបញ្ហា

វាជាអ្វី?

របៀបវាដំណើរការ:

  1. បង្កើតបញ្ចូលបញ្ហា: បង្កើតបញ្ចូលបញ្ហា ឬសំណួរដែលមានរចនាសម្ព័ន្ធល្អ ដោយផ្អែកលើភារកិច្ច ឬការបញ្ចូលរបស់អ្នកប្រើ។
  2. ទាញយកព័ត៌មាន: ប្រើបញ្ចូលបញ្ហាដើម្បីស្វែងរកព័ត៌មានពាក់ព័ន្ធពីមូលដ្ឋានចំណេះដឹង ឬឃ្លាំងទិន្នន័យដែលមានរួចមុន។
  3. បង្កើតចម្លើយ: ផ្គុំព័ត៌មានដែលបានទាញយកជាមួយម៉ូឌែល AI បង្កើតចម្លើយដែលពេញលេញនិងមានភាពភាសា។

ឧទាហរណ៍ក្នុងភ្នាក់ងារធ្វើដំណើរ:

RAG ជាឧបករណ៍

វាជាអ្វី?

របៀបវាដំណើរការ:

  1. ការរួមបញ្ចូល: បញ្ចូល RAG ក្នុងស្ថាបត្យកម្មភ្នាក់ងារ AI ដែលអោយវាអូតូគ្រប់គ្រងការទាញយក និងបង្កើតចម្លើយដោយស្វ័យប្រវត្តិ។
  2. អូតូម៉ាទិក: ឧបករណ៍គ្រប់គ្រងដំណើរការប្រកបដោយគ្មានបញ្ចូលបញ្ហា ឲ្យច្បាស់សម្រាប់គ្រប់ជំហានចាប់ពីទទួលការបញ្ចូលរបស់អ្នកប្រើដល់បង្កើតចម្លើយចុងក្រោយ។
  3. ប្រសិទ្ធភាព: បង្កើនសមត្ថភាពភ្នាក់ងារដោយធ្វើឲ្យដំណើរការទាញយក និងបង្កើតមានល្បឿនលឿន និងត្រឹមត្រូវ។

ឧទាហរណ៍ក្នុងភ្នាក់ងារធ្វើដំណើរ:

ការប្រៀបធៀប

បែបផែន បច្ចេកទេសបញ្ចូលបញ្ហា ឧបករណ៍
ដៃ vs អូតូ បង្កើតបញ្ចូលបញ្ហាដោយដៃសម្រាប់សំណួរពីរបៀបមួយៗ។ ដំណើរការអូតូម៉ាទិកសម្រាប់ការទាញយក និងបង្កើតចម្លើយ។
ការគ្រប់គ្រង ផ្ដល់ការគ្រប់គ្រងលើដំណើរការទាញយក។ ធ្វើឲ្យដំណើរការទាញយក និងបង្កើតស្វ័យប្រវត្តិ និងឆាប់រហ័ស។
ភាពបត់បែន អាចបង្កើតបញ្ចូលបញ្ហាផ្ទាល់ខ្លួនដោយផ្អែកលើតម្រូវការ។ មានប្រសិទ្ធភាពខ្ពស់សម្រាប់ការអនុវត្តនៅល្បែងធំៗ។
ភាពស្មុគស្មាញ ពិបាកក្នុងការបង្កើត និងកែសម្រួលបញ្ចូលបញ្ហា។ ងាយស្រួលបញ្ចូលក្នុងស្ថាបត្យកម្មភ្នាក់ងារ AI។

ឧទាហរណ៍ប្រតិបត្តិកម្ម

ឧទាហរណ៍បច្ចេកទេសបញ្ចូលបញ្ហា:

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)

ឧទាហរណ៍ឧបករណ៍:

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)

វាយតម្លៃភាពពាក់ព័ន្ធ

ការវាយតម្លៃភាពពាក់ព័ន្ធគឺជាផ្នែកសំខាន់នៃការអនុវត្តភ្នាក់ងារ AI។ វាធានាថាព័ត៌មានដែលបានទាញ និងបង្កើតដោយភ្នាក់ងារមានសមាសភាពត្រូវតាម, ត្រឹមត្រូវ និងមានប្រយោជន៍សម្រាប់អ្នកប្រើ។ តោះមកស្វែងយល់ពីរបៀបវាយតម្លៃភាពពាក់ព័ន្ធនៅក្នុងភ្នាក់ងារ AI រួមទាំងឧទាហរណ៍ និងបច្ចេកទេស។

គំនិតសំខាន់ក្នុងការវាយតម្លៃភាពពាក់ព័ន្ធ

  1. ការយល់ដឹងបរិបទ:
    • ភ្នាក់ងារត្រូវយល់ដឹង​បរិបទនៃសំណួរអ្នកប្រើ ដើម្បីទាញយក និងបង្កើតព័ត៌មានដែលពាក់ព័ន្ធ។
    • ឧទាហរណ៍: ប្រសិនបើអ្នកប្រើសួរអំពី “ភោជនីយដ្ឋានល្អបំផុតនៅប៉ារីស” ភ្នាក់ងារត្រូវពិចារណាចំណូលចិត្តរបស់អ្នកប្រើ ដូចជាប្រភេទម្ហូប និងថវិកា។
  2. ភាពត្រឹមត្រូវ:
    • ព័ត៌មានដែលផ្តល់ដោយភ្នាក់ងារត្រូវតែផ្អែកលើគ្នានិងមានភាពទាន់សម័យ។
    • ឧទាហរណ៍: ផ្ដល់អនុសាសន៍ភោជនីយដ្ឋានដែលកំពុងបើក និងមានពិន្ទុកល្អ ជាជម្រើសជាងភោជនីយដ្ឋានដែលបានបិទ ឬចាស់។
  3. ចង់បានរបស់អ្នកប្រើ:
    • ភ្នាក់ងារត្រូវរាយការណ៍បំណងត្រឹមត្រូវពីវិចារណារូបដោយក្នុងសំណួរអ្នកប្រើ ដើម្បីផ្ដល់ព័ត៌មានពាក់ព័ន្ធបំផុត។
    • ឧទាហរណ៍: ប្រសិនបើអ្នកប្រើសួរអំពី “សណ្ឋាគារតម្លៃសមរម្យ” ភ្នាក់ងារត្រូវអនុវត្តជម្រើសសណ្ឋាគារដ៏មានតម្លៃសមរម្យប៉ងផ្តល់ជាមុន។
  4. មូលដ្ឋានមតិយោបល់:
    • ប្រមូល និងវិភាគមតិយោបល់អ្នកប្រើយ៉ាងមិនឈប់ឈរ ជួយភ្នាក់ងារកែលម្អដំណើរការវាយតម្លៃភាពពាក់ព័ន្ធ។
    • ឧទាហរណ៍: រួមបញ្ចូលពិន្ទុ និងមតិយោបល់អ្នកប្រើលើការផ្តល់អនុសាសន៍មុន ដើម្បីកែលម្អចម្លើយសម្រាប់អនាគត។

បច្ចេកទេសប្រតិបត្តិកម្មសំរាប់វាយតម្លៃភាពពាក់ព័ន្ធ

  1. ចំណាត់ថ្នាក់ភាពពាក់ព័ន្ធ:
    • ផ្ដល់ពិន្ទុភាពពាក់ព័ន្ធសម្រាប់ធាតុខ្លះៗដែលបានទាញយក ប្រកបដោយជម្រើសបែបណាដែលវាផ្គូផ្គងនឹងសំណួរនិងចំណូលចិត្តអ្នកប្រើ។

    • ឧទាហរណ៍:

      def relevance_score(item, query):
    score = 0
    if item['category'] in query['interests']:
        score += 1
    if item['price'] <= query['budget']:
        score += 1
    if item['location'] == query['destination']:
        score += 1
    return score
  2. ចម្រាញ់ និងចំណាត់ថ្នាក់:
    • ចម្រាញ់ធាតុដែលមិនពាក់ព័ន្ធ និងចំណាត់ថ្នាក់ធាតុដែលនៅសល់ដោយផ្អែកលើពិន្ទុភាពពាក់ព័ន្ធ។

    • ឧទាហរណ៍:

      def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # ត្រឡប់មកវិញ ១០ គ្រឿងធាតុដែលពាក់ព័ន្ធខ្ពស់
  3. កែចំណាំភាសាពីធម្មជាតិ (NLP):
    • ប្រើបច្ចេកទេស NLP ដើម្បីយល់សំណួរអ្នកប្រើ និងទាញយកព័ត៌មានពាក់ព័ន្ធ។

    • ឧទាហរណ៍:

      def process_query(query):
    # ប្រើ NLP ដើម្បីដកយកព័ត៌មានសំខាន់ពីសំណើររបស់អ្នកប្រើប្រាស់
    processed_query = nlp(query)
    return processed_query
  4. ភ្ជាប់មតិយោបល់អ្នកប្រើ:
    • ប្រមូលមតិយោបល់ពីអនុសាសន៍ដែលបានផ្តល់ និងប្រើវាសម្រាប់កែលម្អការវាយតម្លៃភាពពាក់ព័ន្ធនៅពេលក្រោយ។

    • ឧទាហរណ៍:

      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

ឧទាហរណ៍៖ ការវាយតម្លៃភាពពាក់ព័ន្ធក្នុងភ្នាក់ងារធ្វើដំណើរ

នេះជាឧទាហរណ៍ប្រតិបត្តិមួយនៃរបៀបដែលភ្នាក់ងារធ្វើដំណើរអាចវាយតម្លៃភាពពាក់ព័ន្ធនៃកំណត់អនុសាសន៍ធ្វើដំណើរ៖

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]  # បង្វិលធាតុ ១០កំពូលដែលពាក់ព័ន្ធ

    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

# ឧទាហរណ៍ការប្រើប្រាស់
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)

ស្វែងរកដោយបំណង

ការស្វែងរកដោយបំណងមានន័យថាប្រាប់ពីបំណង និងគោលបំណងដែលស្ថិតពីក្រោយសំណួរអ្នកប្រើ ដើម្បីទាញយក និងបង្កើតព័ត៌មានដែលពាក់ព័ន្ធនិងមានប្រយោជន៍បំផុត។ វិធីសាស្រ្តនេះមិនត្រឹមតែផ្គូផ្គងពាក្យគន្លឹះទេ ប៉ុន្ដែផ្តោតលើការយល់ដឹងពីតម្រូវការពិតប្រាកដ និងបរិបទរបស់អ្នកប្រើ។

គំនិតសំខាន់ក្នុងការស្វែងរកដោយបំណង

  1. ការយល់ដឹងអំពីបំណងអ្នកប្រើ:
    • បំណងអ្នកប្រើអាចចែងបែងចែកជា៣ ប្រភេទសំខាន់ៗគឺ ព័ត៌មាន, ណាវីហ្គេសិន និងប្រតិបត្តិការ។
      • បំណងព័ត៌មានៈ អ្នកប្រើស្វែងរកព័ត៌មានអំពីប្រធានបទមួយ (ឧ. “ធ្វើដូចម្តេចដើម្បីបានសារមន្ទីរល្អបំផុតនៅប៉ារីស?”)
      • បំណងណាវីហ្គេសិន: អ្នកប្រើចង់ចូលទៅកាន់គេហទំព័រឬទំព័រពិសេសមួយ (ឧ. “គេហទំព័រសារមន្ទីរ Louvre ផ្លូវការជាអ្វី?”)
      • បំណងប្រតិបត្តិការ: អ្នកប្រើមានគោលបំណងធ្វើប្រតិបត្តិការមួយ ដូចជា កក់សំបុត្រហោះហើរ ឬធ្វើការជាវ (ឧ. “កក់សំបុត្រហោះហើរទៅប៉ារីស”)។
  2. ការយល់ដឹងបរិបទ:
    • ការវិភាគបរិបទនៃសំណួរអ្នកប្រើជួយកំណត់បំណងមានភាពត្រឹមត្រូវ។ នេះរួមបញ្ចូលការពិចារណាសកម្មភាពមុនៗ ចំណូលចិត្តអ្នកប្រើ និងព័ត៌មានពិសេសនៃសំណួរបច្ចុប្បន្ន។
  3. កែចំណាំភាសាពីធម្មជាតិ (NLP):
    • ប្រើបច្ចេកវិទ្យា NLP ដើម្បីយល់ និងបកស្រាយសំណួរភាសាធម្មជាតិដែលបានផ្ដល់ដោយអ្នកប្រើ។ វារួមបញ្ចូលការរកសម្គាល់អង្គភាព បរិយាកាស និងបម្លែងសំណួរ។
  4. ប្តូរតាមបុគ្គលិកលក្ខណៈ:
    • កែលម្អលទ្ធផលស្វែងរកដោយផ្អែកលើប្រវត្តិរូបចំណូលចិត្ត និងមតិយោបល់របស់អ្នកប្រើឲ្យបានល្អបំផុត។

ឧទាហរណ៍ប្រតិបត្តិកម្ម៖ ស្វែងរកដោយបំណងក្នុងភ្នាក់ងារធ្វើដំណើរ

មកមើលថាភ្នាក់ងារធ្វើដំណើរមានរបៀបណាប្រើស្វែងរកដោយបំណង។

  1. ប្រមូលចំណូលចិត្តអ្នកប្រើ

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

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

  2. យល់ដឹងបំណងអ្នកប្រើ

    def identify_intent(query):
    if "book" in query or "purchase" in query:
        return "transactional"
    elif "website" in query or "official" in query:
        return "navigational"
    else:
        return "informational"

  3. ការយល់ដឹងបរិបទ

    def analyze_context(query, user_history):
    # លាយបញ្ចូលសំនួរបច្ចុប្បន្នជាមួយប្រវត្តិនៃអ្នកប្រើដើម្បីយល់អំពីបរិបទ
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

  4. ស្វែងរក និងផ្ទាល់ខ្លួនលទ្ធផល

    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):
    # ឧទាហរណ៍តំណើរការស្វែងរកសម្រាប់បំណងព័ត៌មាន
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # ឧទាហរណ៍តំណើរការស្វែងរកសម្រាប់បំណងផ្លូវដឹកនាំ
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # ឧទាហរណ៍តំណើរការស្វែងរកសម្រាប់បំណងប្រតិបត្តិការជាប្រាក់
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # ឧទាហរណ៍តំណើរការផ្ទាល់ខ្លួន
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # ត្រឡប់លទ្ធផលផ្ទាល់ខ្លួន ១០ លើស្តាប់

  5. ឧទាហរណ៍ការប្រើប្រាស់

    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. ការបង្កើតកូដជាឧបករណ៍

តំណាងបង្កើតកូដប្រើម៉ូដែល AI ដើម្បីសរសេរ និងអនុវត្តកូដ ដោះស្រាយបញ្ហាស្មុគស្មាញ និងស្វ័យប្រវត្តិការងារ។

តំណាងបង្កើតកូដ

តំណាងបង្កើតកូដប្រើម៉ូដែល AI ផលិតគូដសម្រាប់សរសេរ និងអនុវត្តកូដ។ តំណាងទាំងនេះអាចដោះស្រាយបញ្ហាស្មុគស្មាញ ស្វ័យប្រវត្តិការងារ និងផ្តល់ចំណេះដឹងមានតម្លៃ ដោយបង្កើតនិងរត់កូដនៅក្នុងភាសាកម្មវិធីផ្សេងៗ។

ការប្រើប្រាស់ក្នុងអនុវត្តពិតប្រាកដ

  1. ការបង្កើតកូដស្វ័យប្រវត្តិ: បង្កើតកូដសម្រាប់ការងារផ្សេងៗ ដូចជា វិភាគទិន្នន័យ ការ scrape វេបសាយ ឬ ការរៀនម៉ាស៊ីន។
  2. SQL ជា RAG: ប្រើការស្វ័យរកក្នុង SQL ដើម្បីយកនិងកែប្រែទិន្នន័យពីមូលដ្ឋានទិន្នន័យ។
  3. ដោះស្រាយបញ្ហា: បង្កើតនិងអនុវត្តកូដដើម្បីដោះស្រាយបញ្ហាដូចជា បង្រ្កាបអាល់ហ្គុរិធម ឬ វិភាគទិន្នន័យ។

ឧទាហរណ៍៖ តំណាងបង្កើតកូដសម្រាប់វិភាគទិន្នន័យ

សូមនឹកស្រមៃថាអ្នកកំពុងរចនា តំណាងបង្កើតកូដ។ នេះជារបៀបវាអាចដំណើរការ:

  1. ភារកិច្ច: វិភាគឯកសារទិន្នន័យដើម្បីស្វែងរកនិន្នាការ និងលំនាំ។
  2. ជំហាន:
    • បញ្ចូលឯកសារទិន្នន័យទៅក្នុងឧបករណ៍វិភាគទិន្នន័យ។
    • បង្កើតសំណួរ SQL សម្រាប់តម្រាច់និងសរុបទិន្នន័យ។
    • អនុវត្តសំណួរនិងយកលទ្ធផល។
    • ប្រើលទ្ធផលបង្កើតការបង្ហាញនិងចំណេះដឹង។
  3. ធនធានចាំបាច់: ចូលប្រើឯកសារទិន្នន័យ ឧបករណ៍វិភាគទិន្នន័យ និងសមត្ថភាព SQL។
  4. បទពិសោធន៍: ប្រើលទ្ធផលពីការវិភាគកន្លងមកដើម្បីបង្កើតភាពត្រឹមត្រូវនិងពាក់ព័ន្ធនៅការវិភាគក្រោយ។

ឧទាហរណ៍៖ តំណាងបង្កើតកូដសម្រាប់ភ្នាក់ងារធ្វើដំណើរ

ក្នុងឧទាហរណ៍នេះ យើងនឹងរចនាតំណាងបង្កើតកូដ Travel Agent ដើម្បីជួយអ្នកប្រើក្នុងការធ្វើផែនការធ្វើដំណើរ ដោយបង្កើតនិងអនុវត្តកូដ។ តំណាងនេះអាចបំពេញភារកិច្ចដូចជា ដកយកជម្រើសធ្វើដំណើរ តម្រាច់លទ្ធផល និងសម្រួលផែនការផ្ទាល់ខ្លួនដោយប្រើ AI ផលិត។

សេចក្ដីសង្ខេបនៃតំណាងបង្កើតកូដ

  1. ប្រមូលចំណូលចិត្តអ្នកប្រើ: ប្រមូលព័ត៌មានពីអ្នកប្រើ ដូចជា ទីកន្លែង ទីស្នាក់ការធ្វើដំណើរ ថ្ងៃខែ ឆ្នាំ ថវិកា និងចំណង់ចំណូលចិត្ត។
  2. បង្កើតកូដសម្រាប់យកទិន្នន័យ: បង្កើតកូដសម្រាប់យកព័ត៌មានអំពីជើងហោះអាកាស សណ្ឋាគារ និងកន្លែងទេសចរណ៍។
  3. អនុវត្តកូដដែលបានបង្កើត: រត់កូដដើម្បីយកព័ត៌មានពេលវេលាពិត។
  4. បង្កើតផែនការធ្វើដំណើរ: សម្រួលព័ត៌មានដែលបានយកជាគម្រោងធ្វើដំណើរផ្ទាល់ខ្លួន។
  5. កែប្រែដោយផ្អែកលើមតិយោបល់: ទទួលមតិយោបល់ពីអ្នកប្រើ ហើយបង្កើតកូដឡើងវិញបើចាំបាច់ដើម្បីធ្វើអោយលទ្ធផលប្រសើរឡើង។

ការអនុវត្តជាជំហានៗ

  1. ប្រមូលចំណូលចិត្តអ្នកប្រើ

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

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

  2. បង្កើតកូដសម្រាប់យកទិន្នន័យ

    def generate_code_to_fetch_data(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):
    # ឧទាហរណ៍៖ បង្កើតកូដសម្រាប់ស្វែងរកសណ្ឋាគារ
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

  3. អនុវត្តកូដដែលបានបង្កើត

    def execute_code(code):
    # ដំណើរការកូដដែលបានបង្កើតដោយប្រើ exec
    exec(code)
    result = locals()
    return result

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

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

  4. បង្កើតផែនការធ្វើដំណើរ

    def generate_itinerary(flights, hotels, attractions):
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

attractions = search_attractions(preferences)
itinerary = generate_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)

  5. កែប្រែដោយផ្អែកលើមតិយោបល់

    def adjust_based_on_feedback(feedback, preferences):
    # តម្រូវចំណង់ចំណូលផ្អែកលើមតិយោបល់អ្នកប្រើប្រាស់
    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)
   
# បង្កើតឡើងវិញ និងអនុវត្តកូដជាមួយចំណង់ចំណូលដែលបានធ្វើឱ្យទាន់សម័យ
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)

ប្រើប្រាស់ការយល់ដឹង និងហេតុផលបរិស្ថាន

ប្អែកលើស្គីម៉ារបស់តារាង អាចធ្វើឲ្យដំណើរការបង្កើតសំណួរល្អប្រសើរឡើងដោយប្រើប្រាស់ការយល់ដឹង និងហេតុផលបរិស្ថាន។

នេះជាឧទាហរណ៍ពីរបៀបដែលអាចធ្វើបាន៖

  1. យល់អំពីស្គីម៉ា: ប្រព័ន្ធនឹងយល់ដឹងពីស្គីម៉ារបស់តារាង និងប្រើព័ត៌មាននេះក្នុងការបង្កើតសំណួរ។
  2. កែប្រែដោយផ្អែកលើមតិយោបល់: ប្រព័ន្ធនឹងកែប្រែចំណូលចិត្តអ្នកប្រើដោយផ្អែកលើមតិយោបល់ និងយល់អំពីវាលដែលត្រូវកែប្រែក្នុងស្គីម៉ា។
  3. បង្កើតនិងអនុវត្តសំណួរ: ប្រព័ន្ធនឹងបង្កើតនិងអនុវត្តសំណួរដើម្បីយកទិន្នន័យជើងហោះហើរ និងសណ្ឋាគារបន្ទាប់ពីកែប្រែចុងក្រោយ។

នេះជាឧទាហរណ៍កូដ Python ដែលបានធ្វើបច្ចុប្បន្នភាពរួមបញ្ចូលគំនិតទាំងនេះ៖

def adjust_based_on_feedback(feedback, preferences, schema):
    # កែសម្រួលចំណង់ចំណូលចិត្តដោយផ្អែកលើមតិបញ្ចាក់ពីអ្នកប្រើ
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # ការចោទឡើងវិញដោយផ្អែកលើរូបមន្តដើម្បីកែសម្រួលចំណង់ចំណូលចិត្តផ្សេងទៀតដែលពាក់ព័ន្ធ
    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):
    # លក្ខណៈថ្នាក់ប្ដូរផ្ទាល់ខ្លួនសម្រាប់កែសម្រួលចំណង់ចំណូលចិត្តដោយផ្អែកលើរូបមន្តនិងមតិបញ្ចាក់
    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):
    # បង្កើតកូដដើម្បីយកទិន្នន័យហោះហើរដោយផ្អែកលើចំណង់ចំណូលចិត្តដែលបានធ្វើបច្ចុប្បន្នភាព
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # បង្កើតកូដដើម្បីយកទិន្នន័យសណ្ឋាគារដោយផ្អែកលើចំណង់ចំណូលចិត្តដែលបានធ្វើបច្ចុប្បន្នភាព
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # ការបង្ហាញការប្រតិបត្តិករនៃកូដរៀបចំហើយបញ្ចូនទិន្នន័យគំរូ
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # បង្កើតផែនការធ្វើដំណើរដោយផ្អែកលើហោះហើរ សណ្ឋាគារ និងកន្លែងទាក់ទាញ
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# រូបមន្តឧទាហរណ៍
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# ការប្រើប្រាស់ឧទាហរណ៍
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# បង្កើតឡើងវិញ និងអង្គុយបញ្ចូលកូដជាមួយចំណង់ចំណូលចិត្តដែលបានធ្វើបច្ចុប្បន្នភាព
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)

ពន្យល់ - ការកក់ដោយផ្អែកលើមតិយោបល់

  1. ការយល់ដឹងអំពីស្គីម៉ា: កំណត់តារាង schema បញ្ជាក់របៀបកែប្រែចំណូលចិត្តដោយផ្អែកលើមតិយោបល់។ មានវាលដូចជា favorites និង avoid ជាមួយការកែប្រែដែលពាក់ព័ន្ធ។
  2. កែប្រែចំណូលចិត្ត (វិធីសាស្រ្ត adjust_based_on_feedback): វិធីសាស្រ្តនេះកែប្រែចំណូលចិត្តដោយផ្អែកលើមតិយោបល់អ្នកប្រើ និងស្គីម៉ា។
  3. កែប្រែផ្អែកលើបរិស្ថាន (វិធីសាស្រ្ត adjust_based_on_environment): វិធីសាស្រ្តនេះតម្រូវការការកែប្រែដោយផ្អែកលើស្គីម៉ា និងមតិយោបល់។
  4. បង្កើតនិងអនុវត្តសំណួរ: ប្រព័ន្ធបង្កើតកូដដើម្បីយកទិន្នន័យជើងហោះហើរ និងសណ្ឋាគារដែលបានកែប្រែ និងចាក់សម្រង់សំណួរទាំងនេះ។
  5. បង្កើតផែនការ: ប្រព័ន្ធបង្កើតផែនការថ្មីដោយផ្អែកលើទិន្នន័យជើងហោះហើរ សណ្ឋាគារ និងកន្លែងទេសចរណ៍ថ្មី។

ដោយធ្វើឲ្យប្រព័ន្ធមានការយល់ដឹងបរិស្ថាន និងហេតុផលដោយផ្អែកលើស្គីម៉ា វាអាចបង្កើតសំណួរដែលត្រឹមត្រូវនិងពាក់ព័ន្ធបន្ថែម ដែលនាំឲ្យមានការផ្ដល់អនុសាសន៍ធ្វើដំណើរល្អប្រសើរជាងមុន និងបទពិសោធន៍អ្នកប្រើផ្ទាល់ខ្លួន។

ប្រើ SQL ជាវិធីសាស្រ្ត Retrieval-Augmented Generation (RAG)

SQL (Structured Query Language) ជាឧបករណ៍មានកម្លាំងសម្រាប់ធ្វើប្រតិបត្តិការជាមួយមូលដ្ឋានទិន្នន័យ។ នៅពេលប្រើជាផ្នែកនៃវិធីសាស្រ្ត Retrieval-Augmented Generation (RAG) SQL អាចយកទិន្នន័យពាក់ព័ន្ធពីមូលដ្ឋានទិន្នន័យដើម្បីផ្តល់ឲ្យនិងបង្កើតចម្លើយ ឬសកម្មភាពនៅក្នុងតំណាង AI។ យើងមកស្វែងយល់ពីរបៀបប្រើប្រាស់ SQL ជាវិធីសាស្រ្ត RAG ក្នុងបរិបទ Travel Agent។

គំនិតសំខាន់ៗ

  1. ប្រតិបត្តិការមូលដ្ឋានទិន្នន័យ:
    • SQL ប្រើសម្រាប់សំណួរមូលដ្ឋានទិន្នន័យ ដកយកព័ត៌មានពាក់ព័ន្ធ និងកែប្រែទិន្នន័យ។
    • ឧទាហរណ៍ៈ ដកព័ត៌មានជើងហោះហើរ សណ្ឋាគារ និងកន្លែងទេសចរណ៍ពីមូលដ្ឋានទិន្នន័យធ្វើដំណើរ។
  2. ការផ្សំនិង RAG:
    • សំណួរ SQL ត្រូវបានបង្កើតដោយផ្អែកលើអត្ថបទអ្នកប្រើ និងចំណូលចិត្ត។
    • ទិន្នន័យដែលបានយកនោះត្រូវបានប្រើដើម្បីបង្កើតអនុសាសន៍ ឬសកម្មភាពផ្ទាល់ខ្លួន។
  3. ការបង្កើតសំណួរដោយ δυναμικόភាព:
    • តំណាង AI បង្កើតសំណួរ SQL ដោយមាន δυναμικόភាព អាស្រ័យលើបរិបទ និងតម្រូវការអ្នកប្រើ។
    • ឧទាហរណ៍ៈ ប្តូរសំណួរ SQL តម្រាច់លទ្ធផលដោយផ្អែកលើយថវិកា កាលបរិច្ឆេទ និងចំណង់ចំណូលចិត្ត។

ការប្រើប្រាស់

ឧទាហរណ៍: តំណាងវិភាគទិន្នន័យ៖

  1. ភារកិច្ច: វិភាគឯកសារទិន្នន័យដើម្បីស្វែងរកនិន្នាការ។
  2. ជំហាន:
    • បញ្ចូលឯកសារទិន្នន័យ។
    • បង្កើតសំណួរ SQL សម្រាប់តម្រាច់ទិន្នន័យ។
    • អនុវត្តសំណួរនិងយកលទ្ធផល។
    • បង្កើតការបង្ហាញនិងចំណេះដឹង។
  3. ធនធាន: ចូលប្រើឯកសារ និងសមត្ថភាព SQL។
  4. បទពិសោធន៍: ប្រើលទ្ធផលកន្លងមកដើម្បីធ្វើឲ្យមានភាពត្រឹមត្រូវនិងពាក់ព័ន្ធក្នុងការវិភាគក្រោយ។

ឧទាហរណ៍ជាក់លាក់៖ ប្រើ SQL នៅ Travel Agent

  1. ប្រមូលចំណូលចិត្តអ្នកប្រើ

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

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

  2. បង្កើតសំណួរ SQL

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

  3. អនុវត្តសំណួរ SQL

    import sqlite3

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

  4. បង្កើតអនុសាសន៍

    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)

ឧទាហរណ៍សំណួរ SQL

  1. សំណួរជើងហោះហើរ

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

  2. សំណួរសណ្ឋាគារ

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

  3. សំណួរកន្លែងទេសចរណ៍

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

ដោយប្រើ SQL ជាផ្នែកនៃវិធីសាស្រ្ត Retrieval-Augmented Generation (RAG) តំណាង AI ដូចជា Travel Agent អាចយកនិងប្រើទិន្នន័យពាក់ព័ន្ធបាន δυναμικό អោយផ្ដល់អនុសាសន៍ត្រឹមត្រូវ និងផ្ទាល់ខ្លួនបានល្អ។

ឧទាហរណ៍នៃការគិតស្រមៃ Meta-cognition

ដើម្បីបង្ហាញវិធីអនុវត្តន៍ meta-cognition មួយ យើងសាងសង់តំណាងតូចម្នាក់ដែល ពិចារណាអំពីដំណើរការសម្រេចចិត្តរបស់ខ្លួន ខណៈកំពុងដោះស្រាយបញ្ហា។ សម្រាប់ឧទាហរណ៍នេះ យើងនឹងបង្កើតប្រព័ន្ធមួយ ដែលតំណាងនេះព្យាយាមធ្វើឲ្យជម្រើសសណ្ឋាគារល្អបំផុត ប៉ុន្តែបន្ទាប់មកវាចាប់ផ្តើមវាយតម្លៃហេតុផលរបស់ខ្លួន ហើយកែប្រែយុទ្ធសាស្រ្តនៅពេលវាធ្វើកំហុស ឬជម្រើសមិនល្អ។

យើងនឹងទទួលយកឧទាហរណ៍មូលដ្ឋានមួយ ដែលអ្នកតំណាងជ្រើសរើសសណ្ឋាគារដោយផ្អែកលើតម្លៃ និងគុណភាព ប៉ុន្តែវា “ពិចារណា” រឿងជម្រើសរបស់ខ្លួន ហើយកែប្រែតាមការពិចារណា។

របៀបនេះបង្ហាញពី Meta-cognition:

  1. ការសម្រេចចិត្តដំបូង: តំណាងនឹងជ្រើសរើសសណ្ឋាគារដែលថ្លៃជាទាបជាងគេ ដោយមិនយល់ពីផលប៉ះពាល់គុណភាព។
  2. ការផ្តោតលើ និងវាយតម្លៃ: បន្ទាប់ការជ្រើសដំបូង អ្នកតំណាងនឹងពិនិត្យមើលថាសណ្ឋាគារនោះជាជម្រើស “អាក្រក់” ឬអត់ ដោយផ្អែកលើមតិយោបល់អ្នកប្រើ។ បើវាជួបថាគុណភាពសណ្ឋាគារតិចពេក វានឹងពិចារណាហេតុផលរបស់ខ្លួន។
  3. ការកែប្រែយុទ្ធសាស្រ្ត: អ្នកតំណាងកែប្រែយុទ្ធសាស្រ្តដោយផ្អែកលើការពិចារណា ខាលពីជម្រើសវាចេញពី “ថ្លៃជាតម្លៃទាប” ទៅជា “គុណភាពខ្ពស់បំផុត” ដូច្នេះធ្វើឱ្យដំណើរការសម្រេចចិត្តល្អប្រសើរលើការដំណើរការថ្មីៗ។

នេះជាឧទាហរណ៍៖

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # ទុកស្តុកសណ្ឋាគារដែលបានជ្រើសរើសមុន
        self.corrected_choices = []  # ទុកស្តុកជម្រើសដែលបានកែតម្រូវ
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # យុទ្ធសាស្រ្តដែលមានស្រាប់

    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]
        # យើងសន្មត់ថាមានមតិយោបល់ពីអ្នកប្រើប្រាស់ដែលប្រាប់យើងថាជម្រើសចុងក្រោយល្អឬអត់
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # កែសម្រួលយុទ្ធសាស្រ្ត ប្រសិនបើជម្រើសមុនមិនពេញចិត្ត
            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"

# ការបញ្ចាក់តំណាងរបស់បញ្ជីសណ្ឋាគារ (តម្លៃ និងគុណភាព)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# បង្កើតភ្នាក់ងារ
agent = HotelRecommendationAgent()

# ជំហានទី 1: ភ្នាក់ងារផ្តល់អនុសាសន៍សណ្ឋាគារមួយដោយប្រើយុទ្ធសាស្រ្ត "ថ្លៃទាបជាងគេ"
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# ជំហានទី 2: ភ្នាក់ងាររំលឹកពីជម្រើស និងកែសម្រួលយុទ្ធសាស្ត្របើចាំបាច់
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# ជំហានទី 3: ភ្នាក់ងារផ្តល់អនុសាសន៍ម្តងទៀត ដោយប្រើយុទ្ធសាស្ត្រដែលបានកែសម្រួល
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

សមត្ថភាព Meta-cognition របស់តំណាង

គន្លឹះនៅទីនេះ គឺសមត្ថភាពរបស់តំណាងក្នុងការធ្វើ៖

នេះគឺជារបៀប meta-cognition លំហាត់មូលដ្ឋាន ដែលប្រព័ន្ធអាចកែប្រែដំណើរការហេតុផលរបស់ខ្លួនដោយផ្អែកលើការពេញចិត្តខាងក្នុង។

សន្និដ្ឋាន

Meta-cognition ជាឧបករណ៍មានកម្លាំងដែលអាចបង្កើនសមត្ថភាពរបស់តំណាង AI យ៉ាងខ្លាំង។ ដោយបញ្ចូលដំបូន្មាន meta-cognitive អ្នកអាចរចនាតំណាងដែលមានភាពឆ្លាតវៃ ជឿនលឿន និងមានប្រសិទ្ធិភាព។ ប្រើធនធានបន្ថែមដើម្បីស្វែងយល់បន្ថែមអំពីពិភព meta-cognition ក្នុងតំណាង AI។

តើអ្នកមានសំណួរបន្ថែមអំពីគំរោងរចនាតំណាង Meta-cognition?

ចូលរួមជាមួយ Microsoft Foundry Discord ដើម្បីជួបជាមួយអ្នករៀនផ្សេងទៀត ចូលរួមម៉ោងការិយាល័យ និងទទួលបានចម្លើយសំណួរអំពីតំណាង AI របស់អ្នក។

មេរៀនមុន

គំរូបន្ថែមសម្រាប់ Multi-Agent

មេរៀនបន្ទាប់

តំណាង AI នៅក្នុងការផលិត

ការបដិសេធ: ឯកសារនេះត្រូវបានបម្លែងភាសា ដោយប្រើសេវាបម្លែងភាសា AI Co-op Translator។ ទោះយើងខ្ញុំមានក្តីប្រាថ្នាឱ្យបានច្បាស់លាស់ តែសូមយល់ដឹងថាការបម្លែងដោយស្វ័យប្រវត្តិក៏អាចមានកំហុសឬភាពមិនត្រឹមត្រូវ។ ឯកសារដើមជាភាសាទីតាំងគួរត្រូវបានគេប្រើជាប្រភពច្បាស់លាស់។ សម្រាប់ព័ត៌មានសំខាន់ៗ សូមណែនាំឱ្យប្រើប្រាស់ការប្រែដោយមនុស្សជំនាញ។ យើងខ្ញុំមិនទទួលខុសត្រូវចំពោះការយល់ច្រឡំ ឬការបកស្រាយខុសបន្ទាប់ពីការប្រើប្រាស់ការបម្លែងនេះនោះទេ។

This site is open source. Improve this page.