Maksim Sekretov, Node.js இல் இயங்கக்கூடிய ஒரு சிறிய, தூய JavaScript டிரான்ஸ்பார்மரை (transformer) வெளியிட்டுள்ளார். இது பயிற்சியின் போது ஒவ்வொரு ஸ்கேலார் (scalar), எடை (weight) மற்றும் கிரேடியன்ட் (gradient) ஆகியவற்றையும் காட்டுகிறது. tiny-language-model-neuro-js என்ற இந்த ரெப்போ (repo), எவரும் ஒரு சீரற்ற மாதிரியுடன் (random model) தொடங்கி, "can human read ?" போன்ற ஒரு ப்ராம்ப்ட்டை (prompt) கொடுத்து, அது தோல்வியடைவதைப் பார்த்துவிட்டு, பின்னர் ஒரு ஒற்றை கட்டளைப் பயிற்சியின் மூலம் சரியான பதிலைப் பெற வழிவகை செய்கிறது.

ஏன் பெரும்பாலான LLM டெமோக்கள் கணிதத்தை மறைக்கின்றன

வழக்கமான மொழி மாதிரி (language-model) பயிற்சிகள் TensorFlow அல்லது PyTorch ஆகியவற்றைச் சார்ந்துள்ளன. அந்த கட்டமைப்புகள் (frameworks) தானாகவே கணக்கீட்டு வரைபடங்களை (computation graphs) உருவாக்கி, பின்னணியில் கிரேடியன்ட்களைக் கணக்கிடுகின்றன, எனவே கற்பவர்கள் உயர்நிலை குறியீடு (high-level code) மற்றும் இழப்பு வளைவுகளை (loss curves) மட்டுமே பார்க்கிறார்கள். அடிப்படைச் செயல்பாடுகள்—ஒவ்வொரு டோக்கனும் எவ்வாறு ஒரு எம்பெடிங்காக (embedding) மாறுகிறது, attention scores எவ்வாறு கணக்கிடப்படுகின்றன, ஒவ்வொரு மேட்ரிக்ஸும் வழியாக கிரேடியன்ட்கள் எவ்வாறு பின்னோக்கிப் பாய்கின்றன என்பது ஆகியவை கண்ணுக்குத் தெரியாமல் மறைந்துவிடுகின்றன.

JavaScript மாதிரி எவ்வாறு மாறுபடுகிறது

Sekretov-இன் செயலாக்கம், எந்தத் சார்புகளும் (dependencies) இல்லாத ஒரு ஒற்றை Node.js ஸ்கிரிப்டாக அனைத்தையும் சுருக்குகிறது. அதன் பயிற்சிப் பாதை (training pipeline) ஒரு நேரடியான வரிசையைப் பின்பற்றுகிறது:

  • Tokenization
  • Embeddings
  • Causal transformer blocks
  • Multi-head self-attention
  • Feed-forward networks (FFN)
  • Language-model head மற்றும் softmax
  • Cross-entropy loss
  • Backpropagation

node src/train.js --generalize --adaptive-teach என்பதை இயக்குவது முழுமையான பயிற்சி சுழற்சியைத் (training loop) தொடங்கும். குறியீடு சாதாரண JavaScript என்பதால், ஒவ்வொரு டென்சரும் (tensor) ஒரு எளிய வரிசையாகவும் (array), ஒவ்வொரு மேட்ரிக்ஸ் பெருக்கமும் ஒரு வெளிப்படையான லூப்பாகவும் (loop), ஒவ்வொரு கிரேடியன்ட்டும் அதன் மூல எடைக்கு (source weight) அருகிலேயே இருக்கும்.

சீரற்ற யூகங்களிலிருந்து சரியான பதில்கள் வரை

