இயந்திரங்களில் நினைவாற்றல்
(Memory in Machines: RNN vs LSTM)

அடிப்படை N-Grams இலிருந்து RNNs, LSTMs, மற்றும் Transformers வரையிலான பரிணாம வளர்ச்சியைப் புரிந்து கொள்ளுதல்.

Navigate செய்ய Arrow Keys-ஐ பயன்படுத்தவும் →

பிரச்சனை: Language Modeling

Neural Networks-ஐப் பற்றி பார்ப்பதற்கு முன், நாம் கேட்க வேண்டிய கேள்வி: ஒரு இயந்திரம் அடுத்த வார்த்தையை எப்படி கணிக்கிறது?

இதை கவனியுங்கள்: "I like to eat ____"

  • அடுத்த வார்த்தை "apples" என்றும் "cars" அல்ல என்றும் உங்களுக்கு எப்படித் தெரியும்?
  • பதில் Context (சூழல்). இதற்கு முன் வந்த வார்த்தைகளை நீங்கள் பார்க்கிறீர்கள்.
  • அடுத்த வார்த்தையைத் துல்லியமாகக் கணிக்க ஒரு model-க்கு எவ்வளவு முந்தைய Context தேவை என்பதைக் கண்டுபிடிப்பதே AI-இல் உள்ள முக்கிய சவால்.

மிக எளிய அணுகுமுறை: N-Gram Models

Deep Learning-க்கு முன்பு, dataset-இல் குறிப்பிட்ட வார்த்தைகள் எவ்வளவு முறை சேர்ந்து வருகின்றன என்பதை நாம் எண்ணினோம்!

  • 1-Gram (Unigram) - 0 Context:
    அகராதியில் உள்ள பொதுவான வார்த்தையைத் தேர்ந்தெடுக்கும். கணிப்பு: "the".
  • 2-Gram (Bigram) - 1 Word Context:
    மிகச் சமீபத்திய வார்த்தையை ("eat") மட்டும் பார்த்து, அதன்பின் எது அதிகம் வருகிறது என எண்ணும். கணிப்பு: "apples".
  • N-Gram - (N-1) Context:
    N-1 முந்தைய வார்த்தைகளின் ஒரு குறிப்பிட்ட sequence-ஐப் பார்க்கும்.

N-Gram Wall (Curse of Dimensionality)

கடந்த 99 வார்த்தைகளைப் பார்க்கும் ஒரு 100-Gram model-ஐ நாம் ஏன் உருவாக்கக் கூடாது?

  • Data Sparsity: 99 குறிப்பிட்ட வார்த்தைகள் அதே வரிசையில் வருவது உங்கள் training data-வில் ஒருபோதும் நிகழ்ந்திருக்காது!
  • சரியான sequence கிடைக்கவில்லை என்றால், ஒரு N-Gram model முற்றிலுமாக செயலிழந்துவிடும்.
  • வெறும் வார்த்தைகளை எண்ணுவதை விட, Context-ஐப் பொதுமைப்படுத்தும் (generalize) ஒரு model நமக்குத் தேவை.

தடையை உடைத்தல்: Neural Language Models

Training data-வில் முன்கூட்டியே வராத ஒரு புதிய வார்த்தை வரிசையை N-Gram, RNN மற்றும் LSTM models-க்கு கொடுத்து சோதிக்கும் போது:

--- Testing the N-Gram Wall Sequence ---
Context: 'and i do'
N-Gram Model Prediction: <UNKNOWN CONTEXT>
RNN Model Prediction: 'not'
LSTM Model Prediction: 'like'

Neural Networks துல்லியமான பொருத்தங்களை (exact matches) சார்ந்திருப்பதில்லை! அவை Hidden State-ஐப் பயன்படுத்தி சூழலை (context) சுருக்கிப் பொதுமைப்படுத்துகின்றன. இதனால் புதிய வார்த்தை வரிசைகளுக்கும் அவற்றால் கணிக்க முடிகிறது.

Variable Lengths: Types of Sequence Tasks

Natural Language Processing-ல் sequence lengths மாறுபடுவது (variable length) ஒரு பெரிய சவால். Input மற்றும் Output sequence lengths-ஐப் பொறுத்து நாம் Neural Networks-ஐ பல வழிகளில் பயன்படுத்தலாம்:

  • Sequence-to-Label (Many-to-One):
    Input: Variable length sequence. Output: ஒரு Label.
    உதாரணம்: Sentiment Classification (ஒரு Review positive-ஆ அல்லது negative-ஆ எனக் கணிப்பது). RNN/LSTM-ன் கடைசி hidden state-ஐ இதற்குப் பயன்படுத்தலாம்.
  • Sequence-to-Sequence (Aligned - Same Length):
    Input மற்றும் Output இரண்டும் ஒரே length-ல் இருக்கும்.
    உதாரணம்: POS Tagging (ஒவ்வொரு வார்த்தைக்கும் அது Noun-ஆ, Verb-ஆ எனக் கணிப்பது).
  • Sequence-to-Sequence (Unaligned - Different Length):
    Input ஒரு length-லும், Output வேறு length-லும் இருக்கும்.
    உதாரணம்: Machine Translation (ஆங்கிலத்திலிருந்து தமிழுக்கு மொழிபெயர்ப்பது).

