Sequence-to-Sequence মডেল Training

Sequence-to-Sequence (Seq2Seq) মডেল হল একটি ডীপ লার্নিং আর্কিটেকচার যা সাধারণত এনকোডার-ডিকোডার কাঠামো ব্যবহার করে। এটি বিশেষভাবে টেক্সট ট্রান্সলেশন, সেন্টেন্স পার্সিং, সিস্টেম ডায়ালগ, এবং অন্যান্য টেক্সট জেনারেশন সমস্যায় ব্যবহৃত হয়।

Seq2Seq মডেল দুটি অংশে বিভক্ত: এনকোডার (Encoder) এবং ডিকোডার (Decoder)।

1. Encoder: ইনপুট সিকোয়েন্সকে (যেমন একটি বাক্য) ভেক্টরে রূপান্তরিত করে। এটি ইনপুট সিকোয়েন্সের উপর ভিত্তি করে context vector তৈরি করে, যা পুরো সিকোয়েন্সের সারাংশ ধারণ করে।
2. Decoder: Context vector ব্যবহার করে আউটপুট সিকোয়েন্স তৈরি করে (যেমন, অনুবাদ করা বাক্য)।

Seq2Seq মডেলগুলো সাধারণত Recurrent Neural Networks (RNNs), LSTM, অথবা GRU লেয়ার ব্যবহার করে তৈরি করা হয়।

Sequence-to-Sequence মডেল Training Example

এখানে আমরা Keras এবং TensorFlow ব্যবহার করে একটি Seq2Seq মডেল তৈরি করব। এই মডেলটি একটি LSTM এনকোডার-ডিকোডার আর্কিটেকচার হবে এবং আমরা এটিকে ইংরেজি থেকে স্প্যানিশ অনুবাদ করতে ট্রেন করব।

১. প্রয়োজনীয় লাইব্রেরি ইনস্টলেশন

প্রথমে কিছু প্রয়োজনীয় লাইব্রেরি ইনস্টল করতে হবে:

pip install tensorflow
pip install numpy
pip install scikit-learn

২. ডেটাসেট লোড এবং প্রিপ্রসেসিং

এই উদাহরণে আমরা English-Spanish Translation ডেটাসেট ব্যবহার করব। এই ডেটাসেটটি ডাউনলোড করা যেতে পারে অথবা আপনি নিজেই একটি তৈরি করতে পারেন। এখানে একটি সাধারণ ডেটাসেট তৈরি করা হলো:

import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from sklearn.model_selection import train_test_split

# উদাহরণস্বরূপ ডেটাসেট
input_texts = ['hello', 'how are you?', 'what is your name?', 'good morning']
output_texts = ['hola', 'cómo estás?', 'cuál es tu nombre?', 'buenos días']

# টোকেনাইজার তৈরি
input_tokenizer = Tokenizer()
output_tokenizer = Tokenizer()

# টোকেনাইজ করা ইনপুট এবং আউটপুট টেক্সট
input_tokenizer.fit_on_texts(input_texts)
output_tokenizer.fit_on_texts(output_texts)

# সিকোয়েন্সে রূপান্তর করা
input_sequences = input_tokenizer.texts_to_sequences(input_texts)
output_sequences = output_tokenizer.texts_to_sequences(output_texts)

# প্যাডিং দেওয়া
max_input_length = max([len(seq) for seq in input_sequences])
max_output_length = max([len(seq) for seq in output_sequences])

input_sequences = pad_sequences(input_sequences, maxlen=max_input_length, padding='post')
output_sequences = pad_sequences(output_sequences, maxlen=max_output_length, padding='post')

# ডেটা ভাগ করা (train, test)
X_train, X_test, y_train, y_test = train_test_split(input_sequences, output_sequences, test_size=0.2, random_state=42)

# ইনপুট এবং আউটপুট আকার
vocab_size_input = len(input_tokenizer.word_index) + 1
vocab_size_output = len(output_tokenizer.word_index) + 1

৩. Encoder-Decoder আর্কিটেকচার

এখন আমরা একটি LSTM Encoder-Decoder মডেল তৈরি করব।

from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, LSTM, Dense, Embedding

def build_seq2seq_model(vocab_size_input, vocab_size_output, input_length, output_length, latent_dim):
    # এনকোডার
    encoder_inputs = Input(shape=(input_length,))
    encoder_embedding = Embedding(input_dim=vocab_size_input, output_dim=latent_dim)(encoder_inputs)
    encoder_lstm = LSTM(latent_dim, return_state=True)
    encoder_outputs, state_h, state_c = encoder_lstm(encoder_embedding)
    encoder_states = [state_h, state_c]

    # ডিকোডার
    decoder_inputs = Input(shape=(output_length,))
    decoder_embedding = Embedding(input_dim=vocab_size_output, output_dim=latent_dim)(decoder_inputs)
    decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)
    decoder_lstm_outputs, _, _ = decoder_lstm(decoder_embedding, initial_state=encoder_states)
    decoder_dense = Dense(vocab_size_output, activation='softmax')
    decoder_outputs = decoder_dense(decoder_lstm_outputs)

    # মডেল তৈরি
    model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

    model.summary()
    return model

