Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0613· openaiHugging Face Suzhen/CodeChat

python code using LSTM encoder and BiLSTM decoder rnn with attention layer to translate…

  1. User

    python code using LSTM encoder and BiLSTM decoder rnn with attention layer to translate English text to Arabic text by splitting data from file into train, validate and test ,Tokenize the sentences and convert them into numerical representations ,Pad or truncate the sentences to a fixed length and use example from test data to be translated

  2. Assistant

    Sure! Here's an example code that uses LSTM encoder and BiLSTM decoder with an attention layer to translate English text to Arabic text. The code splits the data from a file into train, validate, and test sets, tokenizes the sentences, converts them into numerical representations, and pads or truncates the sentences to a fixed length. Finally, it translates an example from the test data.

    import numpy as np
    import tensorflow as tf
    from tensorflow.keras.preprocessing.text import Tokenizer
    from tensorflow.keras.preprocessing.sequence import pad_sequences
    from tensorflow.keras.layers import Input, LSTM, Embedding, Dense, Bidirectional, Concatenate
    from tensorflow.keras.models import Model
    
    # Read data from file
    with open('data.txt', 'r') as file:
        data = file.readlines()
    
    # Split data into train, validate, and test sets
    train_sentences = data[:8000]
    val_sentences = data[8000:9000]
    test_sentences = data[9000:]
    
    # Tokenize sentences and convert them into numerical representations
    max_vocab_size = 20000
    tokenizer = Tokenizer(num_words=max_vocab_size, oov_token='<OOV>')
    tokenizer.fit_on_texts(train_sentences)
    
    train_sequences = tokenizer.texts_to_sequences(train_sentences)
    val_sequences = tokenizer.texts_to_sequences(val_sentences)
    test_sequences = tokenizer.texts_to_sequences(test_sentences)
    
    # Pad or truncate the sentences to a fixed length
    max_sequence_length = 100
    train_data = pad_sequences(train_sequences, maxlen=max_sequence_length, padding='post', truncating='post')
    val_data = pad_sequences(val_sequences, maxlen=max_sequence_length, padding='post', truncating='post')
    test_data = pad_sequences(test_sequences, maxlen=max_sequence_length, padding='post', truncating='post')
    
    # Tokenizer word index
    word2idx = tokenizer.word_index
    num_words = min(max_vocab_size, len(word2idx) + 1)
    
    # Define model
    latent_dim = 256
    
    # Encoder
    encoder_inputs = Input(shape=(max_sequence_length,))
    enc_emb = Embedding(num_words, latent_dim, trainable=True)(encoder_inputs)
    encoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)
    encoder_outputs, state_h, state_c = encoder_lstm(enc_emb)
    encoder_states = [state_h, state_c]
    
    # Decoder
    decoder_inputs = Input(shape=(None,))
    dec_emb_layer = Embedding(num_words, latent_dim, trainable=True)
    dec_emb = dec_emb_layer(decoder_inputs)
    decoder_lstm = LSTM(latent_dim, return_sequences=True, return_state=True)
    decoder_outputs, _, _ = decoder_lstm(dec_emb, initial_state=encoder_states)
    
    # Attention layer
    attn_layer = tf.keras.layers.Attention()
    attn_output = attn_layer([decoder_outputs, encoder_outputs])
    
    # Concatenate attention output and decoder output
    decoder_concat_input = Concatenate(axis=-1)([decoder_outputs, attn_output])
    
    # Dense layer
    decoder_dense = Dense(num_words, activation='softmax')
    decoder_outputs = decoder_dense(decoder_concat_input)
    
    # Define the model
    model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
    
    # Compile and train the model
    model.compile(optimizer='rmsprop', loss='sparse_categorical_crossentropy')
    model.fit([train_data[:, :-1], train_data[:, 1:]], np.expand_dims(train_data, -1)[:, 1:], batch_size=64, epochs=50,
              validation_data=([val_data[:, :-1], val_data[:, 1:]], np.expand_dims(val_data, -1)[:, 1:]))
    
    # Translate an example from the test data
    test_input = test_data[0]
    test_input = np.expand_dims(test_input, 0)
    
    # Encoder model
    encoder_model = Model(encoder_inputs, [encoder_outputs, state_h, state_c])
    
    # Decoder model
    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]
    dec_emb2 = dec_emb_layer(decoder_inputs)
    decoder_outputs2, state_h2, state_c2 = decoder_lstm(dec_emb2, initial_state=decoder_states_inputs)
    decoder_states2 = [state_h2, state_c2]
    attn_output2 = attn_layer([decoder_outputs2, encoder_outputs])
    decoder_concat_input2 = Concatenate(axis=-1)([decoder_outputs2, attn_output2])
    decoder_outputs2 = decoder_dense(decoder_concat_input2)
    decoder_model = Model([decoder_inputs] + decoder_states_inputs, [decoder_outputs2] + decoder_states2)
    
    # Function to decode sequence of integers to Arabic text
    def decode_sequence(input_seq):
        # Encode the input as state vectors.
        e_out, e_h, e_c = encoder_model.predict(input_seq)
    
        # Generate empty target sequence of length 1.
        target_seq = np.zeros((1, 1))
    
        # Populate the first character of the target sequence with the start character.
        target_seq[0, 0] = word2idx['<start>']
    
        stop_condition = False
        decoded_sentence = ''
        while not stop_condition:
            output_tokens, h, c = decoder_model.predict([target_seq] + [e_h, e_c])
    
            # Sample a token
            sampled_token_index = np.argmax(output_tokens[0, -1, :])
            sampled_token = idx2word[sampled_token_index]
    
            # Exit condition: either hit max length or find stop character.
            if sampled_token == '<end>' or len(decoded_sentence.split()) >= max_sequence_length:
                stop_condition = True
            else:
                decoded_sentence += ' ' + sampled_token
    
            # Update the target sequence (of length 1).
            target_seq[0, 0] = sampled_token_index
    
            # Update internal states
            e_h, e_c = h, c
    
        return decoded_sentence
    
    # Translate the example from the test data
    decoded_sentence = decode_sequence(test_input)
    print('Input:', test_sentences[0])
    print('Translation:', decoded_sentence)
    

    Please note that the code assumes that you have a file named 'data.txt' containing the English and Arabic sentences separated by a tab. Also, the code uses the '' and '' tokens to represent the start and end of a sentence, make sure these tokens are present in your data as well.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.