Advanced Layers (Attention, Transformer, etc.) তৈরি করা

Advanced Layers যেমন Attention এবং Transformer কৌশলগুলি বর্তমানে ডীপ লার্নিং এবং NLP (Natural Language Processing) এ ব্যাপকভাবে ব্যবহৃত হচ্ছে। এই ধরনের লেয়ারগুলি মডেলের পারফরম্যান্স এবং কার্যকারিতা ব্যাপকভাবে উন্নত করতে সহায়তা করে, বিশেষত যখন ডেটার মধ্যে দীর্ঘস্থায়ী সম্পর্ক বা কার্যকরী নির্ভরতা থাকে। নিচে এই ধরনের লেয়ারগুলির সাথে কাজ করার পদ্ধতি ব্যাখ্যা করা হলো।

১. Attention Mechanism

Attention একটি কৌশল যা নিউরাল নেটওয়ার্কের বিশেষ অংশের উপর ফোকাস করে, নির্দিষ্ট অংশগুলোকে গুরুত্ব দিয়ে আউটপুট তৈরি করতে সহায়তা করে। এটি মেশিন ট্রান্সলেশন, সিকোয়েন্স টু সিকোয়েন্স (Seq2Seq) মডেল, এবং অন্যান্য ডীপ লার্নিং অ্যাপ্লিকেশনে ব্যবহৃত হয়।

Attention Layer তৈরি করা

Keras এ Attention লেয়ার তৈরি করার জন্য, সাধারণত Additive Attention বা Scaled Dot-Product Attention ব্যবহৃত হয়। এখানে একটি সাধারণ Attention লেয়ার তৈরি করার উদাহরণ দেওয়া হলো, যেখানে একে কাস্টম লেয়ার হিসেবে তৈরি করা হয়েছে।

import tensorflow as tf
from tensorflow.keras.layers import Layer
import tensorflow.keras.backend as K

class AttentionLayer(Layer):
    def __init__(self):
        super(AttentionLayer, self).__init__()

    def build(self, input_shape):
        # Weights initialization (for key, value, and query)
        self.W_q = self.add_weight(name="W_q", shape=(input_shape[-1], input_shape[-1]), initializer='random_normal')
        self.W_k = self.add_weight(name="W_k", shape=(input_shape[-1], input_shape[-1]), initializer='random_normal')
        self.W_v = self.add_weight(name="W_v", shape=(input_shape[-1], input_shape[-1]), initializer='random_normal')
        
    def call(self, inputs):
        query, key, value = inputs
        
        # Compute attention scores
        Q = K.dot(query, self.W_q)
        K_ = K.dot(key, self.W_k)
        V = K.dot(value, self.W_v)
        
        # Calculate attention weights (dot product of Q and K)
        attention_scores = K.batch_dot(Q, K_, axes=[2, 2])
        attention_weights = K.softmax(attention_scores)
        
        # Output weighted sum of values
        output = K.batch_dot(attention_weights, V, axes=[2, 1])
        return output

# Example usage of Attention layer in a Keras model
inputs = tf.keras.Input(shape=(10, 64))  # Assume input is a sequence of length 10 and 64 features
query = tf.keras.Input(shape=(10, 64))  # Query input
key = tf.keras.Input(shape=(10, 64))    # Key input
value = tf.keras.Input(shape=(10, 64))  # Value input

attention_output = AttentionLayer()([query, key, value])

model = tf.keras.Model(inputs=[query, key, value], outputs=attention_output)
model.summary()

এই কাস্টম AttentionLayer আউটপুট হিসাবে একটি weighted sum প্রদান করে, যেখানে query, key, এবং value তিনটি আলাদা ইনপুট হিসেবে নেওয়া হয়। এখানে scaled dot-product attention ব্যবহার করা হয়েছে, যেটি ডিপ লার্নিং মডেলগুলোতে জনপ্রিয়।

২. Transformer Architecture

Transformer মডেলটি বিশেষভাবে self-attention এবং multi-head attention এর মাধ্যমে কাজ করে, যা Seq2Seq মডেলগুলির তুলনায় অনেক দ্রুত এবং শক্তিশালী। Transformer আর্কিটেকচারের মূল বৈশিষ্ট্য হল যে এটি RNN বা LSTM এর পরিবর্তে fully connected layers ব্যবহার করে।

Transformer এর সবচেয়ে বড় সুবিধা হল এটি একাধিক ইনপুটের মধ্যে পারস্পরিক সম্পর্ক (dependency) শিখতে সক্ষম এবং সিকোয়েন্স ডেটা প্রক্রিয়াকরণে একটি নতুন দিক নিয়ে এসেছে।

Transformer Layer তৈরি করা

Transformer মডেলের মধ্যে সবচেয়ে গুরুত্বপূর্ণ অংশ হল Multi-Head Attention, যা একাধিক attention ফিচার একযোগভাবে শিখে। এখানে একটি কাস্টম Multi-Head Attention লেয়ার তৈরি করা হয়েছে:

