¿Por qué TensorFlow devuelve ] en lugar de probabilidades de un archivo CSV?

Aquí está el código que estoy usando. Estoy tratando de obtener un 1, 0 o, con suerte, una probabilidad en el resultado de un conjunto de prueba real. Cuando acabo de dividir el conjunto de entrenamiento y ejecutarlo en el conjunto de entrenamiento, obtengo una tasa de precisión de ~ 93%, pero cuando entreno el progtwig y lo ejecuto en el conjunto de prueba real (el que no tiene el 1 y el 0 rellenando la columna 1 ) No devuelve nada más que los de Nan.

import tensorflow as tf import numpy as np from numpy import genfromtxt import sklearn # Convert to one hot def convertOneHot(data): y=np.array([int(i[0]) for i in data]) y_onehot=[0]*len(y) for i,j in enumerate(y): y_onehot[i]=[0]*(y.max() + 1) y_onehot[i][j]=1 return (y,y_onehot) data = genfromtxt('cs-training.csv',delimiter=',') # Training data test_data = genfromtxt('cs-test-actual.csv',delimiter=',') # Actual test data #This part is to get rid of the nan's at the start of the actual test data g = 0 for i in test_data: i[0] = 1 test_data[g] = i g += 1 x_train=np.array([ i[1::] for i in data]) y_train,y_train_onehot = convertOneHot(data) x_test=np.array([ i[1::] for i in test_data]) y_test,y_test_onehot = convertOneHot(test_data) A=data.shape[1]-1 # Number of features, Note first is y B=len(y_train_onehot[0]) tf_in = tf.placeholder("float", [None, A]) # Features tf_weight = tf.Variable(tf.zeros([A,B])) tf_bias = tf.Variable(tf.zeros([B])) tf_softmax = tf.nn.softmax(tf.matmul(tf_in,tf_weight) + tf_bias) # Training via backpropagation tf_softmax_correct = tf.placeholder("float", [None,B]) tf_cross_entropy = -tf.reduce_sum(tf_softmax_correct*tf.log(tf_softmax)) # Train using tf.train.GradientDescentOptimizer tf_train_step = tf.train.GradientDescentOptimizer(0.01).minimize(tf_cross_entropy) # Add accuracy checking nodes tf_correct_prediction = tf.equal(tf.argmax(tf_softmax,1), tf.argmax(tf_softmax_correct,1)) tf_accuracy = tf.reduce_mean(tf.cast(tf_correct_prediction, "float")) saver = tf.train.Saver([tf_weight,tf_bias]) # Initialize and run init = tf.initialize_all_variables() sess = tf.Session() sess.run(init) print("...") # Run the training for i in range(1): sess.run(tf_train_step, feed_dict={tf_in: x_train, tf_softmax_correct: y_train_onehot}) #print y_train_onehot saver.save(sess, 'trained_csv_model') ans = sess.run(tf_softmax, feed_dict={tf_in: x_test}) print ans #Print accuracy #result = sess.run(tf_accuracy, feed_dict={tf_in: x_test, tf_softmax_correct: y_test_onehot}) #print result 

Cuando imprimo ans me sale lo siguiente.

 [[ nan nan] [ nan nan] [ nan nan] ..., [ nan nan] [ nan nan] [ nan nan]] 

No sé qué estoy haciendo mal aquí. Todo lo que quiero es que ans produzca un 1, 0 o, especialmente, una matriz de probabilidades donde cada unidad dentro de la matriz tenga una longitud de 2.

No espero que muchas personas puedan responder esta pregunta por mí, pero al menos inténtalo. Estoy atrapado aquí esperando un momento de genio que no ha llegado en 2 días, así que pensé que iba a preguntar. ¡Gracias!

El test_data sale así:

 [[ 1.00000000e+00 8.85519080e-01 4.30000000e+01 ..., 0.00000000e+00 0.00000000e+00 0.00000000e+00] [ 1.00000000e+00 4.63295269e-01 5.70000000e+01 ..., 4.00000000e+00 0.00000000e+00 2.00000000e+00] [ 1.00000000e+00 4.32750360e-02 5.90000000e+01 ..., 1.00000000e+00 0.00000000e+00 2.00000000e+00] ..., [ 1.00000000e+00 8.15963730e-02 7.00000000e+01 ..., 0.00000000e+00 0.00000000e+00 nan] [ 1.00000000e+00 3.35456547e-01 5.60000000e+01 ..., 2.00000000e+00 1.00000000e+00 3.00000000e+00] [ 1.00000000e+00 4.41841663e-01 2.90000000e+01 ..., 0.00000000e+00 0.00000000e+00 0.00000000e+00]] 

Y la única razón por la que la primera unidad en los datos es igual a 1 es porque me deshice de la nan que llenaba esa posición para evitar errores. Tenga en cuenta que todo después de la primera columna es una característica. La primera columna es lo que estoy tratando de poder predecir.

EDITAR:

Cambié el código a la siguiente

 import tensorflow as tf import numpy as np from numpy import genfromtxt import sklearn from sklearn.cross_validation import train_test_split from tensorflow import Print # Convert to one hot def convertOneHot(data): y=np.array([int(i[0]) for i in data]) y_onehot=[0]*len(y) for i,j in enumerate(y): y_onehot[i]=[0]*(y.max() + 1) y_onehot[i][j]=1 return (y,y_onehot) #buildDataFromIris() data = genfromtxt('cs-training.csv',delimiter=',') # Training data test_data = genfromtxt('cs-test-actual.csv',delimiter=',') # Test data #for i in test_data[0]: # print i #print test_data #print test_data g = 0 for i in test_data: i[0] = 1. test_data[g] = i g += 1 #print 1, test_data x_train=np.array([ i[1::] for i in data]) y_train,y_train_onehot = convertOneHot(data) #print len(x_train), len(y_train), len(y_train_onehot) x_test=np.array([ i[1::] for i in test_data]) y_test,y_test_onehot = convertOneHot(test_data) #for u in y_test_onehot[0]: # print u #print y_test_onehot #print len(x_test), len(y_test), len(y_test_onehot) #print x_test[0] #print '1' # A number of features, 4 in this example # B = 3 species of Iris (setosa, virginica and versicolor) A=data.shape[1]-1 # Number of features, Note first is y #print A B=len(y_train_onehot[0]) #print B #print y_train_onehot tf_in = tf.placeholder("float", [None, A]) # Features tf_weight = tf.Variable(tf.zeros([A,B])) tf_bias = tf.Variable(tf.zeros([B])) tf_softmax = tf.nn.softmax(tf.matmul(tf_in,tf_weight) + tf_bias) tf_bias = tf.Print(tf_bias, [tf_bias], "Bias: ") tf_weight = tf.Print(tf_weight, [tf_weight], "Weight: ") tf_in = tf.Print(tf_in, [tf_in], "TF_in: ") matmul_result = tf.matmul(tf_in, tf_weight) matmul_result = tf.Print(matmul_result, [matmul_result], "Matmul: ") tf_softmax = tf.nn.softmax(matmul_result + tf_bias) print tf_bias print tf_weight print tf_in print matmul_result # Training via backpropagation tf_softmax_correct = tf.placeholder("float", [None,B]) tf_cross_entropy = -tf.reduce_sum(tf_softmax_correct*tf.log(tf_softmax)) print tf_softmax_correct # Train using tf.train.GradientDescentOptimizer tf_train_step = tf.train.GradientDescentOptimizer(0.01).minimize(tf_cross_entropy) # Add accuracy checking nodes tf_correct_prediction = tf.equal(tf.argmax(tf_softmax,1), tf.argmax(tf_softmax_correct,1)) tf_accuracy = tf.reduce_mean(tf.cast(tf_correct_prediction, "float")) print tf_correct_prediction print tf_accuracy #saver = tf.train.Saver([tf_weight,tf_bias]) # Initialize and run init = tf.initialize_all_variables() sess = tf.Session() sess.run(init) print("...") prediction = [] # Run the training #probabilities = [] #print y_train_onehot #print '-----------------------------------------' for i in range(1): sess.run(tf_train_step, feed_dict={tf_in: x_train, tf_softmax_correct: y_train_onehot}) #print y_train_onehot #saver.save(sess, 'trained_csv_model') ans = sess.run(tf_softmax, feed_dict={tf_in: x_test}) print ans 

Después de la impresión veo que uno de los objetos es booleano. No sé si ese es el problema, pero eche un vistazo a lo siguiente y vea si hay alguna manera en que pueda ayudar.

 Tensor("Print_16:0", shape=TensorShape([Dimension(2)]), dtype=float32) Tensor("Print_17:0", shape=TensorShape([Dimension(10), Dimension(2)]), dtype=float32) Tensor("Print_18:0", shape=TensorShape([Dimension(None), Dimension(10)]), dtype=float32) Tensor("Print_19:0", shape=TensorShape([Dimension(None), Dimension(2)]), dtype=float32) Tensor("Placeholder_9:0", shape=TensorShape([Dimension(None), Dimension(2)]), dtype=float32) Tensor("Equal_4:0", shape=TensorShape([Dimension(None)]), dtype=bool) Tensor("Mean_4:0", shape=TensorShape([]), dtype=float32) ... [[ nan nan] [ nan nan] [ nan nan] ..., [ nan nan] [ nan nan] [ nan nan]] 

No sé la respuesta directa, pero sé cómo me acercaría a la depuración: tf.Print . Es una operación que imprime el valor a medida que se está ejecutando tensorflow, y devuelve el tensor para cálculos adicionales, por lo que solo puede rociarlos en línea en su modelo.

