LSTM सेल: इनपुट, फ़ॉरगेट और आउटपुट गेट
शिक्षार्थी LSTM सेल का आरेख बनाएँगे, प्रत्येक गेट से सूचना के प्रवाह का अनुकरण करेंगे और nn.LSTM का उपयोग करके LSTM पाठ वर्गीकारक लागू करेंगे।
LSTM सेल: इनपुट, फ़ॉरगेट और आउटपुट गेट, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
RNN को Gating Mechanisms की आवश्यकता क्यों होती है
Standard Vanilla RNN long-range dependencies के साथ संघर्ष करते हैं, क्योंकि backpropagation through time के दौरान gradients लुप्त हो जाते हैं। Hidden state h_t = tanh(W_h * h_{t-1} + W_x * x_t) प्रत्येक नए input के साथ पिछले context को overwrite कर देता है, जिससे network कई steps पहले की जानकारी भूल जाता है।
Long Short-Term Memory (LSTM) को इस समस्या को हल करने के लिए Hochreiter और Schmidhuber ने 1997 में design किया था। इसमें cell state — यानी एक अलग memory conveyor belt — और ऐसे gating mechanisms शामिल हैं जो स्पष्ट रूप से नियंत्रित करते हैं कि कौन-सी जानकारी जोड़ी जाए, हटाई जाए या आगे भेजी जाए।
LSTM Cell State की अवधारणा
LSTM में दो आंतरिक states होती हैं: cell state C_t और hidden state h_t। Cell state पूरे अनुक्रम में conveyor belt की तरह चलती है और gates छोटे linear interactions को नियंत्रित करते हैं। इससे gradients का समय के माध्यम से प्रवाहित होना आसान हो जाता है।
Hidden state h_t प्रत्येक timestep पर output होती है, जिसकी गणना cell state से की जाती है। C_t को दीर्घकालिक memory और h_t को working memory समझें, जिसे अगली layer तक भेजा जाता है और output के रूप में लौटाया जाता है।
import torch
import torch.nn as nn
# An LSTM processes sequences and returns (output, (h_n, c_n))
lstm = nn.LSTM(input_size=10, hidden_size=32, batch_first=True)
print('LSTM parameters:', sum(p.numel() for p in lstm.parameters()))Forget Gate
Forget gate पहला gate है जिससे input होकर गुजरता है। यह पिछली hidden state h_{t-1} और वर्तमान input x_t को पढ़ता है और cell state के प्रत्येक element के लिए 0 और 1 के बीच का एक मान output करता है।
1 का अर्थ है 'सब कुछ रखें', जबकि 0 का अर्थ है 'पूरी तरह भूल जाएँ'। सूत्र है: f_t = sigmoid(W_f · [h_{t-1}, x_t] + b_f)। उदाहरण के लिए, NLP task में नया वाक्य संसाधित करते समय forget gate पिछले वाक्य से संग्रहीत subject संबंधी जानकारी को reset कर देगा।
import torch
import torch.nn as nn
# Manual forget gate illustration
batch_size, hidden_size, input_size = 1, 4, 3
h_prev = torch.zeros(batch_size, hidden_size)
x_t = torch.randn(batch_size, input_size)
W_f = torch.randn(hidden_size, hidden_size + input_size)
b_f = torch.zeros(hidden_size)
combined = torch.cat([h_prev, x_t], dim=1)
f_t = torch.sigmoid(combined @ W_f.T + b_f)
print('Forget gate output:', f_t) # Values between 0 and 1Input Gate और Candidate Cell
इनपुट गेट यह तय करता है कि सेल स्थिति में कौन-से नए मान संग्रहीत किए जाएँ। इसके दो भाग मिलकर काम करते हैं: इनपुट गेट i_t = sigmoid(W_i · [h_{t-1}, x_t] + b_i) यह निर्धारित करता है कि कितना अपडेट करना है, और संभावित सेल g_t = tanh(W_g · [h_{t-1}, x_t] + b_g) संभावित रूप से जोड़े जाने वाले मान बनाता है।
सिग्मॉइड गेट को नियंत्रित करता है (0 = बंद, 1 = खुला), जबकि tanh, [-1, 1] की सीमा में मान बनाता है। सेल स्थिति में जोड़ी जाने वाली नई जानकारी i_t * g_t होती है — यानी संभावित मानों द्वारा छनकर आई गेट की जानकारी।
# Input gate and candidate values
W_i = torch.randn(hidden_size, hidden_size + input_size)
b_i = torch.zeros(hidden_size)
W_g = torch.randn(hidden_size, hidden_size + input_size)
b_g = torch.zeros(hidden_size)
i_t = torch.sigmoid(combined @ W_i.T + b_i) # Input gate: what to update
g_t = torch.tanh(combined @ W_g.T + b_g) # Candidate values to add
print('Input gate:', i_t.detach())
print('Candidate cell:', g_t.detach())सेल स्थिति को अपडेट करना
जब हमारे पास फ़ॉरगेट गेट f_t, इनपुट गेट i_t और संभावित सेल g_t हों, तो सेल स्थिति को अपडेट करना सरल होता है: C_t = f_t * C_{t-1} + i_t * g_t।
पहला पद f_t * C_{t-1} फ़ॉरगेट गेट लागू करता है — पिछली सेल स्थिति से चुनिंदा रूप से जानकारी मिटाता है। दूसरा पद i_t * g_t चुनिंदा रूप से नई जानकारी जोड़ता है। यह जोड़ने वाली संरचना ग्रेडिएंट को कई टाइमस्टेप तक बिना लुप्त हुए पीछे की ओर प्रवाहित होने देती है, क्योंकि ग्रेडिएंट सीधे जोड़ने की क्रिया से होकर गुजरता है।
# Update cell state
C_prev = torch.zeros(batch_size, hidden_size) # Previous cell state
C_t = f_t * C_prev + i_t * g_t # Element-wise operations
print('Updated cell state C_t:', C_t.detach())
# The additive update is key: gradients flow through + easily
# Compare to vanilla RNN: h_t = tanh(W * h_{t-1} + U * x_t)
# where gradients must flow through the tanh compression each stepआउटपुट गेट
आउटपुट गेट यह नियंत्रित करता है कि सेल स्थिति का कौन-सा भाग हिडन स्थिति आउटपुट h_t के रूप में सामने आए। पहले, आउटपुट गेट तय करता है कि सेल स्थिति के कौन-से भाग आउटपुट करने हैं: o_t = sigmoid(W_o · [h_{t-1}, x_t] + b_o)।
फिर, सेल स्थिति को tanh से गुजारा जाता है (ताकि मान -1 और 1 के बीच आ जाएँ) और आउटपुट गेट से गुणा किया जाता है: h_t = o_t * tanh(C_t)। हिडन स्थिति h_t इस टाइमस्टेप के आउटपुट और नई सेल स्थिति के साथ अगले LSTM चरण के इनपुट, दोनों के रूप में काम करती है।
# Output gate and hidden state
W_o = torch.randn(hidden_size, hidden_size + input_size)
b_o = torch.zeros(hidden_size)
o_t = torch.sigmoid(combined @ W_o.T + b_o) # Output gate
h_t = o_t * torch.tanh(C_t) # New hidden state
print('Output gate:', o_t.detach())
print('New hidden state h_t:', h_t.detach())LSTM पैरामीटर की संख्या और वेट मैट्रिस
एक LSTM में चार वेट मैट्रिस होते हैं (फ़ॉरगेट, इनपुट, संभावित और आउटपुट), जिनमें से प्रत्येक का आकार (hidden_size, hidden_size + input_size) होता है, साथ में बायस भी होता है। कुल पैरामीटर संख्या 4 * hidden_size * (hidden_size + input_size) + 4 * hidden_size होती है।
PyTorch का nn.LSTM दक्षता के लिए चारों गेट को संयुक्त वेट मैट्रिस weight_ih_l0 और weight_hh_l0 में पैक करता है। इसी कारण LSTM का प्रशिक्षण GRU (गेटेड रिकरेंट यूनिट) से धीमा हो सकता है, क्योंकि GRU केवल दो गेट और कम पैरामीटर का उपयोग करता है।
import torch.nn as nn
hidden = 64
input_s = 32
lstm = nn.LSTM(input_size=input_s, hidden_size=hidden, batch_first=True)
# PyTorch stores weight_ih (input-hidden) and weight_hh (hidden-hidden)
print('weight_ih_l0 shape:', lstm.weight_ih_l0.shape) # (4*hidden, input)
print('weight_hh_l0 shape:', lstm.weight_hh_l0.shape) # (4*hidden, hidden)
print('Total params:', sum(p.numel() for p in lstm.parameters()))PyTorch में nn.LSTM का उपयोग करना
PyTorch का nn.LSTM batch_first=True होने पर (batch, seq_len, input_size) आकार वाले अनुक्रम टेन्सर को स्वीकार करता है और वैकल्पिक रूप से प्रारंभिक स्थिति युग्म (h_0, c_0) भी ले सकता है। यह आउटपुट टेन्सर (सभी हिडन स्थितियाँ) और अंतिम स्थितियों का एक युग्म लौटाता है।
अनुक्रम वर्गीकरण के लिए आमतौर पर आपको अंतिम टाइमस्टेप की केवल अंतिम हिडन स्थिति h_n चाहिए। अनुक्रम लेबलिंग कार्यों (जैसे नामित इकाई पहचान) में आप सभी टाइमस्टेप के आउटपुट का उपयोग करते हैं। जब तक बैचों के बीच संदर्भ भेजने का कोई कारण न हो, हिडन स्थितियों को हमेशा शून्य से प्रारंभ करें।
import torch
import torch.nn as nn
batch_size, seq_len, input_size = 16, 20, 32
hidden_size = 64
lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size, batch_first=True)
x = torch.randn(batch_size, seq_len, input_size)
# Forward pass
output, (h_n, c_n) = lstm(x)
print('Output shape (all timesteps):', output.shape) # (16, 20, 64)
print('h_n shape (final hidden):', h_n.shape) # (1, 16, 64)
print('c_n shape (final cell):', c_n.shape) # (1, 16, 64)बहु-परत और द्विदिशात्मक LSTM
एक स्टैक्ड LSTM एक LSTM परत के आउटपुट को अगली परत के इनपुट के रूप में भेजता है, जिससे नेटवर्क को समय-आधारित पदानुक्रमित निरूपण सीखने की सुविधा मिलती है। nn.LSTM में num_layers=2 या उससे अधिक सेट करें।
एक द्विदिशात्मक LSTM अनुक्रम में एक LSTM को आगे की दिशा में और दूसरे को पीछे की दिशा में चलाता है तथा उनकी हिडन स्थितियों को जोड़ता है। इससे प्रत्येक टाइमस्टेप को अतीत और भविष्य, दोनों का संदर्भ मिलता है। bidirectional=True सेट करें; आउटपुट का आयाम 2 * hidden_size हो जाता है। द्विदिशात्मक LSTM उन NLP कार्यों में बहुत प्रभावी होते हैं जहाँ बाएँ और दाएँ, दोनों संदर्भ महत्वपूर्ण होते हैं।
import torch
import torch.nn as nn
# Bidirectional stacked LSTM
lstm = nn.LSTM(
input_size=32,
hidden_size=64,
num_layers=2,
batch_first=True,
bidirectional=True,
dropout=0.3 # Dropout between layers
)
x = torch.randn(16, 20, 32)
output, (h_n, c_n) = lstm(x)
print('Bidirectional output shape:', output.shape) # (16, 20, 128)
print('h_n shape:', h_n.shape) # (4, 16, 64): 2 layers * 2 directionsGRU: LSTM का सरल विकल्प
गेटेड रिकरेंट यूनिट (GRU) फ़ॉरगेट और इनपुट गेट को एक अपडेट गेट में मिलाकर तथा सेल और हिडन स्थिति को एकीकृत करके LSTM को सरल बनाता है। इसमें केवल दो गेट होते हैं: रीसेट गेट (अतीत की कितनी जानकारी भूलनी है) और अपडेट गेट (कितना अपडेट करना है)।
GRU में LSTM की तुलना में कम पैरामीटर होते हैं और इसका प्रशिक्षण तेज़ होता है, जबकि प्रदर्शन अक्सर समान रहता है। जटिल अनुक्रमों पर अधिकतम अभिव्यक्ति क्षमता चाहिए तो LSTM का उपयोग करें, और गति व सरलता महत्वपूर्ण हों तो GRU का। व्यवहार में, आपके विशिष्ट कार्य पर किया गया अनुभवजन्य परीक्षण बेहतर विकल्प निर्धारित करता है।
import torch
import torch.nn as nn
# GRU is simpler: only 3 weight matrices instead of 4
gru = nn.GRU(input_size=32, hidden_size=64, batch_first=True)
lstm = nn.LSTM(input_size=32, hidden_size=64, batch_first=True)
print('GRU params:', sum(p.numel() for p in gru.parameters()))
print('LSTM params:', sum(p.numel() for p in lstm.parameters()))
# GRU has 25% fewer parameters than LSTM for same hidden sizeभाषा के उदाहरण से LSTM को समझना
इस वाक्य पर विचार करें: 'The author, who lived in Paris for many years, wrote a novel.' कई शब्दों के बाद 'wrote' आने पर LSTM को 'author' (एकवचन) याद रखना आवश्यक है।
फ़ॉरगेट गेट लंबे संबंधवाचक उपवाक्य के दौरान सेल स्थिति में 'author' को बनाए रखता है। इनपुट गेट 'wrote' जैसी नई प्रासंगिक जानकारी को सेल स्थिति में जोड़ता है। आउटपुट गेट सही समय पर सेल स्थिति का उपयोग करके अगले शब्द का अनुमान लगाने या वाक्य का वर्गीकरण करने जैसे आगे के कार्यों के लिए सही हिडन स्थिति तैयार करता है।
- फ़ॉरगेट गेट: संबंधवाचक उपवाक्य के दौरान कर्ता को बनाए रखें
- इनपुट गेट: क्रिया मिलने पर उसकी जानकारी संग्रहीत करें
- आउटपुट गेट: अनुमान के समय संग्रहीत जानकारी का उपयोग करें
त्वरित जाँच
इस पाठ में LSTM गेट के बारे में अपनी समझ जाँचें।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: LSTM की सेल स्थिति दीर्घकालिक स्मृति की तरह काम करती है, जो बहुत कम बदलाव के साथ पूरे अनुक्रम में प्रवाहित होती है; तीन गेटिंग तंत्र (फ़ॉरगेट, इनपुट और आउटपुट) सिग्मॉइड-नियंत्रित गुणा द्वारा जानकारी के प्रवाह को नियंत्रित करते हैं; और सेल स्थिति का जोड़-आधारित अपडेट C_t = f_t * C_{t-1} + i_t * g_t ग्रेडिएंट को लुप्त हुए बिना प्रवाहित होने देता है। अगले भाग में हम LSTM को वास्तविक भावना विश्लेषण कार्य पर लागू करेंगे और शुरू से अंत तक पाठ वर्गीकार बनाएँगे।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “LSTM सेल: इनपुट, फ़ॉरगेट और आउटपुट गेट” पाठ निःशुल्क है?
हाँ—“LSTM सेल: इनपुट, फ़ॉरगेट और आउटपुट गेट” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“LSTM सेल: इनपुट, फ़ॉरगेट और आउटपुट गेट” में मैं क्या सीखूँगा?
शिक्षार्थी LSTM सेल का आरेख बनाएँगे, प्रत्येक गेट से सूचना के प्रवाह का अनुकरण करेंगे और nn.LSTM का उपयोग करके LSTM पाठ वर्गीकारक लागू करेंगे। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।
“LSTM सेल: इनपुट, फ़ॉरगेट और आउटपुट गेट” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- Vanilla RNN: छिपी अवस्था और अनुक्रम अनरोलिंग
- गहरे समय-चरणों में गायब होते ग्रेडिएंट की समस्या
- LSTM सेल: इनपुट, फ़ॉरगेट और आउटपुट गेट
- अनुक्रम-से-एक: LSTM के साथ भावना विश्लेषण