import tensorflow as tf
from tensorflow.keras.layers import Layer
import tensorflow.keras.backend as K

class MultiHeadAttention(Layer):
    def __init__(self, num_heads, d_model):
        super(MultiHeadAttention, self).__init__()
        self.num_heads = num_heads
        self.d_model = d_model
        self.depth = d_model // self.num_heads
    
    def build(self, input_shape):
        self.query_dense = tf.keras.layers.Dense(self.d_model)
        self.key_dense = tf.keras.layers.Dense(self.d_model)
        self.value_dense = tf.keras.layers.Dense(self.d_model)
        self.output_dense = tf.keras.layers.Dense(self.d_model)
    
    def split_heads(self, x, batch_size):
        # Split the last dimension into (num_heads, depth)
        x = K.reshape(x, (batch_size, -1, self.num_heads, self.depth))
        return K.permute_dimensions(x, (0, 2, 1, 3))
    
    def call(self, inputs):
        query, key, value = inputs
        batch_size = K.shape(query)[0]
        
        query = self.query_dense(query)
        key = self.key_dense(key)
        value = self.value_dense(value)
        
        query = self.split_heads(query, batch_size)
        key = self.split_heads(key, batch_size)
        value = self.split_heads(value, batch_size)
        
        attention_scores = K.batch_dot(query, key, axes=[3, 3]) / K.sqrt(float(self.depth))
        attention_weights = K.softmax(attention_scores, axis=-1)
        
        output = K.batch_dot(attention_weights, value, axes=[3, 2])
        output = K.permute_dimensions(output, (0, 2, 1, 3))
        output = K.reshape(output, (batch_size, -1, self.d_model))
        
        output = self.output_dense(output)
        return output

# Example of using Multi-Head Attention in a Transformer block
inputs = tf.keras.Input(shape=(10, 64))  # (Sequence Length, Features)
multi_head_attention_output = MultiHeadAttention(num_heads=4, d_model=64)([inputs, inputs, inputs])

model = tf.keras.Model(inputs=inputs, outputs=multi_head_attention_output)
model.summary()

এখানে MultiHeadAttention লেয়ারে একাধিক attention পারস্পরিক সম্পর্ক শিখে এবং সেগুলিকে মিশিয়ে আউটপুট প্রদান করে। num_heads হল attention heads এর সংখ্যা এবং d_model হল মডেল আউটপুটের আকার।

৩. Position-wise Feed Forward Network

Transformer আর্কিটেকচারের মধ্যে আরও একটি গুরুত্বপূর্ণ অংশ হল position-wise feed-forward network যা ইনপুট টেক্সটের প্রতিটি শব্দের জন্য আলাদাভাবে একটি নিউরাল নেটওয়ার্ক প্রয়োগ করে।

class PositionwiseFeedForward(Layer):
    def __init__(self, d_model, d_ff):
        super(PositionwiseFeedForward, self).__init__()
        self.dense1 = tf.keras.layers.Dense(d_ff, activation='relu')
        self.dense2 = tf.keras.layers.Dense(d_model)
    
    def call(self, inputs):
        x = self.dense1(inputs)
        return self.dense2(x)

# Example usage in Transformer block
inputs = tf.keras.Input(shape=(10, 64))
feed_forward_output = PositionwiseFeedForward(d_model=64, d_ff=256)(inputs)

model = tf.keras.Model(inputs=inputs, outputs=feed_forward_output)
model.summary()

এটি একটি সাধারণ feed-forward network যা ReLU অ্যাকটিভেশন ফাংশন ব্যবহার করে।

সারাংশ

• Attention: এটি বিশেষভাবে গুরুত্বপূর্ণ যখন ইনপুট ডেটার মধ্যে দীর্ঘমেয়াদী নির্ভরতা থাকে এবং মডেলটিকে নির্দিষ্ট অংশের উপর ফোকাস করতে সহায়তা করে।
• Multi-Head Attention: এটি একাধিক attention mechanism একযোগভাবে কাজ করতে সহায়তা করে এবং বিভিন্ন তথ্য একত্রিত করে।
• Transformer: এটি আধুনিক NLP মডেলগুলির জন্য ভিত্তি হিসেবে কাজ করে, যেখানে রেকারেন্ট নেটওয়ার্ক বা LSTM এর পরিবর্তে attention mechanism ব্যবহার করা হয়, যা প্রশিক্ষণের গতি এবং দক্ষতা বৃদ্ধি করে।

এই Advanced Layers তৈরি করে, আপনি অত্যন্ত শক্তিশালী এবং দক্ষ মডেল তৈরি করতে পারেন যা বিভিন্ন ডোমেইনে, যেমন NLP, মেশিন ট্রান্সলেশন, এবং ভাষা প্রক্রিয়াকরণে কার্যকরী হতে পারে।