def graph(): """ Function to encapsulate the construction of a TensorFlow computation graph. :return: input placeholders, optimisation operation, loss, accuracy, prediction operations """ # Define placeholders for the data # The sentence to classify, has shape [batch_size x word_dimensions*2] because the input will be the sentence # and abstract concatenated. sentence_input = tf.placeholder(tf.float32, shape=[None, WORD_DIMENSIONS + ABSTRACT_DIMENSION + NUM_FEATURES]) # The labels for the sentences as one-hot vectors, of the form [batch_size x num_classes] labels = tf.placeholder(tf.float32, shape=[None, NUM_CLASSES]) # Keep probability for dropout keep_prob = tf.placeholder(tf.float32) # Define the computation graph # The keep gate - decides which parts to keep hidden_weight = weight_variable([WORD_DIMENSIONS + ABSTRACT_DIMENSION + NUM_FEATURES, HIDDEN_LAYER_WEIGHTS]) hidden_bias = bias_variable([HIDDEN_LAYER_WEIGHTS]) hidden_layer = tf.nn.relu(tf.matmul(sentence_input, hidden_weight) + hidden_bias) # Add dropout hidden_layer_output = tf.nn.dropout(hidden_layer, keep_prob) # Project the output to two classes projection_weight = weight_variable([HIDDEN_LAYER_WEIGHTS, NUM_CLASSES]) projection_bias = bias_variable([NUM_CLASSES]) output = tf.matmul(hidden_layer_output, projection_weight) + projection_bias # Define the loss function loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(output, labels)) opt = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss) # Predictions predictions = tf.nn.softmax(output) # Calculate accuracy pred_answers = tf.argmax(output, axis=1) correct_answers = tf.argmax(labels, axis=1) accuracy = tf.reduce_mean(tf.cast(tf.equal(pred_answers, correct_answers), tf.float32)) return_dict = { "input": sentence_input, "labels": labels, "keep_prob": keep_prob, "loss": loss, "opt": opt, "prediction_probs": predictions, "prediction_class": pred_answers, "correct_answers": correct_answers, "accuracy": accuracy } return return_dict
def graph(): """ Function to encapsulate the construction of a TensorFlow computation graph. :return: input placeholders, optimisation operation, loss, accuracy, prediction operations """ # Define placeholders for the data # The sentence to classify, has shape [batch_size x word_dimensions*2] because the input will be the sentence # and abstract concatenated. sentence_input = tf.placeholder( tf.float32, shape=[None, WORD_DIMENSIONS + ABSTRACT_DIMENSION + NUM_FEATURES]) # The labels for the sentences as one-hot vectors, of the form [batch_size x num_classes] labels = tf.placeholder(tf.float32, shape=[None, NUM_CLASSES]) # Keep probability for dropout keep_prob = tf.placeholder(tf.float32) # Define the computation graph W_conv1 = weight_variable([5, 5, 1, 32]) b_conv1 = bias_variable([32]) x_image = tf.reshape(sentence_input, [-1, 8, 26, 1]) h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) h_pool1 = max_pool_2x2(h_conv1) W_fc1 = weight_variable([4 * 13 * 32, HIDDEN_LAYER_WEIGHTS]) b_fc1 = bias_variable([HIDDEN_LAYER_WEIGHTS]) h_pool1_flat = tf.reshape(h_pool1, [-1, 4 * 13 * 32]) h_fc1 = tf.nn.relu(tf.matmul(h_pool1_flat, W_fc1) + b_fc1) h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob) W_fc2 = weight_variable([HIDDEN_LAYER_WEIGHTS, NUM_CLASSES]) b_fc2 = bias_variable([NUM_CLASSES]) output = tf.matmul(h_fc1_drop, W_fc2) + b_fc2 # Define the loss function loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(output, labels)) opt = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss) # Predictions predictions = tf.nn.softmax(output) # Calculate accuracy pred_answers = tf.argmax(output, axis=1) correct_answers = tf.argmax(labels, axis=1) accuracy = tf.reduce_mean( tf.cast(tf.equal(pred_answers, correct_answers), tf.float32)) return sentence_input, labels, keep_prob, loss, opt, predictions, pred_answers, correct_answers, accuracy
def graph(): # Define placeholders for the data # The sentence to classify, has shape [batch_size x word_dimensions] sentence_input = tf.placeholder(tf.float32, shape=[None, WORD_DIMENSIONS]) # The labels for the sentences as one-hot vectors, of the form [batch_size x num_classes] labels = tf.placeholder(tf.float32, shape=[None, NUM_CLASSES]) # Keep probability for dropout keep_prob = tf.placeholder(tf.float32) # Define the computation graph # Linear transformation sent_weight = weight_variable([WORD_DIMENSIONS, HIDDEN_LAYER_WEIGHTS]) sent_bias = bias_variable([HIDDEN_LAYER_WEIGHTS]) sentence_gate = tf.nn.sigmoid( tf.matmul(sentence_input, sent_weight) + sent_bias) # Add ReLU non-linearity hidden_layer = tf.nn.relu(sentence_gate) # Projection to output classes output_weights = weight_variable([HIDDEN_LAYER_WEIGHTS, NUM_CLASSES]) output_bias = bias_variable([NUM_CLASSES]) output = tf.matmul(hidden_layer, output_weights) + output_bias # Add dropout for regularisation output = tf.nn.dropout(output, keep_prob=keep_prob) # Define the loss function loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(output, labels)) opt = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss) # Predictions predictions = tf.nn.softmax(output) # Calculate accuracy pred_answers = tf.argmax(output, axis=1) correct_answers = tf.argmax(labels, axis=1) accuracy = tf.reduce_mean( tf.cast(tf.equal(pred_answers, correct_answers), tf.float32)) return_dict = { "sentence_input": sentence_input, "labels": labels, "keep_prob": keep_prob, "loss": loss, "opt": opt, "prediction_probs": predictions, "prediction_class": pred_answers, "correct_answers": correct_answers, "accuracy": accuracy } return return_dict
def graph(): """ Function to encapsulate the construction of a TensorFlow computation graph. :return: input placeholders, optimisation operation, loss, accuracy, prediction operations """ # Define placeholders for the data # The sentence to classify, has shape [batch_size x word_dimensions*2] because the input will be the sentence # and abstract concatenated. sentence_input = tf.placeholder(tf.float32, shape=[None, WORD_DIMENSIONS*2]) # The labels for the sentences as one-hot vectors, of the form [batch_size x num_classes] labels = tf.placeholder(tf.float32, shape=[None, NUM_CLASSES]) # Keep probability for dropout keep_prob = tf.placeholder(tf.float32) # Define the computation graph # The keep gate - decides which parts to keep keep_weight = weight_variable([WORD_DIMENSIONS*2, SENTENCE_WEIGHTS]) keep_bias = bias_variable([SENTENCE_WEIGHTS]) keep_gate = tf.nn.sigmoid(tf.matmul(sentence_input, keep_weight) + keep_bias) # Project the output to a 100 dimensional vector projection_weight = weight_variable([SENTENCE_WEIGHTS, WORD_DIMENSIONS]) projection_bias = bias_variable([WORD_DIMENSIONS]) combined_information = tf.nn.relu(tf.matmul(keep_gate, projection_weight) + projection_bias) # Add a ReLU layer to this classification_layer_weights = weight_variable([WORD_DIMENSIONS, HIDDEN_LAYER_WEIGHTS]) classification_layer_bias = bias_variable([HIDDEN_LAYER_WEIGHTS]) classification_layer = tf.nn.relu(tf.matmul(combined_information, classification_layer_weights) + classification_layer_bias) # Add dropout hidden_layer_output = tf.nn.dropout(classification_layer, keep_prob) # Project to two classes final_layer_weights = weight_variable([HIDDEN_LAYER_WEIGHTS, NUM_CLASSES]) final_layer_bias = bias_variable([NUM_CLASSES]) output = tf.matmul(classification_layer, final_layer_weights) + final_layer_bias # Define the loss function loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(output, labels)) opt = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss) # Predictions predictions = tf.nn.softmax(output) # Calculate accuracy pred_answers = tf.argmax(output, axis=1) correct_answers = tf.argmax(labels, axis=1) accuracy = tf.reduce_mean(tf.cast(tf.equal(pred_answers, correct_answers), tf.float32)) return sentence_input, labels, keep_prob, loss, opt, predictions, pred_answers, correct_answers, accuracy
def graph_vis(): # Define placeholders for the data # The sentence to classify, has shape [batch_size x word_dimensions] sentence_input = tf.placeholder(tf.float32, shape=[None, NUM_FEATURES]) # The labels for the sentences as one-hot vectors, of the form [batch_size x num_classes] labels = tf.placeholder(tf.float32, shape=[None, NUM_CLASSES]) # Define the computation graph # Linear layer sent_weight = weight_variable([NUM_FEATURES, HIDDEN_LAYER_WEIGHTS]) sent_bias = bias_variable([HIDDEN_LAYER_WEIGHTS]) # ReLU hidden_layer = tf.nn.relu( tf.matmul(sentence_input, sent_weight) + sent_bias) # Down to num features down_to_feats = tf.contrib.layers.linear(hidden_layer, NUM_FEATURES) # Project to two classes projection_weight = weight_variable([NUM_FEATURES, NUM_CLASSES]) projection_bias = bias_variable([NUM_CLASSES]) output = tf.matmul(down_to_feats, projection_weight) + projection_bias # Define the loss function loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(output, labels)) opt = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss) # Predictions predictions = tf.nn.softmax(output) # Calculate accuracy pred_answers = tf.argmax(output, axis=1) correct_answers = tf.argmax(labels, axis=1) accuracy = tf.reduce_mean( tf.cast(tf.equal(pred_answers, correct_answers), tf.float32)) return_dict = { "features_input": sentence_input, "labels": labels, "loss": loss, "opt": opt, "prediction_probs": predictions, "prediction_class": pred_answers, "correct_answers": correct_answers, "accuracy": accuracy, "extra": projection_weight } return return_dict
def graph(): # Define placeholders for the data # The sentence to classify, has shape [batch_size x word_dimensions] sentence_input = tf.placeholder(tf.float32, shape=[None, NUM_FEATURES]) # The labels for the sentences as one-hot vectors, of the form [batch_size x num_classes] labels = tf.placeholder(tf.float32, shape=[None, NUM_CLASSES]) # Define the computation graph # Linear layer sent_weight = weight_variable([NUM_FEATURES, NUM_CLASSES]) sent_bias = bias_variable([NUM_CLASSES]) output = tf.matmul(sentence_input, sent_weight) + sent_bias # Define the loss function loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(output, labels)) opt = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss) # Predictions predictions = tf.nn.softmax(output) # Calculate accuracy pred_answers = tf.argmax(output, axis=1) correct_answers = tf.argmax(labels, axis=1) accuracy = tf.reduce_mean( tf.cast(tf.equal(pred_answers, correct_answers), tf.float32)) return sentence_input, labels, loss, opt, predictions, pred_answers, correct_answers, accuracy, sent_weight
def graph(): """ Function to encapsulate the construction of a TensorFlow computation graph. :return: input placeholders, optimisation operation, loss, accuracy, prediction operations """ # Define placeholders for the data # The sentence to classify, has shape [batch_size x word_dimensions*2] because the input will be the sentence # and abstract concatenated. sentence_input = tf.placeholder( tf.float32, shape=[None, WORD_DIMENSIONS + ABSTRACT_DIMENSION + NUM_FEATURES]) # The labels for the sentences as one-hot vectors, of the form [batch_size x num_classes] labels = tf.placeholder(tf.float32, shape=[None, NUM_CLASSES]) # Define the computation graph # The keep gate - decides which parts to keep keep_weight = weight_variable( [WORD_DIMENSIONS + ABSTRACT_DIMENSION + NUM_FEATURES, NUM_CLASSES]) keep_bias = bias_variable([NUM_CLASSES]) output = tf.matmul(sentence_input, keep_weight) + keep_bias # Define the loss function loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(output, labels)) opt = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss) # Predictions predictions = tf.nn.softmax(output) # Calculate accuracy pred_answers = tf.argmax(output, axis=1) correct_answers = tf.argmax(labels, axis=1) accuracy = tf.reduce_mean( tf.cast(tf.equal(pred_answers, correct_answers), tf.float32)) return sentence_input, labels, loss, opt, predictions, pred_answers, correct_answers, accuracy
# =========================================== # ================ MAIN ================ # Define placeholders for the data # The sentence to classify, has shape [batch_size x word_dimensions] sentence_input = tf.placeholder(tf.float32, shape=[None, WORD_DIMENSIONS]) # The labels for the sentences as one-hot vectors, of the form [batch_size x num_classes] labels = tf.placeholder(tf.float32, shape=[None, NUM_CLASSES]) # Define the computation graph # Linear layer sent_weight = weight_variable([WORD_DIMENSIONS, NUM_CLASSES]) sent_bias = bias_variable([NUM_CLASSES]) output = tf.matmul(sentence_input, sent_weight) + sent_bias # Define the loss function loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(output, labels)) opt = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss) # Predictions predictions = tf.nn.softmax(output) # Calculate accuracy pred_answers = tf.argmax(output, axis=1) correct_answers = tf.argmax(labels, axis=1) accuracy = tf.reduce_mean(