Maksim Sekretov Node.js పై నడిచే ఒక చిన్న, స్వచ్ఛమైన JavaScript ట్రాన్స్ఫార్మర్ను విడుదల చేశారు, ఇది శిక్షణ పొందుతున్నప్పుడు ప్రతి స్కేలర్, వెయిట్ మరియు గ్రేడియంట్ను చూపుతుంది. tiny-language-model-neuro-js అనే రిపోజిటరీ ద్వారా ఎవరైనా ఒక యాదృచ్ఛిక మోడల్తో ప్రారంభించి, “can human read ?” వంటి ప్రాంప్ట్ను ఇచ్చి, అది విఫలమవ్వడాన్ని చూసి, ఆపై ఒకే కమాండ్తో శిక్షణ ఇచ్చి సమాధానం ఎలా సరైనదవుతుందో చూడవచ్చు.
చాలా LLM డెమోలు గణితాన్ని ఎందుకు దాచిపెడతాయి
సాధారణ లాంగ్వేజ్-మోడల్ ట్యుటోరియల్స్ TensorFlow లేదా PyTorch పై ఆధారపడతాయి. ఆ ఫ్రేమ్వర్క్లు తెర వెనుక స్వయంచాలకంగా కంప్యూటేషన్ గ్రాఫ్లను నిర్మిస్తాయి మరియు గ్రేడియంట్లను లెక్కిస్తాయి, కాబట్టి నేర్చుకునేవారు కేవలం హై-లెవల్ కోడ్ మరియు లాస్ కర్వ్లను మాత్రమే చూస్తారు. అంతర్లీన కార్యకలాపాలు—ప్రతి టోకెన్ ఎలా ఎంబెడ్డింగ్గా మారుతుంది, అటెన్షన్ స్కోర్లు ఎలా లెక్కించబడతాయి, ప్రతి మ్యాట్రిక్స్ ద్వారా గ్రేడియంట్లు ఎలా వెనక్కి ప్రవహిస్తాయి—అవి కనిపించకుండా ఉంటాయి.
JavaScript మోడల్ దేనిని భిన్నంగా చేస్తుంది
Sekretov యొక్క ఇంప్లిమెంటేషన్ ఎటువంటి డిపెండెన్సీలు లేని ఒకే ఒక Node.js స్క్రిప్ట్గా అన్నింటినీ తగ్గించింది. శిక్షణ పైప్లైన్ ఒక సరళమైన క్రమాన్ని అనుసరిస్తుంది:
- Tokenization
- Embeddings
- Causal transformer blocks
- Multi-head self-attention
- Feed-forward networks (FFN)
- Language-model head and softmax
- Cross-entropy loss
- Backpropagation
node src/train.js --generalize --adaptive-teach అని రన్ చేయడం ద్వారా పూర్తి ట్రైనింగ్ లూప్ను ప్రారంభించవచ్చు. కోడ్ సాధారణ JavaScript కాబట్టి, ప్రతి టెన్సర్ ఒక సాధారణ అర్రే (array), ప్రతి మ్యాట్రిక్స్ మల్టిప్లికేషన్ ఒక స్పష్టమైన లూప్, మరియు ప్రతి గ్రేడియంట్ దాని మూల వెయిట్ (source weight) పక్కనే ఉంటుంది.
యాదృచ్ఛిక అంచనాల నుండి సరైన సమాధానాల వరకు
మోడల్ ప్రారంభంలో, అన్ని పారామీటర్లు యాదృచ్ఛికంగా ఉంటాయి. దానికి “can human read ?” అని అడిగితే అర్థం లేని సమాధానం (gibberish) వస్తుంది. ఒక చిన్న ప్రీ-ట్రైనింగ్ దశ మరియు సూపర్వైజ్డ్ ఫైన్-ట్యూనింగ్ (SFT) తర్వాత, అదే ప్రాంప్ట్కు అర్థవంతమైన సమాధానం వస్తుంది. టీచర్ సిగ్నల్—లాస్ ఫంక్షన్ ద్వారా అందించబడిన సరైన టోకెన్ సీక్వెన్స్లు—ఎంబెడ్డింగ్లు, అటెన్షన్ హెడ్స్ మరియు FFN లేయర్ల ద్వారా వెనక్కి ప్రవహిస్తూ, ఒక్కో స్కేలర్ను వరుసగా అప్డేట్ చేస్తుంది.
కాటాస్ట్రోఫిక్ ఫర్గెట్టింగ్ను (catastrophic forgetting) ఎదుర్కోవడం
ప్రారంభ దశలో ఒక క్లాసిక్ సమస్య కనిపించింది: కొత్త విషయాన్ని నేర్చుకోవడం వల్ల అంతకుముందు నేర్చుకున్నవి చెరిగిపోవడం. కొత్త డేటాను పరిచయం చేసేటప్పుడే పాత ఉదాహరణలను మళ్ళీ చూపించడం (rehearsal) ద్వారా Sekretov దీనిని పరిష్కరించారు. ప్రతి టార్గెట్ టోకెన్ కనీసం 95% సంభావ్యతను (probability) చేరుకుని, పది వరుస తనిఖీలలో నిలబడినప్పుడు మాత్రమే శిక్షణ ఆగుతుంది. ఈ సరళమైన లూప్ ఎటువంటి బాహ్య లైబ్రరీల సహాయం లేకుండానే ఒక ప్రధాన పరిశోధనా సవాలును ప్రదర్శిస్తుంది.
ఎవరికి ప్రయోజనం మరియు ఎవరు దీని నుండి బయటపడవచ్చు
ఈ ప్రాజెక్ట్ బిలియన్ల కొద్దీ పారామీటర్లు మరియు GPU క్లస్టర్లపై నడిచే వాణిజ్య LLMలతో పోటీ పడదు. ఆ పనితీరు వ్యత్యాసం వల్ల ఇది ప్రొడక్షన్ వర్క్లోడ్లకు అనువైనది కాదు, కానీ ఇది మోడల్ను ఒక పారదర్శకమైన బోధనా సాధనంగా మారుస్తుంది. బ్లాక్-బాక్స్ ఫ్రేమ్వర్క్ లోపల ఏమి జరుగుతుందో చూడలేక ఇబ్బంది పడే విద్యార్థులు, అభిరుచి గలవారు (hobbyists) మరియు పరిశోధకులకు ఇప్పుడు గణితం నేరుగా కోడ్లా కనిపించే ఒక శాండ్బాక్స్ అందుబాటులోకి వచ్చింది.
ఏమి లోపించింది మరియు ఈ ప్రాజెక్ట్ ఎటు వెళ్ళవచ్చు
ఈ ఇంప్లిమెంటేషన్ కావాలనే చాలా తక్కువగా (minimal) రూపొందించబడింది, ఇది కోడ్ను చదవడానికి సులభంగా ఉంచుతుంది కానీ స్కేలబిలిటీని పరిమితం చేస్తుంది.
తదుపరి ఏమి చూడాలి
ఈ రిపోజిటరీ ఇప్పటికే GitHubలో పబ్లిక్గా అందుబాటులో ఉంది.
ముగింపు (Takeaway): ట్రాన్స్ఫార్మర్ను స్వచ్ఛమైన JavaScriptగా మార్చడం ద్వారా, Sekretov అత్యంత క్లిష్టమైన సాంకేతికతను చదవగలిగే, సవరించగలిగే స్క్రిప్ట్గా మార్చారు. దీని వల్ల వేగం తగ్గుతుంది, కానీ అవగాహన (insight) పెరుగుతుంది—ఎవరైనా ఇప్పుడు ఒక లాంగ్వేజ్ మోడల్ ఎలా నేర్చుకుంటుందో, మర్చిపోతుందో మరియు మళ్ళీ నేర్చుకుంటుందో, ప్రతి స్కేలర్ను గమనించవచ్చు.