সিকোয়েন্স-টু-সিকোয়েন্স  লারনিং - ২ (কোডিং)

আমাদের উদাহরণ প্রয়োগের জন্য, আমরা ইংরেজী বাক্য এবং তাদের ফরাসি ভাষায় অনুবাদ করা একটি ডেটাসেট ব্যবহার করব, যা আপনি manythings.org/anki থেকে ডাউনলোড করতে পারেন। ডাউনলোড করা ফাইলটির নাম fra-eng.zip। আমরা একটি ওয়ার্ড-লেভেল সিক্যুয়েন্স-টু-সিকোয়েন্সন মডেলটি প্রয়োগ করব, ইনপুট অক্ষর-দ্বারা-স্ট্রিং প্রসেসিং করব এবং আউটপুট চরিত্র অনুসারে অক্ষর তৈরি করব। অন্য বিকল্পটি একটি শব্দ-স্তরের মডেল হবে, যা মেশিন অনুবাদে আরও সাধারণ হয়ে থাকে। এই পোস্টের শেষে, আপনি এম্বেডিং স্তরগুলি ব্যবহার করে আমাদের মডেলটিকে একটি শব্দ-স্তরের মডেলে পরিণত করার বিষয়ে কিছু নোট পাবেন। 

আমাদের উদাহরণের জন্য সম্পূর্ণ সোর্সকোডটি গিটহাবে পাওয়া যাবে। 

আমাদের প্রক্রিয়াটির একটি সিকোয়েন্স আকারে যাবেঃ

1. প্রথমে বাক্যগুলিকে তিনটি নামপাই অ্যারেতে encoder_input_data, decoder_input_data, decoder_target_data ভাগ করতে হবেঃ

• encoder_input_data হল ইংরেজী বাক্যগুলির থ্রি ডাইমেনশনাল আকারের ভেক্টরাইজেশনযুক্ত তিনটি অ্যারে (num_pairs, max_english_senferences_leth, num_english_characters)।

• decoder_input_data হল ফরাসি বাক্যগুলির থ্রি ডাইমেনশনাল আকারের ভেক্টরাইজেশনযুক্ত তিনটি অ্যারে (num_pairs, max_french_sentence_length, num_funch_characters) 

• decoder_target_data হল decoder_input_data  মতোই কিন্তু এটা অফসেট করা হয় প্রত্যেক টাইমস্টেপ দিয়ে যেটা কিনা  t দিয়ে প্রকাশ করা হয়। সমান তবে এক টাইমস্টেপ দ্বারা অফসেট। এখানে decoder_target_data[:, t, :] সব সময়ই decoder_input_data[:, t + 1, :] এর সমান হবে।

2. এই ধাপে একটি LSTM বেসড সিকোয়েন্স-টু-সিকোয়েন্স মডেল বানাতে হবে encoder_input_data আর decoder_input_data এর উপর ভিত্তি করে decoder_target_data প্রিডিকশন করতে হবে। আমাদের মডেল টিচার ফোর্সিং পদ্ধতি ব্যবহার করবে।

3. মডেলটি কাজ করছে কিনা তা পরীক্ষা করার জন্য আমরা কয়েকটি বাক্য ডিকোড করবো (অর্থাত এনকোডার_পুট_ডাটা থেকে নমুনাটিকে ডিকোডার_টারেট_ডাটা থেকে সংশ্লিষ্ট নমুনায় পরিণত করুন)।

প্রশিক্ষণ প্রক্রিয়া এবং অনুমান প্রক্রিয়া (ডিকোডিং বাক্যগুলি) একেবারে পৃথক হওয়ার কারণে আমরা উভয়ের জন্য আলাদা আলাদা মডেল ব্যবহার করি, যদিও তারা সকলেই একই অভ্যন্তরীণ স্তরকে উত্তোলন করে।

এটি আমাদের প্রশিক্ষণের মডেল। এটি কেরাস আরএনএনগুলির তিনটি মূল বৈশিষ্ট্যকে উপকৃত করে:

রিটার্ন_সেটের কনট্রাক্টর আর্গুমেন্ট, একটি তালিকা ফেরত দেওয়ার জন্য একটি আরএনএন স্তর কনফিগার করে যেখানে প্রথম এন্ট্রি আউটপুট এবং পরের এন্ট্রিগুলি অভ্যন্তরীণ আরএনএন রাজ্যগুলি। এটি এনকোডারের রাজ্যগুলি পুনরুদ্ধার করতে ব্যবহৃত হয়।

আরএনএন এর প্রাথমিক অবস্থা (গুলি) নির্দিষ্ট করে ইনিটাল_স্টেট কল আর্গুমেন্ট। এটি এনকোডার রাজ্যগুলি ডিকোডারের কাছে প্রাথমিক রাজ্য হিসাবে পাস করতে ব্যবহৃত হয়।

রিটার্ন_সেসকেন্স কনস্ট্রাক্টর আর্গুমেন্ট, আউটপুটগুলির সম্পূর্ণ ক্রম ফিরে পাওয়ার জন্য একটি আরএনএনকে কনফিগার করে (কেবলমাত্র শেষ আউটপুট পরিবর্তে, যা ডিফল্ট আচরণ করে)। এটি ডিকোডারে ব্যবহৃত হয়।