மாதிரி தொடங்கும் போது, அனைத்து அளவுருக்களும் (parameters) சீரற்ற முறையில் இருக்கும். அதனிடம் “can human read ?” என்று கேட்டால் அர்த்தமற்ற சொற்கள் (gibberish) கிடைக்கும். ஒரு சிறிய முன்-பயிற்சி மற்றும் மேற்பார்வையிடப்பட்ட நுணுக்கமான சரிசெய்தலுக்குப் (supervised fine-tuning - SFT) பிறகு, அதே ப்ராம்ப்ட் ஒரு அர்த்தமுள்ள பதிலைத் தரும். ஆசிரியர் சிக்னல்—இழப்புச் செயல்பாட்டின் (loss function) மூலம் வழங்கப்படும் சரியான டோக்கன் வரிசைகள்—embeddings, attention heads மற்றும் FFN அடுக்குகளின் வழியாகப் பின்னோக்கிப் பரவி, ஒவ்வொரு ஸ்கேலாரையும் வரிசையாகப் புதுப்பிக்கிறது.

பேரழிவு மறதியை (catastrophic forgetting) கையாளுதல்

ஆரம்பகால முயற்சிகள் ஒரு பொதுவான சிக்கலைக் காட்டின: புதிய உண்மைகளைக் கற்பது ஏற்கனவே கற்றவற்றை அழித்துவிடும். புதிய தரவுகளை அறிமுகப்படுத்தும் அதே வேளையில் பழைய உதாரணங்களையும் மீண்டும் வழங்குவதன் மூலம் (rehearsal) இதைச் சரிசெய்தார் Sekretov. ஒவ்வொரு இலக்கு டோக்கனும் குறைந்தது 95% நிகழ்தகவை எட்டி, பத்து தொடர்ச்சியான சோதனைகளில் வெற்றி பெற்றால் மட்டுமே பயிற்சி நிறுத்தப்படும். இந்த எளிய லூப், எந்தவொரு வெளிப்புற நூலகங்களும் (external libraries) இன்றி ஒரு முக்கிய ஆராய்ச்சி சவாலை நிரூபிக்கிறது.

யார் பயனடைவார்கள் மற்றும் யார் விடுபடுவார்கள்?

இந்தத் திட்டம் பில்லியன் கணக்கான அளவுருக்கள் மற்றும் GPU கிளஸ்டர்களில் இயங்கும் வணிக ரீதியான LLM-களுடன் போட்டியிடுவதில்லை. அந்த செயல்திறன் இடைவெளி இதை உற்பத்திப் பணிகளுக்கு (production workloads) பொருத்தமற்றதாக மாற்றுகிறது, ஆனால் இது மாதிரியை ஒரு வெளிப்படையான கற்பித்தல் கருவியாக மாற்றுகிறது. ஒரு பிளாக்-பாக்ஸ் (black-box) கட்டமைப்பிற்குள் பார்ப்பதில் சிரமப்படும் மாணவர்கள், பொழுதுபோக்கு ஆர்வலர்கள் மற்றும் ஆராய்ச்சியாளர்களுக்கு, கணிதம் என்பது நேரடி குறியீடாக இருக்கும் ஒரு சாண்ட்பாக்ஸ் (sandbox) இப்போது கிடைத்துள்ளது.

என்ன விடுபட்டுள்ளது மற்றும் இந்தத் திட்டம் எங்கு செல்லக்கூடும்?

இந்தச் செயலாக்கம் வேண்டுமென்றே மிகக் குறைவாக இருப்பதால், குறியீடு வாசிக்க எளிதாக உள்ளது, ஆனால் அளவிடுதலை (scalability) மட்டுப்படுத்துகிறது.

அடுத்து எதைக் கவனிக்கலாம்?

இந்த ரெப்போ ஏற்கனவே GitHub-இல் பொதுப்படையாக உள்ளது.

முக்கிய கருத்து: டிரான்ஸ்பார்மரைத் தூய JavaScript-ஆகச் சுருக்குவதன் மூலம், மிகவும் தெளிவற்ற தொழில்நுட்பமாக இருந்த ஒன்றைத் தெளிவான, திருத்தக்கூடிய குறியீடாக மாற்றியுள்ளார் Sekretov. இதன் இழப்பு வேகம், ஆனால் அதன் மூலம் கிடைக்கும் ஆதாயம் புரிதல்—யாரும் இப்போது ஒரு மொழி மாதிரி எவ்வாறு கற்றுக்கொள்வது, மறப்பது மற்றும் மீண்டும் கற்றுக்கொள்வது என்பதை ஒவ்வொரு ஸ்கேலாராகக் கண்காணிக்க முடியும்.