Làm thế nào để có được độ chính xác, F1, độ chính xác và thu hồi, cho một mô hình máy ảnh?

Tôi muốn tính toán độ chính xác, thu hồi và điểm F1 cho mô hình KerasClassifier nhị phân của mình, nhưng không tìm thấy bất kỳ giải pháp nào.

Đây là mã thực tế của tôi:

# 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]) 

Và sau đó tôi dự đoán về dữ liệu thử nghiệm mới và nhận được ma trận nhầm lẫn như thế này:

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

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

Nhưng có giải pháp nào để có được điểm chính xác, điểm F1, độ chính xác và thu hồi không? (Nếu không phức tạp, cũng là điểm xác thực chéo, nhưng không cần thiết cho câu trả lời này)

Cảm ơn bạn đã giúp đỡ!

Số liệu đã được loại bỏ khỏi lõi Keras. Bạn cần tính toán chúng bằng tay. Họ đã loại bỏ chúng trên phiên bản 2.0 . Các số liệu đó là tất cả các số liệu toàn cầu, nhưng Keras hoạt động theo lô. Kết quả là, nó có thể gây hiểu lầm nhiều hơn là hữu ích.

Tuy nhiên, nếu bạn thực sự cần chúng, bạn có thể làm như thế này

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)

Bạn có thể sử dụng báo cáo phân loại scikit-learn . Để chuyển đổi nhãn của bạn thành định dạng số hoặc nhị phân, hãy xem bộ mã hóa nhãn 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))

cung cấp cho bạn (đầu ra được sao chép từ ví dụ 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

Bạn cũng có thể thử như được đề cập dưới đây.

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

Hãy thử điều này: https://scikit-learn.org/urdy/modules/generated/sklearn.metrics.precision_recall_fscore_support.html với Y_test, y_pred làm tham số.