[PYTHON] Versuchen Sie es mit tf.metrics

Auslösen

Als ich versuchte, tf.metrics.accuracy zu verwenden, war ich beunruhigt darüber, dass es zwei Rückgabewerte gab (Genauigkeit, Aktualisierung \ _op) und die Werte nicht die normale korrekte Antwortrate waren. Gleiches gilt für tf.metrics.recall und tf.metrics.precision. Es scheint, dass es im Moment fast keine japanischen Artikel darüber gibt, also habe ich mir vorerst eine Notiz gemacht.

Verhalten von tf.metrics

Wie der Name schon sagt, werden verschiedene Metriken berechnet, einschließlich der richtigen Antwortrate.

Wenn Sie jedoch nur den Namen sehen,

# labels:1-dimensionaler Tensor mit korrektem Antwortetikett
# predictions:Voraussichtlicher eindimensionaler Tensor

accuracy, update_op = tf.metrics.accuracy(labels, predictions)
accuracy = tf.reduce_mean(tf.cast(predictions == labels, tf.float32))

Sie würden erwarten, dass diese beiden Genauigkeiten den gleichen Wert haben. Was denkst du über update_op?

Zusammenfassend verhält sich tf.metrics.accuracy so, als ob es alle früheren Werte enthält. (Tatsächlich bleiben die Gesamtzahl der richtigen Antworten in der Vergangenheit und die Anzahl der Daten erhalten, und es wird nur die "Gesamtzahl" verwendet.)

Das heißt, wenn Sie in der ersten Epoche alle Fragen richtig beantwortet haben und in der zweiten Epoche alle Fragen falsch waren (und wenn die Stapelgröße jeder Epoche immer gleich ist), beträgt die erste Genauigkeit 1,00 und die zweite Genauigkeit 0,50. Es wird. Wenn alle Fragen in der dritten Epoche richtig beantwortet wurden, beträgt die dritte Genauigkeit etwa 0,67.

Es scheint, dass viele Menschen über dieses Verhalten verwirrt sind, selbst wenn Sie sich [Tensorflow-Probleme] ansehen (https://github.com/tensorflow/tensorflow/issues/9498). Es gibt Meinungen wie "Es ist nicht intuitiv" und "Ich denke, tf.metrics.streaming \ _accuracy ist ein besserer Name für diese Funktion."

Ein Befragter sagte übrigens

Es heißt nicht "Streaming \ _ ◯◯", da alle tf.metrics sowieso streamen.
Der Grund dafür, dass keine Nicht-Streaming-Metriken erstellt werden, besteht darin, dass sie ohnehin einfach zu implementieren sind.
1 Ich interessiere mich nicht für den Prozentsatz der richtigen Antworten in Batch-Einheiten, daher bin ich häufig nicht an Nicht-Streaming-Metriken interessiert.

Und das. Ich verstehe, ich habe mich in sie verliebt. Es scheint sicherlich bequem.

Verwendung von tf.metrics

tf.metrics hat zwei Rückgabewerte. Genauigkeit und Aktualisierung \ _op.

Wenn Sie update \ _op aufrufen, wird die richtige Antwortrate aktualisiert. Die Genauigkeit enthält die zuletzt berechnete korrekte Antwortrate (Anfangswert ist 0).

Kurz gesagt, es sieht so aus.

import numpy as np
import tensorflow as tf

labels = tf.placeholder(tf.float32, [None])
predictions = tf.placeholder(tf.float32, [None])
accuracy, update_op = tf.metrics.accuracy(labels, predictions)

with tf.Session() as sess:
    sess.run(tf.local_variables_initializer())
    print(sess.run(accuracy))  #Anfangswert 0

    #Erstes Mal(Alle Fragen richtig)
    sess.run(update_op, feed_dict={
        labels: np.array([1, 1, 1]),
        predictions: np.array([1, 1, 1])
    })
    print(sess.run(accuracy))  # 3 / 3 = 1

    #Zweites Mal(Alle Fragen falsch)
    sess.run(update_op, feed_dict={
        labels: np.array([0, 0, 0]),
        predictions: np.array([1, 1, 1])
    })
    print(sess.run(accuracy))  # 3 / 6 = 0.5

    #Drittes Mal(Alle Fragen richtig)
    sess.run(update_op, feed_dict={
        labels: np.array([1, 1, 1]),
        predictions: np.array([1, 1, 1])
    })
    print(sess.run(accuracy))  # 6 / 9 =Über 0.67

Implementierung mit tf.metrics

Ich weiß nicht, ob das gut ist, aber es sieht zum Beispiel so aus. Bitte lassen Sie mich wissen, ob es einen anderen guten Weg gibt.

def create_metrics(labels, predictions, register_to_summary=True):
    update_op, metrics_op = {}, {}

    # accuracy, recall,tf zur Präzisionsberechnung.Verwenden Sie Metriken
    for key, func in zip(('accuracy', 'recall', 'precision'),
                         (tf.metrics.accuracy, tf.metrics.recall, tf.metrics.precision)):
        metrics_op[key], update_op[key] = func(labels, predictions, name=key)

    # f1_Die Punktzahl wird von Ihnen selbst berechnet
    metrics_op['f1_score'] = tf.divide(
        2 * metrics_op['precision'] * metrics_op['recall'],
        metrics_op['precision'] + metrics_op['recall'] + 1e-8,
        name='f1_score'
    )  # 1e-8 ist ein Nullteilungsmaß

    entire_update_op = tf.group(*update_op.values())

    if register_to_summary:  #Später tf.summary.merge_all()tun können
        for k, v in metrics_op.items():
            tf.summary.scalar(k, v)

    return metrics_op, entire_update_op

metrics_op, entire_update_op = create_metrics(labels, predictions)
merged = tf.summary.merge_all()

Was ich sagen und tun möchte, ist kurz gesagt

Wenn Sie mehrere Metriken zusammen verwenden, ist es einfacher, jedes Update \ _op in tf.group zusammenzustellen.
Wenn Sie sich mit tf.summary anmelden möchten, ist es einfacher, alle Metriken später zusammenzuführen.
f1 \ _ score wird in tf.metrics nicht gefunden, daher müssen Sie möglicherweise Ihre eigene erstellen.

darüber.

Bemerkungen

Übrigens sind diese Metriken lokale Variablen, keine globalen Variablen.

local_init_op = tf.local_variables_initializer()
sess.run(local_init_op)

müssen es tun.