ਮਕਸੀਮ ਸੇਕਰੇਟੋਵ (Maksim Sekretov) ਨੇ ਇੱਕ ਬਹੁਤ ਹੀ ਛੋਟਾ, ਸ਼ੁੱਧ-JavaScript ਟ੍ਰਾਂਸਫਾਰਮਰ ਰਿਲੀਜ਼ ਕੀਤਾ ਹੈ ਜੋ Node.js 'ਤੇ ਚਲਦਾ ਹੈ ਅਤੇ ਟ੍ਰੇਨਿੰਗ ਦੌਰਾਨ ਹਰ scalar, weight ਅਤੇ gradient ਨੂੰ ਦਿਖਾਉਂਦਾ ਹੈ। ਰੈਪੋ tiny-language-model-neuro-js ਕਿਸੇ ਨੂੰ ਵੀ ਇੱਕ ਰੈਂਡਮ ਮਾਡਲ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਨ, ਇਸਨੂੰ “can human read ?” ਵਰਗਾ ਪ੍ਰੋਂਪਟ ਦੇਣ, ਇਸਨੂੰ ਫੇਲ ਹੋਣ ਵੇਖਣ, ਫਿਰ ਇੱਕ ਸਿੰਗਲ-ਕਮਾਂਡ ਟ੍ਰੇਨਿੰਗ ਚਲਾਉਣ ਅਤੇ ਜਵਾਬ ਨੂੰ ਸਹੀ ਹੁੰਦੇ ਵੇਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ।

ਜ਼ਿਆਦਾਤਰ LLM ਡੈਮੋ ਗਣਿਤ (math) ਨੂੰ ਕਿਉਂ ਛੁਪਾਉਂਦੇ ਹਨ

ਆਮ ਭਾਸ਼ਾ-ਮਾਡਲ ਟਿਊਟੋਰਿਅਲ TensorFlow ਜਾਂ PyTorch 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ। ਉਹ ਫਰੇਮਵਰਕ ਆਪਣੇ ਆਪ ਕੰਪਿਊਟੇਸ਼ਨ ਗ੍ਰਾਫ ਬਣਾਉਂਦੇ ਹਨ ਅਤੇ ਪਿੱਛੇ ਹੀ ਗ੍ਰੇਡੀਐਂਟ ਦੀ ਗਣਨਾ ਕਰਦੇ ਹਨ, ਜਿਸ ਕਾਰਨ ਸਿੱਖਣ ਵਾਲੇ ਸਿਰਫ਼ ਉੱਚ-ਪੱਧਰੀ ਕੋਡ ਅਤੇ loss curves ਹੀ ਦੇਖ ਪਾਉਂਦੇ ਹਨ। ਅਸਲ ਕਾਰਜ—ਕਿਵੇਂ ਹਰ ਟੋਕਨ ਇੱਕ embedding ਬਣਦਾ ਹੈ, attention scores ਦੀ ਗਣਨਾ ਕਿਵੇਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਗ੍ਰੇਡੀਐਂਟ ਹਰ ਮੈਟ੍ਰਿਕਸ ਰਾਹੀਂ ਕਿਵੇਂ ਵਾਪਸ ਵਹਿੰਦੇ ਹਨ—ਅਦਿੱਖ ਰਹਿੰਦੇ ਹਨ।

JavaScript ਮਾਡਲ ਕੀ ਵੱਖਰਾ ਕਰਦਾ ਹੈ

ਸੇਕਰੇਟੋਵ ਦਾ ਇੰਪਲੀਮੈਂਟੇਸ਼ਨ ਸਭ ਕੁਝ ਇੱਕ ਸਿੰਗਲ ਡਿਪੈਂਡੈਂਸੀ-ਮੁਕਤ 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 ਹੈ, ਹਰ tensor ਇੱਕ ਸਧਾਰਨ array ਹੈ, ਹਰ ਮੈਟ੍ਰਿਕਸ ਗੁਣਾ ਇੱਕ ਸਪੱਸ਼ਟ ਲੂਪ ਹੈ, ਅਤੇ ਹਰ gradient ਆਪਣੇ ਸਰੋਤ weight ਦੇ ਨਾਲ ਹੀ ਹੁੰਦਾ ਹੈ।

