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

আমি যদি একটি এলএসটিএম এর পরিবর্তে জিআরইউ লেয়ারটি ব্যবহার করতে চাই তবে কী হবে?

এটি আসলে কিছুটা সহজ, কারণ জিআরইউর একটি মাত্র ধাপ আছে, যেখানে এলএসটিএমের দুটি ধাপ আছে। জিআরইউ লেয়ারটি ব্যবহার করতে লারনিং মডেলটি কীভাবে পরিবর্তন করতে হয় তা নিচে দেওয়া হলোঃ

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

encoder = GRU(latent_dim, return_state=True)

encoder_outputs, state_h = encoder(encoder_inputs)

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

decoder_gru = GRU(latent_dim, return_sequences=True)

decoder_outputs = decoder_gru(decoder_inputs, initial_state=state_h)

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

decoder_outputs = decoder_dense(decoder_outputs)

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

আমি যদি পূর্ণসংখ্যার সিরিজ সহ শব্দের মডেলটি ব্যবহার করতে চাই তবে কী হবে?

আপনার ইনপুটগুলি যদি পূর্ণসংখ্যার সিরিজ হয় (যেমন শব্দের ধারাগুলি উদাহরণ সরূপ বাক্য উপস্থাপিত করে, ডিকশনারিতে তাদের ইনডেক্সিং করে এনকোড করা হয়েছে)? আপনি একটি এম্বেডিং ধাপের মাধ্যমে এই পূর্ণসংখ্যা টোকেনগুলি এম্বেড করতে পারেন। নিচে কোডটি দেওয়া হলোঃ

# Define an input sequence and process it.

encoder_inputs = Input(shape=(None,))

x = Embedding(num_encoder_tokens, latent_dim)(encoder_inputs)

x, state_h, state_c = LSTM(latent_dim,

                           return_state=True)(x)

encoder_states = [state_h, state_c]

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

decoder_inputs = Input(shape=(None,))

x = Embedding(num_decoder_tokens, latent_dim)(decoder_inputs)

x = LSTM(latent_dim, return_sequences=True)(x, initial_state=encoder_states)

decoder_outputs = Dense(num_decoder_tokens, activation='softmax')(x)

# Define the model that will turn

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

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

# Compile & run training

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

# Note that `decoder_target_data` needs to be one-hot encoded,

# rather than sequences of integers like `decoder_input_data`!

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

          batch_size=batch_size,

          epochs=epochs,

          validation_split=0.2)

যদি আমি মডেলকে ফোর্স ট্রেনিং করতে না চাই তবে কী হবে?

কিছু ক্ষেত্রে আপনি মডেলকে ফোর্স ট্রেনিং করাতে পারবেন না, কারণ আপনার সম্পূর্ণ আউটপুট সিকোয়েন্সগুলিতে অ্যাক্সেস নেই, যেমন ধরেন, যদি আপনি খুব দীর্ঘ সিকোয়েন্সগুলিতে অনলাইনে ট্রেনিং দিচ্ছেন, যেখানে সম্পূর্ণ ইনপুট-টার্গেট জোড়া বাফার করা অসম্ভব। সেক্ষেত্রে আপনি ডিকোডারের ইনপুটে ডিকোডারের প্রেডিকশন আবার বাদ দিয়ে ট্রেনিং করাতে পারেন, যেমন আমরা ইনফারেনছ এর জন্য করেছিলাম।

আপনি এমন একটি মডেল তৈরি  করতে পারেন যা কি না অউটপুট কে হার্ড-কোড করে লুপ থেক বের হয়ে যেতে পারেঃ

from keras.layers import Lambda

from keras import backend as K

# The first part is unchanged

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

encoder = LSTM(latent_dim, return_state=True)

encoder_outputs, state_h, state_c = encoder(encoder_inputs)

states = [state_h, state_c]

# Set up the decoder, which will only process one timestep at a time.

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

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

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

all_outputs = []

inputs = decoder_inputs

for _ in range(max_decoder_seq_length):

    # Run the decoder on one timestep

    outputs, state_h, state_c = decoder_lstm(inputs,

                                             initial_state=states)

    outputs = decoder_dense(outputs)

    # Store the current prediction (we will concatenate all predictions later)

    all_outputs.append(outputs)

    # Reinject the outputs as inputs for the next loop iteration

    # as well as update the states

    inputs = outputs

    states = [state_h, state_c]

# Concatenate all predictions

decoder_outputs = Lambda(lambda x: K.concatenate(x, axis=1))(all_outputs)

# Define and compile model as previously

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

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

# Prepare decoder input data that just contains the start character

# Note that we could have made it a constant hard-coded in the model

decoder_input_data = np.zeros((num_samples, 1, num_decoder_tokens))

decoder_input_data[:, 0, target_token_index['\t']] = 1.

# Train model as previously

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

          batch_size=batch_size,

          epochs=epochs,

          validation_split=0.2)