Tensorflow प्रेसिजन/याद/एफ 1 स्कोर और भ्रम मैट्रिक्स

Question

मैं अगर वहाँ scikit से अलग स्कोर समारोह को लागू करने के इस तरह के पैकेज जानने के लिए एक रास्ता है पता करने के लिए करना चाहते हैं: करने के लिए एक tensorflow मॉडल में

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

अलग स्कोर प्राप्त करें।

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}) 

क्या मुझे पूर्वानुमान प्राप्त करने के लिए सत्र फिर से चलाया जाएगा?

Answer 1

हो सकता है कि इस उदाहरण आप से बात करेंगे:

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

आप वास्तव में नहीं है sklearn जरूरत परिशुद्धता/याद/f1 स्कोर की गणना करने के लिए। आप आसानी से सूत्रों

अब अगर आप 0/1 की वैक्टर के रूप में अपने actual और predicted मान को देखकर TF-ish तरीके से व्यक्त कर सकते हैं, तो आप टी.पी., तमिलनाडु, एफपी, एफ एन गणना कर सकते हैं tf.count_nonzero का उपयोग कर: आपके तालिका

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 

अब caclulate आसान है:

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

Answer 3

उपयोग मैट्रिक्स एपीआई tf.contrib.metrics में प्रदान की जाती है, उदाहरण के लिए:

tf.count_nonzero एक में अपने मूल्यों डाले:

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

के बाद से मैं करने के लिए साल्वाडोर Dalis का जवाब इस जाने का रास्ता है कोई टिप्पणी जोड़ने के लिए पर्याप्त नहीं प्रतिष्ठा है tf.int64 जब तक अन्यथा निर्दिष्ट नहीं किया जाता है। का उपयोग:

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) 

एक वास्तविक विचार है।