Theano দিয়ে RNN এবং LSTM মডেল তৈরি

থিয়ানো (Theano) দিয়ে Recurrent Neural Network (RNN) এবং Long Short-Term Memory (LSTM) মডেল তৈরি করা একটি চ্যালেঞ্জিং, কিন্তু শক্তিশালী কাজ। RNN এবং LSTM সাধারণত টাইম সিরিজ ডেটা এবং সিকোয়েন্সাল ডেটা প্রক্রিয়া করতে ব্যবহৃত হয়। এখানে RNN এবং LSTM তৈরি করার জন্য একটি প্রাথমিক গাইডলাইন দেওয়া হলো।

১. RNN মডেল তৈরি

RNN গুলি সাধারণত টাইম স্টেপ বা সিকোয়েন্সাল ডেটার মধ্যে তথ্য ধারণ করে এবং প্রতিটি টেম্পোরাল স্টেপের মধ্যে লিংক তৈরি করতে পারে।

ধাপ ১: প্রয়োজনীয় লাইব্রেরি ইমপোর্ট

import numpy as np
import theano
import theano.tensor as T
from theano import shared

ধাপ ২: RNN ফাংশন তৈরি

RNN তৈরি করতে Vanilla RNN ব্যবহার করতে পারেন। আমরা একটি সাধারণ রিকারেন্ট ইউনিট (Recurrent Unit) তৈরি করব।

# RNN এর জন্য পারামিটার সেটআপ
n_input = 5   # ইনপুট ডেটার সাইজ
n_hidden = 10  # হিডেন লেয়ার সাইজ
n_output = 1   # আউটপুট সাইজ

# ইনপুট এবং আউটপুট টেনসর তৈরি
X = T.dmatrix('X')  # ইনপুট
Y = T.dmatrix('Y')  # আউটপুট

# ওজন (weights) এবং বায়াস (biases)
Wxh = shared(np.random.randn(n_input, n_hidden))  # ইনপুট থেকে হিডেন লেয়ার
Whh = shared(np.random.randn(n_hidden, n_hidden))  # হিডেন লেয়ার থেকে হিডেন লেয়ার
Why = shared(np.random.randn(n_hidden, n_output))  # হিডেন লেয়ার থেকে আউটপুট

bh = shared(np.zeros(n_hidden))  # হিডেন লেয়ারের বায়াস
by = shared(np.zeros(n_output))  # আউটপুটের বায়াস

# RNN ফাংশন তৈরি
def rnn_step(x_t, h_t_prev):
    h_t = T.tanh(T.dot(x_t, Wxh) + T.dot(h_t_prev, Whh) + bh)  # হিডেন স্টেট
    y_t = T.dot(h_t, Why) + by  # আউটপুট
    return h_t, y_t

# ইনপুট এবং আউটপুট সিকোয়েন্সের জন্য স্টেপ তৈরি
h_0 = shared(np.zeros(n_hidden))  # প্রাথমিক হিডেন স্টেট

[h, y] = theano.scan(rnn_step,
                     sequences=[X],
                     outputs_info=[h_0, None])

# ফাংশন তৈরি
rnn_model = theano.function([X], y)

ধাপ ৩: RNN মডেল ট্রেনিং

এখন আপনি RNN মডেল তৈরি করেছেন। আপনি theano.scan ব্যবহার করে সমস্ত টাইম স্টেপের জন্য ফাংশনটি চালাতে পারেন এবং সিকোয়েন্সের জন্য আউটপুট বের করতে পারেন।

এটি একটি প্রাথমিক রিকারেন্ট ইউনিট, যা আপনার সিকোয়েন্সাল ডেটার উপর কাজ করবে।

২. LSTM মডেল তৈরি

LSTM (Long Short-Term Memory) একটি উন্নত ধরনের RNN যা দীর্ঘমেয়াদী নির্ভরশীলতা ধরে রাখতে সক্ষম। LSTM মূলত 3টি গেটের মাধ্যমে কাজ করে — Forget gate, Input gate, এবং Output gate।

ধাপ ১: LSTM মডেল ফাংশন

