Test a tensorflow cnn model after the training

Question

I created a model of a convolutional neural network, I implemented the training and now I have to create a function to run the model in test mode but I have no idea how I could do it.

Ho due dataset, uno per l'allenamento e uno per il test quindi dovrei trovare un modo per testare il modello nel dataset di test.

I could load the test dataset in the same way as the training dataset but then I would not know how to do the test on the model already trained.

This is the model function

import tensorflow as tf

def cnn_model_fn(X, MODE, log=False):

    # INPUT LAYER
    with tf.name_scope('input_layer') as scope:
        input_layer = tf.reshape(X, [-1, 1000, 48, 1])

    # CONVOLUTIONAL LAYER #1
    with tf.name_scope('Conv1') as scope:
        conv1 = tf.layers.conv2d(
            inputs=input_layer,
            filters=4,
            kernel_size=[10, 10],
            strides=(2, 2),
            padding="valid",
        )
        if log==True:
            print('[LOG:conv1]: ' + str(conv1.shape))

        # apply the relu function
        conv1_relu = tf.nn.relu(conv1)
        if log==True:
            print('[LOG:conv1_relu]: ' + str(conv1_relu.shape))

    # POOLING LAYER #1
    with tf.name_scope('Pool1'):
        pool1 = tf.layers.max_pooling2d(
            inputs=conv1_relu,
            pool_size=[2, 2],
            strides=2
        )
        if log==True:
            print('[LOG:pool1]: ' + str(pool1.shape))

    # CONVOLUTIONAL LAYER #2
    with tf.name_scope('Conv2'):
        conv2 = tf.layers.conv2d(
            inputs=pool1,
            filters=64,
            kernel_size=[5, 5],
            padding="same",
        )
        if log==True:
            print('[LOG:conv2]: ' + str(conv2.shape))

        # apply the relu function
        conv2_relu = tf.nn.relu(conv2)
        if log==True:
            print('[LOG:conv2_relu]: ' + str(conv2_relu.shape))


    # POOLING LAYER #2
    with tf.name_scope('Pool2'):
        pool2 = tf.layers.max_pooling2d(
            inputs=conv2_relu,
            pool_size=[2, 2],
            strides=2
        )
        if log==True:
            print('[LOG:pool2]: ' + str(pool2.shape))

        # create a variable with the pool2 size because I need it to calculate the pool2_flat size
        x = tf.TensorShape.as_list(pool2.shape)

    # REDENSIFY POOL2 TO REDUCE COMPUTATIONAL LOAD
    with tf.name_scope('Reshape'):
        pool2_flat = tf.reshape(pool2, [-1, x[1] * x[2] * x[3]])
        if log==True:
            print('[LOG:pool2_flat]: ' + str(pool2_flat.shape))

    # DENSE LAYER
    with tf.name_scope('Dense_layer'):
        dense = tf.layers.dense(
            inputs=pool2_flat,
            units=1024,
        )
        if log==True:
            print('[LOG:dense]: ' + str(dense.shape))

        # apply the relu function
        dense_relu = tf.nn.relu(dense)
        if log==True:
            print('[LOG:dense_relu]: ' + str(dense_relu.shape))

    # add the dropout function
    with tf.name_scope('Dropout'):
        dropout = tf.layers.dropout(
            inputs=dense_relu,
            rate=0.4,
            training=MODE == tf.estimator.ModeKeys.TRAIN
        )
        if log==True:
            print('[LOG:dropout]: ' + str(dropout.shape))

    # LOGIT LAYER
    with tf.name_scope('Logit_layer'):
        logits = tf.layers.dense(
            inputs=dropout,
            units=2
        )
        if log==True:
            print('[LOG:logits]: ' + str(logits.shape))

    return logits

And this is the main program

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function


# IMPORTS
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import os
import sys
from tqdm import tqdm
import load_dataset
import datetime
import time
get_images = load_dataset.get_images
next_batch = load_dataset.next_batch

import cnn_model_fn
cnn_model_fn = cnn_model_fn.cnn_model_fn

