ai-agents-for-beginners
(ഈ പാഠത്തിന്റെ വീഡിയോ കാണാൻ മുകളിൽ ചിത്രത്തിൽ ക്ലിക്കുചെയ്യുക)
AI ഏജന്റുകളിലെ മെറ്റാകോഗ്നിഷൻ
പരിചയം
AI ഏജന്റുകളിലെ മെറ്റാകോഗ്നിഷൻ പാഠത്തിലേയ്ക്ക് സ്വാഗതം! ഈ അധ്യായം, AI ഏജന്റുകൾ തങ്ങളുടെ താൻ ചിന്തിക്കുന്ന പ്രക്രിയകൾ എങ്ങിനെ ആലോചിക്കാമെന്ന് അറിയാൻ ഇച്ഛിക്കുന്ന തുടങ്ങുന്നവര്ക്ക് വേണ്ടിയാണ്. ഈ പാഠം അവസാനിക്കുന്നതിന് നിങ്ങൾ പ്രധാന ആശയങ്ങൾ മനസിലാക്കുകയും AI ഏജന്റ് രൂപകൽപ്പനയിൽ മെറ്റാകോഗ്നിഷൻ പ്രയോഗിക്കാൻ പ്രായോഗിക ഉദാഹരണങ്ങളാൽ സജ്ജമാകുകയും ചെയ്യും.
പഠന ലക്ഷ്യങ്ങൾ
ഈ പാഠം പൂർത്തിയാക്കിയതിന് ശേഷം, നിങ്ങൾക്ക് കഴിയും:
- ഏജന്റ് നിർവചനങ്ങളിൽ ന്യായവൃത്തങ്ങളുടെ പ്രാധാന്യം മനസിലാക്കുക.
- സ്വയം തിരുത്തൽ സാധ്യമായ ഏജന്റുകൾക്ക് സഹായിക്കുന്നുവാൻ പദ്ധതീകരണവും വിലയിരുത്തലും ഉപയോഗിക്കുക.
- ടാസ്കുകൾ പൂർത്തിയാക്കാൻ കോഡ് കൈകാര്യം ചെയ്യാൻ കഴിവുള്ള നിങ്ങളുടെ സ്വന്തം ഏജന്റുകൾ സൃഷ്ടിക്കുക.
മെറ്റാകോഗ്നിഷനിലേക്ക് പരിചയം
മെറ്റാകോഗ്നിഷൻ അതായത് “ചിന്തിക്കുന്നതിന് ചിന്തിക്കുക” എന്ന അര്ത്ഥത്തിൽ, ഒരാളുടെ സ്വന്തം ചിന്തിക്കുന്ന പ്രക്രിയയെക്കുറിച്ച് ആലോചിക്കുന്ന ഉയർന്ന തലത്തിലെ ബുദ്ധിമുട്ടുകൾ ആണ്. AI ഏജന്റുകൾക്ക്, ഇതിന്റെ അർത്ഥം സ്വയം വിവരം ആസ്വദിക്കുകയും പണ്ട് അനുഭവങ്ങളും അടിസ്ഥാനമാക്കി സ്വയം ക്രിയകൾ വിലയിരുത്തുകയും ക്രമീകരിക്കുകയും ചെയ്യാൻ കഴിയുന്നതാണ്. മെറ്റാകോഗ്നിഷൻ, അല്ലെങ്കിൽ “ചിന്തിക്കുകയെന്നതിനെയും ബോധ്യപ്പെടുത്തുന്നതും,” ഏജന്റിക് AI സിസ്റ്റങ്ങൾ വികസിപ്പിക്കാൻ അത്യന്താപേക്ഷിതമാണ്. ഇത് AI സിസ്റ്റങ്ങൾ സ്വന്തം അന്തർവായിനതൊഴിയെയും ശ്രദ്ധിക്കാനും നിയന്ത്രിക്കാനും ക്രമീകരിക്കാനും സഹായിക്കുന്നു. നമ്മുടെ പോലെ എങ്ങനെ റൂം വായിക്കുകയോ പ്രശ്നം കാണുകയോ ചെയ്യുന്നുവോ, അങ്ങനെ. ഈ സ്വയം ബോധ്യം AI സിസ്റ്റങ്ങൾക്ക് മെച്ചപ്പെട്ട തീരുമാനങ്ങൾ ഉണ്ടാക്കാനും പാളി കണ്ടെത്താനും അവരുടെ പ്രകടനം മികവുറ്റതാക്കാനുമുള്ള ഉപകരണമാകും — തുരിംഗ് പരീക്ഷയും AI takeover കാര്യത്തിൽ ഉള്ള ചർച്ചകളും വീണ്ടും ഇതിലേക്ക് തിരിച്ചുപോകുന്നു.
ഏജന്റിക് AI സിസ്റ്റങ്ങളിൽ, മെറ്റാകോഗ്നിഷൻ താഴെപറയുന്ന ചില വെല്ലുവിളികൾ പരിഹരിക്കാൻ സഹായിക്കുന്നു:
- തനി: AI സിസ്റ്റങ്ങൾ അവരുടെ പരിഗണനയും തീരുമാനങ്ങളും വിശദീകരിക്കാൻ കഴിയണം.
- ന്യായീകരണം: AI സിസ്റ്റങ്ങൾ വിവരങ്ങൾ സംയോജിപ്പിച്ച് നല്ല വിധിയിൽ തീരുമാനങ്ങൾ എടുക്കാനുള്ള കഴിവ് വർദ്ധിപ്പിക്കുക.
- ക്രമീകരണം: AI സിസ്റ്റങ്ങൾ പുതിയ പരിസ്ഥിതികളും മാറ്റം വരുത്തിയ സാഹചര്യങ്ങളും അനുസരിച്ച് ക്രമീകരിക്കണം.
- ദൃശ്യമാനത: AI സിസ്റ്റങ്ങൾ അവരുടെ പരിസ്ഥിതിയിൽ നിന്നുള്ള ഡിറ്റ ഉപയോഗിച്ച് കൃത്യതയും വ്യാഖ്യാനവും മെച്ചപ്പെടുത്തൽ.
മെറ്റാകോഗ്നിഷൻ എന്ത്?
മെറ്റാകോഗ്നിഷൻ, അല്ലെങ്കിൽ “ചിന്തിക്കുന്നതിനേക്കുറിച്ച് ചിന്തിക്കൽ,” ഉയർന്ന തലത്തിലെ ബുദ്ധിമുട്ടുള്ള പ്രക്രിയയാണ്, അത് സ്വയം ബോധ്യവും സ്വയം നിയന്ത്രണവും ഉൾക്കൊള്ളുന്നു. AI മേഖലയിൽ, മെറ്റാകോഗ്നിഷൻ ഏജന്റുകൾക്ക് അവരുടെ തന്ത്രങ്ങളും നടപടികളും വിലയിരുത്തുകയും ക്രമീകരിക്കുകയും ചെയ്യാൻ സജ്ജമാക്കുന്നു, പ്രശ്ന പരിഹാരവും തീരുമാനമെടുക്കലും മെച്ചപ്പെടുന്നു. മെറ്റാകോഗ്നിഷൻ മനസ്സിലാക്കുന്നതിലൂടെ നിങ്ങൾക്ക് ഏറ്റവും ബുദ്ധിമുട്ടുള്ള, അനുസൃതമായ, കാര്യക്ഷമമായ AI ഏജന്റുകൾ രൂപകൽപ്പന ചെയ്യാൻ കഴിയും. ശരിയായ മെറ്റാകോഗ്നിഷനിൽ, AI സ്വയം തന്റെ ന്യായീകരണത്തെക്കുറിച്ച് വ്യക്തമായി കരുതുന്നു.
ഉദാഹരണം: “ഞാൻ വില കുറവായ വിമാന ടിക്കറ്റുകൾ മുൻഗണന നൽകിയതിനാൽ… ഞാന് നേരിട്ട് പോകുന്ന വിമാനങ്ങൾ നഷ്ടപ്പെട്ടിരിക്കാം, എന്നുകൊണ്ട് വീണ്ടും പരിശോധിക്കാം.” ഏതുവഴി یا എങ്ങനെ അത് ഒരു പ്രത്യേക റൂട്ടു തിരഞ്ഞെടുക്കുകയെന്ന് ആരായുന്നത്.
- കഴിഞ്ഞ തവണ ഉപയോക്തൃ ഇഷ്ടങ്ങളോട് മീതെ ആശ്രയിച്ചതിനാൽ പിഴവുകൾ സംഭവിച്ചതായി ശ്രദ്ധിക്കുകയും, ഒടുവിലെ ശുപാർശ അല്ല, ന്യായീകരണ തന്ത്രം തന്നെ മാറ്റുക.
- “ഉപയോക്താവ് ‘വെറുതെ തിരക്കേറിയ’ എന്ന് പറഞ്ഞാൽ, ചില ആകർഷണങ്ങൾ ഒഴിവാക്കണമെന്ന് മാത്രമല്ല, എപ്പോഴെങ്കിലും പ്രശസ്തി അനുസരിച്ച് ‘ഉയർന്ന ആകർഷണങ്ങൾ’ തിരഞ്ഞെടുക്കുന്നതിൽ പിഴവുണ്ട് എന്നും തിരിച്ചറിയുക.”
AI ഏജന്റുകളിലെ മെറ്റാകോഗ്നിഷന്റെ പ്രാധാന്യം
പശ്ചാത്തലവിധേയമായി, മെറ്റാകോഗ്നിഷൻ AI ഏജന്റ് രൂപകൽപ്പനയിൽ വളരെ പ്രധാനമാണ്:
- സ്വയം പരിചിന്തന: ഏജന്റുകൾ തങ്ങളുടെ പ്രകടനം വിലയിരുത്തുകയും മെച്ചപ്പെടുത്താനുള്ള മേഖലകൾ തിരിച്ചറിയുകയും ചെയ്യുന്നു.
- അനുസരണക്ഷമത: ഏജന്റുകൾ കഴിഞ്ഞ അനുഭവങ്ങൾക്കും മാറ്റങ്ങൾ വന്ന പരിസ്ഥിതികൾക്കും അനുസരിച്ച് തന്ത്രങ്ങൾ ക്രമീകരിക്കും.
- പിഴവുകൾ തിരുത്തൽ: ഏജന്റുകൾ സ്വയം പിഴവുകൾ കണ്ടെത്തി തിരുത്താൻ കഴിയും, ഇത് കൂടുതൽ കൃത്യമായ ഫലങ്ങളിലേക്ക് നയിക്കുന്നു.
- വിഭവ പരിപാലനം: ഏജന്റുകൾ സമയം, കമ്പ്യൂട്ടിംഗ് ശക്തി പോലുള്ള വിഭവങ്ങളുടെ ഉപയോഗം പദ്ധതിയിടുകയും വിലയിരുത്തുകയും ചെയ്ത് അതിനെ മെച്ചപ്പെടുത്തും.
AI ഏജന്റെ ഘടകങ്ങൾ
മെറ്റാകോഗ്നിഷൻ പ്രക്രിയകളിലേക്ക് കടക്കുന്നതിനുമുൻപ്, AI ഏജന്റിന്റെ അടിസ്ഥാന ഘടകങ്ങൾ മനസിലാക്കുന്നത് അനിവാര്യമാണ്. ഒരു AI ഏജന്റ് സാധാരണയായി ഉള്ക്കൊള്ളുന്നത്:
- വ്യക്തിത്വം: ഏജന്റിന്റെ വ്യക്തിത്വവും സ്വഭാവങ്ങളും, ഉപയോക്താക്കളുമായി എങ്ങനെ ഇടപഴകുന്നുവെന്ന് നിർവ്വചിക്കുന്നു.
- ഉപകരണങ്ങൾ: ഏജന്റ് നിർവഹിക്കാവുന്ന കഴിവുകളും ഫംഗ്ഷനുകളും.
- നൈപുണ്യങ്ങൾ: ഏജന്റിന് ഉള്ള അറിവും പരിജ്ഞാനവും.
ഈ ഘടകങ്ങൾ ചേർന്ന് ഒരു “വിദഗ്ദ്ധതാ യൂണിറ്റ്” രൂപപ്പെടുത്തുന്നു, പ്രത്യേക തസ്കരങ്ങൾ നിർവഹിക്കാൻ കഴിയും.
ഉദാഹരണം: ഒരു ട്രാവൽ ഏജന്റിനെ പരിഗണിക്കുക, അത് നിങ്ങളുടെ അവധിക്കാലം പദ്ധതിയിടുന്നതിനൊപ്പം യഥാർത്ഥ സമയ ഡാറ്റയും മുൻ ഉപഭോക്തൃ യാത്രാനുഭവങ്ങളും അടിസ്ഥാനമാക്കി തങ്ങളുടെ പാത ക്രമീകരിക്കുകയും ചെയ്യുന്നു.
ഉദാഹരണം: ഒരു ട്രാവൽ ഏജന്റ് സർവീസിൽ മെറ്റാകോഗ്നിഷൻ
ദയവായി സങ്കല്പിക്കുക നിങ്ങൾ ഒരു 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. ഏജന്റുകളിൽ പദ്ധതിയിടൽ
പദ്ധതിയിടൽ 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)
3. തിരുത്തൽ RAG സംവിധാനം
ആദ്യം RAG ടൂൾക്കും പ്രീ-എംപ്റ്റീവ് കോൺടെക്സ് ലോഡിംഗിനും ഇടയിലുള്ള വ്യത്യാസം മനസിലാക്കാം.
റിട്രീവൽ-ഓഗ്മെൻറഡ് ജനിഫറേഷൻ (RAG)
RAG ഒരു റിട്രീവൽ സിസ്റ്റവും ജനറേറ്റീവ് മോഡലും സംയോജിപ്പിക്കുന്നു. ഒരു ക്വറി വന്നപ്പോൾ, റിട്രീവൽ സിസ്റ്റം ബന്ധപ്പെട്ട ഡോക്യൂമെന്റുകളും ഡാറ്റയും പുറത്തെടുക്കുന്നു, ഇതു ജനറേറ്റീവ് മോഡലിൽ ഇൻപുട്ടായി ചേർക്കുന്നു. ഇത് മോഡലിന് കൂടുതൽ കൃത്യവും സാന്ദർഭികവുമായ മറുപടികൾ ജനിപ്പിക്കാൻ സഹായിക്കുന്നു.
RAG സിസ്റ്റത്തിൽ, ഏജന്റ് അറിവ് അടിസ്ഥാനത്തിൽ ബന്ധപ്പെട്ട വിവരങ്ങൾ തിരികെ കൊണ്ടുവരുകയും ശരിയായ മറുപടികളും പ്രവർത്തനങ്ങളും ഉണ്ടാക്കുകയും ചെയ്യുന്നു.
തിരുത്തൽ RAG സമീപനം
തിരുത്തൽ RAG സമീപനം RAG സാങ്കേതികവിദ്യകൾ ഉപയോഗിച്ച് പിഴവുകൾ തിരുത്തുകയും AI ഏജന്റുകളുടെ കൃത്യത മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു. ഇതിൽ ഉൾപ്പെടുന്നത്:
- പ്രമ്പ്റ്റിംഗ് സാങ്കേതികം: ഏജന്റിനെ ബന്ധപ്പെട്ട വിവരങ്ങൾ തിരികെ കൊണ്ടുവരാൻ നയിക്കുന്ന പ്രത്യേക പ്രമ്പ്റ്റുകൾ ഉപയോഗിച്ച്.
- ഉപകരണം: തിരികെ കൊണ്ടുവരുന്ന വിവരങ്ങളുടെ പ്രസക്തി വിലയിരുത്താനും കൃത്യമായ മറുപടികൾ ജനിപ്പിക്കാനും സഹായിക്കുന്ന ആല്ഗോരിതങ്ങളുടെയും സംവിധാനങ്ങളുടെയും നടപ്പാക്കൽ.
- വിലയിരുത്തൽ: ഏജന്റിന്റെ പ്രകടനം തുടർച്ചയായി വിലയിരുത്തി അതിന്റെ കൃത്യതയും കാര്യക്ഷമതയും മെച്ചപ്പെടുത്തണം.
ഉദാഹരണം: തിരുത്തൽ RAG ഒരു സേർച്ച് ഏജന്റിൽ
വെബ് നിന്നുള്ള വിവരങ്ങൾ തിരികെ കൊണ്ടുവന്ന് ഉപയോക്തൃ ചോദനകളയ്ക്ക് മറുപടി നൽകുന്ന ഒരു സേർച്ച് ഏജന്റ് പരിഗണിക്കൂ. തിരുത്തൽ RAG സമീപനം ഘടകങ്ങൾ:
- പ്രമ്പ്റ്റിംഗ് സാങ്കേതികം: ഉപയോക്താവിന്റെ ഇൻപുട്ട് പ്രകാരം തിരയൽ ക്വറികൾ രൂപപ്പെടുത്തി.
- ഉപകരണങ്ങൾ: നാച്ചുറൽ ലാംഗ്വേജ് പ്രോസസ്സിംഗും മെഷീൻ ലേണിംഗ് ആൽഗോരിതങ്ങളും ഉപയോഗിച്ച് തിരയൽ ഫലങ്ങൾ റാങ്ക് ചെയ്ത് ഫിൽട്ടർ ചെയ്യുക.
- വിലയിരുത്തൽ: ഉപയോക്തൃ പ്രതികരണം വിശകലനം ചെയ്ത് തിരികെ ലഭിച്ച വിവരങ്ങളുടെ പിഴവുകൾ തിരുത്തുക.
ട്രാവൽ ഏജന്റിൽ തിരുത്തൽ RAG
തിരുത്തൽ RAG (റിട്രീവൽ-ഓഗ്മെൻറഡ് ജനിഫറേഷൻ) AIക്ക് കൂടുതൽ കൃത്യവും പ്രസക്തവുമായ യാത്രാ ശുപാർശകൾ നൽകാൻ സഹായിക്കുന്നു. ട്രാവൽ ഏജന്റ് ഈ സമീപനം എങ്ങനെ ഉപയോഗിക്കാമെന്ന് നോക്കാം.
ഇതിൽ ഉൾപ്പെടുന്നു:
- പ്രമ്പ്റ്റിംഗ് സാങ്കേതികം: ബന്ധപ്പെട്ട വിവരങ്ങൾ തിരികെ കൊണ്ടുവരാൻ ഏജന്റിനെ നയിക്കാൻ പ്രത്യേക പ്രമ്പ്റ്റുകൾ ഉപയോഗിക്കുക.
- ഉപകരണങ്ങൾ: തിരികെ കൊണ്ടുവരുന്ന വിവരങ്ങളുടെ പ്രസക്തി വിലയിരുത്താനും കൃത്യമായ മറുപടി നൽകാനും സഹായിക്കുന്ന ആല്ഗോരിതങ്ങളും സംവിധാനങ്ങളും നടപ്പിലാക്കുക.
- വിലയിരുത്തൽ: ഏജന്റിന്റെ പ്രകടനം തുടര്ച്ചയായി വിലയിരുത്തുകയും കൃത്യതയും കാര്യക്ഷമതയും മെച്ചപ്പെടുത്താനും ക്രമീകരണങ്ങൾ വരുത്തുകയും ചെയ്യുക.
ട്രാവൽ ഏജന്റിൽ തിരുത്തൽ RAG നടപ്പിലാക്കാനുള്ള പടികൾ
- ആരംഭക ഉപയോക്തൃ ഇടപാട്
- ട്രാവൽ ഏജന്റ് ഉപയോക്താവിൽ നിന്ന് ലക്ഷ്യസ്ഥലം, യാത്രാ തീയതികൾ, ബജറ്റ്, താല്പര്യങ്ങൾ എന്നിവ ശേഖരിക്കുന്നു.
-
ഉദാഹരണം:
preferences = { "destination": "Paris", "dates": "2025-04-01 to 2025-04-10", "budget": "moderate", "interests": ["museums", "cuisine"] }
- വിവരം തിരികെ കൊണ്ടുവരൽ
- ഉപയോക്തൃ ഇഷ്ടങ്ങൾ അടിസ്ഥാനമാക്കി പറക്കൽ, താമസം, ആകർഷണങ്ങൾ, റസ്റ്റോറന്റുകൾ എന്നിവയെ കുറിച്ച് വിവരങ്ങൾ തിരയുക.
-
ഉദಾಹരണം:
flights = search_flights(preferences) hotels = search_hotels(preferences) attractions = search_attractions(preferences)
- ആരംഭക ശുപാർശകൾ sൃഷ്ടിക്കൽ
- ശേഖരിച്ച വിവരങ്ങൾ ഉപയോഗിച്ച് വ്യക്തിഗത യാത്രാസൂചിക സൃഷ്ടിക്കുക.
-
ഉദാഹരണം:
itinerary = create_itinerary(flights, hotels, attractions) print("Suggested Itinerary:", itinerary)
- ഉപയോക്തൃ പ്രതികരണം ശേഖരിക്കൽ
- ആദ്യ ശുപാർശകളെക്കുറിച്ച് ഉപയോക്താവിൽ നിന്നു പ്രതികരണം ചോദിക്കുക.
-
ഉദാഹരണം:
feedback = { "liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"] }
- തിരുത്തൽ RAG പ്രക്രിയ
- പ്രമ്പ്റ്റിംഗ് സാങ്കേതികം: ഉപയോക്തൃ പ്രതികരണത്തെ അടിസ്ഥാനമാക്കി പുതിയ തിരയൽ ക്വറികൾ രൂപപ്പെടുത്തുക.
-
ഉദാഹരണം:
if "disliked" in feedback: preferences["avoid"] = feedback["disliked"]
-
- ഉപകരണം: പുതിയ തിരയൽ ഫലങ്ങൾ റാങ്ക് ചെയ്ത് ഫിൽട്ടർ ചെയ്യാൻ ആൽഗോരിതങ്ങൾ ഉപയോഗിക്കുക, ഉപയോക്തൃ പ്രതികരണത്തെ പ്രധാനം നൽകുക.
-
ഉദാഹരണം:
new_attractions = search_attractions(preferences) new_itinerary = create_itinerary(flights, hotels, new_attractions) print("Updated Itinerary:", new_itinerary)
-
- വിലയിരുത്തൽ: ഉപയോക്തൃ പ്രതികരണങ്ങൾ വിശകലനം ചെയ്ത് നിരന്തരം ശുപാർശകളുടെ പ്രസക്തിയും കൃത്യതയും വിലയിരുത്തുക, ആവശ്യമായ ക്രമീകരണങ്ങൾ നടത്തുക.
-
ഉദാഹരണം:
def adjust_preferences(preferences, feedback): if "liked" in feedback: preferences["favorites"] = feedback["liked"] if "disliked" in feedback: preferences["avoid"] = feedback["disliked"] return preferences preferences = adjust_preferences(preferences, feedback)
-
- പ്രമ്പ്റ്റിംഗ് സാങ്കേതികം: ഉപയോക്തൃ പ്രതികരണത്തെ അടിസ്ഥാനമാക്കി പുതിയ തിരയൽ ക്വറികൾ രൂപപ്പെടുത്തുക.
പ്രായോഗിക ഉദാഹരണം
ട്രാവൽ ഏജന്റിൽ തിരുത്തൽ 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)
പ്രീ-എംപ്റ്റീവ് കോൺടെക്സ് ലോഡ്
മുൻകൂട്ടി സാന്ദർഭിക ലോഡ് ചെയ്യൽ എന്നത്, ഒരു ക്വറി പ്രോസസ്സ് ചെയ്യുന്നതിന് മുമ്പായി മാതൃകയിൽ അനുയോജ്യമായ സാന്ദർഭിക അല്ലെങ്കിൽ പശ്ചാത്തല വിവരങ്ങൾ ലോഡ് ചെയ്യുന്നതാണ്. ഇതിന്റെ അർത്ഥം, മാതൃകയെഴുതുന്നതിന്റെ തുടക്കം മുതൽ ഈ വിവരങ്ങൾക്ക് ആക്സസ് ഉണ്ടാകും, ഫലമായി പ്രോസസ്സിങ്ങിന്റെ സമയത്ത് അധിക ഡാറ്റ തിരയേണ്ടതില്ലാതെ കൂടുതൽ അറിയാമായ പ്രതികരണങ്ങൾ സൃഷ്ടിക്കാൻ ഇത് സഹായിക്കും.
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"))
വിശദീകരണം
-
ഇനിഷ്യലൈസേഷൻ (
__init__മെത്തഡ്):TravelAgentക്ലാസ്, പാരിസ്, ടോക്കിയോ, ന്യൂ യോർക്ക്, സിഡ്നി എന്നിവയുൾപ്പെടെയുള്ള പ്രശസ്ത ഗതാഗത കേന്ദ്രങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങളായ രാജ്യങ്ങൾ, കറൻസി, ഭാഷ, പ്രധാന ആകർഷണങ്ങൾ മുതലായവ ഉൾക്കൊള്ളുന്ന ഒരു ഡിക്ഷണറി മുൻകൂട്ടി ലോഡ് ചെയ്യുന്നു. -
വിവരം തിരയൽ (
get_destination_infoമെത്തഡ്): ഒരു ഉപയോക്താവ് പ്രത്യേക ഗതാഗത കേന്ദ്രത്തെക്കുറിച്ച് ചോദിക്കുമ്പോൾ,get_destination_infoമെത്തഡ് മുൻകൂട്ടി ലോഡ് ചെയ്ത സാന്ദർഭിക ഡിക്ഷണറിയിൽ നിന്നുള്ള അനുയോജ്യമായ വിവരങ്ങൾ മടക്കുന്നു.
മുൻകൂട്ടി സാന്ദർഭികം ലോഡ് ചെയ്യുന്നതിലൂടെ, ട്രാവൽ ഏജന്റ് ആപ്ലിക്കേഷൻ ഉപയോക്താവിന്റെ ചോദനകളിലേക്ക് സജീവമായി മറുപടി നൽകാൻ കഴിയും, യഥാർത്ഥ സമയത്ത് ബാഹ്യ ഉറവിടങ്ങളിൽ നിന്നുള്ള ഡാറ്റ വീണ്ടെടുക്കേണ്ടതില്ല. ഇതോടെ ആപ്ലിക്കേഷൻ കൂടുതൽ കാര്യക്ഷമവും പ്രതികരണക്ഷമവുമാകും.
ലക്ഷ്യത്തോടെ പദ്ധതി തുടക്കം വെയ്ക്കുക
ഒരു ലക്ഷ്യം മുൻകൂട്ടി നിശ്ചയിച്ച് പദ്ധതി തുടക്കം വെയ്ക്കുന്നതിൽവഴി, സ്പഷ്ടമായ നിർദ്ദിഷ്ടം ഉളവാക്കുന്നു. ഈ ലക്ഷ്യം അടിസ്ഥാനമാക്കി, മാതൃക പുനരവലോകന പ്രക്രിയയിലൂടെ ഓരോ പുനരാവർത്തനവും ആവശ്യമായ ഫലത്തിലേക്ക് മുന്നോട്ട് പോകാൻ സഹായിക്കും. ഇത് പ്രക്രിയ കൂടുതൽ ഫലപ്രദവും കേന്ദ്രീകരിച്ചവുമാക്കും.
Python ൽ ഒരു ട്രാവൽ ഏജന്റിനുവേണ്ടി ലക്ഷ്യത്തോടെ പദ്ധതി തുടക്കം വെയ്ക്കാനും അതിനെ തുടര്ന്ന് പുനരാവർത്തിക്കാനും ഉദാഹരണമായിട്ടുള്ള കോഡ് ഇവിടെ കാണിക്കുന്നു:
സ്ഥിതിവിവരം
ഒരു ട്രാവൽ ഏജന്റ് ഒരു കസ്റ്റം മെഴുതുള്ള അവധി പ്ലാൻ ചെയ്യാൻ വേണ്ടി ഒരു ക്ലയന്റിന്റെ ഇഷ്ടങ്ങളും ബജറ്റും അടിസ്ഥാനമാക്കി യാത്രാ പദ്ധതി രൂപീകരിക്കുകയാണ് ലക്ഷ്യം.
ഘട്ടങ്ങൾ
- ക്ലയന്റിന്റെ ഇഷ്ടങ്ങളും ബജറ്റും നിർവ്വചിക്കുക.
- ആ ഇഷ്ടങ്ങൾ അടിസ്ഥാനമാക്കി ആരംഭപദ്ധതി രൂപീകരിക്കുക.
- പ്ലാൻ പുനരാവർത്തിച്ച്, ക്ലയന്റിന്റെ സംതൃപ്തി പരമാവധി ആക്കുക.
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)
കോഡ് വിശദീകരണം
-
ഇനിഷ്യലൈസേഷൻ (
__init__മെഥഡ്):TravelAgentക്ലാസ് ഗതാഗത കേന്ദ്രങ്ങളുടെ ലിസ്റ്റ് ഉപയോഗിച്ച് ആരംഭിക്കുന്നു, ഓരോ കേന്ദ്രത്തിനും പേര്, ചെലവ്, പ്രവർത്തന രീതികൾ തുടങ്ങിയ ഗുണനിലവാരങ്ങൾ ഉൾക്കൊള്ളുന്നു. -
പദ്ധതി ആരംഭിക്കൽ (
bootstrap_planമെഥഡ്): ഉപയോക്താവിന്റെ ഇഷ്ടങ്ങളും ബജറ്റുമായി പൊരുത്തപ്പെടുന്ന ഗതാഗത കേന്ദ്രങ്ങളെ മാത്രം തെരഞ്ഞെടുക്കുകയും, തുടക്ക പദ്ധതി രൂപപ്പെടുത്തുകയും ചെയ്യുന്നു. -
ഇഷ്ടങ്ങൾ പൊരുത്തപ്പെടുത്തൽ (
match_preferencesമെഥഡ്): ഒരു കേന്ദ്രം ഉപയോക്താവിന്റെ ഇഷ്ടങ്ങൾക്ക് അനുയോജ്യമാണോ എന്ന് പരിശോധിക്കുന്നു. -
പദ്ധതി പുനരാവർത്തന (
iterate_planമെഥഡ്): തുടക്കം ചെയ്ത പദ്ധതിയെ മെച്ചപ്പെടുത്താൻ ശ്രമിക്കുന്നു, ഇഷ്ടങ്ങൾക്കും ബജറ്റിനും അനുയോജ്യമുള്ള നല്ല ഒഴിവുകൾ കണ്ടെത്താൻ. -
ചെലവ് കണക്കാക്കൽ (
calculate_costമെഥഡ്): നിലവിലുള്ള പദ്ധതിയുടെ മൊത്തം ചെലവ് കണക്കാക്കുന്നു.
ഉദാഹരണ ഉപയോഗം
- തുടക്ക പദ്ധതി: ട്രാവൽ ഏജന്റ് ഉപയോക്താവിന്റെ സൈറ്റ്സീയായിംഗിനുള്ള ഇഷ്ടവും $2000 ബജറ്റും അടിസ്ഥാനമാക്കി ഒരു പദ്ധതി സൃഷ്ടിക്കുന്നു.
- മെച്ചപ്പെട്ട പദ്ധതി: ട്രാവൽ ഏജന്റ് പദ്ധതിയെ പുനരാവർത്തിച്ച് ഉപയോക്താവിന്റെ ഇഷ്ടങ്ങളും ബജറ്റും അടിസ്ഥാനമാക്കി മെച്ചപ്പെടുത്തുന്നു.
ലക്ഷ്യത്തോടുകൂടി (ഉദാഹരണത്തിന്, ക്ലയന്റിന്റെ സംതൃപ്തി പരമാവധി ആക്കുക) പദ്ധതി ആരംഭിക്കുകയും, പുനരാവർത്തിപ്പെടുത്തുകയും ചെയ്യുന്നതിലൂടെ ട്രാവൽ ഏജന്റ് ഉപയോക്താവിന്റെ ഇഷ്ടങ്ങൾക്കും ബജറ്റിനും പൊരുത്തപ്പെടുന്ന എംപ്ടിമൈസഡ് യാത്രാ പദ്ധതികൾ രൂപപ്പെടുത്താൻ കഴിയും. ഈ സമീപനം, ആദ്യമുതൽ തന്നെ ഉപയോക്താവിന്റെ ആവശ്യങ്ങൾക്കനുസരിച്ച് പ്ലാനുകൾ ഒരുക്കുകയും, ഓരോ പുനരാവർത്തനത്തോടും കൂടാതെ മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു.
റീ-റാങ്കിംഗ്, സ്കോറിംഗ് എന്നിവയ്ക്കായി LLM ഉപയോഗപ്രദമായ മാറ്റങ്ങൾ
വലിയ ഭാഷാ മാതൃകകൾ (LLMs) റീ-റാങ്കിംഗ്, സ്കോറിംഗ് എന്നിവയ്ക്കായി ഉപയോഗിക്കാം, ചോദിച്ച വിവരങ്ങൾക്കോ സൃഷ്ടിച്ച പ്രതികരണങ്ങളിലോ പ്രാധാന്യം, ഗുണനിലവാരം വിലയിരുത്തുന്നതിന്. അതിൻറെ പ്രവർത്തനം ഇങ്ങനെ ആണ്:
തിരയൽ: തുടക്ക തിരയൽ ഘട്ടത്തിൽ ക്വറിയുടെ അടിസ്ഥാനത്തിൽ പ്രാസ്താവിത രേഖകൾ അല്ലെങ്കിൽ മറു പ്രതികരണങ്ങൾ കണ്ടെത്തുന്നു.
റീ-റാങ്കിംഗ്: LLM കണ്ടെത്തിയ കൻഡിഡേറ്റുകളെ അവയുടെ അനുയോജ്യതയും ഗുണനിലവും അടിസ്ഥാനമാക്കി വീണ്ടും ക്രമീകരിക്കുന്നു. ഇതിലൂടെ ഏറ്റവും പ്രസക്തവും ഗുണനിലവാരമുള്ള വിവരങ്ങൾ മുൻപോട്ടു വെക്കുന്നു.
സ്കോറിംഗ്: LLM ഓരോ കൻഡിഡേറ്റിനും സ്കോർ നൽകുന്നു, അവയുടെ അനുയോജ്യതയും ഗുണനിലവും പ്രകടിപ്പിക്കുന്നു. ഇത് മികച്ച മറുപടി അല്ലെങ്കിൽ രേഖ തിരഞ്ഞെടുക്കാൻ സഹായിക്കുന്നു.
LLMകൾ റീ-റാങ്കിംഗിനും സ്കോറിംഗിനും ഉപയോഗപ്പെടുത്തി, സിസ്റ്റം കൂടുതൽ കൃത്യവും ഐക്യസംവൃത വിവരങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നതിനാൽ ഉപയോക്തൃ പരീക്ഷണം മെച്ചപ്പെടുത്തുന്നു.
ഉപയോക്താവിന്റെ ഇഷ്ടങ്ങൾ അടിസ്ഥാനമാക്കി ട്രാവൽ കേന്ദ്രങ്ങളെ റാങ്ക് ചെയ്യാനും സ്കോർ ചെയ്യാനും വലിയ ഭാഷാ മാതൃക (LLM) എങ്ങനെ ഉപയോഗിക്കാമെന്നുള്ള ഉദാഹരണം Python ൽ:
അവസ്ഥ - ഇഷ്ടങ്ങൾ അടിസ്ഥാനമാക്കി യാത്ര
ഒരു ട്രാവൽ ഏജന്റ് ഉപയോക്താവിന്റെ ഇഷ്ടങ്ങൾ അടിസ്ഥാനമാക്കി മികച്ച യാത്രാ കേന്ദ്രങ്ങൾ ശുപാർശ ചെയ്യാൻ ആഗ്രഹിക്കുന്നു. LLM, കാര്യക്ഷമവും പ്രസക്തവുമായ വഴികൾ മുൻപോട്ടു വെക്കാനും സ്കോർ ചെയ്യാനും സഹായിക്കും.
ഘട്ടങ്ങൾ:
- ഉപയോക്താവിന്റെ ഇഷ്ടങ്ങൾ ശേഖരിക്കുക.
- പറ്റിയ യാത്രാ കേന്ദ്രങ്ങളുടെ_l സ്റ്റ്റ് റീവ തിരിച്ചയയ്ക്കുക.
- ഉപയോക്തൃ ഇഷ്ടങ്ങളുടെ അടിസ്ഥാനത്തിൽ LLM റിംഗ് ചെയ്ത് റാങ്കും സ്കോറും നൽകുക.
മുമ്പത്തെ ഉദാഹരണം Azure OpenAI സേവനങ്ങൾ ഉപയോഗിച്ച് എങ്ങനെ പുതുക്കാമെന്നു കാണിച്ചിരിക്കുന്നു:
ആവശ്യകതകൾ
- നിങ്ങൾക്ക് ഒരു Azure സബ്സ്ക്രിപ്ഷൻ വേണം.
- ഒരു Azure OpenAI റിസോഴ്സ് സൃഷ്ടിച്ച് എപി കീ ലഭിക്കുക.
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
}
# പുനഃക്രമീകരിക്കപ്പെട്ടും സ്കോർ ചെയ്തതുമായ ലക്ഷ്യങ്ങൾ பெற Azure OpenAI API വിളിക്കുക
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)
കോഡ് വിശദീകരണം - ഇഷ്ടം ബുക്കർ
-
ഇനിഷ്യലൈസേഷൻ:
TravelAgentക്ലാസ്, ഓരോ ഗതാഗത കേന്ദ്രത്തിന്റെയും പേര്, വിവരണം തുടങ്ങിയ ഗുണങ്ങൾ ഉൾപ്പെടെയുള്ള ഒരു ലിസ്റ്റ് ഉപയോഗിച്ച് ആരംഭിക്കുന്നു. -
ശുപാർശകൾ നേടൽ (
get_recommendationsമെത്തഡ്): ഉപയോക്താവിന്റെ ഇഷ്ടങ്ങളുടെ അടിസ്ഥാനത്തിൽ Azure OpenAI സേവനത്തിനായി പ്രോംപ്റ്റ് സൃഷ്ടിച്ച് HTTP POST അപേക്ഷ ചെയ്തു റീ-റാങ്ക്ഡ്, സ്കോർ ചെയ്ത ഗതാഗത കേന്ദ്രങ്ങൾ വരുത്തുന്നു. -
പ്രോംപ്റ്റ് സൃഷ്ടിക്കൽ (
generate_promptമെത്തഡ്): ഉപയോക്തൃ ഇഷ്ടങ്ങളും ഗതാഗത കേന്ദ്രങ്ങളുടെ ലിസ്റ്റും ഉൾപ്പെടുത്തിയ ഒരു പ്രോംപ്റ്റ് എല്ലാം Azure OpenAI നെ സഹായിക്കാൻ നിർമ്മിക്കുന്നു, പരിഗണിച്ച ഇഷ്ടങ്ങളുടെ അടിസ്ഥാനത്തിൽ ചിന്തിക്കുകയും സ്കോർ ചെയ്യുകയും ചെയ്യുന്നു. -
API കോൾ:
requestsലൈബ്രറി ഉപയോഗിച്ച് HTTP POST അഭ്യർത്ഥന Azure OpenAI API നെ അയയ്ക്കുന്നു. മറുപടിയിൽ റീ-റാങ്ക്ഡ്, സ്കോർ ചെയ്ത ഗതാഗത കേന്ദ്രങ്ങൾ ഉൾപ്പെടുന്നു. -
ഉദാഹരണ ഉപയോഗം: ട്രാവൽ ഏജന്റ് ഉപയോക്താവിന്റെ ഇഷ്ടങ്ങൾ (ഉദാഹരണത്തിന് സൈറ്റ്സീയിംഗ്, വൈവിധ്യമാർന്ന സംസ്കാരം) ശേഖരിച്ച് Azure OpenAI വഴി റാങ്ക് ചെയ്ത് ശുപാർശകൾ നേടുന്നു.
your_azure_openai_api_key നിങ്ങളുടെ യഥാർത്ഥ Azure OpenAI API കീ ആയി മാറ്റുന്നത് ഉറപ്പാക്കുക, കൂടാതെ https://your-endpoint.com/... നിങ്ങളുടെ Azure OpenAI ഡിപ്ലോയ്മെന്റിന്റെ യഥാർത്ഥ എന്റ്പോയിന്റ് URL ആയി നൽകുക.
LLM റീ-റാങ്കിംഗിനും സ്കോറിങ്ങിനും ഉപയോഗിച്ച്, ട്രാവൽ ഏജന്റ് ഉപയോക്താക്കൾക്ക് കൂടുതൽ വ്യക്തിഗതവും പ്രസക്തവുമായ യാത്രാ നിർദ്ദേശങ്ങൾ നൽകാൻ കഴിയും, അവരുടെ ആകെ അനുഭവം മെച്ചപ്പെടുത്തുന്നു.
RAG: പ്രോംപ്റ്റിംഗ് സാങ്കേതികത്ത Algorithm സമൂഹം
Retrieval-Augmented Generation (RAG) AI ഏജന്റ് വികസനത്തിൽ പ്രോംപ്റ്റിംഗ് സാങ്കേതികവും ഒരു ഉപകരണവുമാകാം. ഇവ തമ്മിലുള്ള വ്യത്യാസം മനസ്സിലാക്കുന്നത് RAG കൂടുതൽ ഫലപ്രദമായി ഉപയോഗിക്കുന്നതിന് സഹായിക്കും.
പ്രോംപ്റ്റിംഗ് സാങ്കേതികമായി RAG
എന്താണ് ഇത്?
- പ്രോംപ്റ്റിംഗ് സാങ്കേതികമായി, RAG, വലിയ കോർപ്പസ് അല്ലെങ്കിൽ ഡാറ്റാബേസിൽ നിന്നും അനുയോജ്യമായ വിവരം തിരയുന്നതിന് പ്രത്യേക ചോദ്യങ്ങൾ അല്ലെങ്കിൽ പ്രോംപ്റ്റുകൾ രൂപീകരിക്കുന്ന പ്രക്രിയയാണ്. പിന്നീട് ഈ വിവരം മേഖലയിൽ_AI മോഡലുകളിലൂടെ ഉപയോഗിച്ച് മറുപടികൾ/പ്രവർത്തനങ്ങൾ ഉത്പാദിപ്പിക്കുന്നു.
എങ്ങനെ പ്രവർത്തിക്കുന്നു:
- പ്രോംപ്റ്റുകൾ രൂപപ്പെടുത്തൽ: പ്രവർത്തനത്തിനോ ഉപയോക്തൃ ഇൻപുട്ടിനോ അടിസ്ഥാനമാക്കി നല്ല ഘടിപ്പിച്ച പ്രോംപ്റ്റുകൾ സൃഷ്ടിക്കുക.
- വിവരം തിരയൽ: മുൻകൂട്ടി ഉള്ള അറിവ് അല്ലെങ്കിൽ ഡാറ്റാസെറ്റിൽ നിന്നുള്ള അനുയോജ്യമായ ഡാറ്റ ജീവനെടുക്കുക.
- മറുപടി ഉത്പാദനം: കണ്ടെത്തിയ വിവരങ്ങൾ സൃഷ്ടിക്കുന്ന AI മോഡലുകളുമായി കൂട്ടിച്ച് സമഗ്രവും സുഷ്ഠുവുമായ മറുപടി നൽകുക.
ട്രാവൽ ഏജന്റിൽ ഒരു ഉദാഹരണം:
- ഉപയോക്തൃ ഇൻപുട്ട്: “എനിക്ക് പാരീസിലെ മ്യൂസിയങ്ങളെ സന്ദർശിക്കാൻ ആഗ്രഹം.”
- പ്രോംപ്റ്റ്: “പാരീസിലെ പ്രധാന മ്യൂസിയങ്ങൾ കണ്ടെത്തുക.”
- തിരഞ്ഞെടുത്ത വിവരങ്ങൾ: Louvre മ്യൂസിയം, Musée d’Orsay എന്നിവയുടെ വിശദാംശങ്ങൾ.
- സൃഷ്ടിച്ച മറുപടി: “പാരിസിൽ ചില പ്രധാന മ്യൂസിയങ്ങൾ: Louvre മ്യൂസിയം, Musée d’Orsay, Centre Pompidou.”
ഉപകരണമായ RAG
എന്താണ് ഇത്?
- ഉപകരണമായി, RAG ഒരു സംയോജിത സംവിധാനം ആണ്, തിരയൽ, സൃഷ്ടിക്കൽ പ്രക്രിയകൾ സ്വയം പ്രവർത്തനം നടത്തുന്നു, ഡവലപ്പർമാർക്ക് ഓരോ ചോദനയ്ക്കും പ്രോംപ്റ്റ് രചന ചെയ്യാതെ പരീച്ചലയിലേക്കുള്ള AI സൗകര്യങ്ങൾ ആസൂത്രണം ചെയ്യാൻ ഇത് എളുപ്പമാക്കുന്നു.
എങ്ങനെ പ്രവർത്തിക്കുന്നു:
- സംയോജനം: RAG AI ഏജന്റിന്റെ ആർക്കിടെക്ചറിൽ ഉൾപ്പെടുത്തി, തിരയലും സൃഷ്ടികളും സ്വയമേനമനുവർത്തിക്കുന്നു.
- സ്വയം പ്രവർത്തനം: ഉപയോക്തൃ ഇൻപുട്ട് സ്വീകരിക്കുന്നതിൽ നിന്നും അന്തിമ മറുപടി സൃഷ്ടിക്കുന്നതുവരെ എല്ലാം ഓട്ടോമാറ്റിക്.
- ക്ഷമത: തിരയലും സൃഷ്ടിയും സുതാര്യവും കാര്യക്ഷമവുമാക്കി ഏജന്റിന്റെ പ്രകടനം മെച്ചപ്പെടുത്തുന്നു.
ട്രാവൽ ഏജന്റിൽ ഉദാഹരണം:
- ഉപയോക്തൃ ഇൻപുട്ട്: “എനിക്ക് പാരീസിലെ മ്യൂസിയങ്ങളെ സന്ദർശിക്കാൻ ആഗ്രഹം.”
- RAG ഉപകരണം: മ്യൂസിയങ്ങളുടെ വിവരങ്ങൾ സ്വയം തിരഞ്ഞെടുത്ത് മറുപടി സൃഷ്ടിക്കുന്നു.
- സൃഷ്ടിച്ച മറുപടി: “പാരിസിലെ പ്രധാന മ്യൂസിയങ്ങൾ: Louvre മ്യൂസിയം, Musée d’Orsay, Centre Pompidou.”
താരതമ്യം
| ഘടകം | പ്രോംപ്റ്റിംഗ് സാങ്കേതികം | ഉപകരണം |
|---|---|---|
| മാനുവൽ 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 ഏജന്റിൻറെ പ്രകടനത്തിലെ നിർണ്ണായക ഘടകമാണ്. ഏജന്റ് തിരഞ്ഞടുത്തതും സൃഷ്ടിച്ചതുമായ വിവരങ്ങൾ ഉപയോക്താവിന് അനുയോജ്യവും കൃത്യവും പ്രയോജനപ്രദവുമാകണമെന്ന് ഉറപ്പാക്കുന്നു. പ്രസക്തി വിലയിരുത്തൽ എങ്ങനെ നടത്താം, പ്രായോഗിക ഉദാഹരണങ്ങളും സാങ്കേതികികളും ഇതിൽ പരിശോധിക്കാം.
പ്രസക്തി വിലയിരുത്തലിലെ പ്രധാനം
- സാന്ദർഭ ബോധം:
- ഉപയോക്തൃ ക്വറിയുടെ സാന്ദർഭം മനസിലാക്കി അനുയോജ്യമായ വിവരമെടുത്തു, ഉത്പാദിപ്പിക്കുക.
- ഉദാഹരണം: ഉപയോക്താവ് “പാരിസിലെ മികച്ച ഭക്ഷണശാലകൾ” ചോദിക്കുമ്പോൾ, ഭക്ഷണ ശൈലി, ബജറ്റ് തുടങ്ങിയ വന്മിഷങ്ങളെ കണക്കിലെടുക്കുക.
- കൃത്യത:
- ഏജന്റ് നൽകുന്ന വിവരങ്ങൾ സത്യസന്ധവും പുതിയതുമായിരിക്കണം.
- ഉദാഹരണം: നിലവിൽ പ്രവർത്തിക്കുന്ന നല്ല റസ്റ്റോറന്റുകൾ ശുപാർശ ചെയ്യുക; പഴയ വിവരങ്ങൾ അല്ല.
- ഉപയോക്തൃ ഉദ്ദേശം:
- ഉപയോക്താവിന്റെ ഉദ്ദേശം തിരിച്ചറിയാൻ ഏജന്റ് ശ്രമിക്കുക.
- ഉദാഹരണം: “ബജറ്റ് സൗഹൃദ ഹോട്ടലുകൾ” ചോദിക്കുമ്പോൾ കുറഞ്ഞ വിലയുള്ളവ മുൻഗണന നൽകുക.
- പ്രതികരണ ലൂപ്പ്:
- ഉപയോക്തൃ പ്രതികരണങ്ങൾ ശേഖരിച്ച് വിലയിരുത്തൽ മെച്ചപ്പെടുത്താൻ ഉപയോഗിക്കുക.
- ഉദാഹരണം: മുൻ ശുപാർശകളിലെ ഉപയോക്തൃ റേറ്റിംഗും അഭിപ്രായവും ഉൾപ്പെടുത്തുക.
പ്രസക്തി വിലയിരുത്തലിനുള്ള പ്രായോഗിക സാങ്കേതികികൾ
- പ്രസക്തി സ്കോറിംഗ്:
- ഓരോ തിരഞ്ഞെടുത്ത ഇനത്തെയും ഉപയോക്തൃ ക്വറിയുമായി പൊരുത്തം എ程度മുള്ളതു അനുസരിച്ച് ഒരു സ്കോർ നൽകുക.
-
ഉദാഹരണം:
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
- ഫിൽറ്ററിംഗും റൊങ്കിംഗും:
- പ്രസക്തമല്ലാത്ത ഇനങ്ങൾ ഒഴിവാക്കി ശേഷിക്കുന്നവയെ അംഗതിവസ്തുതിയിൽ ക്രമീകരിക്കുക.
-
ഉദാഹരണം:
def filter_and_rank(items, query): ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True) return ranked_items[:10] # ഏറ്റവും അനുയോജ്യമായ 10 ഇനം തിരികെ നല്കുക
- സ്വാഭാവിക ഭാഷാ പ്രോസസ്സിംഗ് (NLP):
- ഉപയോക്തൃ ക്വറിയിൽ നിന്നുള്ള മാനവേയുള്ള ഭാഷ മനസ്സിലാക്കാനും അനുയോജ്യമായ വിവരങ്ങൾ തിരിച്ചുവരുത്താനും NLP സാങ്കേതികികൾ ഉപയോഗിക്കുക.
-
ഉദാഹരണം:
def process_query(query): # ഉപയോക്താവിന്റെ ചോദ്യം മുതൽ പ്രധാന വിവരങ്ങൾ പിടിക്കുന്നതിന് NLP ഉപയോഗിക്കുക processed_query = nlp(query) return processed_query
- ഉപയോക്തൃ പ്രതികരണ സംയോജനം:
- ശുപാർശകളെപ്പറ്റിയുള്ള ഉപയോക്തൃ പ്രതികരണം ശേഖരിച്ച് ഭാവിയിൽ പ്രശാന്തി വിലയിരുത്തലുകൾ മെച്ചപ്പെടുത്താൻ ഉപയോഗിക്കുക.
-
ഉദാഹരണം:
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] # മുകളിൽ 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
# 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)"]}
updated_items = travel_agent.adjust_based_on_feedback(feedback, itinerary['hotels'])
print("Updated Itinerary with Feedback:", updated_items)
ഉദ്ദേശത്തോടെ തിരയൽ
ഉദ്ദേശത്തോടെ തിരയൽ അർഥമാക്കുന്നത് ഉപയോക്തൃ ക്വറിയുടെ പിന്നിലുള്ള ലക്ഷ്യവും ഉദ്ദേശവും മനസിലാക്കിയാണ് ഏറ്റവും പ്രസക്തവും പ്രയോജനപ്രദവുമായ വിവരം തിരയുകയും സൃഷ്ടിക്കുകയും ചെയ്യുക എന്നത്. ഇത് വെറും കീ വേഡുകൾ പൊരുത്തപ്പെടുത്തുന്നതിൽ നിന്നും മിക്കപ്രകാരമാണ് വ്യത്യസ്തം, ഉപയോക്താവിന്റെ യാഥാർത്ഥ്യ ആവശ്യങ്ങളും സാന്ദർഭവും പിടിച്ചുപറിയും.
ഉദ്ദേശത്തോടെ തിരയൽ - പ്രധാന ആശയങ്ങൾ
- ഉപയോക്തൃ ഉദ്ദേശം മനസ്സിലാക്കൽ:
- ഉപയോക്തൃ ഉദ്ദേശം മൂന്നു പ്രധാന തരങ്ങളായി തിരിച്ചറിയാം: വിവരശേഖരണ, നാവിഗേഷൻ, ലെനാൾ.
- വിവരശേഖരണ ഉദ്ദേശം: ഒരു വിഷയം സംബന്ധിച്ച വിവരം തേടുക (ഉദാ: “പാരിസിലെ മികച്ച മ്യൂസിയങ്ങൾ എന്തൊക്കെയാണ്?”)
- നാവിഗേഷൻ ഉദ്ദേശം: ഒരു പ്രത്യേക വെബ്സൈറ്റ് അല്ലെങ്കിൽ പേജ് സന്ദർശിക്കാൻ ആഗ്രഹിക്കുക (ഉദാ: “Louvre മ്യൂസിയത്തിന്റെ ഔദ്യോഗിക വെബ്സൈറ്റ്”)
- ലെനാൾ ഉദ്ദേശം: ഒരു ഇടപാട് നടത്തുക, ഫ്ലൈറ്റ് ബുക്ക് ചെയ്യുക, വാങ്ങലുകൾ ചെയ്യുക (ഉദാ: “പാരിസിലേക്ക് ഒരു ഫ്ലൈറ്റ് ബുക്ക് ചെയ്യുക”)
- ഉപയോക്തൃ ഉദ്ദേശം മൂന്നു പ്രധാന തരങ്ങളായി തിരിച്ചറിയാം: വിവരശേഖരണ, നാവിഗേഷൻ, ലെനാൾ.
- സാന്ദർഭ ബോധം:
- ഉപയോക്തൃദ്വാര മുൻകൂട്ടി നടത്തിയ ഇടപാടുകൾ, ഇഷ്ടങ്ങൾ, ചോദ്യത്തിലെ പ്രത്യേകാംശങ്ങൾ പരിഗണിച്ച് ഉദ്ദേശം സൂക്ഷ്മമായി തിരിച്ചറിയുക.
- സ്വാഭാവിക ഭാഷാ പ്രോസസിങ് (NLP):
- ഉപഭോക്താക്കളാൽ നൽകിയ സ്വാഭാവിക ഭാഷാ ക്വറിയുടെ അർത്ഥവും അർത്ഥചിന്തയും നിർവ്വഹിക്കാൻ NLP സാങ്കേതികവിദ്യകൾ പ്രയോഗിക്കുക. ഇതിൽ ആന്റിറ്റി തിരിച്ചറിവ്, സെൻറ്റിമെന്റ് വിശകലനം, ക്വറി വിവരണം തുടങ്ങിയവ ഉൾപ്പെടും.
- വ്യക്തിഗത നിരന്തരത:
- ഉപയോക്തൃ ചരിത്രം, ഇഷ്ടങ്ങൾ, പ്രതികരണങ്ങൾ അടിസ്ഥാനമാക്കി തിരയൽ ഫലങ്ങൾ വ്യക്തിഗതമാക്കുന്നത് പ്രസക്തി വർധിപ്പിക്കും.
പ്രായോഗിക ഉദാഹരണം: ട്രാവൽ ഏജന്റിൽ ഉദ്ദേശത്തോടെ തിരയൽ
ട്രാവൽ ഏജന്റ് ഉദാഹരണമായി എടുത്ത്, ഉദ്ദേശത്തോടെ തിരയൽ എങ്ങനെയാണ് നടപ്പാക്കുന്നത് അതിന്റെ കോഡ് കാണാം.
-
ഉപയോക്തൃ ഇഷ്ടങ്ങൾ ശേഖരണം
class Travel_Agent: def __init__(self): self.user_preferences = {} def gather_preferences(self, preferences): self.user_preferences = preferences -
ഉപയോക്തൃ ഉദ്ദേശം മനസ്സിലാക്കൽ
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" -
സാന്ദർഭ ബോധം
def analyze_context(query, user_history): # നിലവിലുള്ള ചോദ്യത്തെയും ഉപയോക്തൃചരിത്രത്തെയും സംയോജിപ്പിച്ച് പ്രബന്ധത്തിന്റെ പശ്ചാത്തലം മനസിലാക്കുക context = { "current_query": query, "user_history": user_history } return context -
ഫലങ്ങൾ തിരയുക, വ്യക്തിഗതമാക്കുക
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] # പരസനവിധേയമായ മികച്ച 10 ഫലങ്ങൾ നൽകുക -
ഉദാഹരണ ഉപയോഗം
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. ഒരു ഉപകരണമായി കോഡ് üretтеу
കോഡ് ജനറേറ്റിംഗ് ഏജന്റുമാർ കോഡ് എഴുതാനും പ്രവർത്തിപ്പിക്കാനും AI മോഡലുകൾ ഉപയോഗിച്ച് ജടിലമായ പ്രശ്നങ്ങൾ പരിഹരിക്കുകയും പ്രവർത്തനങ്ങൾ ഓട്ടോമേറ്റു് ചെയ്യുകയും ചെയ്യുന്നു.
കോഡ് ജനറേറ്റിംഗ് ഏജന്റ്മാർ
കോഡ് ജനറേറ്റിംഗ് ഏജന്റ്മാർ ജനറേറ്റീവ് AI മോഡലുകൾ ഉപയോഗിച്ച് കോഡ് എഴുതുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു. ഈ ഏജന്റുകൾ ജടിലമായ പ്രശ്നങ്ങൾ പരിഹരിക്കാനും, പ്രവർത്തനങ്ങൾ ഓട്ടോമേറ്റ് ചെയ്യാനും, വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ കോഡ് ജെനറേറ്റ് ചെയ്ത് പ്രവർത്തിപ്പിച്ച് വിലയേറിയ洞察ങ്ങൾ നൽകാനും കഴിയും.
പ്രായോഗിക ഉപയോഗങ്ങൾ
- ഓട്ടോമേറ്റഡ് കോഡ് ജനറേഷൻ: നിർദ്ദിഷ്ട പ്രവർത്തനങ്ങൾക്ക് കോഡ് സ്നിപ്പറ്റുകൾ സൃഷ്ടിക്കുക, ഉദാ: ഡാറ്റാ അനാലിസിസ്, വെബ് സ്ക്രാപ്പിംഗ്, മെഷീൻ ലേണിംഗ്.
- RAG ആയി SQL: ഡാറ്റാബേസുകളിൽ നിന്ന് ഡാറ്റ തിരയാനും കൃത്യമായി കൈമാറാനും SQL ഉപയോഗിക്കുക.
- പ്രശ്നപരിഹാരം: പ്രത്യേക പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ കോഡ് സൃഷ്ടിക്കുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുക, ഉദാ: ആൽഗോരിദങ്ങൾ ഓപ്ടിമൈസ് ചെയ്യൽ లేదా ഡാറ്റാ വിശകലനം.
ഉദാഹരണം: ഡാറ്റാ അനാലിസിസിനുള്ള കോഡ് ജനറേറ്റിംഗ് ഏജന്റ്
നിങ്ങൾ ഒരു കോഡ് ജനറേറ്റിംഗ് ഏജന്റിന്റെ രൂപകൽപനയാണ് ചെയ്യുന്നതെന്ന് കരുതുക. ഇത് എങ്ങനെ പ്രവർത്തിക്കാം:
- പ്രവൃത്തി: ഒരു ഡാറ്റാസെറ്റിൽ ട്രെൻഡുകളും മാതൃകകളും തിരിച്ചറിയുക.
- പടികളായി:
- ഡാറ്റാസെറ്റ് ഒരു ഡാറ്റാ അനാലിസിസ് ടൂളിലേയ്ക്ക് ലോഡ് ചെയ്യുക.
- ഡാറ്റ ഫിൽട്ടർ ചെയ്യാനും സംഗ്രഹിക്കാനും SQL ക്വറിയുകൾ സൃഷ്ടിക്കുക.
- ക്വറിയുകൾ കണക്കാക്കുക, ഫലങ്ങൾ പിന്വലിക്കുക.
- ഫലങ്ങൾ ഉപയോഗിച്ച് വിഷ്വലൈസേഷനുകളും洞察ങ്ങളും സൃഷ്ടിക്കുക.
- അവശ്യമായ വിഭവങ്ങൾ: ഡാറ്റാസെറ്റിന്റെ പ്രവേശനം, ഡാറ്റാ അനാലിസിസ് ടൂളുകൾ, SQL കഴിവുകൾ.
- അനുഭവം: മുൻപരിശോധന ഫലങ്ങൾ ഉപയോഗിച്ച് ഭാവിയിലെ വിശകലനങ്ങളുടെ കൃത്യതയും പ്രസക്തിയും മെച്ചപ്പെടുത്തുക.
ഉദാഹരണം: ട്രാവൽ ഏജന്റിനായുള്ള കോഡ് ജനറേറ്റിംഗ് ഏജന്റ്
ഈ ഉദാഹരണത്തിൽ, ഒരു കോഡ് ജനറേറ്റിംഗ് ഏജന്റ്, ട്രാവൽ ഏജന്റ്, രൂപകൽപന ചെയ്ത് ഉപയോക്താക്കളെ അവരുടെ യാത്രാ പദ്ധതി തയ്യാറാക്കുന്നതിൽ സഹായിക്കാൻ കോഡ് ജനറേറ്റ് ചെയ്ത് പ്രവർത്തിപ്പിക്കും. ഈ ഏജന്റ് യാത്രാ ഓപ്ഷനുകൾ തിരയൽ, ഫലങ്ങൾ ഫിൽട്ടർ ചെയ്യൽ, വിന്യാസം തയ്യാറാക്കൽ പോലുള്ള പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യും.
കോഡ് ജനറേറ്റിംഗ് ഏജന്റിന്റെ അവലോകനം
- ഉപയോക്തൃ ഇഷ്ടങ്ങൾ ശേഖരിക്കല്: ലക്ഷ്യം, യാത്രാ തിയതികൾ, ബഡ്ജറ്റ്, അഭിരുചികൾ എന്നിവയുടെ ഉപയോക്തൃ ഇൻപുട്ടുകൾ ശേഖരിക്കുന്നു.
- ഡാറ്റ തിരയുന്നതിനായി കോഡ് ജനറേറ്റ് ചെയ്യുക: വിമാനങ്ങൾ, ഹോട്ടലുകൾ, ആകർഷണങ്ങൾ എന്നിവയെ കുറിച്ചുള്ള ഡാറ്റ തിരയാൻ കോഡ് സ്നിപ്പറ്റുകൾ സൃഷ്ടിക്കുന്നു.
- ജനറേറ്റുചെയ്ത കോഡ് പ്രവർത്തിപ്പിക്കൽ: യഥാർത്ഥ സമയ വിവരം സ്വീകരിക്കാൻ കോഡ് പ്രവർത്തിപ്പിക്കുന്നു.
- ഇടപെടലാണ് സൃഷ്ടിക്കൽ: ശേഖരിച്ച ഡാറ്റയെ വ്യക്തിഗതമാക്കിയ യാത്രാ പദ്ധതിയാക്കി കമ്പൈൽ ചെയ്യുന്നു.
- ഫീഡ്ബാക്ക് അടിസ്ഥാനമാക്കി ക്രമീകരിക്കൽ: ഉപയോക്തൃ പ്രതികരണം സ്വീകരിച്ച് ഫലങ്ങൾ മെച്ചപ്പെടുത്തുന്നതിന് ആവശ്യമെങ്കിൽ കോഡ് പുനർജനറേറ്റ് ചെയ്യുന്നു.
ക്രമാനുസരണം നടപ്പാക്കൽ
-
ഉപയോക്തൃ ഇഷ്ടങ്ങൾ ശേഖരിക്കൽ
class Travel_Agent: def __init__(self): self.user_preferences = {} def gather_preferences(self, preferences): self.user_preferences = preferences -
ഡാറ്റ തിരയാൻ കോഡ് ജനറേറ്റ് ചെയ്യൽ
def generate_code_to_fetch_data(preferences): # ഉദാഹരണം: ഉപഭോക്തൃ Präferenzകൾ അടിസ്ഥാനമാക്കി വിമാനത്താവളങ്ങൾ അന്വേഷിക്കുന്ന കോഡ് സൃഷ്ടിക്കുക 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 -
ജനറേറ്റുചെയ്ത കോഡ് പ്രവർത്തിപ്പിക്കൽ
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) -
ഇടപെടലാണ് സൃഷ്ടിക്കൽ
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) -
ഫീഡ്ബാക്ക് അടിസ്ഥാനമാക്കി ക്രമീകരിക്കൽ
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)
പരിസ്ഥിതി ബോധവും വ്യാഖ്യാനവും ഉപയോഗിക്കുക
പട്ടികയുടെ സ്കീമയുടെ അടിസ്ഥാനത്തിൽ, ക്വറി ജനറേഷൻ പ്രക്രിയ പരിസ്ഥിതി ബോധവും വ്യാഖ്യാനവും ഉപയോഗിച്ച് മെച്ചപ്പെടുത്താൻ കഴിയും.
ഇതിന് ഉദാഹരണമായി:
- സ്കീമ മനസ്സിലാക്കൽ: സിസ്റ്റം പട്ടികയുടെ സ്കീമ മനസിലാക്കി ഇത് ക്വറി ജനറേഷനിൽ അടിസ്ഥാനമാക്കും.
- ഫീഡ്ബാക്ക് അടിസ്ഥാനമാക്കി ക്രമീകരിക്കൽ: ഫീഡ്ബാക്കിന്റെ അടിസ്ഥാനത്തിൽ ഉപയോക്തൃ ഇഷ്ടങ്ങൾ ക്രമീകരിക്കുകയും സ്കീമയിൽ പുതുക്കേണ്ട ഫീൽഡുകൾ തിരിച്ചറിയുകയും ചെയ്യുന്നു.
- ക്വറികൾ സൃഷ്ടിക്കുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യൽ: പുതുക്കിയ ഇഷ്ടങ്ങൾ അടിസ്ഥാനമാക്കി വിമാനവും ഹോട്ടലും ഡാറ്റ തിരയുന്നതിനുള്ള ക്വറികൾ സൃഷ്ടിച്ച് പ്രവർത്തിപ്പിക്കും.
ഈ ആശയങ്ങൾ ഉൾക്കൊള്ളിക്കുന്ന പുതിയ പൈതൺ കോഡ് ഉദാഹരണം ഇവിടെ:
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)
വിശദീകരണം - ഫീഡ്ബാക്ക് അടിസ്ഥാനമാക്കി ബുക്കിങ്
- സ്കീമ ബോധം:
schemaഡിക്ഷണറി ഫീഡ്ബാക്ക് അടിസ്ഥാനമാക്കിയുള്ള ഇഷ്ടങ്ങൾ ക്രമീകരിക്കുന്ന വിധം നിർവചിക്കുന്നു. ഇതിൽfavorites,avoidഎന്നിവ പോലുള്ള ഫീൽഡുകളും അതിനുള്ള ക്രമീകരണങ്ങളും ഉൾപ്പെട്ടിരിക്കുന്നു. - ഇഷ്ടങ്ങൾ ക്രമീകരിക്കൽ (
adjust_based_on_feedbackമേധഡ്): ഈ മേധഡ് ഉപയോക്തൃ ഫീഡ്ബാക്ക് അടിസ്ഥാനമാക്കിയുള്ള ഇഷ്ടങ്ങൾ ക്രമീകരിക്കുന്നു. - പരിസ്ഥിതി അടിസ്ഥാന ക്രമീകരണങ്ങൾ (
adjust_based_on_environmentമേധഡ്): ഈ മേധഡ് സ്കീമയും ഫീഡ്ബാക്കും അടിസ്ഥാനമാക്കി ക്രമീകരണങ്ങൾ ഇഷ്ടാനുസൃതമാക്കുന്നു. - ക്വറികൾ സൃഷ്ടിക്കുകയും പ്രവർത്തിപ്പിക്കുകയും ചെയ്യൽ: ക്രമീകരിച്ച ഇഷ്ടങ്ങൾ അടിസ്ഥാനമാക്കി പുതുക്കിയ വിമാന-ഹോട്ടൽ ഡാറ്റ തിരയാൻ ക്വറികൾ സൃഷ്ടിച്ച് പ്രവർത്തിപ്പിക്കുന്നു.
- ഇടപെടലാണ് സൃഷ്ടിക്കൽ: പുതിയ വിമാന, ഹോട്ടൽ, ആകർഷണ ഡാറ്റയുടെ അടിസ്ഥാനത്തിൽ യാത്രാ പദ്ധതി പുതുക്കുന്നു.
സിസ്റ്റം പരിസ്ഥിതി ബോധമാകുകയും സ്കീമയുടെ അടിസ്ഥാനത്തിൽ വ്യാഖ്യാനിക്കുകയും ചെയ്തപ്പോൾ, ക്വറികൾ കൂടുതൽ കൃത്യവും പ്രസക്തവുമാകുകയും നല്ല യാത്രാ ശിഫാരസുകളും കൂടുതൽ വ്യക്തിഗത അനുഭവവും നൽകുകയും ചെയ്യും.
Retrieval-Augmented Generation (RAG) സാങ്കേതികമായി SQL ഉപയോഗിക്കൽ
SQL (Structured Query Language) ഡാറ്റാബേസുകളുമായി ഇടപഴകാൻ ശക്തമായ ഉപകരണം ആണ്. Retrieval-Augmented Generation (RAG) രീതിയിൽ, SQL ഡാറ്റാബേസുകളിൽ നിന്നുള്ള ബന്ധപ്പെട്ട ഡാറ്റ കണ്ടെത്തുന്നതിനും AI ഏജന്റുകളുടെ പ്രതികരണങ്ങൾ അല്ലെങ്കിൽ പ്രവർത്തനങ്ങൾ ജനറേറ്റ് ചെയ്യുന്നതിന് ഉപയോഗിക്കാം. ട്രാവൽ ഏജന്റിന്റെ സാന്ദർഭ്യത്തിൽ SQL RAG രീതിയായി എങ്ങനെ ഉപയോഗിക്കാമെന്ന് പരിശോധിക്കാം.
പ്രധാന മുന്നോട്ടുള്ള ധാരണകൾ
- ഡാറ്റാബേസ് ഇടപഴകൽ:
- SQL ഡാറ്റാബേസുകളോട് ക്വറിയ് ചെയ്ത് പ്രാസക്തമായ വിവരങ്ങൾ വീണ്ടെടുക്കാനും ഡാറ്റ കൈകാര്യം ചെയ്തും ഉപയോഗിക്കുന്നു.
- ഉദാഹരണം: വിമാന വിശദാംശങ്ങൾ, ഹോട്ടൽ വിവരങ്ങൾ, ആകർഷണങ്ങളും ഒരു ട്രാവൽ ഡാറ്റാബേസിൽ നിന്ന് വന്നത്.
- RAG ഇന്സെർഷൻ:
- ഉപയോക്തൃ ഇൻപുട്ട്, ഇഷ്ടങ്ങൾ അടിസ്ഥാനമാക്കി SQL ക്വറികൾ സൃഷ്ടിക്കുന്നു.
- വീണ്ടെടുത്ത ഡാറ്റ പ്രത്യേകം വ്യക്തിഗത ശിഫാരസുകൾ അല്ലെങ്കിൽ പ്രവർത്തനങ്ങൾ ജനറേറ്റ് ചെയ്യാൻ ഉപയോഗിക്കും.
- ഡൈനാമിക് ക്വറി ജനറേഷൻ:
- AI ഏജന്റ് സാന്ദർഭ്യവും ഉപയോക്തൃ ആവശ്യങ്ങളും അടിസ്ഥാനമാക്കി ഡൈനാമിക് SQL ക്വറികൾ സൃഷ്ടിക്കുന്നു.
- ഉദാ: ബഡ്ജറ്റും തിയതികളും അഭിരുചികളും അടിസ്ഥാനമാക്കി SQL ക്വറിയുകൾ ഫിൽട്ടർ ചെയ്യൽ.
പ്രയോഗങ്ങൾ
- ഓട്ടോമേറ്റഡ് കോഡ് ജനറേഷൻ: പ്രത്യേക പ്രവർത്തനങ്ങൾക്ക് കോഡ് സ്നിപ്പറ്റുകൾ സൃഷ്ടിക്കുക.
- RAG ആയി SQL: ഡാറ്റ കൈമാറ്റത്തിനായി SQL ക്വറിയുകൾ ഉപയോഗിക്കുക.
- പ്രശ്നപരിഹാരം: പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ കോഡ് സൃഷ്ടിച്ച് പ്രവർത്തിപ്പിക്കുക.
ഉദാഹരണം: ഒരു ഡാറ്റ അനാലിസിസ് ഏജന്റ്:
- പ്രവൃത്തി: ട്രെൻഡുകൾ കണ്ടെത്താൻ ഡാറ്റാസെറ്റ് അനാലൈസ് ചെയ്യുക.
- പടികൾ:
- ഡാറ്റാസെറ്റ് ലോഡ് ചെയ്യുക.
- ഡാറ്റ ഫിൽട്ടർ ചെയ്യാൻ SQL ക്വറിയുകൾ സൃഷ്ടിക്കുക.
- ക്വറികൾ പ്രവർത്തിപ്പിക്കുകയും ഫലങ്ങൾ വീണ്ടെടുക്കുകയും ചെയ്യുക.
- വിഷ്വലൈസേഷൻ洞察ങ്ങൾ സൃഷ്ടിക്കുക.
- വിഭവങ്ങൾ: ഡാറ്റാസെറ്റ് പ്രവേശനം, SQL കഴിവുകൾ.
- അനുഭവം: മുൻഫലങ്ങൾ ഉപയോഗിച്ച് ഭാവിയിലെ വിശകലനങ്ങളിൽ മെച്ചപ്പെടുത്തുക.
പ്രായോഗിക ഉദാഹരണം: ട്രാവൽ ഏജന്റിൽ SQL ഉപയോഗിക്കൽ
-
ഉപയോക്തൃ ഇഷ്ടങ്ങൾ ശേഖരിക്കൽ
class Travel_Agent: def __init__(self): self.user_preferences = {} def gather_preferences(self, preferences): self.user_preferences = preferences -
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 -
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 -
ശിഫാരസുകൾ ഉത്പാദനം
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 ക്വറികൾ
-
വിമാനത്തെ ക്വറി
SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-10' AND budget='moderate'; -
ഹോട്ടൽ ക്വറി
SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate'; -
ആകർഷണം ക്വറി
SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';
Retrieval-Augmented Generation (RAG) സാങ്കേതികതയിൽ SQL ഉപയോഗിച്ച്, ട്രാവൽ ഏജന്റ് പോലുള്ള AI ഏജന്റുകൾ ഡൈനാമിക്കായി ബന്ധപ്പെട്ട ഡാറ്റ തിരയുകയും ഉപയോഗിക്കുകയും ചെയ്തു കൃത്യവും വ്യക്തിഗതവുമായ ശिफാരസുകൾ നൽകാൻ കഴിയും.
മെടാകോഗ്നിഷന്റിന്റെ ഉദാഹരണം
മെടാകോഗ്നിഷൻ നടപ്പിലാക്കൽ കാണിക്കാൻ, ആത്മനിരീക്ഷണവുമായി ബന്ധപ്പെട്ട ഒരു ലളിത ഏജന്റ് സൃഷ്ടിക്കാം. ഈ ഉദാഹരണത്തിൽ, ഏജന്റ് ഹോട്ടലിന്റെ തിരഞ്ഞെടുപ്പ് മെച്ചപ്പെടുത്താൻ ശ്രമിക്കും, പക്ഷേ താത്പര്യോനുകൂലമല്ലാത്ത തിരഞ്ഞെടുക്കലുകൾ ഉണ്ടാകുമ്പോൾ സ്വയം തിരഞ്ഞെടുത്ത തന്ത്രം വിലയിരുത്തുകയും ക്രമീകരിക്കുകയും ചെയ്യും.
വിലയും ഗുണനിലവാരവും ഘടകമായ ഒരു ലളിത ഉദാഹരണത്തിലൂടെയാണ് ഇത് സിമുലേറ്റ് ചെയ്യുന്നത്. ഏജന്റ് തിരഞ്ഞെടുപ്പ് “ചെലവു കുറഞ്ഞ” തിരഞ്ഞെടുത്താലും സ്വയം നിരീക്ഷിച്ച് പരിഷ്കരിക്കും.
ഇത് മെടാകോഗ്നിഷൻ എങ്ങനെ അവതരിപ്പിക്കുന്നു:
- ആദിയ ഡിസിഷൻ: ഗുണനിലവാരത്തിന്റെ സ്വാധീനം മനസ്സിലാക്കാതെ ഏജന്റ് ചെലവു കുറഞ്ഞ ഹോട്ടൽ തിരഞ്ഞെടുക്കും.
- നിരീക്ഷണവും വിമർശനവും: ആദ്യ തിരഞ്ഞെടുപ്പിന് ശേഷം ഉപയോക്തൃ ഫീഡ്ബാക്ക് ഉപയോഗിച്ച് ഹോട്ടൽ “മാനദണ്ഡമല്ലാത്ത”തെരെഞ്ഞെടുപ്പാണോ എന്ന് പരിശോധിക്കും. എന്നാൽ ഗുണനിലവാരം കുറഞ്ഞതായാൽ, അതിന്റെ നിരീക്ഷണം ആഴത്തിൽ വിലയിരുത്തും.
- തന്ത്രം ക്രമീകരിക്കൽ: സ്വയം നിരീക്ഷണത്തെ അടിസ്ഥാനമാക്കി “ചെലവു കുറഞ്ഞ”നിന്ന് “ഉയർന്ന ഗുണനിലവാരമുള്ള” തിരഞ്ഞെടുപ്പിലേക്ക് മാറിയാണ് തന്ത്രം ക്രമീകരിക്കുക, ഭാവിയിൽ മെച്ചപ്പെട്ട തീരുമാനങ്ങളാണ് ചെയ്യുന്നത്.
ഉദാഹരണം:
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']}")
ഏജന്റിന്റെ മെടാകോഗ്നിഷൻ കഴിവുകൾ
പ്രധാന അംശങ്ങൾ:
- മുൻ തെരഞ്ഞെടുത്തതും തീരുമാനം പ്രക്രിയയും വിലയിരുത്തുക.
- നിരീക്ഷണത്തിന് ആധാരമായി തന്ത്രം ക്രമീകരിക്കുക, അതായത്, മെടാകോഗ്നിഷൻ പ്രയോഗം.
ഇത് ഒരു ലളിത രൂപത്തിലുള്ള മെടാകോഗ്നിഷൻ ആണ്, അകത്ത് ഫീഡ്ബാക്ക് അടിസ്ഥാനമാക്കി സിസ്റ്റത്തിന് തന്ത്ര നിർണ്ണയം ക്രമീകരിക്കാനും കഴിയും.
നിഘണ്ടു
മെടാകോഗ്നിഷൻ ശക്തനായ ഉപകരണമാകുന്നു, AI ഏജന്റുകളുടെ കഴിവുകൾ നന്നാക്കാൻ സഹായിക്കുന്നു. മെടാകോഗ്നിറ്റീവ് പ്രക്രിയകൾ ഉൾപ്പെടുത്തി, കൂടുതൽ ബുദ്ധിമുട്ടുള്ള, അനുയോജ്യമായ, ഫലപ്രദമായ ഏജന്റുകൾ രൂപകൽപ്പന ചെയ്യാൻ കഴിയും. മെടാകോഗ്നിഷൻ ലോകം ആഴത്തിൽ പഠിക്കാൻ അധിക വിഭവങ്ങൾ ഉപയോഗിക്കുക.
മെടാകോഗ്നിഷൻ ഡിസൈൻ പാറ്റേണിനെപ്പറ്റി കൂടുതൽ സംശയങ്ങളുണ്ടോ?
Microsoft Foundry Discord ലെ മറ്റ് പഠനാർത്ഥികളെയും കാണാനും ഓഫീസ് മണിക്കൂറുകളിൽ പങ്കെടുക്കാനും നിങ്ങളുടെ AI ഏജന്റുമാരുടെ ചോദ്യങ്ങൾക്ക് മറുപടിയെടുക്കാനുമുണ്ട്.
മുൻപത്തെ പാഠം
അടുത്ത പാഠം
അറിയിപ്പ്: ഈ രേഖ AI പരിഭാഷാ സേവനം Co-op Translator ഉപയോഗിച്ച് പരിഭാഷപ്പെടുത്തിയതാണ്. ഞങ്ങൾ കൃത്യതയ്ക്കായി ശ്രമിക്കുന്നുവെങ്കിലും, ഓട്ടോമേറ്റഡ് പരിഭാഷകളിൽ പിഴവുകൾ അല്ലെങ്കിൽ തെറ്റായ വിവരങ്ങൾ ഉണ്ടാകാൻ സാധ്യതയുണ്ട്. അതിന്റെ സ്വാഭാവിക ഭാഷയിലുള്ള അസൽ രേഖയാണ് പ്രാമാണികമായ ഉറവിടമായി പരിഗണിക്കേണ്ടത്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ പരിഭാഷ ശുപാർശ ചെയ്യുന്നു. ഈ പരിഭാഷ ഉപയോഗിച്ച് ഉണ്ടാകുന്ന തെറ്റിദ്ധാരണകൾ അല്ലെങ്കിൽ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കായി ഞങ്ങൾ ഉത്തരവാദികളല്ല.