latent_dim = 256  # LSTM এর ল্যাটেন্ট ডাইমেনশন

# মডেল তৈরি
seq2seq_model = build_seq2seq_model(vocab_size_input, vocab_size_output, max_input_length, max_output_length, latent_dim)

• Encoder: ইনপুট সিকোয়েন্সটি LSTM এর মাধ্যমে আউটপুটের জন্য কনটেক্সট ভেক্টর তৈরি করবে।
• Decoder: LSTM ব্যবহার করে কনটেক্সট ভেক্টর থেকে আউটপুট সিকোয়েন্স তৈরি করবে।
• Dense Layer: আউটপুট সিকোয়েন্সের জন্য softmax অ্যাকটিভেশন ফাংশন ব্যবহার করে শব্দের পূর্বাভাস করবে।

৪. মডেল ট্রেনিং

এখন, আমরা seq2seq_model মডেলটি ট্রেন করব:

# Decoder Inputs এর জন্য শিফট করা আউটপুট সিকোয়েন্স
y_train_decoder_input = np.zeros_like(y_train)
y_train_decoder_input[:, 1:] = y_train[:, :-1]
y_train_decoder_input[:, 0] = output_tokenizer.word_index['<start>']  # "<start>" শব্দ ইনিশিয়ালাইজড করা

# ট্রেনিং
seq2seq_model.fit([X_train, y_train_decoder_input], np.expand_dims(y_train, -1), epochs=100, batch_size=16, validation_data=([X_test, y_test_decoder_input], np.expand_dims(y_test, -1)))

৫. মডেল পূর্বাভাস করা

মডেলটি ট্রেন করার পর, আমরা Encoder-Decoder মডেলটি ব্যবহার করে নতুন ইনপুট সিকোয়েন্সের পূর্বাভাস করতে পারি।

# ইনপুট থেকে এনকোডার স্টেট বের করা
encoder_model = Model(encoder_inputs, encoder_states)

# ডিকোডার মডেল তৈরি
decoder_state_input_h = Input(shape=(latent_dim,))
decoder_state_input_c = Input(shape=(latent_dim,))
decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]
decoder_lstm_outputs, state_h, state_c = decoder_lstm(decoder_embedding, initial_state=decoder_states_inputs)
decoder_states = [state_h, state_c]
decoder_outputs = decoder_dense(decoder_lstm_outputs)
decoder_model = Model([decoder_inputs] + decoder_states_inputs, [decoder_outputs] + decoder_states)

# মডেল দিয়ে প্রেডিকশন করা
def decode_sequence(input_seq):
    # এনকোডার থেকে স্টেট আনা
    states_value = encoder_model.predict(input_seq)

    # ডিকোডার ইনপুটে "<start>" শব্দ ব্যবহার করা
    target_seq = np.zeros((1, 1))
    target_seq[0, 0] = output_tokenizer.word_index['<start>']

    stop_condition = False
    decoded_sentence = ''
    while not stop_condition:
        # ডিকোডার থেকে আউটপুট প্রাপ্তি
        output_tokens, h, c = decoder_model.predict([target_seq] + states_value)

        # পূর্বাভাসকৃত শব্দ নির্বাচন করা
        sampled_token_index = np.argmax(output_tokens[0, -1, :])
        sampled_word = output_tokenizer.index_word[sampled_token_index]
        decoded_sentence += ' ' + sampled_word

        # স্টপ কন্ডিশন চেক করা
        if sampled_word == '<end>' or len(decoded_sentence) > max_output_length:
            stop_condition = True

        # পরবর্তী ইনপুট
        target_seq[0, 0] = sampled_token_index
        states_value = [h, c]

    return decoded_sentence

# এক উদাহরণ দিয়ে প্রেডিকশন করা
input_seq = X_test[0:1]  # একটি ইনপুট সিকোয়েন্স
decoded_sentence = decode_sequence(input_seq)
print(f"Decoded Sentence: {decoded_sentence}")

সারাংশ

Sequence-to-Sequence (Seq2Seq) মডেল দুটি মডেল নিয়ে গঠিত: **Encoder

** এবং Decoder। এটি বিশেষভাবে ব্যবহৃত হয় টেক্সট ট্রান্সলেশন, প্রশ্ন-উত্তর সিস্টেম, এবং অন্যান্য সিকোয়েন্স জেনারেশন সমস্যায়। আমরা LSTM অথবা GRU লেয়ার ব্যবহার করে এই মডেলগুলো তৈরি করতে পারি।

• Encoder ইনপুট সিকোয়েন্সের জন্য কনটেক্সট ভেক্টর তৈরি করে।
• Decoder ঐ কনটেক্সট ভেক্টর ব্যবহার করে আউটপুট সিকোয়েন্স তৈরি করে।

এই মডেলটি একটি Encoder-Decoder কাঠামো ব্যবহার করে যেটি LSTM এর মতো শক্তিশালী মেমরি ধারণ করতে সক্ষম।