Dbritz_ModifiedBram/eval.py at master · BramKasteel/Dbritz_ModifiedBram · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
#! /usr/bin/env python

import tensorflow as tf
import numpy as np
import os
import time
import datetime
import data_helpers
from text_cnn import TextCNN
from tensorflow.contrib import learn
import csv

# Parameters
# ==================================================

#TODO: update this function to also test on own datafiles

# Data Parameters
tf.flags.DEFINE_string("positive_data_file", "./data/rt-polaritydata/rt-polarity.pos", "Data source for the positive data.")
tf.flags.DEFINE_string("negative_data_file", "./data/rt-polaritydata/rt-polarity.neg", "Data source for the negative data.")

# Eval Parameters
tf.flags.DEFINE_integer("batch_size", 64, "Batch Size (default: 64)")
tf.flags.DEFINE_string("checkpoint_dir", "", "Checkpoint directory from training run")
tf.flags.DEFINE_boolean("eval_train", False, "Evaluate on all training data")
tf.flags.DEFINE_string("dev_set","","Datafile for testing accuracy of model")

# Misc Parameters
tf.flags.DEFINE_boolean("allow_soft_placement", True, "Allow device soft device placement")
tf.flags.DEFINE_boolean("log_device_placement", False, "Log placement of ops on devices")


FLAGS = tf.flags.FLAGS
FLAGS._parse_flags()
print("\nParameters:")
for attr, value in sorted(FLAGS.__flags.items()):
    print("{}={}".format(attr.upper(), value))
print("")

# CHANGE THIS: Load data. Load your own data here
if FLAGS.eval_train:
    x_raw, y_test = data_helpers.load_data_and_labels(FLAGS.positive_data_file, FLAGS.negative_data_file)
    y_test = np.argmax(y_test, axis=1)
    # Map data into vocabulary
    vocab_path = os.path.join(FLAGS.checkpoint_dir, "..", "vocab")
    vocab_processor = learn.preprocessing.VocabularyProcessor.restore(vocab_path)
    x_test = np.array(list(vocab_processor.transform(x_raw)))
else:
    x_test, y_test = data_helpers.load_dev_set(os.path.abspath(FLAGS.dev_set))
    y_test = np.argmax(y_test, axis=1)
    # Transform back to real words
    vocab_path = os.path.join(FLAGS.checkpoint_dir, "..", "vocab")
    vocab_processor = learn.preprocessing.VocabularyProcessor.restore(vocab_path)
    x_raw = np.array(list(vocab_processor.reverse(x_test)))  #TODO: remove <UNK>'s


print("\nEvaluating...\n")

# Evaluation
# ==================================================
#checkpoint_file = tf.train.latest_checkpoint(FLAGS.checkpoint_dir)
#Use best performing network
checkpoint_file = os.path.abspath(FLAGS.checkpoint_dir + "modelbest")


#graph = tf.Graph()
#with graph.as_default():
#    session_conf = tf.ConfigProto(
#      allow_soft_placement=FLAGS.allow_soft_placement,
#      log_device_placement=FLAGS.log_device_placement)
#    sess = tf.Session(config=session_conf)
#    with sess.as_default():
#        # Load the saved meta graph and restore variables
#        saver = tf.train.import_meta_graph("{}.meta".format(checkpoint_file))
#        saver.restore(sess, checkpoint_file)
#
#        # Get the placeholders from the graph by name
#        input_x = graph.get_operation_by_name("input_x").outputs[0]
#        # input_y = graph.get_operation_by_name("input_y").outputs[0]
#        dropout_keep_prob = graph.get_operation_by_name("dropout_keep_prob").outputs[0]
#
#        # Tensors we want to evaluate
#        predictions = graph.get_operation_by_name("output/predictions").outputs[0]
#
#        # Generate batches for one epoch
#        batches = data_helpers.batch_iter(list(x_test), FLAGS.batch_size, 1, shuffle=False)
#
#        # Collect the predictions here
#        all_predictions = []
#
#        for x_test_batch in batches:
#            batch_predictions = sess.run(predictions, {input_x: x_test_batch, dropout_keep_prob: 1.0})
#            all_predictions = np.concatenate([all_predictions, batch_predictions])
#
## Print accuracy if y_test is defined
#if y_test is not None:
#    correct_predictions = float(sum(all_predictions == y_test))
#    print("Total number of test examples: {}".format(len(y_test)))
#    print("Accuracy: {:g}".format(correct_predictions/float(len(y_test))))
#
##TODO: remove <UNK>s
## Save the evaluation to a csv
#predictions_human_readable = np.column_stack((np.array(x_raw), all_predictions))
#out_path = os.path.join(FLAGS.checkpoint_dir, "..", "prediction.csv")
#print("Saving evaluation to {0}".format(out_path))
#with open(out_path, 'w') as f:
#    csv.writer(f).writerows(predictions_human_readable)
#

#New feature: get the argmax of the pooling layer and the corresponding words
graph = tf.Graph()
with graph.as_default():
    session_conf = tf.ConfigProto(
      allow_soft_placement=FLAGS.allow_soft_placement,
      log_device_placement=FLAGS.log_device_placement)
    sess = tf.Session(config=session_conf)
    with sess.as_default():
        # Load the saved meta graph and restore variables
        saver = tf.train.import_meta_graph("{}.meta".format(checkpoint_file))
        saver.restore(sess, checkpoint_file)

        # Get the placeholders from the graph by name
        input_x = graph.get_operation_by_name("input_x").outputs[0]
        # input_y = graph.get_operation_by_name("input_y").outputs[0]
        dropout_keep_prob = graph.get_operation_by_name("dropout_keep_prob").outputs[0]

        # Tensors we want to evaluate
        #New::::::::::::::::::::::::
        convrelu = graph.get_operation_by_name("conv-maxpool-3/relu").outputs[0]
        pooled_actual = graph.get_operation_by_name("conv-maxpool-3/pool").outputs[0]
        pooled_here = tf.nn.max_pool(
                    convrelu,
                    ksize=[1, 56 - 3 + 1, 1, 1],
                    strides=[1, 1, 1, 1],
                    padding='VALID',
                    name="Brammie")


        # Generate batches for one epoch
        batches = data_helpers.batch_iter(list(x_test), FLAGS.batch_size, 1, shuffle=False)

        # Collect the predictions here
        all_predictions = []

        for x_test_batch in batches:
            #batch_predictions = sess.run(predictions, {input_x: x_test_batch, dropout_keep_prob: 1.0})
            #all_predictions = np.concatenate([all_predictions, batch_predictions])

            batch_convrelu = sess.run(convrelu, {input_x: x_test_batch, dropout_keep_prob: 1.0})
            batch_pooled_actual = sess.run(pooled_actual, {input_x: x_test_batch, dropout_keep_prob:1.0})
            batch_pooled_here = sess.run(pooled_here, {input_x: x_test_batch, dropout_keep_prob:1.0})
            check = tf.reduce_mean(tf.cast(tf.equal(batch_pooled_actual,batch_pooled_here),tf.float32))
            print(batch_pooled_actual.shape)
            print(batch_pooled_here.shape)
            print(check.eval())     ##### SHAPOWWWWWW