# LSTM মডেল তৈরি
def lstm_step(x_t, h_t_prev, c_t_prev):
    # Forget gate (f)
    f_t = T.nnet.sigmoid(T.dot(x_t, Wxf) + T.dot(h_t_prev, Whf) + bf)
    
    # Input gate (i)
    i_t = T.nnet.sigmoid(T.dot(x_t, Wxi) + T.dot(h_t_prev, Whi) + bi)
    
    # Candidate memory (g)
    g_t = T.tanh(T.dot(x_t, Wxg) + T.dot(h_t_prev, Whg) + bg)
    
    # Output gate (o)
    o_t = T.nnet.sigmoid(T.dot(x_t, Wxo) + T.dot(h_t_prev, Who) + bo)
    
    # Cell state (c)
    c_t = f_t * c_t_prev + i_t * g_t  # Forget previous state and add new state
    
    # Hidden state (h)
    h_t = o_t * T.tanh(c_t)  # Final hidden state
    
    return h_t, c_t

# ইনপুট, আউটপুট, ওজন এবং বায়াস সেটআপ
n_input = 5
n_hidden = 10
n_output = 1

X = T.dmatrix('X')
Y = T.dmatrix('Y')

Wxg = shared(np.random.randn(n_input, n_hidden))
Whg = shared(np.random.randn(n_hidden, n_hidden))
bg = shared(np.zeros(n_hidden))

Wxf = shared(np.random.randn(n_input, n_hidden))
Whf = shared(np.random.randn(n_hidden, n_hidden))
bf = shared(np.zeros(n_hidden))

Wxi = shared(np.random.randn(n_input, n_hidden))
Whi = shared(np.random.randn(n_hidden, n_hidden))
bi = shared(np.zeros(n_hidden))

Wxo = shared(np.random.randn(n_input, n_hidden))
Who = shared(np.random.randn(n_hidden, n_hidden))
bo = shared(np.zeros(n_hidden))

# স্টেপের জন্য প্রাথমিক স্টেট
h_0 = shared(np.zeros(n_hidden))
c_0 = shared(np.zeros(n_hidden))

# LSTM সিকোয়েন্স স্টেপ তৈরি
[h, c] = theano.scan(lstm_step,
                     sequences=[X],
                     outputs_info=[h_0, c_0])

# ফাংশন তৈরি
lstm_model = theano.function([X], h)

ধাপ ২: LSTM ট্রেনিং এবং ইনফারেন্স

LSTM মডেল তৈরি হয়ে গেলে আপনি এটি ট্রেনিং করতে পারবেন যেমন RNN মডেল করতে পারেন এবং নতুন ডেটার উপর ইনফারেন্স করতে পারবেন। ট্রেনিং কাস্টমাইজ করা যেতে পারে, যেমন অ্যাডাম বা SGD অপটিমাইজার ব্যবহার করে।

সারাংশ:

1. RNN তৈরি: একটি সাধারণ রিকারেন্ট ইউনিট ব্যবহার করে ইনপুট সিকোয়েন্সের জন্য গাণিতিক অপারেশন করা হয়। theano.scan দিয়ে সিকোয়েন্সের উপর পুনরাবৃত্তি (iteration) করা হয়।
2. LSTM তৈরি: LSTM অনেক শক্তিশালী মডেল যা টাইম স্টেপের মধ্যে দীর্ঘমেয়াদী নির্ভরশীলতা শিখতে পারে। এটি Forget gate, Input gate, এবং Output gate ব্যবহার করে ইনফরমেশন সংরক্ষণ করে এবং নতুন তথ্য গ্রহণ করে।

এটি একটি প্রাথমিক উদাহরণ, যেখানে আমরা শুধু থিয়ানো ব্যবহার করে RNN এবং LSTM তৈরি করেছি। তবে LSTM এবং RNN এর উন্নত ভ্যারিয়েন্ট (যেমন Bidirectional LSTM, GRU) বা বিভিন্ন অপটিমাইজেশন মেথডস ব্যবহার করার জন্য এই কোডকে আরও উন্নত করা যেতে পারে।