পাইথন কোড :

from keras.models import Model

from keras.layers import Input, LSTM, Dense

# Define an input sequence and process it.

encoder_inputs = Input(shape=(None, num_encoder_tokens))

encoder = LSTM(latent_dim, return_state=True)

encoder_outputs, state_h, state_c = encoder(encoder_inputs)

# We discard `encoder_outputs` and only keep the states.

encoder_states = [state_h, state_c]

# Set up the decoder, using `encoder_states` as initial state.

decoder_inputs = Input(shape=(None, num_decoder_tokens))

# We set up our decoder to return full output sequences,

# and to return internal states as well. We don't use the 

# return states in the training model, but we will use them in inference.

decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)

decoder_outputs, _, _ = decoder_lstm(decoder_inputs,

                                     initial_state=encoder_states)

decoder_dense = Dense(num_decoder_tokens, activation='softmax')

decoder_outputs = decoder_dense(decoder_outputs)

# Define the model that will turn

# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`

model = Model([encoder_inputs, decoder_inputs], decoder_outputs)

আমরা আমাদের মডেলকে ট্রেনিং করাবো মাত্র দুই লাইনের কোড দিয়ে, এখানে ডাটাসেটের 20% ডাটা টেস্টিং এর জন্য রেখে দেয়া হয়েছে। চাইলেই এটি বারিয়ে কমিয়ে নেয়া সম্ভব।

# Run training

model.compile(optimizer='rmsprop', loss='categorical_crossentropy')

model.fit([encoder_input_data, decoder_input_data], decoder_target_data,

          batch_size=batch_size,

          epochs=epochs,

          validation_split=0.2)

এই কাজটা করতে আমার প্রায় দেড় ঘন্টার মতো লেগেছে তা ও ১৬ জিবি র‍্যাম এ।  আপনাদের টাইম আরো কম-বেশি লাগতেই পারে। একটা বাক্য ডিকোড করার জন্য আমরা যা করবো তা হলোঃ

1.  ইনপুট বাক্যটি এনকোড করবো এবং প্রাথমিক ডিকোডার অবস্থা বের করবো ।

2. এই প্রাথমিক অবস্থার সাথে ডিকোডারটির এক ধাপ চালাবো এবং লক্ষ্য হিসাবে  থাকবে "SOS" টোকেন। এর আউটপুট এর পরবর্তী অক্ষর বের করবে।

3. এভাবে পরবর্তী অক্ষরতা বের করবো এবং এই প্রক্রিয়ার পুনরাবৃত্তি করবো।

এখানে আমাদের পরবর্তী অক্ষর বের করার মডেল, যেটা ইনফারেন্স সেটাপ নামে পরিচিতঃ

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_outputs, state_h, state_c = decoder_lstm(

    decoder_inputs, initial_state=decoder_states_inputs)

decoder_states = [state_h, state_c]

decoder_outputs = decoder_dense(decoder_outputs)

decoder_model = Model(

    [decoder_inputs] + decoder_states_inputs,

    [decoder_outputs] + decoder_states)

এবার আমরা উপরে বর্ণিত ইনফারেন্স লুপটি  ব্যবহার করবো একটা ফাংশনের মধ্যে দিয়েঃ:

def decode_sequence(input_seq):

    # Encode the input as state vectors.

    states_value = encoder_model.predict(input_seq)

    # Generate empty target sequence of length 1.

    target_seq = np.zeros((1, 1, num_decoder_tokens))

    # Populate the first character of target sequence with the start character.

    target_seq[0, 0, target_token_index['\t']] = 1.

    # Sampling loop for a batch of sequences

    # (to simplify, here we assume a batch of size 1).

    stop_condition = False

    decoded_sentence = ''

    while not stop_condition:

        output_tokens, h, c = decoder_model.predict(

            [target_seq] + states_value)

        # Sample a token

        sampled_token_index = np.argmax(output_tokens[0, -1, :])

        sampled_char = reverse_target_char_index[sampled_token_index]

        decoded_sentence += sampled_char

        # Exit condition: either hit max length

        # or find stop character.

        if (sampled_char == '\n' or

           len(decoded_sentence) > max_decoder_seq_length):

            stop_condition = True

        # Update the target sequence (of length 1).

        target_seq = np.zeros((1, 1, num_decoder_tokens))

        target_seq[0, 0, sampled_token_index] = 1.

        # Update states

        states_value = [h, c]

    return decoded_sentence

আউটপুটে আমরা বেশ ভালো ফলাফল পেয়েছি - কারণ আমরা ট্রেনিং থেকে নেওয়া বাক্যগুলি ডিকোড করেছি । তবে এর বাইরে গেলে কি হবে তা পরবর্তী পর্বের আলোচনায় থাকবে আশা করছি।

আউটপুট :

Input sentence: Be nice.

Decoded sentence: Soyez gentil !

-

Input sentence: Drop it!

Decoded sentence: Laissez tomber !

-

Input sentence: Get out!

Decoded sentence: Sortez !

Reference:

• Sequence to Sequence Learning with Neural Networks

• Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation