QAPLearning/predict.py at master · OperationalResearchProject/QAPLearning · 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
importtensorflowastf
importnumpyasnp
importglob
importos
importcv2
importsys


defpredict_image(filename, sess):
image_size=128
num_channels=3
images= []
# Reading the image using OpenCV
image=cv2.imread(filename)
# Resizing the image to our desired size and preprocessing will be done exactly as done during training
image=cv2.resize(image, (image_size, image_size), 0, 0, cv2.INTER_LINEAR)
images.append(image)
images=np.array(images, dtype=np.uint8)
images=images.astype('float32')
images=np.multiply(images, 1.0/255.0)
# The input to the network is of shape [None image_size image_size num_channels]. Hence we reshape.
x_batch=images.reshape(1, image_size, image_size, num_channels)

# Accessing the default graph which we have restored
graph=tf.get_default_graph()

# Now, let's get hold of the op that we can be processed to get the output.
# In the original network y_pred is the tensor that is the prediction of the network
y_pred=graph.get_tensor_by_name("y_pred:0")

# Let's feed the images to the input placeholders
x=graph.get_tensor_by_name("x:0")
y_true=graph.get_tensor_by_name("y_true:0")
y_test_images=np.zeros((1, 2))

# Creating the feed_dict that is required to be fed to calculate y_pred
feed_dict_testing= {x: x_batch, y_true: y_test_images}
result=sess.run(y_pred, feed_dict=feed_dict_testing)
returnresult


deftest_data(testing_path, classes, session):
error=0
success=0
forclass_idx, classeinenumerate(classes):
path=os.path.dirname(os.path.realpath(__file__)) +"/"+testing_path+"/"+classe
forfileinglob.glob(path+"/*.png"):
res=predict_image(file, session)[0]
ifmax(res) ==res[class_idx]:
success+=1
else:
error+=1

returnsuccess, error


# Get Image
dir_path=os.path.dirname(os.path.realpath(__file__))

# Restore the saved model
sess=tf.Session()
# Step-1: Recreate the network graph.
saver=tf.train.import_meta_graph(dir_path+'/model-20/.meta')
# Step-2: Load the weights saved using the restore method.
saver.restore(sess, tf.train.latest_checkpoint(dir_path+'/model-20/'))

classes= ['rl', 'uni']
success, error=test_data("testing_data", classes, sess)
print(success, error)
taux=success/ (success+error)

print("Succes rate is "+str(taux))
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
importtensorflowastf
importnumpyasnp
importglob
importos
importcv2
importsys


defpredict_image(filename, sess):
image_size=128
num_channels=3
images= []
# Reading the image using OpenCV
image=cv2.imread(filename)
# Resizing the image to our desired size and preprocessing will be done exactly as done during training
image=cv2.resize(image, (image_size, image_size), 0, 0, cv2.INTER_LINEAR)
images.append(image)
images=np.array(images, dtype=np.uint8)
images=images.astype('float32')
images=np.multiply(images, 1.0/255.0)
# The input to the network is of shape [None image_size image_size num_channels]. Hence we reshape.
x_batch=images.reshape(1, image_size, image_size, num_channels)

# Accessing the default graph which we have restored
graph=tf.get_default_graph()

# Now, let's get hold of the op that we can be processed to get the output.
# In the original network y_pred is the tensor that is the prediction of the network
y_pred=graph.get_tensor_by_name("y_pred:0")

# Let's feed the images to the input placeholders
x=graph.get_tensor_by_name("x:0")
y_true=graph.get_tensor_by_name("y_true:0")
y_test_images=np.zeros((1, 2))

# Creating the feed_dict that is required to be fed to calculate y_pred
feed_dict_testing= {x: x_batch, y_true: y_test_images}
result=sess.run(y_pred, feed_dict=feed_dict_testing)
returnresult


deftest_data(testing_path, classes, session):
error=0
success=0
forclass_idx, classeinenumerate(classes):
path=os.path.dirname(os.path.realpath(__file__)) +"/"+testing_path+"/"+classe
forfileinglob.glob(path+"/*.png"):
res=predict_image(file, session)[0]
ifmax(res) ==res[class_idx]:
success+=1
else:
error+=1

returnsuccess, error


# Get Image
dir_path=os.path.dirname(os.path.realpath(__file__))

# Restore the saved model
sess=tf.Session()
# Step-1: Recreate the network graph.
saver=tf.train.import_meta_graph(dir_path+'/model-20/.meta')
# Step-2: Load the weights saved using the restore method.
saver.restore(sess, tf.train.latest_checkpoint(dir_path+'/model-20/'))

classes= ['rl', 'uni']
success, error=test_data("testing_data", classes, sess)
print(success, error)
taux=success/ (success+error)