ਰੈਂਡਮ ਅੰਦਾਜ਼ਿਆਂ ਤੋਂ ਸਹੀ ਜਵਾਬਾਂ ਤੱਕ

ਜਦੋਂ ਮਾਡਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, ਸਾਰੇ parameters ਰੈਂਡਮ ਹੁੰਦੇ ਹਨ। ਇਸਨੂੰ “can human read ?” ਪੁੱਛਣ 'ਤੇ ਅਰਥਹੀਣ ਸ਼ਬਦ ਮਿਲਦੇ ਹਨ। ਇੱਕ ਛੋਟੇ pre-training ਪੜਾਅ ਅਤੇ supervised fine-tuning (SFT) ਦੇ ਇੱਕ ਰਾਊਂਡ ਤੋਂ ਬਾਅਦ, ਉਹੀ ਪ੍ਰੋਂਪਟ ਇੱਕ ਸਮਝਣਯੋਗ ਜਵਾਬ ਦਿੰਦਾ ਹੈ। Teacher signal—loss function ਰਾਹੀਂ ਦਿੱਤੇ ਗਏ ਸਹੀ token sequences—embeddings, attention heads ਅਤੇ FFN ਲੇਅਰਾਂ ਰਾਹੀਂ ਵਾਪਸ ਪ੍ਰਚਲਿਤ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇੱਕ-ਇੱਕ ਕਰਕੇ ਹਰ scalar ਨੂੰ ਅਪਡੇਟ ਕਰਦਾ ਹੈ।

Catastrophic forgetting ਨਾਲ ਨਜਿੱਠਣਾ

ਸ਼ੁਰੂਆਤੀ ਰਨਾਂ ਵਿੱਚ ਇੱਕ ਕਲਾਸਿਕ ਸਮੱਸਿਆ ਦੇਖੀ ਗਈ: ਨਵੀਂ ਤੱਥ ਸਿੱਖਣ ਨਾਲ ਪਹਿਲਾਂ ਸਿੱਖੇ ਹੋਏ ਤੱਥ ਮਿਟ ਜਾਂਦੇ ਸਨ। ਸੇਕਰੇਟੋਵ ਨੇ ਇਸਨੂੰ rehearsal ਨਾਲ ਠੀਕ ਕੀਤਾ—ਨਵਾਂ ਡੇਟਾ ਪੇਸ਼ ਕਰਦੇ ਸਮੇਂ ਪੁਰਾਣੇ ਉਦਾਹਰਣਾਂ ਨੂੰ ਦੁਬਾਰਾ ਪੇਸ਼ ਕਰਨਾ। ਟ੍ਰੇਨਿੰਗ ਉਦੋਂ ਹੀ ਰੁਕਦੀ ਹੈ ਜਦੋਂ ਹਰ target token ਘੱਟੋ-ਘੱਟ 95% probability ਤੱਕ ਪਹੁੰਚ ਜਾਂਦਾ ਹੈ ਅਤੇ ਲਗਾਤਾਰ ਦਸ ਚੈੱਕਾਂ ਵਿੱਚ ਬਚ ਜਾਂਦਾ ਹੈ। ਇਹ ਸਧਾਰਨ ਲੂਪ ਕਿਸੇ ਵੀ ਬਾਹਰੀ ਲਾਇਬ੍ਰੇਰੀ ਤੋਂ ਬਿਨਾਂ ਇੱਕ ਮੁੱਖ ਖੋਜ ਚੁਣੌਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।

