working on bidirectional lstm

class default_trainer(object):

    train_on = True

    padding = 0

    end_of_sentence = 1

    vocab_size = 10  # a word size

    input_embedding_size = 20  # length of the charater

    encoder_hidden_units = 20

    decoder_hidden_units = encoder_hidden_units * 2

'''

from lstm.configuration import current as config

import lstm.Readers as reader

from tensorflow.python.ops.rnn_cell import LSTMCell, LSTMStateTuple

#def train(config)

#instanziiert das model mit hife der config

#   holt auch die data aus dem ordner der in der config festgelegt ist

def train():

    # TODO split into sub functions

    # this is a tutorial of Siraj Raval! 

    train_vocabulary = reader.get_vocabulary(config.path.read_train)

    print(train_vocabulary)

    tf.__version__

    tf.reset_default_graph()

    sess = tf.InteractiveSession()

    # placeholders

    encoder_inputs = tf.placeholder(shape=(None, None), dtype=tf.int32, name='encoder_inputs')

    encoder_inputs_length = tf.placeholder(shape=(None, ), dtype=tf.int32, name='encoder_inputs_length')

    decoder_targets = tf.placeholder(shape=(None, None), dtype=tf.int32, name='decoder_targets')

    #embeddings

    embeddings = tf.Variable(tf.random_uniform([config.trainer.vocab_size, config.trainer.input_embedding_size], -1.0, 1.0), dtype=tf.float32)

    encoder_inputs_embedded = tf.nn.embedding_lookup(embeddings, encoder_inputs)

    #define encoder

    encoder_cell = LSTMCell(config.trainer.encoder_hidden_units) #each cell each neuron is an lstm itself!

    #dynamic RNN

    # normal rnn only takes the past into account a dynamic RNN does take the future into account

    # biodirectional LSTM

    ((encoder_fw_outputs, encoder_bw_outputs), (encoder_fw_final_state, encoder_bw_final_state)) = (

        tf.nn.bidirectional_dynamic_rnn(cell_fw=encoder_cell,

        cell_bw=encoder_cell,

        inputs=encoder_inputs_embedded,

        sequence_length=encoder_inputs_length,

        dtype=tf.float64, time_major=True)

    )

    #bidirectional step1

    #encoder_outputs = tf.concat((encoder_fw_outputs, encoder_bw_outputs, 2))

    encoder_final_state_c = tf.concat((encoder_fw_final_state.c, encoder_bw_final_state.c, 1))

    encoder_final_state_h = tf.concat((encoder_fw_final_state.h, encoder_bw_final_state.h, 1))

    #TF Tuple by LSTM Cells for state size, zerostate and output state

    encoder_final_state = LSTMStateTuple(

        c=encoder_final_state_c,

        h=encoder_final_state_h

    )

    #decoder

    decoder_cell = LSTMCell(decoder_hidden_units)

    encoder_max_time, config.trainer.batch_size = tf.unstack(tf.shape(encoder_inputs))

    decoder_lengths = encoder_inputs_length + 3