Wie wird eine Vorhersage in Tensorflow ausgegeben?

Question

Ich versuche eine Tensorflow DNN für eine Kaggle Competion zu verwenden. Die Daten umfassen etwa 100 Spalten mit kategorischen Daten, 29 Spalten mit numerischen Daten und 1 Spalte für die Ausgabe. Was ich getan habe, war, dass ich es in Training und Test mit X und Y unter Verwendung von Scikits Train Test Split-Funktion aufteilte, wobei X eine Liste jeder Zeile ohne die "ID" oder den zu prognostizierenden Wert ist und y der Wert ist muss vorhergesagt werden. Ich baute dann das Modell, wie unten gezeigt:

import tensorflow as tf 
import numpy as np 
import time 
import pickle 
with open('pickle.pickle', 'rb') as f: 
    trainX, trainy, testX, testy = pickle.load(f) 
trainX = np.array(trainX) 
trainy = np.array(trainy) 
trainy = trainy.reshape(trainy.shape[0], 1) 
testX = np.array(testX) 
testy = np.array(testy) 
print (trainX.shape) 
print (trainy.shape) 
testX = testX.reshape(testX.shape[0], 130) 
testy = testy.reshape(testy.shape[0], 1) 
print (testX.shape) 
print (testy.shape) 
n_nodes_hl1 = 256 
n_nodes_hl2 = 256 
n_nodes_hl3 = 256 

n_classes = 1 

batch_size = 100 


# Matrix = h X w 
X = tf.placeholder('float', [None, len(trainX[0])]) 
y = tf.placeholder('float') 

def model(data): 

    hidden_1_layer = {'weights':tf.Variable(tf.random_normal([trainX.shape[1], n_nodes_hl1])), 
         'biases':tf.Variable(tf.random_normal([n_nodes_hl1]))} 

    hidden_2_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl1, n_nodes_hl2])), 
         'biases':tf.Variable(tf.random_normal([n_nodes_hl2]))} 

    hidden_3_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl2, n_nodes_hl3])), 
         'biases':tf.Variable(tf.random_normal([n_nodes_hl3]))} 

    output_layer = {'weights':tf.Variable(tf.random_normal([n_nodes_hl3, n_classes])), 
         'biases':tf.Variable(tf.random_normal([n_classes]))} 

    # (input_data * weights) + biases 

    l1 = tf.add(tf.matmul(data, hidden_1_layer['weights']), hidden_1_layer['biases']) 
    l1 = tf.nn.sigmoid(l1) 

    l2 = tf.add(tf.matmul(l1, hidden_2_layer['weights']), hidden_2_layer['biases']) 
    l2 = tf.nn.sigmoid(l2) 

    l3 = tf.add(tf.matmul(l2, hidden_3_layer['weights']), hidden_3_layer['biases']) 
    l3 = tf.nn.sigmoid(l3) 

    output = tf.matmul(l3, output_layer['weights']) + output_layer['biases'] 

    return output 


def train(x): 

    pred = model(x) 
    #loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(pred, y)) 
    loss = tf.reduce_mean(tf.square(pred - y)) 
    optimizer = tf.train.AdamOptimizer(0.01).minimize(loss) 

    epochs = 1 

    with tf.Session() as sess: 
     sess.run(tf.initialize_all_variables()) 
     print ('Beginning Training \n') 
     for e in range(epochs): 
      timeS = time.time() 
      epoch_loss = 0 

      i = 0 
      while i < len(trainX): 

       start = i 
       end = i + batch_size 
       batch_x = np.array(trainX[start:end]) 
       batch_y = np.array(trainy[start:end]) 

       _, c = sess.run([optimizer, loss], feed_dict = {x: batch_x, y: batch_y}) 
       epoch_loss += c 
       i += batch_size 
      done = time.time() - timeS 
      print ('Epoch', e + 1, 'completed out of', epochs, 'loss:', epoch_loss, "\nTime:", done, 'seconds\n') 
     correct = tf.equal(tf.arg_max(pred, 1), tf.arg_max(y, 1)) 
     acc = tf.reduce_mean(tf.cast(correct, 'float')) 
     print("Accuracy:", acc.eval({x:testX, y:testy})) 


train(X) 

Ausgang für 1 Epoche:

Epoch 1 completed out of 1 loss: 1498498282.5 
Time: 1.3765859603881836 seconds 

Accuracy: 1.0 

ich erkennen, dass der Verlust sehr hoch ist, und ich bin mit 1 Epoche nur zu Testzwecken und Ja, ich weiß, dass mein Code ziemlich unordentlich ist. Aber alles, was ich tun möchte, ist eine Vorhersage auszudrucken. Wie würde ich das tun? Ich weiß, dass ich eine Liste von Funktionen für X füttern muss, aber ich verstehe einfach nicht, wie es geht. Ich verstehe auch nicht ganz, warum meine Genauigkeit bei 1.0 liegt. Wenn Sie also irgendwelche Vorschläge dafür oder irgendwelche Möglichkeiten haben, meinen Code zu ändern, wäre ich mehr als glücklich, auf irgendwelche Ideen zu hören. Vielen Dank im Voraus

Answer 1

Um eine Vorhersage zu erhalten, müssen Sie nur pred auswerten. Dies ist die Operation, die die Ausgabe des Modells definiert.

Wie geht das? Mit pred.eval(). Aber Sie benötigen eine Eingabe, um ihre Vorhersage zu bewerten, also müssen Sie ein feed_dict Wörterbuch zu eval() mit dem Beispiel (oder den Proben) zur Verfügung stellen, die Sie verarbeiten möchten.

Der resultierende Code wie folgt aussieht:

predictions = pred.eval(feed_dict = {x:testX}) 

Hinweis, wie Sie dies acc.eval({x:testX, y:testy}) sehr ähnlich, denn die Idee ist das gleiche. Sie haben eine Operation (acc in diesem Fall), die einige Eingaben benötigt, um ausgewertet zu werden, und Sie können sie entweder durch Aufrufen von acc.eval() oder mit dem entsprechenden feed_dict mit den notwendigen Eingaben auswerten.

Answer 2

Der einfachste Weg wäre es, die vorhandene Sitzung zu verwenden, während (zwischen Iterationen) Ausbildung:

print (sess.run(model, {x:X_example})) 

wo X_example einig numpy Beispiel Tensor ist.

Answer 3

Die folgende Zeile zeigt Wahrscheinlichkeit Partituren zum Beispiel für jede Klasse geben, die Sie 3 Klassen dann die folgenden Zeile, die Sie Sie Vorhersage eines einzelnen Datenpunkt eine Reihe von Form von 1x3 In Anbetracht geben wollen X_test Sie Folgendes tun können :

output = sess.run(pred, {x:X_test}) 

die maximale Anzahl in der obigen Variable output werden Sie Vorhersage werden, so dass wir für die obige Aussage ändern wird:

output = sess.run(tf.argmax(pred, 1), {x:X_test}) 
print("your prediction for X_test is :", output[0]) 

Andere dünne Sie können tun ist:

output = sess.run(pred, {x:X_test}) 
output = np.argmax(output) 
print("your prediction for X_test is :", output)