print("Succes rate is "+str(taux))
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
importtensorflowastf
importnumpyasnp
importglob
importos
importcv2
importsys


defpredict_image(filename, sess):
image_size=128
num_channels=3
images= []
# Reading the image using OpenCV
image=cv2.imread(filename)
# Resizing the image to our desired size and preprocessing will be done exactly as done during training
image=cv2.resize(image, (image_size, image_size), 0, 0, cv2.INTER_LINEAR)
images.append(image)
images=np.array(images, dtype=np.uint8)
images=images.astype('float32')
images=np.multiply(images, 1.0/255.0)
# The input to the network is of shape [None image_size image_size num_channels]. Hence we reshape.
x_batch=images.reshape(1, image_size, image_size, num_channels)

# Accessing the default graph which we have restored
graph=tf.get_default_graph()

# Now, let's get hold of the op that we can be processed to get the output.
# In the original network y_pred is the tensor that is the prediction of the network
y_pred=graph.get_tensor_by_name("y_pred:0")

# Let's feed the images to the input placeholders
x=graph.get_tensor_by_name("x:0")
y_true=graph.get_tensor_by_name("y_true:0")
y_test_images=np.zeros((1, 2))

# Creating the feed_dict that is required to be fed to calculate y_pred
feed_dict_testing= {x: x_batch, y_true: y_test_images}
result=sess.run(y_pred, feed_dict=feed_dict_testing)
returnresult


deftest_data(testing_path, classes, session):
error=0
success=0
forclass_idx, classeinenumerate(classes):
path=os.path.dirname(os.path.realpath(__file__)) +"/"+testing_path+"/"+classe
forfileinglob.glob(path+"/*.png"):
res=predict_image(file, session)[0]
ifmax(res) ==res[class_idx]:
success+=1
else:
error+=1

returnsuccess, error


# Get Image
dir_path=os.path.dirname(os.path.realpath(__file__))

# Restore the saved model
sess=tf.Session()
# Step-1: Recreate the network graph.
saver=tf.train.import_meta_graph(dir_path+'/model-20/.meta')
# Step-2: Load the weights saved using the restore method.
saver.restore(sess, tf.train.latest_checkpoint(dir_path+'/model-20/'))

classes= ['rl', 'uni']
success, error=test_data("testing_data", classes, sess)
print(success, error)
taux=success/ (success+error)

print("Succes rate is "+str(taux))
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
importtensorflowastf
importnumpyasnp
importglob
importos
importcv2
importsys


defpredict_image(filename, sess):
image_size=128
num_channels=3
images= []
# Reading the image using OpenCV
image=cv2.imread(filename)
# Resizing the image to our desired size and preprocessing will be done exactly as done during training
image=cv2.resize(image, (image_size, image_size), 0, 0, cv2.INTER_LINEAR)
images.append(image)
images=np.array(images, dtype=np.uint8)
images=images.astype('float32')
images=np.multiply(images, 1.0/255.0)
# The input to the network is of shape [None image_size image_size num_channels]. Hence we reshape.
x_batch=images.reshape(1, image_size, image_size, num_channels)

# Accessing the default graph which we have restored
graph=tf.get_default_graph()

# Now, let's get hold of the op that we can be processed to get the output.
# In the original network y_pred is the tensor that is the prediction of the network
y_pred=graph.get_tensor_by_name("y_pred:0")

# Let's feed the images to the input placeholders
x=graph.get_tensor_by_name("x:0")
y_true=graph.get_tensor_by_name("y_true:0")
y_test_images=np.zeros((1, 2))

# Creating the feed_dict that is required to be fed to calculate y_pred
feed_dict_testing= {x: x_batch, y_true: y_test_images}
result=sess.run(y_pred, feed_dict=feed_dict_testing)
returnresult


deftest_data(testing_path, classes, session):
error=0
success=0
forclass_idx, classeinenumerate(classes):
path=os.path.dirname(os.path.realpath(__file__)) +"/"+testing_path+"/"+classe
forfileinglob.glob(path+"/*.png"):
res=predict_image(file, session)[0]
ifmax(res) ==res[class_idx]:
success+=1
else:
error+=1

returnsuccess, error


# Get Image
dir_path=os.path.dirname(os.path.realpath(__file__))

# Restore the saved model
sess=tf.Session()
# Step-1: Recreate the network graph.
saver=tf.train.import_meta_graph(dir_path+'/model-20/.meta')
# Step-2: Load the weights saved using the restore method.
saver.restore(sess, tf.train.latest_checkpoint(dir_path+'/model-20/'))

classes= ['rl', 'uni']
success, error=test_data("testing_data", classes, sess)
print(success, error)
taux=success/ (success+error)

