Как рассчитать точность и отзыв в Keras

Ответ 1

Пакет Python keras-metrics может быть полезен для этого (я автор пакета).

import keras
import keras_metrics

model = models.Sequential()
model.add(keras.layers.Dense(1, activation="sigmoid", input_dim=2))
model.add(keras.layers.Dense(1, activation="softmax"))

model.compile(optimizer="sgd",
              loss="binary_crossentropy",
              metrics=[keras_metrics.precision(), keras_metrics.recall()])

ОБНОВЛЕНИЕ: Начиная с Keras версии 2.3.0, такие метрики, как точность, отзыв и т.д., предоставляются в составе дистрибутива библиотеки.

Использование следующее:

model.compile(optimizer="sgd",
              loss="binary_crossentropy",
              metrics=[keras.metrics.Precision(), keras.metrics.Recall()])

Ответ 2

Как и в случае с Keras 2.0, точность и отзыв были удалены из основной ветки. Вам придется реализовать их самостоятельно. Следуйте этому руководству, чтобы создать пользовательские показатели: Здесь.

Точное и отзывное уравнение можно найти Здесь

Или повторно используйте код от кера до его удаления Здесь.

Там метрики были удалены, потому что они были пакетными, поэтому значение может быть или не быть правильным.

Ответ 3

Tensorflow имеет метрики, которые вы ищете здесь.

Вы можете обернуть tf.metrics (например, tf.metrics.precision) в keras.metrics.

Из моего ответа на Как использовать метрики TensorFlow в Керасе:

def as_keras_metric(method):
    import functools
    from keras import backend as K
    import tensorflow as tf
    @functools.wraps(method)
    def wrapper(self, args, **kwargs):
        """ Wrapper for turning tensorflow metrics into keras metrics """
        value, update_op = method(self, args, **kwargs)
        K.get_session().run(tf.local_variables_initializer())
        with tf.control_dependencies([update_op]):
            value = tf.identity(value)
        return value
    return wrapper

Основное использование:

precision = as_keras_metric(tf.metrics.precision)
recall = as_keras_metric(tf.metrics.recall)
...

Скомпилируйте модель keras:

model.compile(..., metrics=[precision, recall])

Precision-Recall AUC:

Вы также можете делать такие вещи, как перенос функциональных аргументов (необходим, если вы хотите AUC Precision-Recall):

@as_keras_metric
def auc_pr(y_true, y_pred, curve='PR'):
    return tf.metrics.auc(y_true, y_pred, curve=curve)

А также

model.compile(..., metrics=[auc_pr])

Ответ 4

Мой ответ основан на комментарии Keras GH. Он вычисляет точность проверки и повторный вызов в каждую эпоху для задачи классификации с однокадровым кодированием. Также, пожалуйста, посмотрите на этот SO ответ, чтобы увидеть, как это можно сделать с помощью функции keras.backend.

import keras as keras
import numpy as np
from keras.optimizers import SGD
from sklearn.metrics import precision_score, recall_score

model = keras.models.Sequential()
# ...
sgd = SGD(lr=0.001, momentum=0.9)
model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])


class Metrics(keras.callbacks.Callback):
    def on_train_begin(self, logs={}):
        self._data = []

    def on_epoch_end(self, batch, logs={}):
        X_val, y_val = self.validation_data[0], self.validation_data[1]
        y_predict = np.asarray(model.predict(X_val))

        y_val = np.argmax(y_val, axis=1)
        y_predict = np.argmax(y_predict, axis=1)

        self._data.append({
            'val_recall': recall_score(y_val, y_predict),
            'val_precision': precision_score(y_val, y_predict),
        })
        return

    def get_data(self):
        return self._data


metrics = Metrics()
history = model.fit(X_train, y_train, epochs=100, validation_data=(X_val, y_val), callbacks=[metrics])
metrics.get_data()

Ответ 5

Эта ветка немного несвежая, но на всякий случай она поможет кому-то приземлиться здесь. Если вы хотите перейти на Keras v2.1.6, было проделано много работы для того, чтобы заставить работать метрики с сохранением состояния, хотя, похоже, еще предстоит проделать большую работу (https://github.com/keras-team/keras)./pull/9446).

В любом случае, я обнаружил, что лучший способ интегрировать точность/отзыв - это использовать пользовательскую метрику, которая подклассирует Layer, показанный примером в BinaryTruePositives.

Напомним, это будет выглядеть так:

class Recall(keras.layers.Layer):
    """Stateful Metric to count the total recall over all batches.

    Assumes predictions and targets of shape '(samples, 1)'.

    # Arguments
        name: String, name for the metric.
    """

    def __init__(self, name='recall', **kwargs):
        super(Recall, self).__init__(name=name, **kwargs)
        self.stateful = True

        self.recall = K.variable(value=0.0, dtype='float32')
        self.true_positives = K.variable(value=0, dtype='int32')
        self.false_negatives = K.variable(value=0, dtype='int32')
    def reset_states(self):
        K.set_value(self.recall, 0.0)
        K.set_value(self.true_positives, 0)
        K.set_value(self.false_negatives, 0)

    def __call__(self, y_true, y_pred):
        """Computes the number of true positives in a batch.

        # Arguments
            y_true: Tensor, batch_wise labels
            y_pred: Tensor, batch_wise predictions

        # Returns
            The total number of true positives seen this epoch at the
                completion of the batch.
        """
        y_true = K.cast(y_true, 'int32')
        y_pred = K.cast(K.round(y_pred), 'int32')

        # False negative calculations
        y_true = K.cast(y_true, 'int32')
        y_pred = K.cast(K.round(y_pred), 'int32')
        false_neg = K.cast(K.sum(K.cast(K.greater(y_pred, y_true), 'int32')), 'int32')
        current_false_neg = self.false_negatives * 1
        self.add_update(K.update_add(self.false_negatives,
                                     false_neg),
                        inputs=[y_true, y_pred])
        # True positive  calculations
        correct_preds = K.cast(K.equal(y_pred, y_true), 'int32')
        true_pos = K.cast(K.sum(correct_preds * y_true), 'int32')
        current_true_pos = self.true_positives * 1
        self.add_update(K.update_add(self.true_positives,
                                     true_pos),
                        inputs=[y_true, y_pred])
        # Combine
        recall = (K.cast(self.true_positives, 'float32') / (K.cast(self.true_positives, 'float32') + K.cast(self.false_negatives, 'float32') + K.cast(K.epsilon(), 'float32')))
        self.add_update(K.update(self.recall,
                                     recall),
                        inputs=[y_true, y_pred])

        return recall   

Ответ 6

Используйте Scikit Learn Framework для этого.

from sklearn.metrics import classification_report

history = model.fit(x_train, y_train, batch_size=32, epochs=10, verbose=1, validation_data=(x_test, y_test), shuffle=True)
pred = model.predict(x_test, batch_size=32, verbose=1)
predicted = np.argmax(pred, axis=1)
report = classification_report(np.argmax(y_test, axis=1), predicted)
print(report)

Этот блог очень полезен.