python - inplace - ¿Por qué TensorFlow devuelve[[nan nan]] en lugar de probabilidades de un archivo CSV?

pandas filter nan

Question

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 del ~ 93%, pero cuando entreno el programa y lo ejecuto en el conjunto de prueba real (el que no tiene el 1 y el 0 en la columna 1) ) no devuelve nada más que 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 obtengo lo siguiente.

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

No sé lo que 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 del conjunto tiene una longitud de 2.

No espero que muchas personas puedan responder esta pregunta por mí, pero por favor intente por lo menos. Estoy atrapado aquí esperando un golpe de genial momento que no ha llegado en 2 días, así que pensé que lo haría. ¡Gracias!

El test_data sale como este-

[[ 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 cual la primera unidad en los datos es igual a 1 es porque me deshice de los nan que llenaron esa posición para evitar errores. Tenga en cuenta que todo después de la primera columna es una función. La primera columna es lo que intento ser capaz de 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]]

Answer 1

No sé la respuesta directa, pero sé cómo tf.Print depuración: por tf.Print . Es una operación que imprime el valor a medida que se ejecuta tensorflow, y devuelve el tensor para un mayor cálculo, por lo que puede rociarlos en línea en su modelo.

Intente incluir 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 lo que Tensorflow piensa que son los valores intermedios. Si los NaN se muestran más temprano en la tubería, debería darle una mejor idea de dónde radica el problema. ¡Buena suerte! Si obtiene algunos datos de esto, siéntase libre de hacer un seguimiento y veremos si podemos obtener más.

Actualizado para agregar: Aquí hay una versión de depuración para probar, donde me deshice de las funciones de entrada y acabo de generar 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ía ver líneas que comiencen con "Bias:", etc.

Answer 2

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

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

Si reemplazas esto con:

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

También utilicé reduce_mean en lugar de reduce_sum. Si duplica el tamaño del lote y usa reduce_sum, duplicará el costo (y la magnitud del degradado). Además de eso, cuando se utiliza tf.print (que imprime en la consola desde la que se inició el tensorfow), es un poco más comparable cuando se varía el tamaño del lote.

Específicamente esto es lo que estoy usando ahora cuando se depura:

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