Trjtdtk

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

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

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)