சற்றே கடினமான பிரச்சனை: Sequence-to-Sequence

அடுத்த வார்த்தையை கணிப்பது ஒருபுறம் இருக்க, ஒரு முழுமையான sequence-ஐ எப்படி மொழிபெயர்ப்பது?

ஒரு வார்த்தையை ஒவ்வொரு எழுத்தாகப் படிப்பதை கற்பனை செய்து பாருங்கள்:
COMMUNICATION

  • 13-வது எழுத்து என்ன என்று கேட்டால், வெறும் N-ஐ மட்டும் பார்க்க முடியாது. முன் வந்த அனைத்தையும் நினைவில் கொள்ள வேண்டும்.
  • Sequence-to-Sequence (Seq2Seq) models ஒரு Encoder மற்றும் Decoder-ஐ பயன்படுத்தி இதை தீர்க்கின்றன.
  • Encoder ஆங்கில வார்த்தையின் நினைவாற்றலை (memory) உருவாக்குகிறது, Decoder அதை தமிழுக்கு மொழிபெயர்க்கப் பயன்படுத்துகிறது.

RNN: Baton-ஐ கைமாற்றுதல்

குறிப்பிட்ட "N" எழுத்துக்களை மட்டும் பார்க்காமல், Recurrent Neural Network (RNN) ஒவ்வொரு படியிலும் ஒரு Hidden State-ஐ முன்னோக்கி அனுப்புகிறது.

ஒரு தொடர் ஓட்டப்பந்தயத்தில் (relay race) baton-ஐ கைமாற்றுவது போல, ஒவ்வொரு எழுத்தும் தனது தகவலை baton-ல் சேர்த்து, அடுத்த எழுத்திடம் ஒப்படைக்கிறது. இது முந்தைய அனைத்தையும் ஒரே vector-க்குள் சுருக்குகிறது.

RNN Baton Pass

முக்கிய குறைபாடு: Vanishing Gradient

Baton-ஐ கைமாற்றும் முறை அடிப்படையில் சரியாகத் தோன்றினாலும், நீண்ட sequences-க்கு கணிதரீதியாக இது தோல்வியடைகிறது.

"Telephone" விளையாட்டு போல, அசல் செய்தி ஒவ்வொரு படியிலும் தொடர்ந்து மேலெழுதப்பட்டு, சிதைந்துவிடுகிறது.

ஒரு RNN 13-எழுத்து வார்த்தையின் முடிவை அடையும் போது, அது முதல் 3 எழுத்துக்களை கிட்டத்தட்ட முழுமையாக மறந்துவிடுகிறது.

Vanishing Gradient Telephone Game

LSTM: ஒரு Smart Notebook

இந்த மறதியை சரிசெய்ய, Long Short-Term Memory (LSTM) உருவாக்கப்பட்டது. இது Cell State என்ற ஒன்றை அறிமுகப்படுத்துகிறது—இது ஒரு smart notebook போல செயல்படும் தனி நினைவாற்றல் பாதை.

  • Forget Gate: எந்த பழைய தகவலை அழிக்க வேண்டும் என்பதை முடிவு செய்கிறது.
  • Input Gate: எந்த புதிய தகவலை எழுதி வைக்க வேண்டும் என்பதை முடிவு செய்கிறது.
  • Output Gate: தற்போதைய Hidden State-ஆக எதை வெளியிட வேண்டும் என்பதை முடிவு செய்கிறது.
LSTM Notebook Gates

Code-இல் Dual-Track Memory

இந்த வித்தியாசம் PyTorch code-இல் நேரடியாகத் தெரிகிறது. LSTM எவ்வாறு ஒரு hidden state (குறுகிய கால) மற்றும் ஒரு cell state (நீண்ட கால notebook) ஆகிய இரண்டையும் கடத்துகிறது என்பதைக் கவனியுங்கள்.

class CharDecoderLSTM(nn.Module):
    def forward(self, x, hidden, cell):
        embedded = self.embedding(x)
        
        # Hidden state மற்றும் cell state இரண்டையும் முன்னோக்கி அனுப்புகிறோம்
        output, (hidden, cell) = self.lstm(embedded, (hidden, cell))
        
        prediction = self.fc(output)
        return prediction, hidden, cell

இறுதி சோதனை: Character Translation

முழுமையான வார்த்தைகளை ஒவ்வொரு எழுத்தாக மொழிபெயர்க்கப் பயிற்றுவிக்கப்படும் போது, Standard RNN நீண்ட வார்த்தைகளில் முழுமையாகத் தோல்வியடைகிறது, ஏனெனில் அது வார்த்தையின் தொடக்கத்தை மறந்துவிடுகிறது. ஆனால் LSTM இதை மிகச் சிறப்பாக கையாளுகிறது.

