How to save Tensorflow predictions to data frame?

Question

I am new to Tensorflow. I have trained Tensorflow model, but I need to take model predictions and add them to my original test set as a column. How can I do that?

def model(self, layers_dims, X_train, Y_train, X_test, Y_test, learning_rate=0.00001,
          num_epochs=1000, print_cost=True):
    """
    Implements a three-layer tensorflow neural network: LINEAR->RELU->LINEAR->RELU->LINEAR->SOFTMAX.

    Arguments:
    X_train -- training set, of shape (input size = 12288, number of training examples = 1080)
    Y_train -- test set, of shape (output size = 6, number of training examples = 1080)
    X_test -- training set, of shape (input size = 12288, number of training examples = 120)
    Y_test -- test set, of shape (output size = 6, number of test examples = 120)
    learning_rate -- learning rate of the optimization
    num_epochs -- number of epochs of the optimization loop
    minibatch_size -- size of a minibatch
    print_cost -- True to print the cost every 100 epochs

    Returns:
    parameters -- parameters learnt by the model. They can then be used to predict.
    """

    ops.reset_default_graph()  # to be able to rerun the model without overwriting tf variables
    tf.set_random_seed(1)  # to keep consistent results
    seed = 3  # to keep consistent results
    (n_x, m) = X_train.shape  # (n_x: input size, m : number of examples in the train set)

    n_y = Y_train.shape[0]  # n_y : output size
    #print('Ytrain shape', Y_train.shape)
    costs = []  # To keep track of the cost

    # Create Placeholders of shape (n_x, n_y)
    X, Y = self.create_placeholders(n_x, n_y)

    # Initialize parameters
    parameters = NN_predict_trading_decisions.initialize_parameters(layers_dims)

    # Forward propagation: Build the forward propagation in the tensorflow graph
    ZL = NN_predict_trading_decisions.forward_propagation(X, parameters)

    # Cost function: Add cost function to tensorflow graph
    cost = NN_predict_trading_decisions.compute_cost(ZL, Y)


    # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.
    #optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
    optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

    # Initialize all the variables
    init = tf.global_variables_initializer()

    # Start the session to compute the tensorflow graph
    with tf.Session() as sess:

        # Run the initialization
        sess.run(init)

        # Do the training loop
        for epoch in range(num_epochs):

            epoch_cost = 0.  # Defines a cost related to an epoch
            current_cost = sess.run([optimizer, cost], feed_dict= {X: X_train, Y: Y_train})
            epoch_cost +=  current_cost[1]

            # Print the cost every epoch
            if print_cost == True and epoch % 100 == 0:
                print("Cost after epoch %i: %f" % (epoch, epoch_cost))
            if print_cost == True and epoch % 5 == 0:
                costs.append(epoch_cost)

        # plot the cost
        plt.plot(np.squeeze(costs))
        plt.ylabel('cost')
        plt.xlabel('iterations (per tens)')
        plt.title("Learning rate =" + str(learning_rate))
        plt.show()

        # lets save the parameters in a variable
        parameters = sess.run(parameters)
        print("Parameters have been trained!")

        # Calculate the correct predictions
        correct_prediction = tf.equal(tf.argmax(ZL), tf.argmax(Y))



        # Calculate accuracy on the test set
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

        print("Train Accuracy:", accuracy.eval({X: X_train, Y: Y_train}))
        print("Test Accuracy:", accuracy.eval({X: X_test, Y: Y_test}))

        return parameters

Answer 1

Thanks to Ankit Seth I found the answer.

#this returns output layer of forward prop with trained parameters of the model.
pred =  forward_propagation(X, parameters)
predictions_sigm = pred.eval(feed_dict = {X: X_test})
predictions_sigm = sigmoid(predictions)

#pred.eval returns linear regression layer for each class separately, so we need to pick index of maximum of them. I don't use softmax layer, since the output should be the same.

#init list of classes
y_list = []

for i in range(predictions_sigm.shape[1]):
    class_list = []
    class_list.append(predictions_sigm[0][i])   
    class_list.append(predictions_sigm[1][i])
    class_list.append(predictions_sigm[2][i])
    class_list.append(predictions_sigm[3][i])

    #get index of maximum value of sigmoid. it will correspond to class
    y = np.argmax(class_list)
    y_list.append(y)

   #then append y_list to dataframe
   df['predicted_y'] = y_list

Answer 2

Create a list of the inputs, run each input through your model and save the prediction into a list then you can run the following code.

preds = YOUR_LIST_OF_PREDICTION_FROM_NN
result = pd.DataFrame(data={'Id': YOUR_TEST_DATAFRAME['Id'], 'PREDICTION_COLUM_NAME': preds})
result.to_csv(path_or_buf='submittion.csv', index = False, header = True)

Then extract the prediction from a tensor in Tensorflow. This will extract data from Tensor:

pred = forward_propagation(X, parameters) 
predictions = pred.eval(feed_dict = {X: X_test})