GPT-4 மற்றும் Claude போன்ற Autoregressive மாபெரும் மாதிரிகள், ஒரு கோப்பில் இடமிருந்து வலமாகச் சென்று, ஒவ்வொரு டோக்கனையும் (token) ஒவ்வொன்றாக வெளியிடுகின்றன. இவை சிறிய துணுக்குகளை (snippets) நன்றாகக் கையாளும், ஆனால் ஒரு டெவலப்பர் ஒரு பெரிய codebase-இல் ஆழமாகப் புதைந்துள்ள ஒரு வரியைத் திருத்த முயலும்போது தடுமாறுகின்றன. மாதிரி ஒவ்வொரு அடுத்தடுத்த டோக்கனையும் மீண்டும் மதிப்பீடு செய்ய வேண்டும், மேலும் முழு கோப்பையும் சீராக வைத்திருப்பது ஒரு சவாலான காரியமாகிவிடுகிறது.
Diffusion மாதிரிகள் சீரற்ற டோக்கன்களின் (random tokens) மேகத்திலிருந்து தொடங்கி, ஒரு தெளிவான நிரல் (program) தோன்றும் வரை படிப்படியாக இரைச்சலை (denoise) நீக்குகின்றன. இந்தச் சுத்திகரிப்பு செயல்முறை முழுத் தொடரையும் ஒரே நேரத்தில் தொட்டுச் செல்வதால், மாதிரி வால் பகுதியை (tail) மீண்டும் கணக்கிடாமலேயே குறியீட்டின் எந்தப் பகுதியையும் சேர்க்கவோ, நீக்கவோ அல்லது மீண்டும் எழுதவோ முடியும்.
தற்போதைய முறை மென்பொருள் பொறியியலில் ஏன் சிரமப்படுகிறது
Autoregression என்பது குறியீட்டை ஒரு நேரியல் ஓட்டமாக (linear stream) கருத வேண்டிய கட்டாயத்தை மாதிரியின் மீது சுமத்துகிறது, இதன் பொருள் அது:
- பின்னோக்கி மட்டுமே பார்க்கிறது. இது எதிர்கால டோக்கன்களைப் பார்ப்பதில்லை, எனவே ஒரு மாற்றம் பிந்தைய வரிகளை எவ்வாறு பாதிக்கும் என்பதை முன்கூட்டியே கணிக்க முடியாது.
- அடுத்தடுத்த உரையை மீண்டும் கணக்கிடுகிறது. ஒரு திருத்தம் புதிய கணிப்புகளின் தொடரையும் தூண்டுகிறது, இது refactoring அல்லது bug fixing செய்வதற்கான காலதாமதத்தை அதிகரிக்கிறது.
- நீண்ட தூரப் பிழைகளைத் திரட்டுகிறது. ஆரம்பகால முரண்பாடுகள் பெருகி, இறுதி கோப்பு தொடரியல் ரீதியாக (syntactically) சிதைந்ததாகவோ அல்லது தர்க்கரீதியாக (logically) முரண்பட்டதாகவோ மாறக்கூடும்.
உங்களுக்கு ஒரு கோப்பின் நடுவில் ஒரு function body-ஐ சேர்க்கவோ அல்லது ஒரு API signature-ஐப் புதுப்பிக்கவோ வேண்டியிருக்கும் போது, autoregressive மாதிரிகளின் வரிசைமுறைத் தன்மை கடினமாகவும் பிழையூட்டும் வகையிலும் இருக்கும்.
Diffusion மாற்று வழி: படிப்படியான கணிப்பு அல்ல, படிப்படியான சுத்திகரிப்பு
நாம் ஒரு குறியீட்டு கோப்பை ஒரு இரைச்சல் சிக்னலாக (noisy signal) கருதுகிறோம். இதன் உருவாக்கம் பல சுற்றுகளில் நடைபெறுகிறது:
- தூய இரைச்சலுடன் தொடங்குதல். நாம் மாதிரிக்கு சீரற்ற டோக்கன்களின் தொடரைக் கொடுக்கிறோம், இது பெரும்பாலும் ஒரு சிறப்பு placeholder மூலம் குறிக்கப்படுகிறது.
- படிப்படியான இரைச்சல் நீக்கம். ஒவ்வொரு படியிலும் மாதிரி சற்று சுத்திகரிக்கப்பட்ட பதிப்பைக் கணிக்கிறது, டோக்கன்களைச் சரியான குறியீட்டை நோக்கித் தள்ளுகிறது.
- முழுமையடைந்த நிரலாக மாறுதல். ஒரு குறிப்பிட்ட எண்ணிக்கையிலான படிகளுக்குப் பிறகு இரைச்சல் மறைந்து, முழுமையாக உருவான ஒரு துணுக்குக் கிடைக்கிறது.
ஒவ்வொரு படியும் முழுத் தொடரையும் மீண்டும் பார்வையிடுவதால், மாதிரி எந்த நிலையிலும் எந்தவொரு டோக்கனையும் மாற்றியமைக்க முடியும். இந்த உலகளாவிய பார்வை (global view), அடுத்து வரும் அனைத்தையும் மீண்டும் உருவாக்காமலேயே ஒரு விடுபட்ட import-ஐ சேர்க்கவோ, ஒரு variable பெயரை மாற்றவோ அல்லது ஒரு block-ஐ மீண்டும் வரிசைப்படுத்தவோ (re-indent) அனுமதிக்கிறது.
குறியீடு சார்ந்த ஒரு Diffusion மாதிரியை உருவாக்குதல்
படங்களிலிருந்து உரையை நோக்கி Diffusion முறையை மாற்றுவது எளிதான காரியம் அல்ல. மூன்று தொழில்நுட்ப மாற்றங்கள் முக்கியமானவை.
1. Discrete diffusion
படத்தின் pixels பின்னடைவு இரைச்சலை (fractional noise) ஏற்கின்றன, ஆனால் ஒரு குறியீடு டோக்கன் என்பது categorical — அது ஒரு குறிப்பிட்ட keyword, identifier அல்லது symbol ஆக மட்டுமே இருக்கும். எனவே, நாம் ஒரு Markov chain-ஐப் பயன்படுத்துகிறோம், இது தொடர் பயனுறுதியாகச் சீரற்றதாக மாறும் வரை டோக்கன்களைத் திரும்பத் திரும்ப ஒரு நடுநிலையான placeholder (பெரும்பாலும் [MASK]) மூலம் மாற்றுகிறது. இதன் தலைகீழ் செயல்முறை, படிப்படியாக அசல் டோக்கன்களை எவ்வாறு மீட்டெடுப்பது என்பதைக் கற்றுக்கொள்கிறது.
2. Structural awareness
நிரலாக்க மொழிகள் கடுமையான தொடரியல் விதிகளை விதிக்கின்றன: Python-இல் indentation எல்லையைத் (scope) தீர்மானிக்கிறது, C-style மொழிகளில் braces தொகுதிகளைப் பிரிக்கின்றன, மேலும் variables பயன்படுத்தப்படுவதற்கு முன் அறிவிக்கப்பட வேண்டும். குறியீட்டை வெறும் உரையாகக் கருதும் ஒரு Diffusion மாதிரி, தொடரியல் ரீதியாகத் தவறான வெளியீட்டை உருவாக்கும். இதைத் தடுக்க, ஆராய்ச்சியாளர்கள் tokens ஒன்றையொன்று எவ்வாறு கவனிப்பது என்பதைக் கட்டுப்படுத்தும் syntax-aware attention masks-களைச் சேர்க்கிறார்கள், இது மாதிரி படிநிலை (hierarchy), nesting மற்றும் மொழி சார்ந்த கட்டுப்பாடுகளைப் பின்பற்றுவதை உறுதி செய்கிறது.
3. Hierarchical refinement
ஆரம்பக்கட்ட Diffusion படிகள் ஒரு மேலோட்டமான கட்டமைப்பைத் (coarse structure) தீட்டுகின்றன — function signatures, class definitions, module organization. பிந்தைய படிகள் punctuation, whitespace மற்றும் naming conventions போன்ற நுணுக்கமான விவரங்களைச் செம்மைப்படுத்துகின்றன. இந்த coarse-to-fine உத்தி, மனிதர்கள் ஒரு நிரலைத் தீட்டமிட்டுச் செம்மைப்படுத்துவதைப் போலவே உள்ளது, மேலும் இது ஒவ்வொரு நிலையிலும் மிக முக்கியமான இடத்திற்குத் கணக்கீட்டுத் திறனை (compute) வழிநடத்துகிறது.
Autoregressive vs. diffusion: ஒரு ஒப்பீடு
| அம்சம் | Autoregressive | Diffusion |
|---|---|---|
| உருவாக்கும் ஓட்டம் | Sequential, இடமிருந்து வலமாக | Parallel, படிப்படியான இரைச்சல் நீக்கம் |
| உலகளாவிய சீரான தன்மை | நீண்ட கால ஓட்டத்தில் விலக வாய்ப்புள்ளது | அனைத்து டோக்கன்களிலும் முழுமையான பார்வை |
| பொதுவான பயன்பாடுகள் | Chat, விளக்கம், விரைவான துணுக்குகள் | Refactoring, bug fixing, பெரிய அளவிலான குறியீடு தொகுப்பு |
ஒவ்வொரு முறையும் வெவ்வேறு சூழல்களில் எவ்வாறு சிறந்து விளங்குகின்றன என்பதை இந்தப் அட்டவணை காட்டுகிறது. வேகம் மற்றும் உரையாடல் சார்ந்த தொடர்புகள் முக்கியமாக இருக்கும்போது Autoregressive மாதிரிகள் வெற்றி பெறுகின்றன. கூடுதல் compute cycles-களைப் பயன்படுத்தினாலும், இறுதித் தயாரிப்பு தொடரியல் ரீதியாகச் சரியாகவும் கட்டமைப்பு ரீதியாகச் சீராகவும் இருக்க வேண்டியிருக்கும் போது Diffusion மாதிரிகள் வெற்றி பெறுகின்றன.
அடுத்து கவனிக்க வேண்டியவை
- கலப்பு குழாய்கள் (Hybrid pipelines). எதிர்கால அமைப்புகள் ஒரு சுய-தொடர்முறை மாதிரியை (autoregressive model) விரைவான முதல் வரைவை உருவாக்க அனுமதிக்கலாம், பின்னர் அதை மெருகூட்டுவதற்காக ஒரு டிஃப்யூஷன் மாடலுக்கு (diffusion model) மாற்றலாம்.
- கட்டமைப்பு முகமூடிகளுக்கான கருவிகள் (Tooling for structural masks). டிஃப்யூஷன் மாடல்கள் மொழி சார்ந்த கட்டுப்பாடுகளைப் பின்பற்றுவதற்கு உதவும் வகையில், ஆராய்ச்சியாளர்கள் தொடரியல் சார்ந்த கவன முகமூடிகளை (syntax-aware attention masks) தொடர்ந்து மேம்படுத்தி வருகின்றனர்.
முக்கியக் கருத்து
டிஃப்யூஷன் மாடல்கள் குறியீடு உருவாக்கத்தின் (code generation) போக்கையே மாற்றுகின்றன: ஒவ்வொரு டோக்கனாக (token by token) நகர்வதற்குப் பதிலாக, அவை தொடர்ச்சியான சத்தத்தை நீக்குதல் (iterative denoising) மூலம் ஒரு முழுமையான நிரலைச் செதுக்குகின்றன. இந்த அணுகுமுறை சுய-தொடர்முறை அமைப்புகளின் (autoregressive systems) முக்கிய பலவீனமான—பெரிய மற்றும் மாற்றக்கூடிய குறியீட்டுத் தளங்களில் (codebases) உலகளாவிய ஒருமைப்பாட்டைப் பராமரித்தல்—என்பதைச் சரிசெய்கிறது. இது மெதுவாகவும் அதிக கணக்கீட்டுத் திறன் (compute-heavy) தேவைப்படுபதாகவும் இருந்தாலும், குறியீட்டை மறுசீரமைத்தல் (refactoring), பிழைகளைத் திருத்துதல் (bug fixing) மற்றும் வேகத்தை விடத் தூய்மையான, தொடரியல் ரீதியாகச் சரியான வெளியீடு முக்கியத்துவம் பெறும் எந்தவொரு சூழலுக்கும் ஒரு சிறந்த கருவியாகத் திகழ்கிறது. சுய-தொடர்முறையின் விரைவான வரைவுத் திறனையும், டிஃப்யூஷனின் முழுமையான மெருகூட்டும் திறனையும் இணைக்கும் ஒரு கலப்பு பணிப்பாய்வு (hybrid workflow) தான் எதிர்காலத்திற்கான மிகவும் நம்பிக்கைக்குரிய பாதையாகத் தெரிகிறது.