Tensorflow Precision/Recall/F1 Partitur und Verwirrung Matrix

Question

Ich mag würde wissen, ob es einen Weg gibt, die unterschiedliche Score-Funktion aus dem scikit lernen Paket wie diese umzusetzen:

from sklearn.metrics import confusion_matrix 
confusion_matrix(y_true, y_pred) 

in ein tensorflow Modell Holen Sie sich die unterschiedliche Punktzahl.

with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess: 
init = tf.initialize_all_variables() 
sess.run(init) 
for epoch in xrange(1): 
     avg_cost = 0. 
     total_batch = len(train_arrays)/batch_size 
     for batch in range(total_batch): 
       train_step.run(feed_dict = {x: train_arrays, y: train_labels}) 
       avg_cost += sess.run(cost, feed_dict={x: train_arrays, y: train_labels})/total_batch 
     if epoch % display_step == 0: 
       print "Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost) 

print "Optimization Finished!" 
correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1)) 
# Calculate accuracy 
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) 
print "Accuracy:", batch, accuracy.eval({x: test_arrays, y: test_labels}) 

Muss ich die Sitzung erneut ausführen, um die Vorhersage zu erhalten?

Answer 1

Vielleicht wird dieses Beispiel zu dir sprechen:

pred = multilayer_perceptron(x, weights, biases) 
    correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1)) 
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) 

    with tf.Session() as sess: 
    init = tf.initialize_all_variables() 
    sess.run(init) 
    for epoch in xrange(150): 
      for i in xrange(total_batch): 
        train_step.run(feed_dict = {x: train_arrays, y: train_labels}) 
        avg_cost += sess.run(cost, feed_dict={x: train_arrays, y: train_labels})/total_batch   
      if epoch % display_step == 0: 
        print "Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost) 

    #metrics 
    y_p = tf.argmax(pred, 1) 
    val_accuracy, y_pred = sess.run([accuracy, y_p], feed_dict={x:test_arrays, y:test_label}) 

    print "validation accuracy:", val_accuracy 
    y_true = np.argmax(test_label,1) 
    print "Precision", sk.metrics.precision_score(y_true, y_pred) 
    print "Recall", sk.metrics.recall_score(y_true, y_pred) 
    print "f1_score", sk.metrics.f1_score(y_true, y_pred) 
    print "confusion_matrix" 
    print sk.metrics.confusion_matrix(y_true, y_pred) 
    fpr, tpr, tresholds = sk.metrics.roc_curve(y_true, y_pred) 

Answer 2

Sie nicht wirklich brauchen sklearn Präzision/Rückruf/f1-Score zu berechnen. Sie können sie in der TF-ish Art und Weise leicht ausdrücken

nun bei den Formeln suchen, wenn Sie Ihre actual und predicted Werte als Vektoren von 0/1 haben, können Sie berechnen, TP, TN, FP, FN tf.count_nonzero mit:

TP = tf.count_nonzero(predicted * actual) 
TN = tf.count_nonzero((predicted - 1) * (actual - 1)) 
FP = tf.count_nonzero(predicted * (actual - 1)) 
FN = tf.count_nonzero((predicted - 1) * actual 

Jetzt ist Ihre Metriken einfach zu caclulate:

precision = TP/(TP + FP) 
recall = TP/(TP + FN) 
f1 = 2 * precision * recall/(precision + recall) 

Answer 3

verwenden Sie die Metriken API s in tf.contrib.metrics, zum Beispiel zur Verfügung gestellt:

labels = ... 
predictions = ... 

accuracy, update_op_acc = tf.contrib.metrics.streaming_accuracy(labels, predictions) 
error, update_op_error = tf.contrib.metrics.streaming_mean_absolute_error(labels, predictions) 

sess.run(tf.local_variables_initializer()) 
for batch in range(num_batches): 
    sess.run([update_op_acc, update_op_error]) 
accuracy, mean_absolute_error = sess.run([accuracy, mean_absolute_error]) 

Answer 4

Da ich nicht genug Ruf um einen Kommentar hinzufügen zu Salvador Dalis beantwortet dies der Weg zu gehen:

tf.count_nonzero wirft Ihre Werte in eine tf.int64, sofern nicht anders angegeben. Verwendung:

argmax_prediction = tf.argmax(prediction, 1) 
argmax_y = tf.argmax(y, 1) 

TP = tf.count_nonzero(argmax_prediction * argmax_y, dtype=tf.float32) 
TN = tf.count_nonzero((argmax_prediction - 1) * (argmax_y - 1), dtype=tf.float32) 
FP = tf.count_nonzero(argmax_prediction * (argmax_y - 1), dtype=tf.float32) 
FN = tf.count_nonzero((argmax_prediction - 1) * argmax_y, dtype=tf.float32) 

ist eine wirklich gute Idee.