OpenAI-ன் GPT-5.5 Codex ஒரு சிக்கலைச் சந்தித்துள்ளது. GitHub மற்றும் Hacker News தளங்களில் உள்ள டெவலப்பர்கள் சமீபத்திய வாரங்களில் ஒரு விசித்திரமான நடத்தை முறையைக் கவனித்துத் தெரிவிக்கத் தொடங்கியுள்ளனர். சிக்கலான கோடிங் மற்றும் தர்க்கரீதியான (reasoning) பணிகளைக் கையாளுவதற்காக உருவாக்கப்பட்ட இந்த மாடல், பயனர்கள் "reasoning-token clustering" என்று அழைக்கும் ஒரு விஷயத்தில் தடுமாறுகிறது. இதன் விளைவாக, வெளியீடுகள் துண்டு துண்டாகத் தெரிவது போலவும், தர்க்கம் படிகளைத் தவிர்ப்பது போலவும், இலக்கண அமைப்பு சரியாக இருந்தாலும் விடைகள் இலக்கை அடையாதது போலவும் உள்ளது. மென்பொருள் பொறியியலுக்கான (software engineering) ஒரு முக்கியமான உதவியாளராகக் கருதப்படும் ஒரு கருவிக்கு, இத்தகைய பிழை என்பது ஒரு சிறிய தொந்தரவு மட்டுமல்ல.
பயனர்கள் உண்மையில் என்ன பார்க்கிறார்கள்
இந்த அறிக்கைகள் தெளிவற்ற புகார்களாக வரவில்லை. பயனர்கள் குறிப்பிட்ட தோல்விகளை விவரித்தனர். ஒரு டெவலப்பர் ஒரு function-ஐ refactor செய்யவோ, பல கோப்புகளில் உள்ள ஒரு bug-ஐக் கண்டறியவோ அல்லது ஒரு குறிப்பிட்ட design pattern-ஐப் பின்பற்றவோ மாடலிடம் கேட்டால், அது ஆரம்பத்தில் சிறப்பாகச் செயல்பட்டுவிட்டுப் பிறகு திசைமாறிச் செல்கிறது. இது வெறும் தவறான விடைகளை மட்டும் வழங்கவில்லை. பல படிநிலைகளைக் கொண்ட ஒரு சிந்தனைச் செயல்பாட்டின் இடையில் அது அதன் தொடர்பை இழப்பது போல் தோன்றுகிறது. ஐந்து தர்க்கரீதியான படிகளை எடுக்க வேண்டிய ஒரு function, மூன்றாவது படியிலேயே முடங்கிவிடலாம் அல்லது கட்டமைப்பு ரீதியாகச் சரியாகத் தோன்றும் ஆனால் முக்கியமான edge cases-களைப் புறக்கணிக்கும் வகையில் code-ஐ உருவாக்கலாம். இந்தச் சிக்கலில் ஒரு தனித்துவமான அம்சம் உள்ளது: மாடல் மொழியில் தோல்வியடையவில்லை; அது தனது சொந்த தர்க்கத்தைப் (logic) பராமரிப்பதில் தோல்வியடைகிறது.
reasoning-token clustering-ன் செயல்பாடுகள்
இது ஏன் முக்கியம் என்பதைப் புரிந்துகொள்ள, பெரிய மொழி மாதிரிகள் (large language models) உண்மையில் எவ்வாறு வாசிக்கின்றன என்பதைப் பார்க்க வேண்டும். அவை மனிதர்களைப் போல வாக்கியங்களை ஸ்கேன் செய்வதில்லை. அவை உரையை tokens-களாகப் பிரிக்கின்றன—அதாவது எழுத்துக்களின் தொகுப்புகள், அசைகள் அல்லது சில நேரங்களில் முழு வார்த்தைகள். இந்த tokens தான் இயந்திரத்தின் மூலப்பொருள், அது பதில்களை உருவாக்குவதற்கு அடுக்கி வைக்கும் Lego கட்டைகள் போன்றவை.
reasoning-token clustering என்பது ஒரு மாடல் ஒரு கருத்திலிருந்து (premise) முடிவுக்குச் செல்லும்போது தொடர்புடைய tokens-களை எவ்வாறு குழுவாக்குகிறது என்பதைக் குறிக்கிறது. ஒரு சீரான செயல்பாட்டில், மாடல் ஒரு தர்க்கரீதியான இழையுடன் (logical thread) தொடர்புடைய tokens-களைத் தொகுத்து, அந்தச் சிந்தனையைத் தீர்த்துவிட்டு, பின்னர் அடுத்த குழுவிற்குத் தெளிவாக மாறுகிறது. ஆனால் clustering தோல்வியடையும் போது, வெவ்வேறு தர்க்க இழைகளிலிருந்து வரும் tokens ஒன்றோடொன்று சிக்கிக்கொள்கின்றன. ஒரு தர்க்கரீதியான மாறி (logical variable) மற்றொன்றோடு கலந்துவிடுகிறது. தொடரியல் (syntax) அப்படியே இருந்தாலும், சிந்தனையின் கட்டமைப்பு (architecture) சிதைகிறது.
காய்கறிகளை எப்படி நறுக்குவது என்பதை மறந்த ஒரு சமையல்காரரைப் போல இதை நினைத்துப் பாருங்கள். சமையலறை முழுமையாகத் தயாராக உள்ளது, செய்முறை விளக்கம் (recipe) மேஜையில் உள்ளது, சமையல்காரருக்குப் பல வருடப் பயிற்சி உள்ளது. ஆனால் அடிப்படைத் தயாரிப்புப் பணிகள் குழப்பமடைந்தால்—வேலை செய்யும் இடம் ஒழுங்கமைக்கப்படாததால் வெங்காயம் கேக் மாவில் கொட்டப்பட்டால்—சமையல்காரர் எவ்வளவு திறமையானவராக இருந்தாலும் இறுதி முடிவு மோசமாகவே இருக்கும். GPT-5.5 Codex-க்கு, tokens என்பது மூலப்பொருட்கள், reasoning clusters என்பது தயாரிப்பு நிலையங்கள் (prep stations). அந்த நிலையங்கள் குழப்பமடையும் போது, உணவு கெட்டுப்போகிறது.
ஒரு தெளிவான உதாரணம் உதவும். பயனர் அங்கீகாரத்தை (user authentication) கையாளும் ஒரு Python script-ஐ debug செய்ய மாடலிடம் கேட்பதாகக் கற்பனை செய்து பாருங்கள். இந்தத் பணி ஒரே நேரத்தில் மூன்று வெவ்வேறு இழைகளைச் சரியாகப் பராமரிக்க வேண்டும்: password hashing, session management மற்றும் database queries. reasoning clusters ஒன்றோடொன்று கலந்துவிட்டால், மாடல் session logic-ஐ hashing routine-க்கு பயன்படுத்தலாம் அல்லது ஒரு database variable-ஐ பயனர் உள்ளீடாக (raw user input) கருதலாம். உருவாக்கப்பட்ட code ஒரு மேலோட்டமான பார்வையில் சரியாகத் தோன்றலாம், ஆனால் உண்மையான பயன்பாட்டின் போது (real load) தோல்வியடையலாம் அல்லது ஒரு பாதுகாப்பு இடைவெளியை (security gap) உருவாக்கலாம். இந்தத் தோல்வி code-ன் இலக்கணத்தில் இல்லை. அதை உருவாக்கிய சிந்தனையின் தர்க்கத்தில் (logic) உள்ளது.
கட்டமைப்பு ஏன் சிரமப்படுகிறது
தற்போதைய தலைமுறை மாடல்கள் மனிதர்களைப் போலவே செயல்படுவதற்குத் தூண்டப்படுகின்றன. அந்த லட்சியம் சிக்கலை அதிகரிக்கிறது. இந்த அமைப்பு அதன் பயிற்சித் தரவிலிருந்து (training data) புள்ளிவிவர முறைகளின் அடிப்படையில் அடுத்த token-ஐக் கணிப்பதோடு மட்டும் நின்றுவிடவில்லை. இது இயல்பானதாகவும், சூழலுக்கு ஏற்றதாகவும் மற்றும் உரையாடல் போன்றும் தோன்றும் ஒரு தர்க்க முறையை (reasoning style) உருவகப்படுத்த முயல்கிறது.
அந்த இரட்டைப் பணி உராய்வை (friction) உருவாக்குகிறது. தூய மொழியைக் கையாளுவது (தொனி, நடை, நுணுக்கம், உரையாடல் ஓட்டம்) என்பது கடுமையான, கட்டமைக்கப்பட்ட தர்க்கத்தை விட முற்றிலும் மாறுபட்ட ஒரு கணக்கீட்டுப் பணியாகும் (computational task). இரண்டையும் ஒரே நேரத்தில் செய்வது கட்டமைப்பைச் சிரமப்படுத்துகிறது. தற்போதைய வடிவமைப்பு தர்க்கம் மற்றும் மொழி இரண்டையும் ஒரே நேரத்தில் கையாள்வதில் சிரமப்படுகிறது. தெளிவான, தொடர்ச்சியான தர்க்கச் சங்கிலிகளுக்குப் பதிலாக, மாடல் சில நேரங்களில் மனிதர்களைப் போலவே தோன்றும் ஆனால் கணக்கீட்டு ரீதியாகச் சரியாக அமையாத, திசைமாறும் அல்லது மீண்டும் மீண்டும் சுழலும் தர்க்கங்களை உருவாக்குகிறது.
ஒரு வழக்கறிஞர் ஒரு இறுக்கமான ஒப்பந்தத்தை தயாரிக்கும் அதே வேளையில், வாய்மொழி கவிதை (spoken-word poetry) பாடுவதை கற்பனை செய்து பாருங்கள். இவை இரண்டும் மொழி சார்ந்த பணிகளே, ஆனால் அவை வெவ்வேறு ஒழுக்கங்களைக் கோருகின்றன. ஒரு மாதிரி (model) மிகவும் சரளமான, மனிதனைப் போன்ற வெளிப்பாட்டை நோக்கிச் சாயும்போது, அதன் கடுமையான தர்க்கரீதியான கட்டமைப்பைப் பராமரிக்கும் திறன் பலவீனமடைகிறது. இயல்பாகத் தோன்றுவதற்கான முயற்சி கூடுதல் அறிவுசார் சுமையை (cognitive overhead) ஏற்படுத்துகிறது, மேலும் அதிக சிக்கல்தன்மை எப்போதும் சிறந்த முடிவுகளுக்கு வழிவகுப்பதில்லை. அந்த மாதிரி ஒரே நேரத்தில் சிந்திக்கவும், அதே சமயம் கவர்ச்சிகரமாகவும் இருக்க வேண்டிய கட்டாயத்திற்கு உள்ளாக்கப்படுகிறது; மேலும் attention mechanisms-ன் வன்பொருள் அந்தப் பிரிந்த தேவையை இன்னும் முழுமையாகப் பின்தொடரவில்லை.
ஆய்வகத்திற்கு வெளியே இது ஏன் முக்கியமானது
இந்தச் சம்பவம் இரண்டு தனித்துவமான காரணங்களுக்காக முக்கியத்துவம் பெறுகிறது.
முதலாவதாக, AI என்பது குறையற்றது அல்ல என்பதை இது ஒரு நேரடி நினைவூட்டலாகும். சிறந்த மாதிரிகள் கூட அவற்றின் எல்லைகளை எட்டும்போது தவறுகளைச் செய்கின்றன. பெரிய மொழி மாதிரிகளைச் (large language models) சுற்றியுள்ள சந்தைப்படுத்தல் சுழற்சி, அவற்றை ஒரு oracle போன்ற அமைப்புகளாக விற்கிறது, ஆனால் அவை நிகழ்தகவு இயந்திரங்களாகவே (probabilistic engines) உள்ளன. அடுத்த token எது வரும் என்று அவை யூகிக்கின்றன, சில நேரங்களில் அந்த யூகங்கள் ஒத்திசைவாகத் தோன்றும் அர்த்தமற்ற விஷயங்களாக மாறுகின்றன. GPT-5.5 Codex போன்ற ஒரு முன்னணி கோடிங் மாதிரியின் தர்க்கத்தில் ஏற்படும் தடுமாற்றத்தைக் காண்பது ஒரு ஆரோக்கியமான யதார்த்தப் பார்வையாகும். இது வடிவப் பொருத்தம் (pattern matching) மற்றும் உண்மையான புரிதலுக்கு இடையிலான எல்லையைக் குறிக்கிறது, மேலும் அந்த எல்லை இன்னும் மிகவும் நிஜமானது.
இரண்டாவதாக, வணிகங்கள் இந்த மாதிரிகளை நம்பியிருக்கின்றன. மோசமான செயல்பாடு தயாரிப்பு மேம்பாடு மற்றும் வாடிக்கையாளர் சேவையைப் நேரடியாகவும் அளவிடக்கூடிய வகையிலும் பாதிக்கிறது. Codex-ஐப் பயன்படுத்தி ஒரு backend infrastructure-ஐ உருவாக்கும் ஒரு startup, மாதிரி இரண்டு authentication layers-களைக் குழப்பிக் கொண்டதால் ஒரு பாதுகாப்பு ஓட்டையை (security hole) உருவாக்கக்கூடும். இதே போன்ற கட்டமைப்பால் இயங்கும் ஒரு customer-service bot, உண்மையில் செயல்படுத்த முடியாத refunds அல்லது கொள்கை விதிவிலக்குகளை வாக்குறுதி அளிக்கலாம், இது சட்ட ரீதியான சிக்கல்களையும் கோபமான பயனர்களையும் உருவாக்கும்.
மென்பொருளைத் தாண்டிப் பார்க்கும்போது இதன் முக்கியத்துவம் இன்னும் அதிகமாகிறது. இத்தகைய சம்பவங்கள் சுகாதாரம் அல்லது கார்களை ஓட்டுவதில் AI-ஐப் பயன்படுத்துவது குறித்த கடுமையான கேள்விகளை எழுப்புகின்றன. ஒரு மாதிரி SQL query எழுதும் போது token clusters-களைக் குழப்பிக் கொண்டால், அது ஒரு மருத்துவ ஸ்கேனைப் பகுப்பாய்வு செய்யும் போதோ அல்லது ஒரு தானியங்கி வாகனத்திற்கான நிகழ்நேர sensor data-வை ஆய்வு செய்யும் போதோ என்ன நடக்கும்? பில்லியன் கணக்கான parameters-களுக்கு இடையிலான புள்ளிவிவர வடிவப் பொருத்தம் (statistical pattern matching) போன்ற அடிப்படை இயக்கவியல் முற்றிலும் ஒன்றுதான். அதிக பாதிப்பு ஏற்படக்கூடிய துறைகளில் (high-consequence domains) இந்த அமைப்புகளை நம்புவதற்கு, token-clustering தோல்விகள் நேரடியாகப் பாதிக்கும் அளவிலான தர்க்கரீதியான நம்பகத்தன்மை தேவைப்படுகிறது.
ஒரு தடுமாற்றம், வீழ்ச்சியல்ல
இதை ஒரு தோல்வி என்று அழைப்பது தவறாக இருக்கும். இத்தகைய சிக்கல்கள் புதிய தொழில்நுட்பத்தை உருவாக்குவதில் ஒரு பகுதியாகும். AI திறனில் ஏற்படும் ஒவ்வொரு குறிப்பிடத்தக்க முன்னேற்றமும், ஒரு நிலையற்ற நடத்தையின் (brittle behavior) காலத்தைத் தொடர்ந்து கண்டுள்ளது. ஆரம்பகால GPT மாதிரிகள் குழப்பமான நம்பிக்கையுடன் தவறான தகவல்களை உருவாக்கின (hallucinated facts). Image generators ஒரு காலத்தில் மனிதக் கைகளைச் சிதைத்து உருவாக்கின. தெளிவற்ற அறிவுறுத்தல்களை எதிர்கொள்ளும்போது Code models வழக்கமாக infinite loops-களை வெளியிடுகின்றன. ஒவ்வொரு குறையும் ஒரு எல்லையை வெளிப்படுத்தியது, மேலும் ஆராய்ச்சியாளர்கள் அந்த எல்லைகளைப் பயன்படுத்தி சிறந்த வரைபடங்களை உருவாக்கினர்.
ஆராய்ச்சியாளர்கள் இந்தத் தவறுகளைப் பயன்படுத்தி அமைப்புகளைச் சரிசெய்து மேம்படுத்துகின்றனர். GitHub threads மற்றும் Hacker News கருத்துப் பிரிவுகளில் இருந்து வரும் கருத்துக்கள் வெறும் இரைச்சல் மட்டுமல்ல. அவை நிஜ உலகத்திலிருந்து பெறப்பட்ட மூலக் கண்டறியும் தரவுகள் (raw diagnostic data) ஆகும். நூற்றுக்கணக்கான டெவலப்பர்கள் ஆயிரக்கணக்கான தனித்துவமான பணிகளில் ஒரு மாதிரியைச் சோதிக்கும்போது (stress-test), எந்தவொரு உள் தரக் கட்டுப்பாட்டு குழுவிற்கும் (internal quality-assurance team) முழுமையாகப் பிரதிபலிக்க முடியாத தோல்வி முறைகளை (failure modes) அவர்கள் வெளிக்கொண்டு வருகின்றனர். அந்த கூட்டாகச் செயல்படும் ஆய்வறிக்கை (crowdsourced scrutiny) பின்னூட்டச் சுழற்சியை (feedback loop) இறுக்கமாக்குகிறது மற்றும் வேகமான, இலக்கு வைக்கப்பட்ட திருத்தங்களை (targeted patches) கட்டாயப்படுத்துகிறது.
இந்தச் சம்பவம் பெரும்பாலும் மாதிரியின் சிறந்த பதிப்பிற்கு வழிவகுக்கும். ஒரு குறைபாடு கண்டறியப்பட்டுப் புரிந்துகொள்ளப்பட்டவுடன், OpenAI வரலாற்று ரீதியாக விரைவாகச் செயல்பட்டு மேம்படுத்தி வருகிறது. அந்தத் திருத்தம் attention mechanism-ஐச் சரிசெய்வதாவோ, reasoning layers எவ்வாறு language layers-க்கு எதிராக எடைபோடப்படுகின்றன என்பதைச் செம்மைப்படுத்துவதாவோ, அல்லது பயனர் சென்றடைவதற்கு முன்பே சிக்கலான token clusters-களைக் கண்டறியும் புதிய validation steps-களை அறிமுகப்படுத்துவதாவோ எதுவாக இருந்தாலும், அதன் முடிவு ஒரு நிலையான அமைப்பாகவே அமையும்.
உண்மையான பாடம்
பணிபுரியும் டெவலப்பர்களுக்கு, இதிலிருந்து கிடைக்கும் பாடம் நடைமுறை சார்ந்தது. AI-ஆல் உருவாக்கப்பட்ட code மற்றும் தர்க்கத்தை ஒரு முழுமையான தயாரிப்பாகக் கருதாமல், ஒரு முதல் வரைவாக (first draft) மட்டும் கருதுங்கள். உங்கள் சோதனைகளை (tests) நடத்துங்கள். தர்க்கத்தை ஒவ்வொன்றாகச் சரிபாருங்கள். வெளியீடு மேலோட்டமாகத் துல்லியமாகத் தெரிந்தாலும் கூட, மாதிரி தனது உள் token clusters-களைக் குழப்பிக் கொண்டிருக்கலாம் என்று கருதுங்கள். அழகான syntax ஒரு குழப்பமான சிந்தனையை மறைக்கக்கூடும்.
ஒட்டுமொத்தத் தொழில்துறைக்கும், செயற்கை நுண்ணறிவில் முன்னேற்றம் என்பது ஒரு நேர்க்கோடு அல்ல என்பதை இந்தச் சம்பவம் அடிக்கோடிட்டுக் காட்டுகிறது. இது வெளியீடு, உடைப்பு, கண்டறிதல் மற்றும் பழுதுபார்த்தல் ஆகியவற்றின் ஒரு சுழற்சி ஆகும். GPT-5.5 Codex தடுமாறியது, ஆனால் அந்தத் தடுமாற்றமே அடுத்த பதிப்பு நேராக நடக்கக் கற்றுக்கொள்ளும் வழியாகும்.
விருப்பத்தேர்வு கற்றல் சமூகம்: [