મેક્સિમ સેક્રેટોવે (Maksim Sekretov) એક નાનું, પ્યોર-જાવાસ્ક્રિપ્ટ ટ્રાન્સફોર્મર રિલીઝ કર્યું છે જે Node.js પર ચાલે છે અને તાલીમ (training) દરમિયાન દરેક સ્કેલર, વેઇટ અને ગ્રેડિયન્ટ દર્શાવે છે. tiny-language-model-neuro-js રિપોઝીટરી કોઈપણ વ્યક્તિને રેન્ડમ મોડેલ સાથે શરૂઆત કરવા, તેને “can human read ?” જેવું પ્રોમ્પ્ટ આપવા, તેને નિષ્ફળ જતો જોવા અને પછી સિંગલ-કમાન્ડ ટ્રેનિંગ રન કરીને જવાબ સાચો થતો જોવા દે છે.
શા માટે મોટાભાગના LLM ડેમો ગણિતને છુપાવે છે
સામાન્ય લેંગ્વેજ-મોડેલ ટ્યુટોરિયલ્સ TensorFlow અથવા PyTorch પર આધારિત હોય છે. તે ફ્રેમવર્ક પડદા પાછળ આપમેળે કમ્પ્યુટેશન ગ્રાફ બનાવે છે અને ગ્રેડિયન્ટ્સની ગણતરી કરે છે, તેથી શીખનારાઓ ફક્ત હાઈ-લેવલ કોડ અને લોસ કર્વ્સ (loss curves) જ જોઈ શકે છે. મૂળભૂત પ્રક્રિયાઓ—દરેક ટોકન કેવી રીતે એમ્બેડિંગ બને છે, એટેન્શન સ્કોર્સ કેવી રીતે ગણવામાં આવે છે, ગ્રેડિયન્ટ્સ દરેક મેટ્રિક્સ દ્વારા કેવી રીતે પાછા વહે છે—તે અદ્રશ્ય રહે છે.
જાવાસ્ક્રિપ્ટ મોડેલ શું અલગ રીતે કરે છે
સેક્રેટોવનું અમલીકરણ (implementation) બધું જ એક સિંગલ ડિપેન્ડન્સી-ફ્રી Node.js સ્ક્રિપ્ટ સુધી મર્યાદિત રાખે છે. ટ્રેનિંગ પાઇપલાઇન એક સરળ ક્રમ અનુસરે છે:
- ટોકનાઇઝેશન (Tokenization)
- એમ્બેડિંગ્સ (Embeddings)
- કોઝલ ટ્રાન્સફોર્મર બ્લોક્સ (Causal transformer blocks)
- મલ્ટી-હેડ સેલ્ફ-એટેન્શન (Multi-head self-attention)
- ફીડ-ફોરવર્ડ નેટવર્ક્સ (FFN)
- લેંગ્વેજ-મોડેલ હેડ અને સોફ્ટમેક્સ (Language-model head and softmax)
- ક્રોસ-એન્ટ્રોપી લોસ (Cross-entropy loss)
- બેકપ્રોપેગેશન (Backpropagation)
node src/train.js --generalize --adaptive-teach ચલાવવાથી સંપૂર્ણ ટ્રેનિંગ લૂપ શરૂ થાય છે. કોડ પ્લેન જાવાસ્ક્રિપ્ટ હોવાથી, દરેક ટેન્સર એક સાદું એરે (array) છે, દરેક મેટ્રિક્સ ગુણાકાર એક સ્પષ્ટ લૂપ છે, અને દરેક ગ્રેડિયન્ટ તેના સોર્સ વેઇટની બાજુમાં જ હોય છે.
રેન્ડમ અનુમાનોથી સાચા જવાબો સુધી
જ્યારે મોડેલ શરૂ થાય છે, ત્યારે તમામ પેરામીટર્સ રેન્ડમ હોય છે. તેને “can human read ?” પૂછવાથી અર્થહીન શબ્દો (gibberish) મળે છે. ટૂંકા પ્રી-ટ્રેનિંગ ફેઝ અને સુપરવાઇઝ્ડ ફાઇન-ટ્યુનિંગ (SFT) ના એક રાઉન્ડ પછી, તે જ પ્રોમ્પ્ટ સમજણભર્યો જવાબ આપે છે. ટીચર સિગ્નલ—લોસ ફંક્શન દ્વારા આપવામાં આવેલ સાચા ટોકન સિક્વન્સ—એમ્બેડિંગ્સ, એટેન્શન હેડ્સ અને FFN લેયર્સ દ્વારા પાછા ફેલાય છે, જે ક્રમશઃ દરેક સ્કેલરને અપડેટ કરે છે.
કેટાસ્ટ્રોફિક ફોરગેટિંગ (catastrophic forgetting) ને પહોંચી વળવું
શરૂઆતના રન દરમિયાન એક ક્લાસિક સમસ્યા જોવા મળી: નવો તથ્ય શીખવાથી અગાઉ શીખેલા તથ્યો ભૂંસાઈ જતા હતા. સેક્રેટોવે આ સમસ્યાને 'રિસહર્સલ' (rehearsal) દ્વારા સુધારી છે—નવો ડેટા રજૂ કરતી વખતે જૂના ઉદાહરણો ફરીથી રજૂ કરવા. ટ્રેનિંગ ત્યારે જ અટકે છે જ્યારે દરેક ટાર્ગેટ ટોકન ઓછામાં ઓછી 95% સંભાવના (probability) પ્રાપ્ત કરે અને સતત દસ ચેકમાંથી પસાર થાય. આ સરળ લૂપ કોઈપણ બાહ્ય લાઇબ્રેરી વગર સંશોધનની મુખ્ય પડકારને દર્શાવે છે.
કોને ફાયદો થાય છે અને કોણ રહી શકે છે
આ પ્રોજેક્ટ એવા કોમર્શિયલ LLMs સાથે સ્પર્ધા કરતો નથી જે અબજો પેરામીટર્સ અને GPU ક્લસ્ટર્સ પર ચાલે છે. તે પરફોર્મન્સ ગેપ તેને પ્રોડક્શન વર્કલોડ માટે અયોગ્ય બનાવે છે, પરંતુ તે મોડેલને એક પારદર્શક શૈક્ષણિક સાધન બનાવે છે. વિદ્યાર્થીઓ, શોખીન લોકો અને સંશોધકો જેઓ 'બ્લેક-બોક્સ' ફ્રેમવર્કની અંદર જોવામાં મુશ્કેલી અનુભવે છે, તેમની પાસે હવે એક સેન્ડબોક્સ છે જ્યાં ગણિત એ સીધો કોડ છે.
શું ખૂટે છે અને પ્રોજેક્ટ ક્યાં જઈ શકે છે
અમલીકરણ જાણીજોઈને ન્યૂનતમ રાખવામાં આવ્યું હોવાથી, તે કોડને વાંચવા યોગ્ય રાખે છે પરંતુ સ્કેલેબિલિટીને મર્યાદિત કરે છે.
આગળ શું જોવું
રિપોઝીટરી GitHub પર પહેલેથી જ પબ્લિક છે.
મુખ્ય વાત: ટ્રાન્સફોર્મરને પ્યોર જાવાસ્ક્રિપ્ટ સુધી મર્યાદિત કરીને, સેક્રેટોવે અત્યંત અસ્પષ્ટ ટેકનોલોજીને વાંચી શકાય તેવા અને એડિટ કરી શકાય તેવા સ્ક્રિપ્ટમાં ફેરવી દીધી છે. અહીં સમજૂતી (trade-off) ઝડપની છે, પરંતુ ફાયદો સમજણનો છે—હવે કોઈપણ વ્યક્તિ લેંગ્વેજ મોડેલને દરેક સ્કેલર દ્વારા શીખતા, ભૂલતા અને ફરીથી શીખતા જોઈ શકે છે.