python - recall - Cómo calcular la precisión y el recuerdo en Keras.
precision recall sklearn (6)
A partir de Keras 2.0, la precisión y la recuperación se eliminaron de la rama maestra. Tendrás que implementarlas tú mismo. Siga esta guía para crear métricas personalizadas: Here .
Here se puede encontrar la ecuación de precisión y recuperación.
O reutilice el código de keras antes de que se eliminara Here .
Allí las métricas se eliminaron porque eran por lotes, por lo que el valor puede o no ser correcto.
Estoy creando un clasificador de clases múltiples con Keras 2.02 (con backend Tensorflow), y no sé cómo calcular la precisión y la recuperación en Keras. Por favor, ayúdame.
El paquete Python keras-metrics podría ser útil para esto (soy el autor del paquete).
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()])
Este hilo está un poco agotado, pero por si acaso ayudará a alguien que aterrice aquí. Si está dispuesto a actualizar a Keras v2.1.6, ha habido mucho trabajo para que funcionen las métricas con estado, aunque parece que se está haciendo más trabajo ( https://github.com/keras-team/keras/pull/9446 ).
De todos modos, encontré que la mejor manera de integrar la precisión / recuperación era usando la métrica personalizada que subclases de Layer , que se muestra con el ejemplo en BinaryTruePositives .
Para recordar, esto se vería como:
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
Mi respuesta se basa en el comentario de Keras GH . Calcula la precisión de la validación y la recuperación en cada época para una tarea de clasificación con codificación Onehot.
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()
Tensorflow tiene las métricas que busca here .
Puede ajustar tf.metrics (por ejemplo, tf.metrics.precision ) en keras.metrics.
De mi respuesta a Cómo usar las métricas de TensorFlow en Keras :
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
Uso básico:
precision = as_keras_metric(tf.metrics.precision)
recall = as_keras_metric(tf.metrics.recall)
...
Compila el modelo de keras:
model.compile(..., metrics=[precision, recall])
Precisión-recuerdo AUC:
También puede hacer cosas como envolver argumentos funcionales (necesarios si desea obtener el AUC de Recall de precisión):
@as_keras_metric
def auc_pr(y_true, y_pred, curve=''PR''):
return tf.metrics.auc(y_true, y_pred, curve=curve)
Y
model.compile(..., metrics=[auc_pr])
Utiliza el framework Scikit Learn para esto.
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)
Este blog es muy útil.