Intenta lanzar algunos de estos. En lugar de esta línea:

 tf_softmax = tf.nn.softmax(tf.matmul(tf_in,tf_weight) + tf_bias) 

Tratar:

 tf_bias = tf.Print(tf_bias, [tf_bias], "Bias: ") tf_weight = tf.Print(tf_weight, [tf_weight], "Weight: ") tf_in = tf.Print(tf_in, [tf_in], "TF_in: ") matmul_result = tf.matmul(tf_in, tf_weight) matmul_result = tf.Print(matmul_result, [matmul_result], "Matmul: ") tf_softmax = tf.nn.softmax(matmul_result + tf_bias) 

Para ver qué piensa Tensorflow son los valores intermedios. Si los NaN aparecen antes en la tubería, debería darle una mejor idea de dónde se encuentra el problema. ¡Buena suerte! Si obtiene algunos datos de esto, no dude en hacer un seguimiento y veremos si podemos brindarle más información.

Actualizado para agregar: Aquí hay una versión de depuración reducida para probar, donde me deshice de las funciones de entrada y solo generé algunos datos aleatorios:

 import tensorflow as tf import numpy as np def dense_to_one_hot(labels_dense, num_classes=10): """Convert class labels from scalars to one-hot vectors.""" num_labels = labels_dense.shape[0] index_offset = np.arange(num_labels) * num_classes labels_one_hot = np.zeros((num_labels, num_classes)) labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1 return labels_one_hot x_train=np.random.normal(0, 1, [50,10]) y_train=np.random.randint(0, 10, [50]) y_train_onehot = dense_to_one_hot(y_train, 10) x_test=np.random.normal(0, 1, [50,10]) y_test=np.random.randint(0, 10, [50]) y_test_onehot = dense_to_one_hot(y_test, 10) # A number of features, 4 in this example # B = 3 species of Iris (setosa, virginica and versicolor) A=10 B=10 tf_in = tf.placeholder("float", [None, A]) # Features tf_weight = tf.Variable(tf.zeros([A,B])) tf_bias = tf.Variable(tf.zeros([B])) tf_softmax = tf.nn.softmax(tf.matmul(tf_in,tf_weight) + tf_bias) tf_bias = tf.Print(tf_bias, [tf_bias], "Bias: ") tf_weight = tf.Print(tf_weight, [tf_weight], "Weight: ") tf_in = tf.Print(tf_in, [tf_in], "TF_in: ") matmul_result = tf.matmul(tf_in, tf_weight) matmul_result = tf.Print(matmul_result, [matmul_result], "Matmul: ") tf_softmax = tf.nn.softmax(matmul_result + tf_bias) # Training via backpropagation tf_softmax_correct = tf.placeholder("float", [None,B]) tf_cross_entropy = -tf.reduce_sum(tf_softmax_correct*tf.log(tf_softmax)) # Train using tf.train.GradientDescentOptimizer tf_train_step = tf.train.GradientDescentOptimizer(0.01).minimize(tf_cross_entropy) # Add accuracy checking nodes tf_correct_prediction = tf.equal(tf.argmax(tf_softmax,1), tf.argmax(tf_softmax_correct,1)) tf_accuracy = tf.reduce_mean(tf.cast(tf_correct_prediction, "float")) print tf_correct_prediction print tf_accuracy init = tf.initialize_all_variables() sess = tf.Session() sess.run(init) for i in range(1): print "Running the training step" sess.run(tf_train_step, feed_dict={tf_in: x_train, tf_softmax_correct: y_train_onehot}) #print y_train_onehot #saver.save(sess, 'trained_csv_model') print "Running the eval step" ans = sess.run(tf_softmax, feed_dict={tf_in: x_test}) print ans 

Deberías ver líneas que comienzan con “Bias:”, etc.

tf_cross_entropy = -tf.reduce_sum(tf_softmax_correct*tf.log(tf_softmax))

Este fue mi problema en un proyecto que estaba probando. Específicamente terminó siendo 0 * log (0) que produce nan.

Si reemplaza esto con:

tf_cross_entropy = -tf.reduce_sum(tf_softmax_correct*tf.log(tf_softmax + 1e-50)) Debe evitar el problema.

También he usado reduce_mean en lugar de reduce_sum. Si duplica el tamaño del lote y utiliza reducir_sum, duplicará el costo (y la magnitud del gradiente). Además de eso, cuando se usa tf.print (desde donde se inició la impresión desde la consola) se hace un poco más comparable al variar el tamaño del lote.

Específicamente esto es lo que estoy usando ahora al depurar:

cross_entropy = -tf.reduce_sum(y*tf.log(model + 1e-50)) ## avoid nan due to 0*log(0) cross_entropy = tf.Print(cross_entropy, [cross_entropy], "cost") #print to the console tensorflow was started from