ਕਿਸ ਨੂੰ ਫਾਇਦਾ ਹੋਵੇਗਾ ਅਤੇ ਕੌਣ ਪਿੱਛੇ ਰਹਿ ਸਕਦਾ ਹੈ

ਇਹ ਪ੍ਰੋਜੈਕਟ ਉਹਨਾਂ ਵਪਾਰਕ LLMs ਨਾਲ ਮੁਕਾਬਲਾ ਨਹੀਂ ਕਰਦਾ ਜੋ ਅਰਬਾਂ parameters ਅਤੇ GPU clusters 'ਤੇ ਚਲਦੇ ਹਨ। ਉਹ ਪ੍ਰਦਰਸ਼ਨ ਦਾ ਪਾੜਾ ਇਸਨੂੰ production workloads ਲਈ ਅਣਉਚਿਤ ਬਣਾਉਂਦਾ ਹੈ, ਪਰ ਇਹ ਮਾਡਲ ਨੂੰ ਇੱਕ ਪਾਰਦਰਸ਼ੀ ਸਿਖਲਾਈ ਸਾਧਨ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਵਿਦਿਆਰਥੀ, ਸ਼ੌਕੀਨ ਅਤੇ ਖੋਜਕਰਤਾ ਜੋ black-box ਫਰੇਮਵਰਕ ਦੇ ਅੰਦਰ ਦੇਖਣ ਲਈ ਸੰਘਰਸ਼ ਕਰਦੇ ਹਨ, ਹੁਣ ਉਹਨਾਂ ਕੋਲ ਇੱਕ sandbox ਹੈ ਜਿੱਥੇ ਗਣਿਤ ਸ਼ਾਬਦਿਕ ਕੋਡ ਹੈ।

ਕੀ ਗੁੰਮ ਹੈ ਅਤੇ ਪ੍ਰੋਜੈਕਟ ਕਿੱਥੇ ਜਾ ਸਕਦਾ ਹੈ

ਕਿਉਂਕਿ ਇੰਪਲੀਮੈਂਟੇਸ਼ਨ ਜਾਣਬੁੱਝ ਕੇ minimal ਰੱਖੀ ਗਈ ਹੈ, ਇਹ ਕੋਡ ਨੂੰ ਪੜ੍ਹਨਯੋਗ ਰੱਖਦੀ ਹੈ ਪਰ ਇਸਦੀ scalability ਨੂੰ ਸੀਮਤ ਕਰਦੀ ਹੈ।

ਅੱਗੇ ਕੀ ਦੇਖਣਾ ਹੈ

ਰੈਪੋਰੀਟਰੀ ਪਹਿਲਾਂ ਹੀ GitHub 'ਤੇ ਜਨਤਕ ਹੈ।

Takeaway: ਇੱਕ transformer ਨੂੰ ਸ਼ੁੱਧ JavaScript ਤੱਕ ਸੀਮਤ ਕਰਕੇ, ਸੇਕਰੇਟੋਵ ਨੇ ਇੱਕ ਬਹੁਤ ਹੀ ਗੁੰਝਲਦਾਰ ਤਕਨਾਲੋਜੀ ਨੂੰ ਇੱਕ ਪੜ੍ਹਨਯੋਗ, ਐਡਿਟ ਕਰਨਯੋਗ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ ਹੈ। ਇਸਦਾ ਸਮਝੌਤਾ ਰਫਤਾਰ ਹੈ, ਪਰ ਇਸਦਾ ਫਾਇਦਾ ਡੂੰਘੀ ਸਮਝ ਹੈ—ਹੁਣ ਕੋਈ ਵੀ ਭਾਸ਼ਾ ਮਾਡਲ ਨੂੰ scalar-by-scalar ਸਿੱਖਦੇ, ਭੁੱਲਦੇ ਅਤੇ ਦੁਬਾਰਾ ਸਿੱਖਦੇ ਵੇਖ ਸਕਦਾ ਹੈ।