print("Succes rate is "+str(taux))
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
importtensorflowastf
importnumpyasnp
importglob
importos
importcv2
importsys


defpredict_image(filename, sess):
image_size=128
num_channels=3
images= []
# Reading the image using OpenCV
image=cv2.imread(filename)
# Resizing the image to our desired size and preprocessing will be done exactly as done during training
image=cv2.resize(image, (image_size, image_size), 0, 0, cv2.INTER_LINEAR)
images.append(image)
images=np.array(images, dtype=np.uint8)
images=images.astype('float32')
images=np.multiply(images, 1.0/255.0)
# The input to the network is of shape [None image_size image_size num_channels]. Hence we reshape.
x_batch=images.reshape(1, image_size, image_size, num_channels)

# Accessing the default graph which we have restored
graph=tf.get_default_graph()

# Now, let's get hold of the op that we can be processed to get the output.
# In the original network y_pred is the tensor that is the prediction of the network
y_pred=graph.get_tensor_by_name("y_pred:0")

# Let's feed the images to the input placeholders
x=graph.get_tensor_by_name("x:0")
y_true=graph.get_tensor_by_name("y_true:0")
y_test_images=np.zeros((1, 2))

# Creating the feed_dict that is required to be fed to calculate y_pred
feed_dict_testing= {x: x_batch, y_true: y_test_images}
result=sess.run(y_pred, feed_dict=feed_dict_testing)
returnresult


deftest_data(testing_path, classes, session):
error=0
success=0
forclass_idx, classeinenumerate(classes):
path=os.path.dirname(os.path.realpath(__file__)) +"/"+testing_path+"/"+classe
forfileinglob.glob(path+"/*.png"):
res=predict_image(file, session)[0]
ifmax(res) ==res[class_idx]:
success+=1
else:
error+=1

returnsuccess, error


# Get Image
dir_path=os.path.dirname(os.path.realpath(__file__))

# Restore the saved model
sess=tf.Session()
# Step-1: Recreate the network graph.
saver=tf.train.import_meta_graph(dir_path+'/model-20/.meta')
# Step-2: Load the weights saved using the restore method.
saver.restore(sess, tf.train.latest_checkpoint(dir_path+'/model-20/'))

classes= ['rl', 'uni']
success, error=test_data("testing_data", classes, sess)
print(success, error)
taux=success/ (success+error)

print("Succes rate is "+str(taux))
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
importtensorflowastf
importnumpyasnp
importglob
importos
importcv2
importsys


defpredict_image(filename, sess):
image_size=128
num_channels=3
images= []
# Reading the image using OpenCV
image=cv2.imread(filename)
# Resizing the image to our desired size and preprocessing will be done exactly as done during training
image=cv2.resize(image, (image_size, image_size), 0, 0, cv2.INTER_LINEAR)
images.append(image)
images=np.array(images, dtype=np.uint8)
images=images.astype('float32')
images=np.multiply(images, 1.0/255.0)
# The input to the network is of shape [None image_size image_size num_channels]. Hence we reshape.
x_batch=images.reshape(1, image_size, image_size, num_channels)

# Accessing the default graph which we have restored
graph=tf.get_default_graph()

# Now, let's get hold of the op that we can be processed to get the output.
# In the original network y_pred is the tensor that is the prediction of the network
y_pred=graph.get_tensor_by_name("y_pred:0")

# Let's feed the images to the input placeholders
x=graph.get_tensor_by_name("x:0")
y_true=graph.get_tensor_by_name("y_true:0")
y_test_images=np.zeros((1, 2))

# Creating the feed_dict that is required to be fed to calculate y_pred
feed_dict_testing= {x: x_batch, y_true: y_test_images}
result=sess.run(y_pred, feed_dict=feed_dict_testing)
returnresult


deftest_data(testing_path, classes, session):
error=0
success=0
forclass_idx, classeinenumerate(classes):
path=os.path.dirname(os.path.realpath(__file__)) +"/"+testing_path+"/"+classe
forfileinglob.glob(path+"/*.png"):
res=predict_image(file, session)[0]
ifmax(res) ==res[class_idx]:
success+=1
else:
error+=1

returnsuccess, error


# Get Image
dir_path=os.path.dirname(os.path.realpath(__file__))

# Restore the saved model
sess=tf.Session()
# Step-1: Recreate the network graph.
saver=tf.train.import_meta_graph(dir_path+'/model-20/.meta')
# Step-2: Load the weights saved using the restore method.
saver.restore(sess, tf.train.latest_checkpoint(dir_path+'/model-20/'))

classes= ['rl', 'uni']
success, error=test_data("testing_data", classes, sess)
print(success, error)
taux=success/ (success+error)

