AI ஏஜென்ட்களை மதிப்பிடுதல்: Deterministic Metrics + ஓர் LLM Judge

நீங்கள் பல சிறிய AI ஏஜென்ட்களை இயக்குகிறீர்கள். உங்களிடம் backend, frontend, mobile மற்றும் devops ஆகியவற்றிற்கான ஏஜென்ட்கள் உள்ளன. ஒவ்வொரு ஏஜென்ட்டிற்கும் ஒரு வேலை உண்டு.

உங்களிடம் பல ஏஜென்ட்கள் இருக்கும்போது, நீங்கள் ஒரு சிக்கலை எதிர்கொள்கிறீர்கள். அவை சிறப்பாகச் செயல்படுகின்றனவா என்று உங்களுக்குத் தெரியாது. ஒரு prompt மாற்றத்தைச் செய்யும்போது அது அவற்றை மேம்படுத்துகிறதா அல்லது மோசமாக்குகிறதா என்பதையும் நீங்கள் அறிய முடியாது. "இது நன்றாகத் தெரிகிறது" என்று சொல்வது பெரிய அளவில் (at scale) வேலை செய்யாது.

இதைத் தீர்க்க நான் ஒரு framework-ஐ உருவாக்கினேன். இது செயல்திறனை அளவிட எண்களைப் பயன்படுத்துகிறது மற்றும் prompts-களைத் தானாகவே மேம்படுத்துகிறது.

The Strategy

கணிதத்தின் மூலம் எதை அளவிட முடியுமோ அதை முதலில் அளவிடுங்கள். தேவைப்படும்போது மட்டுமே ஓர் LLM judge-ஐப் பயன்படுத்துங்கள். Deterministic metrics வேகமானவை மற்றும் இலவசமானவை. ஓர் LLM judge மெதுவானது மற்றும் அதற்குச் செலவாகும்.

இந்த அமைப்பு எவ்வாறு செயல்படுகிறது:

• The harness ஒவ்வொரு ஏஜென்ட்டையும் ஒரு தனிச் செயல்பாடாக (separate process) இயக்குகிறது. • இது ஏஜென்ட்டிற்கு ஒரு பணியை வழங்குகிறது. • இது வெளியீட்டைப் (output) பிடிக்கிறது. • இது எதிர்பார்க்கப்படும் தரவுகளுடன் (expected data) முடிவை ஒப்பிட்டு மதிப்பெண் வழங்குகிறது.

ஏஜென்ட் stdin-லிருந்து படிக்கவும் stdout-இல் எழுதவும் மட்டுமே செய்ய வேண்டும். அது Python அல்லது shell script ஆக இருக்கலாம். Harness-க்கு அது ஒரு பொருட்டல்ல.

கண்காணிக்க வேண்டிய ஐந்து முக்கிய அளவீடுகள்:

  • Accuracy: வெளியீடு இலக்கைச் சரியாகப் பொருந்துகிறதா?
  • Fuzzy score: உரை இலக்குடன் எவ்வளவு ஒத்துப்போகிறது?
  • Timeout rate: ஏஜென்ட் எவ்வளவு அடிக்கடி பணியை முடிக்கத் தவறிவிடுகிறது?
  • Safety violations: வெளியீடு பாதுகாப்பற்ற முறைகளைப் பின்பற்றுகிறதா?
  • Reproducibility variance: ஏஜென்ட் ஒவ்வொரு முறையும் ஒரே பதிலைத் தருகிறதா?

ஒரு ஏஜென்ட் சரியாக இருந்தாலும், நிலையற்றதாக (inconsistent) இருந்தால், அது ஒரு பிழை (bug).

The LLM Judge

சில விஷயங்களை கணிதத்தின் மூலம் அளவிடுவது கடினம். ஒரு ஏஜென்ட் தனது பங்கில் (role) நிலைத்திருக்கிறதா அல்லது கட்டுப்பாடுகளைப் பின்பற்றுகிறதா என்பதை நீங்கள் அறிய வேண்டும்.

இத்தகைய சந்தர்ப்பங்களில், ஓர் LLM judge வேலையை ஆய்வு செய்கிறது. இது ஒரு மதிப்பீட்டுத் தாளையும் (rubric) ஏஜென்ட் வெளியீட்டையும் பெறுகிறது. இது ஒரு கட்டமைக்கப்பட்ட தீர்ப்பைத் (structured verdict) தருகிறது. அறிக்கை பாதிக்கப்படாமல் இருக்க, நான் இந்தத் தீர்ப்பை ஒரு JSON schema மூலம் சரிபார்க்கிறேன்.

நீதிபதி மதிப்பெண் வழங்குவதைத் தாண்டிச் செய்கிறார். அவர் தீர்வுகளையும் பரிந்துரைக்க வேண்டும். "இது பலவீனமானது" போன்ற விமர்சனம் பயனற்றது. "prompt-இல் ஒரு JSON block-ஐச் சேர்க்கவும்" போன்ற விமர்சனம் நடைமுறைக்குச் சாத்தியமானது (actionable).

The Improvement Loop

தோல்விகள் ஒரு கோப்பில் (file) சேமிக்கப்படுகின்றன. இந்த கோப்பு ஒரு தானியங்கிச் சுழற்சிக்கு (automated loop) உள்ளீடாக அமைகிறது. இந்த அமைப்பு ஒரு prompt-இன் பலவீனமான பகுதியைத் தேடி அதைச் சரிசெய்ய முயல்கிறது. இது சிறந்த சாத்தியக்கூறுகளைத் தொகுத்து வைத்துக்கொண்டு, மிகச்சிறந்த பதிப்புகளை மீண்டும் குறியீட்டில் (code) எழுதுகிறது.

ஒரு ஒற்றை மதிப்பெண் என்பது ஒரு தற்காலிகப் பார்வை (snapshot) மட்டுமே. போக்குகளைக் கண்காணிக்க வரலாற்றைப் (history) பயன்படுத்துங்கள். இது காலப்போக்கில் நீங்கள் முன்னேறி வருகிறீர்களா என்பதை உங்களுக்குத் தெரிவிக்கும்.

உங்கள் அடித்தளத்தை deterministic metrics-களின் மீது கட்டமைக்கவும். நீதிபதியை ஒரு சுத்தியலாகப் பயன்படுத்தாமல், ஒரு அறுவை சிகிச்சை கத்தியைப் (scalpel) போலத் துல்லியமாகப் பயன்படுத்துங்கள்.

Source: https://dev.to/pponali/scoring-ai-agents-deterministic-metrics-an-llm-judge-poj

Optional learning community: https://t.me/GyaanSetuAi