Come ottenere precisione, F1, precisione e richiamo, per un modello di keras?

Voglio calcolare la precisione, il richiamo e il punteggio F1 per il mio modello binario KerasClassifier, ma non trovo alcuna soluzione.

Ecco il mio codice attuale:

# Split dataset in train and test data 
X_train, X_test, Y_train, Y_test = train_test_split(normalized_X, Y, test_size=0.3, random_state=seed)

# Build the model
model = Sequential()
model.add(Dense(23, input_dim=45, kernel_initializer='normal', activation='relu'))
model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))

# Compile model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])


tensorboard = TensorBoard(log_dir="logs/{}".format(time.time()))

time_callback = TimeHistory()

# Fit the model
history = model.fit(X_train, Y_train, validation_split=0.3, epochs=200, batch_size=5, verbose=1, callbacks=[tensorboard, time_callback]) 

E quindi prevedo nuovi dati di test e ottengo la matrice di confusione in questo modo:

y_pred = model.predict(X_test)
y_pred =(y_pred>0.5)
list(y_pred)

cm = confusion_matrix(Y_test, y_pred)
print(cm)

Ma c'è qualche soluzione per ottenere il punteggio di precisione, il punteggio di F1, la precisione e il richiamo? (Se non complicato, anche il punteggio di convalida incrociata, ma non necessario per questa risposta)

Grazie per tutto l'aiuto!

Le metriche sono state rimosse dal core di Keras. Devi calcolarli manualmente. Li hanno rimossi sulla versione 2.0 . Queste metriche sono tutte metriche globali, ma Keras funziona in batch. Di conseguenza, potrebbe essere più fuorviante che utile.

Tuttavia, se ne hai davvero bisogno, puoi farlo in questo modo

from keras import backend as K

def recall_m(y_true, y_pred):
    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
    recall = true_positives / (possible_positives + K.epsilon())
    return recall

def precision_m(y_true, y_pred):
    true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
    predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
    precision = true_positives / (predicted_positives + K.epsilon())
    return precision

def f1_m(y_true, y_pred):
    precision = precision_m(y_true, y_pred)
    recall = recall_m(y_true, y_pred)
    return 2*((precision*recall)/(precision+recall+K.epsilon()))

# compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc',f1_m,precision_m, recall_m])

# fit the model
history = model.fit(Xtrain, ytrain, validation_split=0.3, epochs=10, verbose=0)

# evaluate the model
loss, accuracy, f1_score, precision, recall = model.evaluate(Xtest, ytest, verbose=0)

È possibile utilizzare il rapporto di classificazione scikit-learn . Per convertire le etichette in un formato numerico o binario dai un'occhiata al codificatore di etichette scikit-learn .

from sklearn.metrics import classification_report

y_pred = model.predict(x_test, batch_size=64, verbose=1)
y_pred_bool = np.argmax(y_pred, axis=1)

print(classification_report(y_test, y_pred_bool))

che ti dà (output copiato dall'esempio di scikit-learn):

             precision  recall   f1-score    support

 class 0       0.50      1.00      0.67         1
 class 1       0.00      0.00      0.00         1
 class 2       1.00      0.67      0.80         3

Puoi anche provare come indicato di seguito.

from sklearn.metrics import f1_score, precision_score, recall_score, confusion_matrix
y_pred1 = model.predict(X_test)
y_pred = np.argmax(y_pred1, axis=1)

# Print f1, precision, and recall scores
print(precision_score(y_test, y_pred , average="macro"))
print(recall_score(y_test, y_pred , average="macro"))
print(f1_score(y_test, y_pred , average="macro"))

Prova questo: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_fscore_support.html con Y_test, y_pred come parametri.