print("Succes rate is "+str(taux))
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
importtensorflowastf
importnumpyasnp
importglob
importos
importcv2
importsys


defpredict_image(filename, sess):
image_size=128
num_channels=3
images= []
# Reading the image using OpenCV
image=cv2.imread(filename)
# Resizing the image to our desired size and preprocessing will be done exactly as done during training
image=cv2.resize(image, (image_size, image_size), 0, 0, cv2.INTER_LINEAR)
images.append(image)
images=np.array(images, dtype=np.uint8)
images=images.astype('float32')
images=np.multiply(images, 1.0/255.0)
# The input to the network is of shape [None image_size image_size num_channels]. Hence we reshape.
x_batch=images.reshape(1, image_size, image_size, num_channels)

# Accessing the default graph which we have restored
graph=tf.get_default_graph()

# Now, let's get hold of the op that we can be processed to get the output.
# In the original network y_pred is the tensor that is the prediction of the network
y_pred=graph.get_tensor_by_name("y_pred:0")

# Let's feed the images to the input placeholders
x=graph.get_tensor_by_name("x:0")
y_true=graph.get_tensor_by_name("y_true:0")
y_test_images=np.zeros((1, 2))

# Creating the feed_dict that is required to be fed to calculate y_pred
feed_dict_testing= {x: x_batch, y_true: y_test_images}
result=sess.run(y_pred, feed_dict=feed_dict_testing)
returnresult


deftest_data(testing_path, classes, session):
error=0
success=0
forclass_idx, classeinenumerate(classes):
path=os.path.dirname(os.path.realpath(__file__)) +"/"+testing_path+"/"+classe
forfileinglob.glob(path+"/*.png"):
res=predict_image(file, session)[0]
ifmax(res) ==res[class_idx]:
success+=1
else:
error+=1

returnsuccess, error


# Get Image
dir_path=os.path.dirname(os.path.realpath(__file__))

# Restore the saved model
sess=tf.Session()
# Step-1: Recreate the network graph.
saver=tf.train.import_meta_graph(dir_path+'/model-20/.meta')
# Step-2: Load the weights saved using the restore method.
saver.restore(sess, tf.train.latest_checkpoint(dir_path+'/model-20/'))

classes= ['rl', 'uni']
success, error=test_data("testing_data", classes, sess)
print(success, error)
taux=success/ (success+error)

print("Succes rate is "+str(taux))
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
importtensorflowastf
importnumpyasnp
importglob
importos
importcv2
importsys


defpredict_image(filename, sess):
image_size=128
num_channels=3
images= []
# Reading the image using OpenCV
image=cv2.imread(filename)
# Resizing the image to our desired size and preprocessing will be done exactly as done during training
image=cv2.resize(image, (image_size, image_size), 0, 0, cv2.INTER_LINEAR)
images.append(image)
images=np.array(images, dtype=np.uint8)
images=images.astype('float32')
images=np.multiply(images, 1.0/255.0)
# The input to the network is of shape [None image_size image_size num_channels]. Hence we reshape.
x_batch=images.reshape(1, image_size, image_size, num_channels)

# Accessing the default graph which we have restored
graph=tf.get_default_graph()

# Now, let's get hold of the op that we can be processed to get the output.
# In the original network y_pred is the tensor that is the prediction of the network
y_pred=graph.get_tensor_by_name("y_pred:0")

# Let's feed the images to the input placeholders
x=graph.get_tensor_by_name("x:0")
y_true=graph.get_tensor_by_name("y_true:0")
y_test_images=np.zeros((1, 2))

# Creating the feed_dict that is required to be fed to calculate y_pred
feed_dict_testing= {x: x_batch, y_true: y_test_images}
result=sess.run(y_pred, feed_dict=feed_dict_testing)
returnresult


deftest_data(testing_path, classes, session):
error=0
success=0
forclass_idx, classeinenumerate(classes):
path=os.path.dirname(os.path.realpath(__file__)) +"/"+testing_path+"/"+classe
forfileinglob.glob(path+"/*.png"):
res=predict_image(file, session)[0]
ifmax(res) ==res[class_idx]:
success+=1
else:
error+=1

returnsuccess, error


# Get Image
dir_path=os.path.dirname(os.path.realpath(__file__))

# Restore the saved model
sess=tf.Session()
# Step-1: Recreate the network graph.
saver=tf.train.import_meta_graph(dir_path+'/model-20/.meta')
# Step-2: Load the weights saved using the restore method.
saver.restore(sess, tf.train.latest_checkpoint(dir_path+'/model-20/'))

classes= ['rl', 'uni']
success, error=test_data("testing_data", classes, sess)
print(success, error)
taux=success/ (success+error)

print("Succes rate is "+str(taux))