एक केरास मॉडल के लिए सटीकता, एफ 1, परिशुद्धता और रिकॉल कैसे प्राप्त करें?

Question

मैं अपने बाइनरी KerasClassifier मॉडल के लिए सटीक, रिकॉल और F1-स्कोर की गणना करना चाहता हूं, लेकिन कोई समाधान नहीं ढूंढता।

यहाँ मेरा वास्तविक कोड है:

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

और फिर मैं नए परीक्षण डेटा पर भविष्यवाणी कर रहा हूं, और इस तरह से भ्रम मैट्रिक्स प्राप्त कर रहा हूं:

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

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

लेकिन क्या सटीकता-स्कोर, एफ -1-स्कोर, सटीक और रिकॉल प्राप्त करने के लिए कोई समाधान है? (यदि जटिल नहीं है, तो क्रॉस-सत्यापन-स्कोर भी है, लेकिन इस उत्तर के लिए आवश्यक नहीं है)

हर प्रकार की सहायता के लिए आपका धन्यवाद!

Answer 1

केरेस कोर से मेट्रिक्स हटा दिए गए हैं। आपको उन्हें मैन्युअल रूप से गणना करने की आवश्यकता है। उन्होंने उन्हें 2.0 संस्करण पर हटा दिया । वे मैट्रिक्स सभी वैश्विक मैट्रिक्स हैं, लेकिन केरस बैचों में काम करते हैं। परिणामस्वरूप, यह सहायक से अधिक भ्रामक हो सकता है।

हालांकि, अगर आपको वास्तव में उनकी आवश्यकता है, तो आप इसे इस तरह से कर सकते हैं

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)

Comments

अगर वे भ्रामक हो सकते हैं, तो एक केरस मॉडल का मूल्यांकन कैसे करें?

— ZelelB

चूंकि केरस प्रत्येक बैच के अंत में उन मैट्रिक्स की गणना करते हैं, इसलिए आप "वास्तविक" मीट्रिक से अलग परिणाम प्राप्त कर सकते हैं। प्रशिक्षण और परीक्षण में अपने डेटासेट को विभाजित करने और परिणामों की भविष्यवाणी करने के लिए परीक्षण भाग का उपयोग करने का एक वैकल्पिक तरीका होगा। तब से आप वास्तविक लेबल को जानते हैं, सटीक गणना करते हैं और मैन्युअल रूप से याद करते हैं।

— Tasos

तसो, क्या मैं आपको इस एसओ प्रश्न में अपना उत्तर पुन: पोस्ट करने की सलाह दूंगा: मुझे अपने तंत्रिका नेटवर्क मॉडल में सटीक और रिकॉल मैट्रिक्स कैसे लागू करना चाहिए? चीयर्स, Iraklis

— डेजर्टनट

क्षमा करें, अभी-अभी देखा गया था कि इसे बंद कर दिया गया था :(

— डेजर्टनॉट

किसी भी विचार क्यों यह मेरे लिए सत्यापन पर काम नहीं कर रहा है? प्रशिक्षण के लिए ठीक काम करता है।

— रॉड्रिगो रूइज

Answer 2

आप scikit-learn वर्गीकरण रिपोर्ट का उपयोग कर सकते हैं । अपने लेबल को संख्यात्मक या बाइनरी फॉर्मेट में बदलने के लिए 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))

जो आपको देता है (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

Comments

यह वही है जो मैं उपयोग करता हूं, सरल और प्रभावी।

— मैथ्यू

Answer 3

आप नीचे बताए अनुसार भी आजमा सकते हैं।

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

Answer 4

इसे आज़माएँ: https://scikit-learn.org/stable/modules/generated/sklearn.metrics.preaches_recall_fscore_support.html Y_test, y_pred को मापदंडों के रूप में।

Comments

मैंने इसे आज़माया: model.reults_recall_fscore_support (Y_test, y_pred, औसत = 'माइक्रो') और निष्पादन पर यह त्रुटि प्राप्त करें: विशेषता: 'अनुक्रमिक' ऑब्जेक्ट में कोई विशेषता नहीं है 'recision_recall_fscore_support'

— ZelelB

आपको model.reaches_recall_fscore_support () को निर्दिष्ट करने की आवश्यकता नहीं है, बल्कि बस recision_recall_fscore_support (Y_test, y_pred, औसत = 'माइक्रो') ("मॉडल" के बिना) और सुनिश्चित करें कि आपके पास सही आयात है: sklearn.metrics से आयात परिशुद्धता_recall_fscore_support

— वायाचेस्लाव कोमिसरेन्को