# input shape: (batch_size, seq_width, embedding_size) ==> (seq_width, batch_size, embedding_size)

inputs = tf.transpose(inputs, [1, 0, 2])

# Reshape before feeding to hidden activation layers

inputs = tf.reshape(inputs, [-1, embedding_size])

# Hidden activation

#inputs = tf.nn.relu(tf.matmul(inputs, weights['hidden']) + biases['hidden'])

# Split the inputs to make a list of inputs for the rnn

inputs = tf.split(0, seq_width, inputs) # seq_width * (batch_size, n_hidden)

initializer = tf.random_uniform_initializer(-1,1)

with tf.variable_scope('forward'):

#fw_cell = rnn_cell.BasicLSTMCell(n_hidden, forget_bias=1.0)

fw_cell = rnn_cell.LSTMCell(n_hidden, embedding_size, initializer=initializer)

with tf.variable_scope('backward'):

#bw_cell = rnn_cell.BasicLSTMCell(n_hidden, forget_bias=1.0)

bw_cell = rnn_cell.LSTMCell(n_hidden, embedding_size, initializer=initializer)

# Get lstm cell output

outputs,_,_ = rnn.bidirectional_rnn(fw_cell, bw_cell, inputs, dtype="float32", sequence_length=_seq_length)

outputs_tensor = tf.reshape(tf.concat(0, outputs),[-1, 2*n_hidden])

logits = []

for i in xrange(len(outputs)):

final_transformed_val = tf.matmul(outputs[i],weights['out']) + biases['out']

'''

# TODO replace with zeroes where sentences are shorter and biases should not be calculated

for length in tf_train_seq_length:

tf.shape()

if length <= i:

final_transformed_val[tf_train_seq_length.index(length)] = empty_pos

'''

logits.append(final_transformed_val)

logits = tf.reshape(tf.concat(0, logits), [-1, n_classes])

train_data = np.empty([batch_size, seq_width, embedding_size], dtype=float)

train_labels = np.empty([batch_size, seq_width, n_classes])

seq_length = np.empty([batch_size])

batch = train_data_list[offset:(offset+batch_size)]

for count, sent in enumerate(batch):

if len(sent) > 50:

sent = sent[:50]

'''

sent_padded = [embeddings[word_to_embedding[word.lower()]] if word.lower() in word_to_embedding

else embeddings[word_to_embedding["UNK"]] for word,_ in sent] \

+ (seq_width-len(sent)) * [empty_embedding]

'''

# Use lemmas of words, or their mean vectors if multiple lemmas found

sent_padded = []

for word,_ in sent:

final_lemma = np.zeros(embedding_size)

word = word.lower().encode("utf8")

if word in morpho_dict:

lemmas = morpho_dict[word]

if len(lemmas) > 0:

for lemma in lemmas:

final_lemma = np.add(final_lemma, embeddings[word_to_embedding[lemma]] if lemma in word_to_embedding else embeddings[word_to_embedding["UNK"]])

final_lemma = final_lemma/len(lemmas)

else:

final_lemma = embeddings[word_to_embedding["UNK"]]

else:

final_lemma = embeddings[word_to_embedding["UNK"]]

sent_padded.append(final_lemma)

sent_padded = sent_padded + (seq_width-len(sent)) * [empty_embedding]

sent_array = np.asarray(sent_padded)

train_data[count] = sent_array

train_labels_sent = [pos_dict[label] for _,label in sent] + (seq_width-len(sent)) * [empty_pos]

train_labels[count] = train_labels_sent

seq_length[count] = len(sent)

reshaped_labels = np.reshape(np.transpose(labels, (1,0,2)), (-1,n_classes))

matching_cases = 0

eval_cases = 0

# Do not count results beyond the end of a sentence (in the case of sentences shorter than 50 words)

for i in xrange(reshaped_labels.shape[0]):

# If all values in a gold POS label are zeros, skip this calculation

if max(reshaped_labels[i]) == 0:

continue

if np.argmax(reshaped_labels[i]) == np.argmax(predictions[i]):

matching_cases+=1

eval_cases+=1

return (100.0 * matching_cases) / eval_cases

'''

# for debugging:

argmax1 = np.argmax(predictions,1)

reshaped_labels = np.reshape(np.transpose(labels, (1,0,2)), (-1,n_classes))

argmax2 = np.argmax(reshaped_labels,1)

comparison = (argmax1 == argmax2)

sum = np.sum(comparison)

return (100.0 * sum) / predictions.shape[0]

#return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(np.reshape(labels, (-1, n_classes)), 1))

# / predictions.shape[0])