English Word | Actual Tamil | LSTM Prediction | RNN Prediction
--------------------------------------------------------------------------------
communication | தொடர்பு | ✓ தொடர்பு | ✗ தொடரபுபப
international | சர்வதேச | ✓ சர்வதேச | ✗ சரவசசச

மீதமுள்ள பெரும் குறைபாடு (The Remaining Bottleneck)

LSTM-கள் சிறப்பானவை, ஆனால் அவற்றில் ஒரு அடிப்படையான பெரிய பிரச்சனை உள்ளது: Sequential Processing (தொடர்ச்சியான செயலாக்கம்).

  • வார்த்தை 1-க்கான வேலையை முடிக்கும் வரை வார்த்தை 2-க்கான hidden state-ஐ நீங்கள் கணக்கிட முடியாது.
  • இதனால், பல GPU-களை வைத்து ஒரே நேரத்தில் (in parallel) இவற்றை train செய்ய முடியாது. பெரிய data-வில் train செய்ய மிகவும் அதிக நேரம் எடுக்கும்.
  • ஒரு "notebook" (Cell State) இருந்தாலும், முதல் வார்த்தையிலிருந்து ஆயிரம் வார்த்தைகள் தள்ளியிருக்கும் வார்த்தைக்குத் தகவலைக் கடத்த $O(N)$ தூரம் பயணிக்க வேண்டும்.

Transformer புரட்சி: Self-Attention

2017-ஆம் ஆண்டில், Google நிறுவனம் "Attention Is All You Need" என்ற ஆய்வறிக்கையை வெளியிட்டு, Transformer-ஐ அறிமுகப்படுத்தியது. இது RNN-களை முற்றிலுமாக நிராகரித்தது.

  • Baton-ஐ வரிசையாகக் கடத்துவதற்குப் பதிலாக, இது Self-Attention முறையைப் பயன்படுத்துகிறது.
  • ஒரு அறையில் உள்ள அனைவரும் ஒருவரோடு ஒருவர் நேரடியாகப் பேசுவதைப் போல கற்பனை செய்து கொள்ளுங்கள். வரிசையாகச் செய்தியைக் கடத்த வேண்டியதில்லை!
  • எந்த ஒரு வார்த்தைக்கும் மற்றொரு வார்த்தைக்கும் இடையிலான தூரம் மிகச்சரியாக $O(1)$ ஆகும். இது ஒரு நேரடி கணிதத் தொடர்பாகும் (direct mathematical connection).
  • இது Sequential ஆக இல்லாததால், முழு sequence-ஐயும் GPU-வில் ஒரே நேரத்தில் மிக வேகமாக (parallel processing) கணக்கிட முடியும்!

The Attention Matrix in Action

நமது `transformer_demo.py` script-ல், Self-Attention இடைப்பட்ட stages-ஐத் தவிர்த்துவிட்டு வார்த்தைகளை எவ்வாறு நேரடியாக இணைக்கிறது என்பதைப் பார்ப்போம்.

--- The Attention Matrix ---
How much does each word 'pay attention' to the other words?

the bank of the river
the 0.05 0.51 0.18 0.20 0.06
bank 0.41 0.07 0.04 0.08 0.40
of 0.18 0.03 0.15 0.41 0.23
the 0.28 0.07 0.27 0.29 0.09
river 0.08 0.50 0.25 0.07 0.09

"bank" என்ற வார்த்தை, அதன் Context-ஐப் புரிந்துகொள்ள, "river" என்ற வார்த்தைக்கு நேரடியாக 0.40 Attention Weight-ஐ வழங்குவதைக் கவனியுங்கள்! இங்கே Baton-ஐ வரிசையாகக் கடத்த வேண்டிய அவசியமே இல்லை.

இறுதி முத்தாய்ப்பு (The Grand Finale): Text Generation

Language Models-இன் உண்மையான சக்தி, அவை ஒரு வார்த்தையை மட்டும் கணிப்பதில்லை—அவற்றால் புதிய வரிகளைத் தொடர்ந்து உருவாக்க முடியும். கணிக்கப்பட்ட வார்த்தையை மீண்டும் Input-ஆகக் கொடுப்பதன் மூலம், ஒரு சுழற்சியை உருவாக்கலாம். ChatGPT எப்படி கட்டுரைகளை எழுதுகிறது என்பதன் அடிப்படை இதுதான்!

========================================
5. The Magic of Generation (Autoregressive)
========================================

Seed Context: 'i like'
RNN Generates: 'i like to eat grapes and i like to eat'
LSTM Generates: 'i like to eat grapes and i like to eat'
Transformer Generates: 'i like to eat apples and i like to eat'

தான் கற்றுக்கொண்ட அமைப்பின் அடிப்படையில் மாடல் கற்பனையாகப் புதிய வாக்கியங்களை உருவாக்குகிறது (Hallucination)!

1 / 16