os.system('clear')

local_path = os.getcwd()
save_path = local_path + '/.Checkpoints/model.ckpt'
TensorBoard_path = local_path + "/.TensorBoard"
dataset_path = local_path + '/DATASET/'

#Training Parameters
learning_rate = 0.001
batch_size = 5
epochs = 2

MODE = 'TRAIN'

len_X, X, Y = get_images(
    files_path=dataset_path,
    img_size_h=1000,
    img_size_w=48,
    mode='TRAIN',
    randomize=True
)

X_batch, Y_batch = next_batch(
    total=len_X,
    images=X,
    labels=Y,
    batch_size=batch_size,
    index=0
)

logits = cnn_model_fn(X_batch, MODE)
prediction = tf.nn.softmax(logits)
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits, labels=Y_batch))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss)
correct_predict = tf.equal(tf.argmax(prediction, 1), tf.argmax(Y_batch, 1))
accuracy = tf.reduce_mean(tf.cast(correct_predict, tf.float32))

init = tf.global_variables_initializer()
best_acc=0

with tf.Session() as sess:

    sess.run(init)
    saver = tf.train.Saver()

    if MODE == 'TRAIN':
        os.system('clear')
        print("TRAINING MODE")
        print('\n[epoch, iter]\t\tAccuracy\tProgress\tTime')

        for step in range(1, epochs+1):
            for i in range(0, int(len_X/batch_size)+1):
                t0 = time.time()

                X_batch, Y_batch = next_batch(
                    total=len_X,
                    images=X,
                    labels=Y,
                    batch_size=batch_size,
                    index=i
                )

                sess.run(train_op)
                los, acc= sess.run([loss, accuracy])

                t1 = time.time()
                t = t1-t0

                check = '[ ]'
                if acc >= best_acc:
                    check = '[X]'
                    best_acc = acc
                    print('[e:' + str(step) + ', i:' + str(i) + ']\t\t' + '%.4f' % acc + '\t\t' + check + '\t\t' + '%.3f' % t + 's')
                    saver.save(sess,save_path)
                else:
                    print('[e:' + str(step) + ', i:' + str(i) + ']\t\t' + '%.4f' % acc + '\t\t' + check + '\t\t' + '%.3f' % t + 's')

        writer = tf.summary.FileWriter(TensorBoard_path, sess.graph)

    elif MODE=='TEST':
        os.system('clear')
        print("TESTING MODE")
        saver.restore(sess, save_path)
        # here I need to test the model 


sess.close()

Thank you so much for your help and your time.

EDIT: I solved doing this

saver.restore(sess, save_path)
print("Initialization Complete")

len_X_test, X_test, Y_test = get_images(
    files_path=dataset_path,
    img_size_h=img_size_h,
    img_size_w=img_size_w,
    mode='TEST',
    randomize=True
)

train_feed = {x: X_test, y: Y_test}

print("Testing Accuracy:"+str(sess.run(accuracy, feed_dict=train_feed)))

Answer 1

I solved doing this:

saver.restore(sess, save_path)
print("Initialization Complete")

len_X_test, X_test, Y_test = get_images(
    files_path=dataset_path,
    img_size_h=img_size_h,
    img_size_w=img_size_w,
    mode='TEST',
    randomize=True
)

train_feed = {x: X_test, y: Y_test}

# test the model
print("Testing Accuracy:"+str(sess.run(accuracy, feed_dict=train_feed)))

Answer 2

You can do it in the same way as model training. Split the test into batches and compute loss and accuracy for each batch independently. Assuming the test set length is divisible by the batch size:

accuracies = []
losses = []
for i in range(0, len_X // batch_size + 1:
    X_batch, Y_batch = next_batch(
         total=len_X,
         images=X,
         labels=Y,
         batch_size=batch_size,
         index=i
    )

    los, acc= sess.run([loss, accuracy])
    accuracies.append(acc)
    losses.append(loss)
test_acc = np.mean(accuracies)
test_loss = np.mean(losses)