കോൺഫാബുലേഷൻ കാസ്കേഡ് (The Confabulation Cascade)
എന്റെ AI ഏജന്റ് ഒരു ലൂപ്പിൽ കുടുങ്ങിപ്പോയി.
അത് വ്യാജമായ ഒരു കോളം പേര് ഉപയോഗിച്ച് ഒരു SQL ക്വറി എഴുതുന്നു. ഡാറ്റാബേസ് ഒരു എറർ (error) നൽകുന്നു. ആ എറർ മെസ്സേജിൽ യഥാർത്ഥ കോളം ലിസ്റ്റ് ഉണ്ടാകും. ഏജന്റ് ആ തിരുത്തൽ വായിക്കുന്നു. എന്നാൽ, അത് വീണ്ടും അതേ തെറ്റായ കോളം പേര് തന്നെ എഴുതുന്നു.
ഇതിനെ ഞാൻ 'കോൺഫാബുലേഷൻ കാസ്കേഡ്' (confabulation cascade) എന്ന് വിളിക്കുന്നു.
ഇതൊരു മോഡൽ പ്രശ്നമല്ല. ഇതൊരു ടൂൾ ഡിസൈൻ (tool design) പ്രശ്നമാണ്.
ആ ലൂപ്പ് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് നോക്കാം:
- ഏജന്റ് അതിന്റെ ട്രെയിനിംഗിന്റെ അടിസ്ഥാനത്തിൽ ഒരു ക്വറി തയ്യാറാക്കുന്നു.
- ക്വറി പരാജയപ്പെടുന്നു.
- എറർ മെസ്സേജ് യഥാർത്ഥ വിവരങ്ങൾ നൽകുന്നു.
- ഏജന്റ് സത്യം കാണുന്നുണ്ടെങ്കിലും പകരം അതിന്റെ ആന്തരിക ട്രെയിനിംഗിനെയാണ് ആശ്രയിക്കുന്നത്.
- ഏജന്റ് ആ തെറ്റ് ആവർത്തിക്കുന്നു.
ഏജന്റ് രണ്ട് സിഗ്നലുകൾ നേരിടുന്നുണ്ട്. ഒന്ന് എറർ മെസ്സേജ് ആണ്. മറ്റൊന്ന് മോഡലിന്റെ ട്രെയിനിംഗ് ആണ്. ട്രെയിനിംഗ് പലപ്പോഴും കൂടുതൽ ശക്തമായിരിക്കും. എറർ മെസ്സേജ് ഒരു തവണ മാത്രമേ കാണപ്പെടുന്നുള്ളൂ. എന്നാൽ മോഡൽ എഴുതുന്ന ഓരോ വാക്കിനും കൂടെ ട്രെയിനിംഗ് നിലനിൽക്കുന്നുണ്ട്.
പ്രോംപ്റ്റ് എൻജിനീയറിംഗിലൂടെ (prompt engineering) ഇത് പരിഹരിക്കാൻ ഞാൻ ശ്രമിച്ചു. എററുകൾ ശ്രദ്ധിക്കണമെന്ന് ഞാൻ മോഡലിനോട് പറഞ്ഞു. പക്ഷേ അത് ഫലിച്ചില്ല.
യഥാർത്ഥ പ്രശ്നം എന്റെ ഏജന്റിന് പരാജയപ്പെട്ടാൽ മാത്രമേ പഠിക്കാൻ കഴിയുമായിരുന്നു എന്നതാണ്. പ്രവർത്തിക്കുന്നതിന് മുമ്പ് ടേബിൾ ഘടന (table structure) പരിശോധിക്കാൻ അതിന് മാർഗമില്ലായിരുന്നു. അതിന് ഊഹിച്ചു മാത്രം പ്രവർത്തിക്കേണ്ടി വന്നു.
നിങ്ങൾ ഒരു മനുഷ്യന് ഒരു API നൽകുകയാണെങ്കിൽ, അവർക്ക് ഡോക്യുമെന്റേഷനും നൽകും. എറർ മെസ്സേജുകൾ വഴി സ്കീമ (schema) പഠിക്കുന്നത് വരെ അവരെ തെറ്റായ റിക്വസ്റ്റുകൾ അയക്കാൻ നിങ്ങൾ നിർബന്ധിക്കില്ല.
ഒരു പ്രോആക്റ്റീവ് ടൂൾ (proactive tool) നിർമ്മിച്ചുകൊണ്ട് ഞാൻ ഇത് പരിഹരിച്ചു. ഒരു എററിനായി കാത്തുനിൽക്കുന്നതിന് പകരം, ഏജന്റ് ഇപ്പോൾ ആദ്യം describe_table എന്ന ടൂൾ വിളിക്കുന്നു.
പുതിയ പ്രവർത്തനരീതി:
- ഏജന്റിന് ഒരു ടേബിൾ ക്വറി ചെയ്യണം.
- യഥാർത്ഥ കോളങ്ങൾ കാണുന്നതിനായി ഏജന്റ്
describe_tableവിളിക്കുന്നു. - ഏജന്റിന് ശരിയായ പേരുകളും ടൈപ്പുകളും ലഭിക്കുന്നു.
- ഏജന്റ് ആദ്യ ശ്രമത്തിൽ തന്നെ ശരിയായ ക്വറി എഴുതുന്നു.
ആ ലൂപ്പ് അവസാനിച്ചു. മോഡൽ കൂടുതൽ ബുദ്ധിമാനായില്ല. ഏജന്റ് ഊഹിക്കുന്നത് നിർത്തി എന്ന് മാത്രം.
നിങ്ങളുടെ ഏജന്റുകൾ ഡാറ്റാബേസുകളോ API-കളോ ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ, ഇത് ചോദിച്ചു നോക്കൂ: പ്രവർത്തിക്കുന്നതിന് മുമ്പ് അവയ്ക്ക് ഘടന (structure) പരിശോധിക്കാൻ കഴിയുമോ? അതോ പരാജയപ്പെട്ടാൽ മാത്രം പഠിക്കുന്നവയാണോ അവർ?
റിയാക്റ്റീവ് എറർ ഹിന്റുകൾ (Reactive error hints) നല്ലതാണ്. എന്നാൽ അവ മാത്രം മതിയാകില്ല. പരാജയത്തിലൂടെ മാത്രം പഠിക്കുന്ന ഒരു ഏജന്റ് എപ്പോഴും ഒരു 'ഹാലൂസിനേഷൻ' (hallucination) എന്ന അവസ്ഥയിലേക്ക് എത്തിയിരിക്കുകയാണ്.
തെറ്റുകൾ വരുത്തുന്നതിന് മുമ്പ് ചോദ്യങ്ങൾ ചോദിക്കാൻ ഏജന്റുകളെ അനുവദിക്കുന്ന ടൂളുകൾ നിർമ്മിക്കുക.
Optional learning community: https://t.me/GyaanSetuAi