Tensorflow API Zum Testen der Daten

Question

Ich habe einen Datensatz mit 5 Spalten, ich füttere in den ersten 3 Spalten als meine Eingaben und die anderen 2 Spalten als meine Ausgaben.

Ich habe das Programm erfolgreich ausgeführt, aber ich bin mir nicht sicher, wie ich das Modell testen soll, indem ich meine eigenen Werte als Eingabe gebe und eine vorhergesagte Ausgabe vom Modell bekomme.

Kann mir bitte jemand helfen, wie kann ich das Modell mit meinem eigenen Wert nach dem Training tatsächlich testen?

Ich verwende Tensorflow in Python. Ich bin in der Lage Genauigkeit der Prüfung angezeigt werden, aber wie kann ich vorhersagen, tatsächlich mit dem Wert, wenn ich einige zufällige Eingabe passieren (hier, ich brauche drei Eingangswerte passieren 2 Ausgangswerte zu erhalten)

Hier ist mein Code:

# Implementation of a simple MLP network with one hidden layer. Tested on the iris data set. 
# Requires: numpy, sklearn>=0.18.1, tensorflow>=1.0 

# NOTE: In order to make the code simple, we rewrite x * W_1 + b_1 = x' * W_1' 
# where x' = [x | 1] and W_1' is the matrix W_1 appended with a new row with elements b_1's. 
# Similarly, for h * W_2 + b_2 
import tensorflow as tf 
import numpy as np 
from sklearn import datasets 
from sklearn.model_selection import train_test_split 
import pandas as pd 

RANDOM_SEED = 1000 
tf.set_random_seed(RANDOM_SEED) 


def init_weights(shape): 
    """ Weight initialization """ 
    weights = tf.random_normal(shape, stddev=0.1) 
    return tf.Variable(weights) 

def forwardprop(X, w_1, w_2): 
    """ 
    Forward-propagation. 
    IMPORTANT: yhat is not softmax since TensorFlow's softmax_cross_entropy_with_logits() does that internally. 
    """ 
    h = tf.nn.sigmoid(tf.matmul(X, w_1)) # The \sigma function 
    yhat = tf.matmul(h, w_2) # The \varphi function 
    return yhat 

def get_iris_data(): 
    """ Read the iris data set and split them into training and test sets """ 
    df = pd.read_csv("H:\MiniThessis\Sample.csv") 
    train_X = np.array(df[df.columns[0:3]]) 
    train_Y = np.array(df[df.columns[3:]]) 
    print(train_X) 

    # Convert into one-hot vectors 
    #num_labels = len(np.unique(train_Y)) 
    #all_Y = np.eye(num_labels)[train_Y] # One liner trick! 
    #print() 
    return train_test_split(train_X, train_Y, test_size=0.33, random_state=RANDOM_SEED) 

def main(): 
    train_X, test_X, train_y, test_y = get_iris_data() 

    # Layer's sizes 
    x_size = train_X.shape[1] # Number of input nodes: 4 features and 1 bias 
    h_size = 256    # Number of hidden nodes 
    y_size = train_y.shape[1] # Number of outcomes (3 iris flowers) 

    # Symbols 
    X = tf.placeholder("float", shape=[None, x_size]) 
    y = tf.placeholder("float", shape=[None, y_size]) 

    # Weight initializations 
    w_1 = init_weights((x_size, h_size)) 
    w_2 = init_weights((h_size, y_size)) 

    # Forward propagation 
    yhat = forwardprop(X, w_1, w_2) 
    predict = tf.argmax(yhat, axis=1) 

    # Backward propagation 
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=yhat)) 
    updates = tf.train.GradientDescentOptimizer(0.01).minimize(cost) 

    # Run SGD 
    sess = tf.Session() 
    init = tf.global_variables_initializer() 
    sess.run(init) 

    for epoch in range(3): 
     # Train with each example 
     for i in range(len(train_X)): 
      sess.run(updates, feed_dict={X: train_X[i: i + 1], y: train_y[i: i + 1]}) 

     train_accuracy = np.mean(np.argmax(train_y, axis=1) == sess.run(predict, feed_dict={X: train_X, y: train_y})) 
     test_accuracy = np.mean(np.argmax(test_y, axis=1) ==sess.run(predict, feed_dict={X: test_X, y: test_y})) 

     print("Epoch = %d, train accuracy = %.2f%%, test accuracy = %.2f%%" 
       % (epoch + 1, 100. * train_accuracy, 100. * test_accuracy)) 


    correct_Prediction = tf.equal((tf.arg_max(predict,1)),(tf.arg_max(y,1))) 
    best = sess.run([predict], feed_dict={X: np.array([[20.14, 46.93, 1014.66]])}) 
    #print(correct_Prediction) 
    print(best) 


    sess.close() 

if __name__ == '__main__': 
    main() 

Answer 1

Hinweis, diese Antwort nimmt einige Annahmen über die Eingabe, die Sie in Ihrer ursprünglichen Frage nicht angegeben haben.

An diesem Punkt denke ich, dass Ihre Hausaufgaben mehr Arbeit erfordern, um beendet zu werden. Die vierte und fünfte Spalte sind wahrscheinlich die Blütenblattbreite (ein realer Wert) und der Iris-Typ (codiert als eine Kategorie). Dies bedeutet, dass Sie wahrscheinlich eine reellwertige Ausgabe (Blütenblattbreite) und eine kategorische Vorhersage benötigen. Dies bedeutet, dass Ihr softmax_cross_entry_with_logits wahrscheinlich nicht gut mit der Blütenblattbreite zusammenspielt. Außerdem wenden Sie einen Argmax als Teil der Vorhersage an, und dies wird den Index mit dem höchsten Wert (in diesem Fall die Blütenblattbreite oder den kugorisch kodierten Wert) zurückgeben, was ebenfalls keinen Sinn ergibt. So wie Debugging-Hilfe, warum nicht beginnen mit:

print(sess.run([yhat], feed_dict={X: np.array([[20.14, 46.93, 1014.66]])}) 

Dieses aus yhat druckt, (basierend auf den Eingängen [20.14, 46.93, 1014.66] (das ist eine massive Blume, völlig anders als alles innerhalb des Datensatzes) und 2 Ausgänge enthalten

.