GRU

GRU Cell সমীকরণ

z_t = σ(W_z · [h_{t-1}, x_t])             # Update gate
r_t = σ(W_r · [h_{t-1}, x_t])             # Reset gate
h̃_t = tanh(W · [r_t * h_{t-1}, x_t])      # Candidate hidden
h_t = (1 - z_t) * h_{t-1} + z_t * h̃_t     # Final hidden

LSTM বনাম GRU

কখন কোনটি?

• ছোট ডেটা / দ্রুত prototype → GRU
• খুব দীর্ঘ sequence / language modeling → LSTM
• সন্দেহ হলে দুটোই try করুন — task-ভেদে পার্থক্য সামান্য।

Keras GRU

from tensorflow.keras import layers, models
m = models.Sequential([
    layers.Embedding(20000, 128, mask_zero=True),
    layers.Bidirectional(layers.GRU(128, return_sequences=True)),
    layers.GRU(64),
    layers.Dense(1, activation="sigmoid"),
])

PyTorch GRU

import torch.nn as nn
class GRUTagger(nn.Module):
    def __init__(self, vocab, n_tag, emb=128, hid=128):
        super().__init__()
        self.emb = nn.Embedding(vocab, emb, padding_idx=0)
        self.gru = nn.GRU(emb, hid, num_layers=1, batch_first=True,
                          bidirectional=True)
        self.fc = nn.Linear(hid*2, n_tag)
    def forward(self, x):
        out, _ = self.gru(self.emb(x))
        return self.fc(out)        # (B, T, n_tag)

Seq2Seq with GRU — Encoder-Decoder

class Encoder(nn.Module):
    def __init__(self, v, e, h):
        super().__init__()
        self.emb = nn.Embedding(v, e)
        self.gru = nn.GRU(e, h, batch_first=True)
    def forward(self, x): return self.gru(self.emb(x))

class Decoder(nn.Module):
    def __init__(self, v, e, h):
        super().__init__()
        self.emb = nn.Embedding(v, e)
        self.gru = nn.GRU(e, h, batch_first=True)
        self.fc = nn.Linear(h, v)
    def forward(self, x, h):
        out, h = self.gru(self.emb(x), h)
        return self.fc(out), h

অনুশীলন

সারসংক্ষেপ