def length(sequence): ##Zero padding to fit the max lenght... Question whether that is a good idea.
        used = tf.sign(tf.reduce_max(tf.abs(sequence), reduction_indices=2))
        length = tf.reduce_sum(used, reduction_indices=1)
        length = tf.cast(length, tf.int32)
        return length

    def cost(output, target):
        # Compute cross entropy for each frame.
        print output
        cross_entropy = target * tf.log(output)
        print "Hello world"
        cross_entropy = -tf.reduce_sum(cross_entropy, reduction_indices=2)
        mask = tf.sign(tf.reduce_max(tf.abs(target), reduction_indices=2))
        cross_entropy *= mask
        # Average over actual sequence lengths.
        cross_entropy = tf.reduce_sum(cross_entropy, reduction_indices=1)
        cross_entropy /= tf.reduce_sum(mask, reduction_indices=1)
        return tf.reduce_mean(cross_entropy)

    def last_relevant(output):
        max_length = int(output.get_shape()[1])
        relevant = tf.reduce_sum(tf.mul(output, tf.expand_dims(tf.one_hot(length(output), max_length), -1)), 1)
        return relevant

    files_train_path = [dnn_train+f for f in listdir(dnn_train) if isfile(join(dnn_train, f))]
    files_test_path = [dnn_test+f for f in listdir(dnn_test) if isfile(join(dnn_test, f))]

    files_train_name = [f for f in listdir(dnn_train) if isfile(join(dnn_train, f))]
    files_test_name = [f for f in listdir(dnn_test) if isfile(join(dnn_test, f))]

    os.chdir(dnn_train)

    train_name,train_data = generate_list_of_names_data(files_train_path)
    train_data, train_names, train_output_data, train_class_output = load_sound_files(files_train_path,train_name,train_data)

    max_length = 0 ## Used for variable sequence input

    for element in train_data:
        if element.size > max_length:
            max_length = element.size

    NUM_EXAMPLES = len(train_data)/2

    test_data = train_data[NUM_EXAMPLES:]
    test_output = train_output_data[NUM_EXAMPLES:]

    train_data = train_data[:NUM_EXAMPLES]
    train_output = train_output_data[:NUM_EXAMPLES]
    print("--- %s seconds ---" % (time.time() - start_time))

    #----------------------------------------------------------------------#
    #----------------------------Main--------------------------------------#
    ### Tensorflow neural network setup

    batch_size = None
    sequence_length_max = max_length
    input_dimension=1

    data = tf.placeholder(tf.float32,[batch_size,sequence_length_max,input_dimension])
    target = tf.placeholder(tf.float32,[None,14])

    num_hidden = 24 ## Hidden layer
    cell = tf.nn.rnn_cell.LSTMCell(num_hidden,state_is_tuple=True)  ## Long short term memory

    output, state = tf.nn.dynamic_rnn(cell, data, dtype=tf.float32,sequence_length = length(data))  ## Creates the Rnn skeleton

    last = last_relevant(output)#tf.gather(val, int(val.get_shape()[0]) - 1) ## Appedning as last

    weight = tf.Variable(tf.truncated_normal([num_hidden, int(target.get_shape()[1])]))
    bias = tf.Variable(tf.constant(0.1, shape=[target.get_shape()[1]]))

    prediction = tf.nn.softmax(tf.matmul(last, weight) + bias)

    cross_entropy = cost(output,target)# How far am I from correct value?

    optimizer = tf.train.AdamOptimizer() ## TensorflowOptimizer
    minimize = optimizer.minimize(cross_entropy)

    mistakes = tf.not_equal(tf.argmax(target, 1), tf.argmax(prediction, 1))
    error = tf.reduce_mean(tf.cast(mistakes, tf.float32))

    ## Training ##

    init_op = tf.initialize_all_variables()
    sess = tf.Session()
    sess.run(init_op)

    batch_size = 1000
    no_of_batches = int(len(train_data)/batch_size)
    epoch = 5000
    for i in range(epoch):
        ptr = 0
        for j in range(no_of_batches):
            inp, out = train_data[ptr:ptr+batch_size], train_output[ptr:ptr+batch_size]
            ptr+=batch_size
            sess.run(minimize,{data: inp, target: out})
        print "Epoch - ",str(i)
    incorrect = sess.run(error,{data: test_data, target: test_output})
    print('Epoch {:2d} error {:3.1f}%'.format(i + 1, 100 * incorrect))
    sess.close()